diff --git a/krita/data/aboutdata/libraries.txt b/krita/data/aboutdata/libraries.txt
index 998cec61af..58e9becf1a 100644
--- a/krita/data/aboutdata/libraries.txt
+++ b/krita/data/aboutdata/libraries.txt
@@ -1,33 +1,33 @@
 Boost,https://www.boost.org,Boost Software License - Version 1.0
 DrMingw,https://github.com/jrfonseca/drmingw,LGPLv2.1
 Eigen3,http://eigen.tuxfamily.org,MPL2
 Exiv2,http://www.exiv2.org,GPLv2
 Expat,https://github.com/libexpat/libexpat,MIT
 ffmpeg,https://www.ffmpeg.org,LGPL2.1+
 fftw3,http://www.fftw.org/,GPLv2+
 fontconfig,https://www.freedesktop.org/wiki/Software/fontconfig/,BSD
 freetype,https://www.freetype.org/,FTL or GPLv2
 gettext,https://www.gnu.org/software/gettext/,GPLv3
 giflib,http://giflib.sourceforge.net/,BSD
 gmic,http://gmic.eu/,CeCILLv2.1
 gmic-qt,http://gmic.eu/,GPLv3
 GNU Scientific Library,http://www.gnu.org/software/gsl,GPLv3
 iconv,https://www.gnu.org/software/libiconv/,LGPLv2 or GPLv3
 ilmbase,http://www.openexr.com,Modified BSD
 KDE Frameworks 5,https://www.kde.org,LGPLv2.1+
 libheif,https://github.com/strukturag/libheif,LGPLv3
 libjpeg-turbo,http://www.libjpeg-turbo.org,BSD
 libpng,http://www.libpng.org,libpng license
 libraw,http://www.libraw.org,LGPLv2.1 or CDDL 1.0
 libtiff,http://libtiff.org/,BSD
 littlecms2,http://www.littlecms.com,MIT
 OpenColorIO,http://www.opencolorio.org,BSD
 OpenEXR,http://www.openexr.com,Modified BSD
 poppler,http://poppler.freedesktop.org,GPLv2 and GPLv3
 PyQt,https://www.riverbankcomputing.com/software/pyqt/download5,GPLv3
 Python,http://www.python.org,Python Software Foundation License v2
 Qt,https://www.qt.io,GPLv2 + GPLv3 + LGPLv2.1 + LGPLv3
-Quazip,https://github.com/stachenov/quazip,LBPLv2.1
+Quazip,https://github.com/stachenov/quazip,LGPLv2.1
 SIP,https://www.riverbankcomputing.com/software/sip/download,GPLv3
 Vc,https://github.com/VcDevel/Vc,BSD
 zlib,http://www.zlib.net/,BSD
diff --git a/libs/flake/KoPathShape.cpp b/libs/flake/KoPathShape.cpp
index bb955d7e9d..641de90986 100644
--- a/libs/flake/KoPathShape.cpp
+++ b/libs/flake/KoPathShape.cpp
@@ -1,1656 +1,1661 @@
 /* This file is part of the KDE project
    Copyright (C) 2006-2008, 2010-2011 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-2011 Jan Hambrecht <jaham@gmx.net>
    Copyright (C) 2007-2009 Thomas Zander <zander@kde.org>
    Copyright (C) 2011 Jean-Nicolas Artaud <jeannicolasartaud@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 "KoPathShape.h"
 #include "KoPathShape_p.h"
 
 #include "KoPathSegment.h"
 #include "KoOdfWorkaround.h"
 #include "KoPathPoint.h"
 #include "KoShapeStrokeModel.h"
 #include "KoViewConverter.h"
 #include "KoPathShapeLoader.h"
 #include "KoShapeSavingContext.h"
 #include "KoShapeLoadingContext.h"
 #include "KoShapeShadow.h"
 #include "KoShapeBackground.h"
 #include "KoShapeContainer.h"
 #include "KoFilterEffectStack.h"
 #include "KoMarker.h"
 #include "KoShapeStroke.h"
 #include "KoInsets.h"
 
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoXmlNS.h>
 #include <KoUnit.h>
 #include <KoGenStyle.h>
 #include <KoStyleStack.h>
 #include <KoOdfLoadingContext.h>
 #include "KisQPainterStateSaver.h"
 
 #include <FlakeDebug.h>
 #include <QPainter>
 
 #include "kis_global.h"
 
 #include <qnumeric.h> // for qIsNaN
 static bool qIsNaNPoint(const QPointF &p) {
     return qIsNaN(p.x()) || qIsNaN(p.y());
 }
 
 KoPathShape::Private::Private()
     : QSharedData()
     , fillRule(Qt::OddEvenFill)
     , autoFillMarkers(false)
 {
 }
 
 KoPathShape::Private::Private(const Private &rhs)
     : QSharedData()
     , fillRule(rhs.fillRule)
     , markersNew(rhs.markersNew)
     , autoFillMarkers(rhs.autoFillMarkers)
 {
 }
 
 QRectF KoPathShape::Private::handleRect(const QPointF &p, qreal radius) const
 {
     return QRectF(p.x() - radius, p.y() - radius, 2*radius, 2*radius);
 }
 
 void KoPathShape::Private::applyViewboxTransformation(const KoXmlElement &element)
 {
     // apply viewbox transformation
     const QRect viewBox = KoPathShape::loadOdfViewbox(element);
     if (! viewBox.isEmpty()) {
         // load the desired size
         QSizeF size;
         size.setWidth(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "width", QString())));
         size.setHeight(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "height", QString())));
 
         // load the desired position
         QPointF pos;
         pos.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x", QString())));
         pos.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y", QString())));
 
         // create matrix to transform original path data into desired size and position
         QTransform viewMatrix;
         viewMatrix.translate(-viewBox.left(), -viewBox.top());
         viewMatrix.scale(size.width() / viewBox.width(), size.height() / viewBox.height());
         viewMatrix.translate(pos.x(), pos.y());
 
         // transform the path data
         map(viewMatrix);
     }
 }
 
 KoPathShape::KoPathShape()
     : KoTosContainer()
     , d(new Private)
 {
 }
 
 KoPathShape::KoPathShape(const KoPathShape &rhs)
     : KoTosContainer(rhs)
     , d(rhs.d)
 {
     KoSubpathList subpaths;
     Q_FOREACH (KoSubpath *subPath, rhs.d->subpaths) {
         KoSubpath *clonedSubPath = new KoSubpath();
 
         Q_FOREACH (KoPathPoint *point, *subPath) {
             *clonedSubPath << new KoPathPoint(*point, this);
         }
 
         subpaths << clonedSubPath;
     }
     d->subpaths = subpaths;
 }
 
 KoPathShape::~KoPathShape()
 {
     clear();
 }
 
 KoShape *KoPathShape::cloneShape() const
 {
     return new KoPathShape(*this);
 }
 
 void KoPathShape::saveContourOdf(KoShapeSavingContext &context, const QSizeF &scaleFactor) const
 {
     if (d->subpaths.length() <= 1) {
         QTransform matrix;
         matrix.scale(scaleFactor.width(), scaleFactor.height());
         QString points;
         KoSubpath *subPath = d->subpaths.first();
         KoSubpath::const_iterator pointIt(subPath->constBegin());
 
         KoPathPoint *currPoint= 0;
         // iterate over all points
         for (; pointIt != subPath->constEnd(); ++pointIt) {
             currPoint = *pointIt;
 
             if (currPoint->activeControlPoint1() || currPoint->activeControlPoint2()) {
                 break;
             }
             const QPointF p = matrix.map(currPoint->point());
             points += QString("%1,%2 ").arg(qRound(1000*p.x())).arg(qRound(1000*p.y()));
         }
 
         if (currPoint && !(currPoint->activeControlPoint1() || currPoint->activeControlPoint2())) {
             context.xmlWriter().startElement("draw:contour-polygon");
             context.xmlWriter().addAttribute("svg:width", size().width());
             context.xmlWriter().addAttribute("svg:height", size().height());
 
             const QSizeF s(size());
             QString viewBox = QString("0 0 %1 %2").arg(qRound(1000*s.width())).arg(qRound(1000*s.height()));
             context.xmlWriter().addAttribute("svg:viewBox", viewBox);
 
             context.xmlWriter().addAttribute("draw:points", points);
 
             context.xmlWriter().addAttribute("draw:recreate-on-edit", "true");
             context.xmlWriter().endElement();
 
             return;
         }
     }
 
     // if we get here we couldn't save as polygon - let-s try contour-path
     context.xmlWriter().startElement("draw:contour-path");
     saveOdfAttributes(context, OdfViewbox);
 
     context.xmlWriter().addAttribute("svg:d", toString());
     context.xmlWriter().addAttribute("calligra:nodeTypes", d->nodeTypes());
     context.xmlWriter().addAttribute("draw:recreate-on-edit", "true");
     context.xmlWriter().endElement();
 }
 
 void KoPathShape::saveOdf(KoShapeSavingContext & context) const
 {
     context.xmlWriter().startElement("draw:path");
     saveOdfAttributes(context, OdfAllAttributes | OdfViewbox);
 
     context.xmlWriter().addAttribute("svg:d", toString());
     context.xmlWriter().addAttribute("calligra:nodeTypes", d->nodeTypes());
 
     saveOdfCommonChildElements(context);
     saveText(context);
     context.xmlWriter().endElement();
 }
 
 bool KoPathShape::loadContourOdf(const KoXmlElement &element, KoShapeLoadingContext &, const QSizeF &scaleFactor)
 {
     // first clear the path data from the default path
     clear();
 
     if (element.localName() == "contour-polygon") {
         QString points = element.attributeNS(KoXmlNS::draw, "points").simplified();
         points.replace(',', ' ');
         points.remove('\r');
         points.remove('\n');
         bool firstPoint = true;
         const QStringList coordinateList = points.split(' ');
         for (QStringList::ConstIterator it = coordinateList.constBegin(); it != coordinateList.constEnd(); ++it) {
             QPointF point;
             point.setX((*it).toDouble());
             ++it;
             point.setY((*it).toDouble());
             if (firstPoint) {
                 moveTo(point);
                 firstPoint = false;
             } else
                 lineTo(point);
         }
         close();
     } else if (element.localName() == "contour-path") {
         KoPathShapeLoader loader(this);
         loader.parseSvg(element.attributeNS(KoXmlNS::svg, "d"), true);
         d->loadNodeTypes(element);
     }
 
     // apply viewbox transformation
     const QRect viewBox = KoPathShape::loadOdfViewbox(element);
     if (! viewBox.isEmpty()) {
         QSizeF size;
         size.setWidth(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "width", QString())));
         size.setHeight(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "height", QString())));
 
         // create matrix to transform original path data into desired size and position
         QTransform viewMatrix;
         viewMatrix.translate(-viewBox.left(), -viewBox.top());
         viewMatrix.scale(scaleFactor.width(), scaleFactor.height());
         viewMatrix.scale(size.width() / viewBox.width(), size.height() / viewBox.height());
 
         // transform the path data
         d->map(viewMatrix);
     }
     setTransformation(QTransform());
 
     return true;
 }
 
 bool KoPathShape::loadOdf(const KoXmlElement & element, KoShapeLoadingContext &context)
 {
     loadOdfAttributes(element, context, OdfMandatories | OdfAdditionalAttributes | OdfCommonChildElements);
 
     // first clear the path data from the default path
     clear();
 
     if (element.localName() == "line") {
         QPointF start;
         start.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x1", "")));
         start.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y1", "")));
         QPointF end;
         end.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x2", "")));
         end.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y2", "")));
         moveTo(start);
         lineTo(end);
     } else if (element.localName() == "polyline" || element.localName() == "polygon") {
         QString points = element.attributeNS(KoXmlNS::draw, "points").simplified();
         points.replace(',', ' ');
         points.remove('\r');
         points.remove('\n');
         bool firstPoint = true;
         const QStringList coordinateList = points.split(' ');
         for (QStringList::ConstIterator it = coordinateList.constBegin(); it != coordinateList.constEnd(); ++it) {
             QPointF point;
             point.setX((*it).toDouble());
             ++it;
             point.setY((*it).toDouble());
             if (firstPoint) {
                 moveTo(point);
                 firstPoint = false;
             } else
                 lineTo(point);
         }
         if (element.localName() == "polygon")
             close();
     } else { // path loading
         KoPathShapeLoader loader(this);
         loader.parseSvg(element.attributeNS(KoXmlNS::svg, "d"), true);
         d->loadNodeTypes(element);
     }
 
     d->applyViewboxTransformation(element);
     QPointF pos = normalize();
     setTransformation(QTransform());
 
     if (element.hasAttributeNS(KoXmlNS::svg, "x") || element.hasAttributeNS(KoXmlNS::svg, "y")) {
         pos.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x", QString())));
         pos.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y", QString())));
     }
 
     setPosition(pos);
 
     loadOdfAttributes(element, context, OdfTransformation);
 
     // now that the correct transformation is set up
     // apply that matrix to the path geometry so that
     // we don't transform the stroke
     d->map(transformation());
     setTransformation(QTransform());
     normalize();
 
     loadText(element, context);
 
     return true;
 }
 
 QString KoPathShape::saveStyle(KoGenStyle &style, KoShapeSavingContext &context) const
 {
     style.addProperty("svg:fill-rule", d->fillRule == Qt::OddEvenFill ? "evenodd" : "nonzero");
 
     QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke());
     qreal lineWidth = 0;
     if (lineBorder) {
         lineWidth = lineBorder->lineWidth();
     }
 
     Q_UNUSED(lineWidth)
 
     return KoTosContainer::saveStyle(style, context);
 }
 
 void KoPathShape::loadStyle(const KoXmlElement & element, KoShapeLoadingContext &context)
 {
     KoTosContainer::loadStyle(element, context);
 
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
     styleStack.setTypeProperties("graphic");
 
     if (styleStack.hasProperty(KoXmlNS::svg, "fill-rule")) {
         QString rule = styleStack.property(KoXmlNS::svg, "fill-rule");
         d->fillRule = (rule == "nonzero") ?  Qt::WindingFill : Qt::OddEvenFill;
     } else {
         d->fillRule = Qt::WindingFill;
 #ifndef NWORKAROUND_ODF_BUGS
         KoOdfWorkaround::fixMissingFillRule(d->fillRule, context);
 #endif
     }
 
     QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke());
     qreal lineWidth = 0;
     if (lineBorder) {
         lineWidth = lineBorder->lineWidth();
     }
 
     Q_UNUSED(lineWidth);
 }
 
 QRect KoPathShape::loadOdfViewbox(const KoXmlElement & element)
 {
     QRect viewbox;
 
     QString data = element.attributeNS(KoXmlNS::svg, QLatin1String("viewBox"));
     if (! data.isEmpty()) {
         data.replace(QLatin1Char(','), QLatin1Char(' '));
         const QStringList coordinates = data.simplified().split(QLatin1Char(' '), QString::SkipEmptyParts);
         if (coordinates.count() == 4) {
             viewbox.setRect(coordinates.at(0).toInt(), coordinates.at(1).toInt(),
                             coordinates.at(2).toInt(), coordinates.at(3).toInt());
         }
     }
 
     return viewbox;
 }
 
 void KoPathShape::clear()
 {
     Q_FOREACH (KoSubpath *subpath, d->subpaths) {
         Q_FOREACH (KoPathPoint *point, *subpath)
             delete point;
         delete subpath;
     }
     d->subpaths.clear();
 
     notifyPointsChanged();
 }
 
 void KoPathShape::paint(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     KisQPainterStateSaver saver(&painter);
 
     applyConversion(painter, converter);
     QPainterPath path(outline());
     path.setFillRule(d->fillRule);
 
     if (background()) {
         background()->paint(painter, converter, paintContext, path);
     }
     //d->paintDebug(painter);
 }
 
 
 #ifndef NDEBUG
 void KoPathShape::Private::paintDebug(QPainter &painter)
 {
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     int i = 0;
 
     QPen pen(Qt::black, 0);
     painter.save();
     painter.setPen(pen);
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             ++i;
             KoPathPoint *point = (*it);
             QRectF r(point->point(), QSizeF(5, 5));
             r.translate(-2.5, -2.5);
             QPen pen(Qt::black, 0);
             painter.setPen(pen);
             if (point->activeControlPoint1() && point->activeControlPoint2()) {
                 QBrush b(Qt::red);
                 painter.setBrush(b);
             } else if (point->activeControlPoint1()) {
                 QBrush b(Qt::yellow);
                 painter.setBrush(b);
             } else if (point->activeControlPoint2()) {
                 QBrush b(Qt::darkYellow);
                 painter.setBrush(b);
             }
             painter.drawEllipse(r);
         }
     }
     painter.restore();
     debugFlake << "nop =" << i;
 }
 
 void KoPathShape::Private::debugPath() const
 {
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             debugFlake << "p:" << (*pathIt) << "," << *it << "," << (*it)->point() << "," << (*it)->properties();
         }
     }
 }
 #endif
 
 void KoPathShape::paintPoints(KisHandlePainterHelper &handlesHelper)
 {
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
 
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it)
             (*it)->paint(handlesHelper, KoPathPoint::Node);
     }
 }
 
 QRectF KoPathShape::outlineRect() const
 {
     return outline().boundingRect();
 }
 
 QPainterPath KoPathShape::outline() const
 {
     QPainterPath path;
     for (auto subpathIt = d->subpaths.constBegin(); subpathIt != d->subpaths.constEnd(); ++subpathIt) {
         const KoSubpath * subpath = *subpathIt;
         const KoPathPoint * lastPoint = subpath->constFirst();
         bool activeCP = false;
         for (auto pointIt = subpath->constBegin(); pointIt != subpath->constEnd(); ++pointIt) {
             const KoPathPoint * currPoint = *pointIt;
             KoPathPoint::PointProperties currProperties = currPoint->properties();
             if (currPoint == subpath->constFirst()) {
                 if (currProperties & KoPathPoint::StartSubpath) {
                     Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                     path.moveTo(currPoint->point());
                 }
             } else if (activeCP && currPoint->activeControlPoint1()) {
                 Q_ASSERT(!qIsNaNPoint(lastPoint->controlPoint2()));
                 Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                 Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                 path.cubicTo(
-                    lastPoint->controlPoint2(),
-                    currPoint->controlPoint1(),
-                    currPoint->point());
+                            lastPoint->controlPoint2(),
+                            currPoint->controlPoint1(),
+                            currPoint->point());
             } else if (activeCP || currPoint->activeControlPoint1()) {
                 Q_ASSERT(!qIsNaNPoint(lastPoint->controlPoint2()));
                 Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                 path.quadTo(
-                    activeCP ? lastPoint->controlPoint2() : currPoint->controlPoint1(),
-                    currPoint->point());
+                            activeCP ? lastPoint->controlPoint2() : currPoint->controlPoint1(),
+                            currPoint->point());
             } else {
                 Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                 path.lineTo(currPoint->point());
             }
             if (currProperties & KoPathPoint::CloseSubpath && currProperties & KoPathPoint::StopSubpath) {
                 // add curve when there is a curve on the way to the first point
                 KoPathPoint * firstPoint = subpath->first();
                 Q_ASSERT(!qIsNaNPoint(firstPoint->point()));
                 if (currPoint->activeControlPoint2() && firstPoint->activeControlPoint1()) {
                     path.cubicTo(
-                        currPoint->controlPoint2(),
-                        firstPoint->controlPoint1(),
-                        firstPoint->point());
+                                currPoint->controlPoint2(),
+                                firstPoint->controlPoint1(),
+                                firstPoint->point());
                 }
                 else if (currPoint->activeControlPoint2() || firstPoint->activeControlPoint1()) {
                     Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                     Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                     path.quadTo(
-                        currPoint->activeControlPoint2() ? currPoint->controlPoint2() : firstPoint->controlPoint1(),
-                        firstPoint->point());
+                                currPoint->activeControlPoint2() ? currPoint->controlPoint2() : firstPoint->controlPoint1(),
+                                firstPoint->point());
                 }
                 path.closeSubpath();
             }
 
             if (currPoint->activeControlPoint2()) {
                 activeCP = true;
             } else {
                 activeCP = false;
             }
             lastPoint = currPoint;
         }
     }
 
     return path;
 }
 
 QRectF KoPathShape::boundingRect() const
 {
     const QTransform transform = absoluteTransformation(0);
 
     /**
      * First we approximate the insets of the stroke by rendering a fat bezier curve
      * with width set to the maximum inset of miters and markers. The are swept by this
      * curve will be a good approximation of the real curve bounding rect.
      */
     qreal outlineSweepWidth = 0;
 
     const QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke());
     if (lineBorder) {
         outlineSweepWidth = lineBorder->lineWidth();
     }
 
     if (stroke()) {
         KoInsets inset;
         stroke()->strokeInsets(this, inset);
         const qreal maxInset = std::max({inset.left, inset.top, inset.right, inset.bottom});
 
         // insets extend outside the shape, but width extends both inside and outside,
         // so we should multiply insets by 2.0
         outlineSweepWidth = std::max({outlineSweepWidth,
                                       2.0 * maxInset,
                                       2.0 * stroke()->strokeMaxMarkersInset(this)});
     }
 
     QPen pen(Qt::black, outlineSweepWidth);
 
     // select round joins and caps to ensure it sweeps exactly
     // 'outlineSweepWidth' pixels in every possible
     pen.setJoinStyle(Qt::RoundJoin);
     pen.setCapStyle(Qt::RoundCap);
 
     QRectF bb = transform.map(pathStroke(pen)).boundingRect();
 
     if (shadow()) {
         KoInsets insets;
         shadow()->insets(insets);
         bb.adjust(-insets.left, -insets.top, insets.right, insets.bottom);
     }
     if (filterEffectStack()) {
         QRectF clipRect = filterEffectStack()->clipRectForBoundingRect(QRectF(QPointF(), size()));
         bb |= transform.mapRect(clipRect);
     }
     return bb;
 }
 
 QSizeF KoPathShape::size() const
 {
     // don't call boundingRect here as it uses absoluteTransformation
     // which itself uses size() -> leads to infinite recursion
     return outlineRect().size();
 }
 
 void KoPathShape::setSize(const QSizeF &newSize)
 {
     QTransform matrix(resizeMatrix(newSize));
 
     KoShape::setSize(newSize);
     d->map(matrix);
 }
 
 QTransform KoPathShape::resizeMatrix(const QSizeF & newSize) const
 {
     QSizeF oldSize = size();
     if (oldSize.width() == 0.0) {
         oldSize.setWidth(0.000001);
     }
     if (oldSize.height() == 0.0) {
         oldSize.setHeight(0.000001);
     }
 
     QSizeF sizeNew(newSize);
     if (sizeNew.width() == 0.0) {
         sizeNew.setWidth(0.000001);
     }
     if (sizeNew.height() == 0.0) {
         sizeNew.setHeight(0.000001);
     }
 
     return QTransform(sizeNew.width() / oldSize.width(), 0, 0, sizeNew.height() / oldSize.height(), 0, 0);
 }
 
 KoPathPoint * KoPathShape::moveTo(const QPointF &p)
 {
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StartSubpath | KoPathPoint::StopSubpath);
     KoSubpath * path = new KoSubpath;
     path->push_back(point);
     d->subpaths.push_back(path);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::lineTo(const QPointF &p)
 {
     if (d->subpaths.empty()) {
         moveTo(QPointF(0, 0));
     }
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     updateLastPriv(&lastPoint);
     d->subpaths.last()->push_back(point);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::curveTo(const QPointF &c1, const QPointF &c2, const QPointF &p)
 {
     if (d->subpaths.empty()) {
         moveTo(QPointF(0, 0));
     }
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     updateLastPriv(&lastPoint);
     lastPoint->setControlPoint2(c1);
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
     point->setControlPoint1(c2);
     d->subpaths.last()->push_back(point);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::curveTo(const QPointF &c, const QPointF &p)
 {
     if (d->subpaths.empty())
         moveTo(QPointF(0, 0));
 
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     updateLastPriv(&lastPoint);
     lastPoint->setControlPoint2(c);
     KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
     d->subpaths.last()->push_back(point);
     notifyPointsChanged();
     return point;
 }
 
 KoPathPoint * KoPathShape::arcTo(qreal rx, qreal ry, qreal startAngle, qreal sweepAngle)
 {
     if (d->subpaths.empty()) {
         moveTo(QPointF(0, 0));
     }
 
     KoPathPoint * lastPoint = d->subpaths.last()->last();
     if (lastPoint->properties() & KoPathPoint::CloseSubpath) {
         lastPoint = d->subpaths.last()->first();
     }
     QPointF startpoint(lastPoint->point());
 
     KoPathPoint * newEndPoint = lastPoint;
 
     QPointF curvePoints[12];
     int pointCnt = arcToCurve(rx, ry, startAngle, sweepAngle, startpoint, curvePoints);
     for (int i = 0; i < pointCnt; i += 3) {
         newEndPoint = curveTo(curvePoints[i], curvePoints[i+1], curvePoints[i+2]);
     }
     return newEndPoint;
 }
 
 int KoPathShape::arcToCurve(qreal rx, qreal ry, qreal startAngle, qreal sweepAngle, const QPointF & offset, QPointF * curvePoints) const
 {
     int pointCnt = 0;
 
     // check Parameters
     if (sweepAngle == 0.0)
         return pointCnt;
 
     sweepAngle = qBound(-360.0, sweepAngle, 360.0);
 
     if (rx == 0 || ry == 0) {
         //TODO
     }
 
     // split angles bigger than 90° so that it gives a good approximation to the circle
     qreal parts = ceil(qAbs(sweepAngle / 90.0));
 
     qreal sa_rad = startAngle * M_PI / 180.0;
     qreal partangle = sweepAngle / parts;
     qreal endangle = startAngle + partangle;
     qreal se_rad = endangle * M_PI / 180.0;
     qreal sinsa = sin(sa_rad);
     qreal cossa = cos(sa_rad);
     qreal kappa = 4.0 / 3.0 * tan((se_rad - sa_rad) / 4);
 
     // startpoint is at the last point is the path but when it is closed
     // it is at the first point
     QPointF startpoint(offset);
 
     //center berechnen
     QPointF center(startpoint - QPointF(cossa * rx, -sinsa * ry));
 
     //debugFlake <<"kappa" << kappa <<"parts" << parts;
 
     for (int part = 0; part < parts; ++part) {
         // start tangent
         curvePoints[pointCnt++] = QPointF(startpoint - QPointF(sinsa * rx * kappa, cossa * ry * kappa));
 
         qreal sinse = sin(se_rad);
         qreal cosse = cos(se_rad);
 
         // end point
         QPointF endpoint(center + QPointF(cosse * rx, -sinse * ry));
         // end tangent
         curvePoints[pointCnt++] = QPointF(endpoint - QPointF(-sinse * rx * kappa, -cosse * ry * kappa));
         curvePoints[pointCnt++] = endpoint;
 
         // set the endpoint as next start point
         startpoint = endpoint;
         sinsa = sinse;
         cossa = cosse;
         endangle += partangle;
         se_rad = endangle * M_PI / 180.0;
     }
 
     return pointCnt;
 }
 
 void KoPathShape::close()
 {
     if (d->subpaths.empty()) {
         return;
     }
     closeSubpathPriv(d->subpaths.last());
 }
 
 void KoPathShape::closeMerge()
 {
     if (d->subpaths.empty()) {
         return;
     }
     closeMergeSubpathPriv(d->subpaths.last());
 }
 
 QPointF KoPathShape::normalize()
 {
     QPointF tl(outline().boundingRect().topLeft());
     QTransform matrix;
     matrix.translate(-tl.x(), -tl.y());
     d->map(matrix);
 
     // keep the top left point of the object
     applyTransformation(matrix.inverted());
     shapeChangedPriv(ContentChanged);
     return tl;
 }
 
 void KoPathShape::Private::map(const QTransform &matrix)
 {
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             // It's possible there are null points in the map...
             if (*it) {
                 (*it)->map(matrix);
             }
         }
     }
 }
 
 void KoPathShape::updateLastPriv(KoPathPoint **lastPoint)
 {
     // check if we are about to add a new point to a closed subpath
     if ((*lastPoint)->properties() & KoPathPoint::StopSubpath
             && (*lastPoint)->properties() & KoPathPoint::CloseSubpath) {
         // get the first point of the subpath
         KoPathPoint *subpathStart = d->subpaths.last()->first();
         // clone the first point of the subpath...
         KoPathPoint * newLastPoint = new KoPathPoint(*subpathStart, this);
         // ... and make it a normal point
         newLastPoint->setProperties(KoPathPoint::Normal);
         // now start a new subpath with the cloned start point
         KoSubpath *path = new KoSubpath;
         path->push_back(newLastPoint);
         d->subpaths.push_back(path);
         *lastPoint = newLastPoint;
     } else {
         // the subpath was not closed so the formerly last point
         // of the subpath is no end point anymore
         (*lastPoint)->unsetProperty(KoPathPoint::StopSubpath);
     }
     (*lastPoint)->unsetProperty(KoPathPoint::CloseSubpath);
 }
 
 QList<KoPathPoint*> KoPathShape::pointsAt(const QRectF &r) const
 {
     QList<KoPathPoint*> result;
 
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             if (r.contains((*it)->point()))
                 result.append(*it);
             else if ((*it)->activeControlPoint1() && r.contains((*it)->controlPoint1()))
                 result.append(*it);
             else if ((*it)->activeControlPoint2() && r.contains((*it)->controlPoint2()))
                 result.append(*it);
         }
     }
     return result;
 }
 
 QList<KoPathSegment> KoPathShape::segmentsAt(const QRectF &r) const
 {
     QList<KoPathSegment> segments;
     int subpathCount = d->subpaths.count();
     for (int subpathIndex = 0; subpathIndex < subpathCount; ++subpathIndex) {
         KoSubpath * subpath = d->subpaths[subpathIndex];
         int pointCount = subpath->count();
         bool subpathClosed = isClosedSubpath(subpathIndex);
         for (int pointIndex = 0; pointIndex < pointCount; ++pointIndex) {
             if (pointIndex == (pointCount - 1) && ! subpathClosed)
                 break;
             KoPathSegment s(subpath->at(pointIndex), subpath->at((pointIndex + 1) % pointCount));
             QRectF controlRect = s.controlPointRect();
             if (! r.intersects(controlRect) && ! controlRect.contains(r))
                 continue;
             QRectF bound = s.boundingRect();
             if (! r.intersects(bound) && ! bound.contains(r))
                 continue;
 
             segments.append(s);
         }
     }
     return segments;
 }
 
 KoPathPointIndex KoPathShape::pathPointIndex(const KoPathPoint *point) const
 {
     for (int subpathIndex = 0; subpathIndex < d->subpaths.size(); ++subpathIndex) {
         KoSubpath * subpath = d->subpaths.at(subpathIndex);
         for (int pointPos = 0; pointPos < subpath->size(); ++pointPos) {
             if (subpath->at(pointPos) == point) {
                 return KoPathPointIndex(subpathIndex, pointPos);
             }
         }
     }
     return KoPathPointIndex(-1, -1);
 }
 
 KoPathPoint * KoPathShape::pointByIndex(const KoPathPointIndex &pointIndex) const
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath == 0 || pointIndex.second < 0 || pointIndex.second >= subpath->size())
         return 0;
 
     return subpath->at(pointIndex.second);
 }
 
 KoPathSegment KoPathShape::segmentByIndex(const KoPathPointIndex &pointIndex) const
 {
     KoPathSegment segment(0, 0);
 
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath != 0 && pointIndex.second >= 0 && pointIndex.second < subpath->size()) {
         KoPathPoint * point = subpath->at(pointIndex.second);
         int index = pointIndex.second;
         // check if we have a (closing) segment starting from the last point
         if ((index == subpath->size() - 1) && point->properties() & KoPathPoint::CloseSubpath)
             index = 0;
         else
             ++index;
 
         if (index < subpath->size()) {
             segment = KoPathSegment(point, subpath->at(index));
         }
     }
     return segment;
 }
 
 int KoPathShape::pointCount() const
 {
     int i = 0;
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         i += (*pathIt)->size();
     }
 
     return i;
 }
 
 int KoPathShape::subpathCount() const
 {
     return d->subpaths.count();
 }
 
 int KoPathShape::subpathPointCount(int subpathIndex) const
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath == 0)
         return -1;
 
     return subpath->size();
 }
 
 bool KoPathShape::isClosedSubpath(int subpathIndex) const
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath == 0)
         return false;
 
     const bool firstClosed = subpath->first()->properties() & KoPathPoint::CloseSubpath;
     const bool lastClosed = subpath->last()->properties() & KoPathPoint::CloseSubpath;
 
     return firstClosed && lastClosed;
 }
 
 bool KoPathShape::insertPoint(KoPathPoint* point, const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath == 0 || pointIndex.second < 0 || pointIndex.second > subpath->size())
         return false;
 
     KoPathPoint::PointProperties properties = point->properties();
     properties &= ~KoPathPoint::StartSubpath;
     properties &= ~KoPathPoint::StopSubpath;
     properties &= ~KoPathPoint::CloseSubpath;
     // check if new point starts subpath
     if (pointIndex.second == 0) {
         properties |= KoPathPoint::StartSubpath;
         // subpath was closed
         if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
             // keep the path closed
             properties |= KoPathPoint::CloseSubpath;
         }
         // old first point does not start the subpath anymore
         subpath->first()->unsetProperty(KoPathPoint::StartSubpath);
     }
     // check if new point stops subpath
     else if (pointIndex.second == subpath->size()) {
         properties |= KoPathPoint::StopSubpath;
         // subpath was closed
         if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
             // keep the path closed
             properties = properties | KoPathPoint::CloseSubpath;
         }
         // old last point does not end subpath anymore
         subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
     }
 
     point->setProperties(properties);
     point->setParent(this);
     subpath->insert(pointIndex.second , point);
     notifyPointsChanged();
 
     return true;
 }
 
 KoPathPoint * KoPathShape::removePoint(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (subpath == 0 || pointIndex.second < 0 || pointIndex.second >= subpath->size())
         return 0;
 
     KoPathPoint * point = subpath->takeAt(pointIndex.second);
     point->setParent(0);
 
     //don't do anything (not even crash), if there was only one point
     if (pointCount()==0) {
         return point;
     }
     // check if we removed the first point
     else if (pointIndex.second == 0) {
         // first point removed, set new StartSubpath
         subpath->first()->setProperty(KoPathPoint::StartSubpath);
         // check if path was closed
         if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
             // keep path closed
             subpath->first()->setProperty(KoPathPoint::CloseSubpath);
         }
     }
     // check if we removed the last point
     else if (pointIndex.second == subpath->size()) { // use size as point is already removed
         // last point removed, set new StopSubpath
         subpath->last()->setProperty(KoPathPoint::StopSubpath);
         // check if path was closed
         if (point->properties() & KoPathPoint::CloseSubpath) {
             // keep path closed
             subpath->last()->setProperty(KoPathPoint::CloseSubpath);
         }
     }
 
     notifyPointsChanged();
 
     return point;
 }
 
 bool KoPathShape::breakAfter(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (!subpath || pointIndex.second < 0 || pointIndex.second > subpath->size() - 2
-        || isClosedSubpath(pointIndex.first))
+            || isClosedSubpath(pointIndex.first))
         return false;
 
     KoSubpath * newSubpath = new KoSubpath;
 
     int size = subpath->size();
     for (int i = pointIndex.second + 1; i < size; ++i) {
         newSubpath->append(subpath->takeAt(pointIndex.second + 1));
     }
     // now make the first point of the new subpath a starting node
     newSubpath->first()->setProperty(KoPathPoint::StartSubpath);
     // the last point of the old subpath is now an ending node
     subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
     // insert the new subpath after the broken one
     d->subpaths.insert(pointIndex.first + 1, newSubpath);
     notifyPointsChanged();
 
     return true;
 }
 
 bool KoPathShape::join(int subpathIndex)
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
     KoSubpath *nextSubpath = d->subPath(subpathIndex + 1);
 
     if (!subpath || !nextSubpath || isClosedSubpath(subpathIndex)
             || isClosedSubpath(subpathIndex+1))
         return false;
 
     // the last point of the subpath does not end the subpath anymore
     subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
     // the first point of the next subpath does not start a subpath anymore
     nextSubpath->first()->unsetProperty(KoPathPoint::StartSubpath);
 
     // append the second subpath to the first
     Q_FOREACH (KoPathPoint * p, *nextSubpath)
         subpath->append(p);
 
     // remove the nextSubpath from path
     d->subpaths.removeAt(subpathIndex + 1);
 
     // delete it as it is no longer possible to use it
     delete nextSubpath;
 
     notifyPointsChanged();
 
     return true;
 }
 
 bool KoPathShape::moveSubpath(int oldSubpathIndex, int newSubpathIndex)
 {
     KoSubpath *subpath = d->subPath(oldSubpathIndex);
 
     if (subpath == 0 || newSubpathIndex >= d->subpaths.size())
         return false;
 
     if (oldSubpathIndex == newSubpathIndex)
         return true;
 
     d->subpaths.removeAt(oldSubpathIndex);
     d->subpaths.insert(newSubpathIndex, subpath);
 
     notifyPointsChanged();
 
     return true;
 }
 
 KoPathPointIndex KoPathShape::openSubpath(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (!subpath || pointIndex.second < 0 || pointIndex.second >= subpath->size()
             || !isClosedSubpath(pointIndex.first))
         return KoPathPointIndex(-1, -1);
 
     KoPathPoint * oldStartPoint = subpath->first();
     // the old starting node no longer starts the subpath
     oldStartPoint->unsetProperty(KoPathPoint::StartSubpath);
     // the old end node no longer closes the subpath
     subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
 
     // reorder the subpath
     for (int i = 0; i < pointIndex.second; ++i) {
         subpath->append(subpath->takeFirst());
     }
     // make the first point a start node
     subpath->first()->setProperty(KoPathPoint::StartSubpath);
     // make the last point an end node
     subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
     notifyPointsChanged();
 
     return pathPointIndex(oldStartPoint);
 }
 
 KoPathPointIndex KoPathShape::closeSubpath(const KoPathPointIndex &pointIndex)
 {
     KoSubpath *subpath = d->subPath(pointIndex.first);
 
     if (!subpath || pointIndex.second < 0 || pointIndex.second >= subpath->size()
-        || isClosedSubpath(pointIndex.first))
+            || isClosedSubpath(pointIndex.first))
         return KoPathPointIndex(-1, -1);
 
     KoPathPoint * oldStartPoint = subpath->first();
     // the old starting node no longer starts the subpath
     oldStartPoint->unsetProperty(KoPathPoint::StartSubpath);
     // the old end node no longer ends the subpath
     subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
 
     // reorder the subpath
     for (int i = 0; i < pointIndex.second; ++i) {
         subpath->append(subpath->takeFirst());
     }
     subpath->first()->setProperty(KoPathPoint::StartSubpath);
     subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
     closeSubpathPriv(subpath);
 
     notifyPointsChanged();
 
     return pathPointIndex(oldStartPoint);
 }
 
 bool KoPathShape::reverseSubpath(int subpathIndex)
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath == 0)
         return false;
 
     int size = subpath->size();
     for (int i = 0; i < size; ++i) {
         KoPathPoint *p = subpath->takeAt(i);
         p->reverse();
         subpath->prepend(p);
     }
 
     // adjust the position dependent properties
     KoPathPoint *first = subpath->first();
     KoPathPoint *last = subpath->last();
 
     KoPathPoint::PointProperties firstProps = first->properties();
     KoPathPoint::PointProperties lastProps = last->properties();
 
     firstProps |= KoPathPoint::StartSubpath;
     firstProps &= ~KoPathPoint::StopSubpath;
     lastProps |= KoPathPoint::StopSubpath;
     lastProps &= ~KoPathPoint::StartSubpath;
     if (firstProps & KoPathPoint::CloseSubpath) {
         firstProps |= KoPathPoint::CloseSubpath;
         lastProps |= KoPathPoint::CloseSubpath;
     }
     first->setProperties(firstProps);
     last->setProperties(lastProps);
 
     notifyPointsChanged();
 
     return true;
 }
 
 KoSubpath * KoPathShape::removeSubpath(int subpathIndex)
 {
     KoSubpath *subpath = d->subPath(subpathIndex);
 
     if (subpath != 0) {
         Q_FOREACH (KoPathPoint* point, *subpath) {
             point->setParent(this);
         }
         d->subpaths.removeAt(subpathIndex);
     }
 
     notifyPointsChanged();
 
     return subpath;
 }
 
 bool KoPathShape::addSubpath(KoSubpath * subpath, int subpathIndex)
 {
     if (subpathIndex < 0 || subpathIndex > d->subpaths.size())
         return false;
 
     Q_FOREACH (KoPathPoint* point, *subpath) {
         point->setParent(this);
     }
 
     d->subpaths.insert(subpathIndex, subpath);
     notifyPointsChanged();
 
 
     return true;
 }
 int KoPathShape::combine(KoPathShape *path)
 {
     int insertSegmentPosition = -1;
     if (!path) return insertSegmentPosition;
 
     QTransform pathMatrix = path->absoluteTransformation(0);
     QTransform myMatrix = absoluteTransformation(0).inverted();
 
     Q_FOREACH (KoSubpath* subpath, path->d->subpaths) {
         KoSubpath *newSubpath = new KoSubpath();
 
         Q_FOREACH (KoPathPoint* point, *subpath) {
             KoPathPoint *newPoint = new KoPathPoint(*point, this);
             newPoint->map(pathMatrix);
             newPoint->map(myMatrix);
             newSubpath->append(newPoint);
         }
         d->subpaths.append(newSubpath);
 
         if (insertSegmentPosition < 0) {
             insertSegmentPosition = d->subpaths.size() - 1;
         }
     }
     normalize();
 
     notifyPointsChanged();
     return insertSegmentPosition;
 }
 
 bool KoPathShape::separate(QList<KoPathShape*> & separatedPaths)
 {
     if (! d->subpaths.size())
         return false;
 
     QTransform myMatrix = absoluteTransformation(0);
 
     Q_FOREACH (KoSubpath* subpath, d->subpaths) {
         KoPathShape *shape = new KoPathShape();
 
         shape->setStroke(stroke());
         shape->setBackground(background());
         shape->setShapeId(shapeId());
         shape->setZIndex(zIndex());
 
         KoSubpath *newSubpath = new KoSubpath();
 
         Q_FOREACH (KoPathPoint* point, *subpath) {
             KoPathPoint *newPoint = new KoPathPoint(*point, shape);
             newPoint->map(myMatrix);
             newSubpath->append(newPoint);
         }
         shape->d->subpaths.append(newSubpath);
         shape->normalize();
 
         // NOTE: shape cannot have any listeners yet, so no notification about
         //       points modification is needed
 
         separatedPaths.append(shape);
     }
     return true;
 }
 
 void KoPathShape::closeSubpathPriv(KoSubpath *subpath)
 {
     if (! subpath)
         return;
 
     subpath->last()->setProperty(KoPathPoint::CloseSubpath);
     subpath->first()->setProperty(KoPathPoint::CloseSubpath);
 
     notifyPointsChanged();
 }
 
 void KoPathShape::closeMergeSubpathPriv(KoSubpath *subpath)
 {
     if (! subpath || subpath->size() < 2)
         return;
 
     KoPathPoint * lastPoint = subpath->last();
     KoPathPoint * firstPoint = subpath->first();
 
     // check if first and last points are coincident
     if (lastPoint->point() == firstPoint->point()) {
         // we are removing the current last point and
         // reuse its first control point if active
         firstPoint->setProperty(KoPathPoint::StartSubpath);
         firstPoint->setProperty(KoPathPoint::CloseSubpath);
         if (lastPoint->activeControlPoint1())
             firstPoint->setControlPoint1(lastPoint->controlPoint1());
         // remove last point
         delete subpath->takeLast();
         // the new last point closes the subpath now
         lastPoint = subpath->last();
         lastPoint->setProperty(KoPathPoint::StopSubpath);
         lastPoint->setProperty(KoPathPoint::CloseSubpath);
 
         notifyPointsChanged();
     } else {
         closeSubpathPriv(subpath);
     }
 }
 
 const KoSubpathList &KoPathShape::subpaths() const
 {
     return d->subpaths;
 }
 
 KoSubpathList &KoPathShape::subpaths()
 {
     return d->subpaths;
 }
 
 void KoPathShape::map(const QTransform &matrix)
 {
     return d->map(matrix);
 }
 
 KoSubpath *KoPathShape::Private::subPath(int subpathIndex) const
 {
     if (subpathIndex < 0 || subpathIndex >= subpaths.size())
         return 0;
 
     return subpaths.at(subpathIndex);
 }
 
 QString KoPathShape::pathShapeId() const
 {
     return KoPathShapeId;
 }
 
 QString KoPathShape::toString(const QTransform &matrix) const
 {
     QString pathString;
 
     // iterate over all subpaths
     KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
     for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator pointIt((*pathIt)->constBegin());
         // keep a pointer to the first point of the subpath
         KoPathPoint *firstPoint(*pointIt);
         // keep a pointer to the previous point of the subpath
         KoPathPoint *lastPoint = firstPoint;
         // keep track if the previous point has an active control point 2
         bool activeControlPoint2 = false;
 
         // iterate over all points of the current subpath
         for (; pointIt != (*pathIt)->constEnd(); ++pointIt) {
             KoPathPoint *currPoint(*pointIt);
             if (!currPoint) {
                 qWarning() << "Found a zero point in the shape's path!";
                 continue;
             }
             // first point of subpath ?
             if (currPoint == firstPoint) {
                 // are we starting a subpath ?
                 if (currPoint->properties() & KoPathPoint::StartSubpath) {
                     const QPointF p = matrix.map(currPoint->point());
                     pathString += QString("M%1 %2").arg(p.x()).arg(p.y());
                 }
             }
             // end point of curve segment ?
             else if (activeControlPoint2 || currPoint->activeControlPoint1()) {
                 // check if we have a cubic or quadratic curve
                 const bool isCubic = activeControlPoint2 && currPoint->activeControlPoint1();
                 KoPathSegment cubicSeg = isCubic ? KoPathSegment(lastPoint, currPoint)
                                                  : KoPathSegment(lastPoint, currPoint).toCubic();
-                const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
-                const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
-                const QPointF p = matrix.map(cubicSeg.second()->point());
-                pathString += QString("C%1 %2 %3 %4 %5 %6")
-                     .arg(cp1.x()).arg(cp1.y())
-                     .arg(cp2.x()).arg(cp2.y())
-                     .arg(p.x()).arg(p.y());
+                if (cubicSeg.first()  && cubicSeg.second()) {
+                    const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
+                    const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
+                    const QPointF p = matrix.map(cubicSeg.second()->point());
+                    pathString += QString("C%1 %2 %3 %4 %5 %6")
+                            .arg(cp1.x()).arg(cp1.y())
+                            .arg(cp2.x()).arg(cp2.y())
+                            .arg(p.x()).arg(p.y());
+                }
             }
             // end point of line segment!
             else {
                 const QPointF p = matrix.map(currPoint->point());
                 pathString += QString("L%1 %2").arg(p.x()).arg(p.y());
             }
             // last point closes subpath ?
             if (currPoint->properties() & KoPathPoint::StopSubpath
                     && currPoint->properties() & KoPathPoint::CloseSubpath) {
                 // add curve when there is a curve on the way to the first point
                 if (currPoint->activeControlPoint2() || firstPoint->activeControlPoint1()) {
                     // check if we have a cubic or quadratic curve
                     const bool isCubic = currPoint->activeControlPoint2() && firstPoint->activeControlPoint1();
                     KoPathSegment cubicSeg = isCubic ? KoPathSegment(currPoint, firstPoint)
                                                      : KoPathSegment(currPoint, firstPoint).toCubic();
-                    const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
-                    const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
-                    const QPointF p = matrix.map(cubicSeg.second()->point());
-                    pathString += QString("C%1 %2 %3 %4 %5 %6")
-                         .arg(cp1.x()).arg(cp1.y())
-                         .arg(cp2.x()).arg(cp2.y())
-                         .arg(p.x()).arg(p.y());
+                    if (cubicSeg.first()  && cubicSeg.second()) {
+                        const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
+                        const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
+
+                        const QPointF p = matrix.map(cubicSeg.second()->point());
+                        pathString += QString("C%1 %2 %3 %4 %5 %6")
+                                .arg(cp1.x()).arg(cp1.y())
+                                .arg(cp2.x()).arg(cp2.y())
+                                .arg(p.x()).arg(p.y());
+                    }
                 }
                 pathString += QString("Z");
             }
 
             activeControlPoint2 = currPoint->activeControlPoint2();
             lastPoint = currPoint;
         }
     }
 
     return pathString;
 }
 
 char nodeType(const KoPathPoint * point)
 {
     if (point->properties() & KoPathPoint::IsSmooth) {
         return 's';
     }
     else if (point->properties() & KoPathPoint::IsSymmetric) {
         return 'z';
     }
     else {
         return 'c';
     }
 }
 
 QString KoPathShape::Private::nodeTypes() const
 {
     QString types;
     KoSubpathList::const_iterator pathIt(subpaths.constBegin());
     for (; pathIt != subpaths.constEnd(); ++pathIt) {
         KoSubpath::const_iterator it((*pathIt)->constBegin());
         for (; it != (*pathIt)->constEnd(); ++it) {
             if (it == (*pathIt)->constBegin()) {
                 types.append('c');
             }
             else {
                 types.append(nodeType(*it));
             }
 
             if ((*it)->properties() & KoPathPoint::StopSubpath
-                && (*it)->properties() & KoPathPoint::CloseSubpath) {
+                    && (*it)->properties() & KoPathPoint::CloseSubpath) {
                 KoPathPoint * firstPoint = (*pathIt)->first();
                 types.append(nodeType(firstPoint));
             }
         }
     }
     return types;
 }
 
 void updateNodeType(KoPathPoint * point, const QChar & nodeType)
 {
     if (nodeType == 's') {
         point->setProperty(KoPathPoint::IsSmooth);
     }
     else if (nodeType == 'z') {
         point->setProperty(KoPathPoint::IsSymmetric);
     }
 }
 
 void KoPathShape::Private::loadNodeTypes(const KoXmlElement &element)
 {
     if (element.hasAttributeNS(KoXmlNS::calligra, "nodeTypes")) {
         QString nodeTypes = element.attributeNS(KoXmlNS::calligra, "nodeTypes");
         QString::const_iterator nIt(nodeTypes.constBegin());
         KoSubpathList::const_iterator pathIt(subpaths.constBegin());
         for (; pathIt != subpaths.constEnd(); ++pathIt) {
             KoSubpath::const_iterator it((*pathIt)->constBegin());
             for (; it != (*pathIt)->constEnd(); ++it, nIt++) {
                 // be sure not to crash if there are not enough nodes in nodeTypes
                 if (nIt == nodeTypes.constEnd()) {
                     warnFlake << "not enough nodes in calligra:nodeTypes";
                     return;
                 }
                 // the first node is always of type 'c'
                 if (it != (*pathIt)->constBegin()) {
                     updateNodeType(*it, *nIt);
                 }
 
                 if ((*it)->properties() & KoPathPoint::StopSubpath
-                    && (*it)->properties() & KoPathPoint::CloseSubpath) {
+                        && (*it)->properties() & KoPathPoint::CloseSubpath) {
                     ++nIt;
                     updateNodeType((*pathIt)->first(), *nIt);
                 }
             }
         }
     }
 }
 
 Qt::FillRule KoPathShape::fillRule() const
 {
     return d->fillRule;
 }
 
 void KoPathShape::setFillRule(Qt::FillRule fillRule)
 {
     d->fillRule = fillRule;
 }
 
 KoPathShape * KoPathShape::createShapeFromPainterPath(const QPainterPath &path)
 {
     KoPathShape * shape = new KoPathShape();
 
     int elementCount = path.elementCount();
     for (int i = 0; i < elementCount; i++) {
         QPainterPath::Element element = path.elementAt(i);
         switch (element.type) {
         case QPainterPath::MoveToElement:
             shape->moveTo(QPointF(element.x, element.y));
             break;
         case QPainterPath::LineToElement:
             shape->lineTo(QPointF(element.x, element.y));
             break;
         case QPainterPath::CurveToElement:
             shape->curveTo(QPointF(element.x, element.y),
                            QPointF(path.elementAt(i + 1).x, path.elementAt(i + 1).y),
                            QPointF(path.elementAt(i + 2).x, path.elementAt(i + 2).y));
             break;
         default:
             continue;
         }
     }
 
     shape->setShapeId(KoPathShapeId);
 
     //shape->normalize();
     return shape;
 }
 
 bool KoPathShape::hitTest(const QPointF &position) const
 {
     if (parent() && parent()->isClipped(this) && ! parent()->hitTest(position))
         return false;
 
     QPointF point = absoluteTransformation(0).inverted().map(position);
     const QPainterPath outlinePath = outline();
     if (stroke()) {
         KoInsets insets;
         stroke()->strokeInsets(this, insets);
         QRectF roi(QPointF(-insets.left, -insets.top), QPointF(insets.right, insets.bottom));
 
         roi.moveCenter(point);
         if (outlinePath.intersects(roi) || outlinePath.contains(roi))
             return true;
     } else {
         if (outlinePath.contains(point))
             return true;
     }
 
     // if there is no shadow we can as well just leave
     if (! shadow())
         return false;
 
     // the shadow has an offset to the shape, so we simply
     // check if the position minus the shadow offset hits the shape
     point = absoluteTransformation(0).inverted().map(position - shadow()->offset());
 
     return outlinePath.contains(point);
 }
 
 void KoPathShape::setMarker(KoMarker *marker, KoFlake::MarkerPosition pos)
 {
     if (!marker && d->markersNew.contains(pos)) {
         d->markersNew.remove(pos);
     } else {
         d->markersNew[pos] = marker;
     }
 }
 
 KoMarker *KoPathShape::marker(KoFlake::MarkerPosition pos) const
 {
     return d->markersNew[pos].data();
 }
 
 bool KoPathShape::hasMarkers() const
 {
     return !d->markersNew.isEmpty();
 }
 
 bool KoPathShape::autoFillMarkers() const
 {
     return d->autoFillMarkers;
 }
 
 void KoPathShape::setAutoFillMarkers(bool value)
 {
     d->autoFillMarkers = value;
 }
 
 void KoPathShape::recommendPointSelectionChange(const QList<KoPathPointIndex> &newSelection)
 {
     Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
         PointSelectionChangeListener *pointListener = dynamic_cast<PointSelectionChangeListener*>(listener);
         if (pointListener) {
             pointListener->recommendPointSelectionChange(this, newSelection);
         }
     }
 }
 
 void KoPathShape::notifyPointsChanged()
 {
     Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
         PointSelectionChangeListener *pointListener = dynamic_cast<PointSelectionChangeListener*>(listener);
         if (pointListener) {
             pointListener->notifyPathPointsChanged(this);
         }
     }
 }
 
 QPainterPath KoPathShape::pathStroke(const QPen &pen) const
 {
     if (d->subpaths.isEmpty()) {
         return QPainterPath();
     }
     QPainterPath pathOutline;
 
     QPainterPathStroker stroker;
     stroker.setWidth(0);
     stroker.setJoinStyle(Qt::MiterJoin);
     stroker.setWidth(pen.widthF());
     stroker.setJoinStyle(pen.joinStyle());
     stroker.setMiterLimit(pen.miterLimit());
     stroker.setCapStyle(pen.capStyle());
     stroker.setDashOffset(pen.dashOffset());
     stroker.setDashPattern(pen.dashPattern());
 
     QPainterPath path = stroker.createStroke(outline());
 
     pathOutline.addPath(path);
     pathOutline.setFillRule(Qt::WindingFill);
 
     return pathOutline;
 }
 
 void KoPathShape::PointSelectionChangeListener::notifyShapeChanged(KoShape::ChangeType type, KoShape *shape)
 {
     Q_UNUSED(type);
     Q_UNUSED(shape);
 }
diff --git a/libs/global/kis_assert.h b/libs/global/kis_assert.h
index c37a383a80..c0047ef3f6 100644
--- a/libs/global/kis_assert.h
+++ b/libs/global/kis_assert.h
@@ -1,143 +1,143 @@
 /*
  *  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_ASSERT_H
 #define __KIS_ASSERT_H
 
 #include <QtGlobal>
 #include <kritaglobal_export.h>
 
 KRITAGLOBAL_EXPORT void kis_assert_exception(const char *assertion, const char *file, int line);
 KRITAGLOBAL_EXPORT void kis_assert_recoverable(const char *assertion, const char *file, int line);
 KRITAGLOBAL_EXPORT void kis_assert_x_exception(const char *assertion, const char *where, const char *what, const char *file, int line);
 
 KRITAGLOBAL_EXPORT void kis_safe_assert_recoverable(const char *assertion, const char *file, int line);
 
 
 /**
  * KIS_ASSERT family of macros allows the user to choose whether to
  * try to continue working in Krita or to abort an application and see
  * a backtrace.
  *
  * Note, the macro are present in Release mode by default!
  */
 
 /**
  * Checks the condition and depending on the user action either aborts
  * the program or throws an exception, which restarts event loop.
  */
 #define KIS_ASSERT(cond) ((!(cond)) ? kis_assert_exception(#cond,__FILE__,__LINE__) : qt_noop())
 
 /**
  * Same as KIS_ASSERT, but allows to show more text to the user.
  *
  * \see KIS_ASSERT
  */
 #define KIS_ASSERT_X(cond, where, what) ((!(cond)) ? kis_assert_x_exception(#cond,where, what,__FILE__,__LINE__) : qt_noop())
 
 
 /**
  * This is a recoverable variant of KIS_ASSERT. It doesn't throw any
  * exceptions.  It checks the condition, and either aborts the
  * application, or executes user-supplied code. The typical usecase is
  * the following:
  *
  * int fooBar = ...;
  * KIS_ASSERT_RECOVER (fooBar > 0) {
  *     // the code which is executed in a case of emergency
  * }
  *
  */
 #define KIS_ASSERT_RECOVER(cond) if (!(cond) && (kis_assert_recoverable(#cond,__FILE__,__LINE__), true))
 
 /**
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     break;
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_BREAK(cond) KIS_ASSERT_RECOVER(cond) { break; }
+#define KIS_ASSERT_RECOVER_BREAK(cond) do { KIS_ASSERT_RECOVER(cond) { break; } } while (0)
 
 /**
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     return;
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_RETURN(cond) KIS_ASSERT_RECOVER(cond) { return; }
+#define KIS_ASSERT_RECOVER_RETURN(cond) do { KIS_ASSERT_RECOVER(cond) { return; } } while (0)
 
 /**
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     return val;
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_RETURN_VALUE(cond, val) KIS_ASSERT_RECOVER(cond) { return (val); }
+#define KIS_ASSERT_RECOVER_RETURN_VALUE(cond, val) do { KIS_ASSERT_RECOVER(cond) { return (val); } } while (0)
 
 /**
  * Does nothing in case of a failure. Just continues execution.
  *
  * Equivalent of the following:
  *
  * KIS_ASSERT_RECOVER(cond) {
  *     qt_noop();
  * }
  *
  */
-#define KIS_ASSERT_RECOVER_NOOP(cond) KIS_ASSERT_RECOVER(cond) { qt_noop(); }
+#define KIS_ASSERT_RECOVER_NOOP(cond) do { KIS_ASSERT_RECOVER(cond) { qt_noop(); } } while (0)
 
 
 /**
  * This set of macros work in exactly the same way as their non-safe
  * counterparts, but they are automatically converted into console
  * warnings in release builds. That is the user will not see any
  * message box, just a warning message will be printed in a terminal
  * and a recovery branch will be taken automatically.
  *
  * Rules when to use "safe" asserts. Use them if the following
  * conditions are met:
  *
  * 1) The condition in the assert shows that a real *bug* has
  *    happened. It is not just a warning. It is a bug that should be
  *    fixed.
  *
  * 2) The recovery branch will *workaround* the bug and the user will
  *    be able to continue his work *as if nothing has
  *    happened*. Again, please mark the assert "safe" if and only if
  *    you are 100% sure Krita will not crash in a minute after you
  *    faced that bug. The user is not notified about this bug, so he
  *    is not going to take any emergency steps like saving his work
  *    and restarting Krita!
  *
  * 3) If you think that Krita should be better restarted after this
  *    bug, please use a usual KIS_ASSERT_RECOVER.
  */
 
 #define KIS_SAFE_ASSERT_RECOVER(cond) if (!(cond) && (kis_safe_assert_recoverable(#cond,__FILE__,__LINE__), true))
-#define KIS_SAFE_ASSERT_RECOVER_BREAK(cond) KIS_SAFE_ASSERT_RECOVER(cond) { break; }
-#define KIS_SAFE_ASSERT_RECOVER_RETURN(cond) KIS_SAFE_ASSERT_RECOVER(cond) { return; }
-#define KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(cond, val) KIS_SAFE_ASSERT_RECOVER(cond) { return (val); }
-#define KIS_SAFE_ASSERT_RECOVER_NOOP(cond) KIS_SAFE_ASSERT_RECOVER(cond) { qt_noop(); }
+#define KIS_SAFE_ASSERT_RECOVER_BREAK(cond) do { KIS_SAFE_ASSERT_RECOVER(cond) { break; } } while (0)
+#define KIS_SAFE_ASSERT_RECOVER_RETURN(cond) do { KIS_SAFE_ASSERT_RECOVER(cond) { return; } } while (0)
+#define KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(cond, val) do { KIS_SAFE_ASSERT_RECOVER(cond) { return (val); } } while (0)
+#define KIS_SAFE_ASSERT_RECOVER_NOOP(cond) do { KIS_SAFE_ASSERT_RECOVER(cond) { qt_noop(); } } while (0)
 
 #endif /* __KIS_ASSERT_H */
diff --git a/libs/image/KisRecycleProjectionsJob.cpp b/libs/image/KisRecycleProjectionsJob.cpp
index c2041b0da8..0d46b0bdf9 100644
--- a/libs/image/KisRecycleProjectionsJob.cpp
+++ b/libs/image/KisRecycleProjectionsJob.cpp
@@ -1,48 +1,53 @@
 /*
  *  Copyright (c) 2019 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 "KisRecycleProjectionsJob.h"
 #include "KisSafeNodeProjectionStore.h"
 #include "kis_paint_device.h"
 
 KisRecycleProjectionsJob::KisRecycleProjectionsJob(KisSafeNodeProjectionStoreBaseWSP projectionStore)
     : m_projectionStore(projectionStore)
 {
     setExclusive(true);
 }
 
 bool KisRecycleProjectionsJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisRecycleProjectionsJob *otherJob =
         dynamic_cast<const KisRecycleProjectionsJob*>(_otherJob);
 
     return otherJob &&
         otherJob->m_projectionStore == m_projectionStore;
 }
 
 void KisRecycleProjectionsJob::run()
 {
     KisSafeNodeProjectionStoreBaseSP store = m_projectionStore;
     if (store) {
         store->recycleProjectionsInSafety();
     }
 }
 
 int KisRecycleProjectionsJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisRecycleProjectionsJob::debugName() const
+{
+    return "KisRecycleProjectionsJob";
+}
diff --git a/libs/image/KisRecycleProjectionsJob.h b/libs/image/KisRecycleProjectionsJob.h
index 85c2a03332..c0a88183cc 100644
--- a/libs/image/KisRecycleProjectionsJob.h
+++ b/libs/image/KisRecycleProjectionsJob.h
@@ -1,48 +1,50 @@
 /*
  *  Copyright (c) 2019 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 KISRECYCLEPROJECTIONSJOB_H
 #define KISRECYCLEPROJECTIONSJOB_H
 
 #include "kis_types.h"
 #include "kis_spontaneous_job.h"
 
 class QMutex;
 class KisSafeNodeProjectionStoreBase;
 typedef KisWeakSharedPtr<KisSafeNodeProjectionStoreBase> KisSafeNodeProjectionStoreBaseWSP;
 
 /**
  * This is a simple job for initiating recycling of KisLayer's
  * projections in an exclusive context. The problem is that the
  * projection might still be used by update workers after it
  * has been disabled. So this cleaning should run in an exclusive
  * context.
  */
 class KRITAIMAGE_EXPORT KisRecycleProjectionsJob : public KisSpontaneousJob
 {
 public:
     KisRecycleProjectionsJob(KisSafeNodeProjectionStoreBaseWSP projectionStore);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 private:
     KisSafeNodeProjectionStoreBaseWSP m_projectionStore;
 };
 
 #endif // KISRECYCLEPROJECTIONSJOB_H
diff --git a/libs/image/KisRunnableBasedStrokeStrategy.cpp b/libs/image/KisRunnableBasedStrokeStrategy.cpp
index 42e9f9b26d..53105f2da1 100644
--- a/libs/image/KisRunnableBasedStrokeStrategy.cpp
+++ b/libs/image/KisRunnableBasedStrokeStrategy.cpp
@@ -1,79 +1,79 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KisRunnableBasedStrokeStrategy.h"
 
 #include <QRunnable>
 #include <functional>
 
 #include "KisRunnableStrokeJobData.h"
 #include "KisRunnableStrokeJobsInterface.h"
 
 struct KisRunnableBasedStrokeStrategy::JobsInterface : public KisRunnableStrokeJobsInterface
 {
     JobsInterface(KisRunnableBasedStrokeStrategy *q)
         : m_q(q)
     {
     }
 
 
     void addRunnableJobs(const QVector<KisRunnableStrokeJobDataBase*> &list) {
         QVector<KisStrokeJobData*> newList;
 
         Q_FOREACH (KisRunnableStrokeJobDataBase *item, list) {
             newList.append(item);
         }
 
         m_q->addMutatedJobs(newList);
     }
 
 private:
     KisRunnableBasedStrokeStrategy *m_q;
 };
 
 
-KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(QString id, const KUndo2MagicString &name)
+KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name)
     : KisSimpleStrokeStrategy(id, name),
       m_jobsInterface(new JobsInterface(this))
 {
 }
 
 KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(const KisRunnableBasedStrokeStrategy &rhs)
     : KisSimpleStrokeStrategy(rhs),
       m_jobsInterface(new JobsInterface(this))
 {
 }
 
 KisRunnableBasedStrokeStrategy::~KisRunnableBasedStrokeStrategy()
 {
 }
 
 void KisRunnableBasedStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     if (!data) return;
 
     KisRunnableStrokeJobDataBase *runnable = dynamic_cast<KisRunnableStrokeJobDataBase*>(data);
     if (!runnable) return;
 
     runnable->run();
 }
 
 KisRunnableStrokeJobsInterface *KisRunnableBasedStrokeStrategy::runnableJobsInterface() const
 {
     return m_jobsInterface.data();
 }
diff --git a/libs/image/KisRunnableBasedStrokeStrategy.h b/libs/image/KisRunnableBasedStrokeStrategy.h
index 46cd031ae0..476ac466b1 100644
--- a/libs/image/KisRunnableBasedStrokeStrategy.h
+++ b/libs/image/KisRunnableBasedStrokeStrategy.h
@@ -1,44 +1,44 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KISRUNNABLEBASEDSTROKESTRATEGY_H
 #define KISRUNNABLEBASEDSTROKESTRATEGY_H
 
 #include "kis_simple_stroke_strategy.h"
 
 class KisRunnableStrokeJobsInterface;
 
 class KRITAIMAGE_EXPORT KisRunnableBasedStrokeStrategy : public KisSimpleStrokeStrategy
 {
 private:
     struct JobsInterface;
 
 public:
-    KisRunnableBasedStrokeStrategy(QString id, const KUndo2MagicString &name = KUndo2MagicString());
+    KisRunnableBasedStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name = KUndo2MagicString());
     KisRunnableBasedStrokeStrategy(const KisRunnableBasedStrokeStrategy &rhs);
     ~KisRunnableBasedStrokeStrategy();
 
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     KisRunnableStrokeJobsInterface *runnableJobsInterface() const;
 
 private:
     const QScopedPointer<KisRunnableStrokeJobsInterface> m_jobsInterface;
 };
 
 #endif // KISRUNNABLEBASEDSTROKESTRATEGY_H
diff --git a/libs/image/KisSafeNodeProjectionStore.cpp b/libs/image/KisSafeNodeProjectionStore.cpp
index 1c1677fb56..ee754419cf 100644
--- a/libs/image/KisSafeNodeProjectionStore.cpp
+++ b/libs/image/KisSafeNodeProjectionStore.cpp
@@ -1,284 +1,284 @@
 /*
  *  Copyright (c) 2019 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 "KisSafeNodeProjectionStore.h"
 
 #include <QCoreApplication>
 #include <QVector>
 #include <KoColorSpace.h>
 
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 #include "KisRecycleProjectionsJob.h"
 
 /**********************************************************************/
 /*     StoreImplementaionInterface                                    */
 /**********************************************************************/
 
 struct StoreImplementaionInterface
 {
     virtual ~StoreImplementaionInterface() {}
     virtual StoreImplementaionInterface* clone() const = 0;
     virtual bool releaseDevice() = 0;
     virtual void discardCaches() = 0;
     virtual void recycleProjectionsInSafety() = 0;
 };
 
 
 /**********************************************************************/
 /*     StoreImplementaion                                             */
 /**********************************************************************/
 
 template <typename DeviceSP>
 struct StoreImplementation : public StoreImplementaionInterface
 {
-    bool releaseDevice() {
+    bool releaseDevice() override {
         bool hasDeletedProjection = false;
 
         if (m_projection) {
             m_dirtyProjections.append(m_projection);
             m_projection = 0;
             hasDeletedProjection = true;
 
 //            qDebug() << "release a device";
         }
         return hasDeletedProjection;
     }
 
-    virtual void discardCaches() {
+    virtual void discardCaches() override {
 //        qDebug() << "discard caches";
         m_dirtyProjections.clear();
     }
 
-    virtual void recycleProjectionsInSafety() {
+    virtual void recycleProjectionsInSafety() override {
 //        qDebug() << "recycle caches";
         Q_FOREACH (DeviceSP projection, m_dirtyProjections) {
             projection->clear();
             m_cleanProjections.append(projection);
         }
         m_dirtyProjections.clear();
     }
 
 protected:
     DeviceSP m_projection;
     QVector<DeviceSP> m_dirtyProjections;
     QVector<DeviceSP> m_cleanProjections;
 };
 
 
 /**********************************************************************/
 /*     StoreImplementaionForDevice                                    */
 /**********************************************************************/
 
 struct StoreImplementationForDevice : StoreImplementation<KisPaintDeviceSP>
 {
     StoreImplementationForDevice() {}
     StoreImplementationForDevice(const KisPaintDevice &prototype) {
         m_projection = new KisPaintDevice(prototype);
     }
 
-    StoreImplementaionInterface* clone() const {
+    StoreImplementaionInterface* clone() const override {
         return m_projection ?
             new StoreImplementationForDevice(*m_projection) :
             new StoreImplementationForDevice();
     }
 
     KisPaintDeviceSP getDeviceLazy(KisPaintDeviceSP prototype) {
         if(!m_projection ||
            *m_projection->colorSpace() != *prototype->colorSpace()) {
 
             if (!m_cleanProjections.isEmpty()) {
                 m_projection = m_cleanProjections.takeLast();
                 m_projection->makeCloneFromRough(prototype, prototype->extent());
             } else {
                 m_projection = new KisPaintDevice(*prototype);
             }
 
             m_projection->setProjectionDevice(true);
         }
         return m_projection;
     }
 };
 
 
 /**********************************************************************/
 /*     StoreImplementaionForSelection                                 */
 /**********************************************************************/
 
 struct StoreImplementationForSelection : StoreImplementation<KisSelectionSP>
 {
     StoreImplementationForSelection() {}
     StoreImplementationForSelection(const KisSelection &prototype) {
         m_projection = new KisSelection(prototype);
     }
 
-    StoreImplementaionInterface* clone() const {
+    StoreImplementaionInterface* clone() const override {
         return m_projection ?
             new StoreImplementationForSelection(*m_projection) :
             new StoreImplementationForSelection();
     }
 
     KisSelectionSP getDeviceLazy(KisSelectionSP prototype) {
         if(!m_projection) {
             if (!m_cleanProjections.isEmpty()) {
                 m_projection = m_cleanProjections.takeLast();
                 m_projection->pixelSelection()->makeCloneFromRough(prototype->pixelSelection(), prototype->selectedRect());
             } else {
                 m_projection = new KisSelection(*prototype);
             }
 
             m_projection->pixelSelection()->setProjectionDevice(true);
         }
         return m_projection;
     }
 };
 
 
 /**********************************************************************/
 /*     KisSafeNodeProjectionStoreBase                                 */
 /**********************************************************************/
 
 struct KisSafeNodeProjectionStoreBase::Private
 {
     mutable QMutex lock;
     KisImageWSP image;
     QScopedPointer<StoreImplementaionInterface> store;
 };
 
 KisSafeNodeProjectionStoreBase::KisSafeNodeProjectionStoreBase(StoreImplementaionInterface *storeImpl)
     : m_d(new Private)
 {
     m_d->store.reset(storeImpl);
     moveToThread(qApp->thread());
     connect(this, SIGNAL(internalInitiateProjectionsCleanup()), this, SLOT(slotInitiateProjectionsCleanup()));
 }
 
 KisSafeNodeProjectionStoreBase::KisSafeNodeProjectionStoreBase(const KisSafeNodeProjectionStoreBase &rhs)
     : QObject(),
       KisShared(),
       m_d(new Private)
 {
     {
         QMutexLocker rhsLocker(&rhs.m_d->lock);
 
         m_d->image = rhs.m_d->image;
         m_d->store.reset(rhs.m_d->store->clone());
     }
 
     moveToThread(qApp->thread());
     connect(this, SIGNAL(internalInitiateProjectionsCleanup()), this, SLOT(slotInitiateProjectionsCleanup()));
 }
 
 KisSafeNodeProjectionStoreBase::~KisSafeNodeProjectionStoreBase()
 {
 }
 
 void KisSafeNodeProjectionStoreBase::releaseDevice()
 {
     QMutexLocker locker(&m_d->lock);
     if (m_d->store->releaseDevice()) {
         locker.unlock();
         emit internalInitiateProjectionsCleanup();
     }
 }
 
 void KisSafeNodeProjectionStoreBase::setImage(KisImageWSP image)
 {
     m_d->image = image;
 }
 
 void KisSafeNodeProjectionStoreBase::slotInitiateProjectionsCleanup()
 {
     /**
      * After the projection has been used, we should clean it. But we cannot
      * clean it until all the workers accessing it have completed their job.
      *
      * Therefore we just schedule an exclusive job that will execute the
      * recycling action in an exclusive context, when no jobs are running.
      */
 
     KisImageSP image = m_d->image;
 
     if (image) {
         image->addSpontaneousJob(new KisRecycleProjectionsJob(this));
     } else {
         discardCaches();
     }
 }
 
 void KisSafeNodeProjectionStoreBase::discardCaches()
 {
     QMutexLocker locker(&m_d->lock);
     m_d->store->discardCaches();
 }
 
 void KisSafeNodeProjectionStoreBase::recycleProjectionsInSafety()
 {
     QMutexLocker locker(&m_d->lock);
     m_d->store->recycleProjectionsInSafety();
 }
 
 
 /**********************************************************************/
 /*     KisSafeNodeProjectionStore                                     */
 /**********************************************************************/
 
 KisSafeNodeProjectionStore::KisSafeNodeProjectionStore()
     : KisSafeNodeProjectionStoreBase(new StoreImplementationForDevice)
 {
 }
 
 KisSafeNodeProjectionStore::KisSafeNodeProjectionStore(const KisSafeNodeProjectionStore &rhs)
     : KisSafeNodeProjectionStoreBase(rhs)
 {
 }
 
 KisPaintDeviceSP KisSafeNodeProjectionStore::getDeviceLazy(KisPaintDeviceSP prototype)
 {
     QMutexLocker locker(&m_d->lock);
     StoreImplementationForDevice *store = dynamic_cast<StoreImplementationForDevice*>(m_d->store.data());
     KIS_ASSERT(store);
 
     return store->getDeviceLazy(prototype);
 }
 
 
 /**********************************************************************/
 /*     KisSafeSelectionNodeProjectionStore                            */
 /**********************************************************************/
 
 KisSafeSelectionNodeProjectionStore::KisSafeSelectionNodeProjectionStore()
     : KisSafeNodeProjectionStoreBase(new StoreImplementationForSelection)
 {
 }
 
 KisSafeSelectionNodeProjectionStore::KisSafeSelectionNodeProjectionStore(const KisSafeSelectionNodeProjectionStore &rhs)
     : KisSafeNodeProjectionStoreBase(rhs)
 {
 }
 
 KisSelectionSP KisSafeSelectionNodeProjectionStore::getDeviceLazy(KisSelectionSP prototype)
 {
     QMutexLocker locker(&m_d->lock);
     StoreImplementationForSelection *store = dynamic_cast<StoreImplementationForSelection*>(m_d->store.data());
     KIS_ASSERT(store);
 
     return store->getDeviceLazy(prototype);
 }
 
diff --git a/libs/image/commands/kis_node_property_list_command.cpp b/libs/image/commands/kis_node_property_list_command.cpp
index 94d48a5c6f..66a4ad11d2 100644
--- a/libs/image/commands/kis_node_property_list_command.cpp
+++ b/libs/image/commands/kis_node_property_list_command.cpp
@@ -1,227 +1,228 @@
 /*
  *  Copyright (c) 2009 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 <klocalizedstring.h>
 #include "kis_node.h"
 #include "kis_layer.h"
 #include "kis_image.h"
 #include "kis_selection_mask.h"
 #include "kis_paint_layer.h"
 #include "commands/kis_node_property_list_command.h"
 #include "kis_undo_adapter.h"
 #include "kis_layer_properties_icons.h"
 
 // HACK! please refactor out!
 #include "kis_simple_stroke_strategy.h"
 
 
 KisNodePropertyListCommand::KisNodePropertyListCommand(KisNodeSP node, KisBaseNode::PropertyList newPropertyList)
     : KisNodeCommand(kundo2_i18n("Property Changes"), node),
       m_newPropertyList(newPropertyList),
       m_oldPropertyList(node->sectionModelProperties())
     /**
      * TODO instead of "Property Changes" check which property
      * has been changed and display either lock/unlock, visible/hidden
      * or "Property Changes" (this require new strings)
      */
 {
 }
 
 void KisNodePropertyListCommand::redo()
 {
     const KisBaseNode::PropertyList propsBefore = m_node->sectionModelProperties();
     const QRect oldExtent = m_node->extent();
     m_node->setSectionModelProperties(m_newPropertyList);
     doUpdate(propsBefore, m_node->sectionModelProperties(), oldExtent | m_node->extent());
 }
 
 void KisNodePropertyListCommand::undo()
 {
     const KisBaseNode::PropertyList propsBefore = m_node->sectionModelProperties();
     const QRect oldExtent = m_node->extent();
     m_node->setSectionModelProperties(m_oldPropertyList);
     doUpdate(propsBefore, m_node->sectionModelProperties(), oldExtent | m_node->extent());
 }
 
 bool checkOnionSkinChanged(const KisBaseNode::PropertyList &oldPropertyList,
                            const KisBaseNode::PropertyList &newPropertyList)
 {
     if (oldPropertyList.size() != newPropertyList.size()) return false;
 
     bool oldOnionSkinsValue = false;
     bool newOnionSkinsValue = false;
 
     Q_FOREACH (const KisBaseNode::Property &prop, oldPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::onionSkins.id()) {
             oldOnionSkinsValue = prop.state.toBool();
         }
     }
 
     Q_FOREACH (const KisBaseNode::Property &prop, newPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::onionSkins.id()) {
             newOnionSkinsValue = prop.state.toBool();
         }
     }
 
     return oldOnionSkinsValue != newOnionSkinsValue;
 }
 
 
 void KisNodePropertyListCommand::doUpdate(const KisBaseNode::PropertyList &oldPropertyList,
                                           const KisBaseNode::PropertyList &newPropertyList,
                                           const QRect &totalUpdateExtent)
 {
     /**
      * Sometimes the node might refuse to change the property, e.g. needs-update for colorize
      * mask. In this case we should avoid issuing the update and set-modified call.
      */
     if (oldPropertyList == newPropertyList) {
         return;
     }
 
     bool oldPassThroughValue = false;
     bool newPassThroughValue = false;
 
     bool oldVisibilityValue = false;
     bool newVisibilityValue = false;
 
     Q_FOREACH (const KisBaseNode::Property &prop, oldPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::passThrough.id()) {
             oldPassThroughValue = prop.state.toBool();
         }
         if (prop.id == KisLayerPropertiesIcons::visible.id()) {
             oldVisibilityValue = prop.state.toBool();
         }
     }
 
     Q_FOREACH (const KisBaseNode::Property &prop, newPropertyList) {
         if (prop.id == KisLayerPropertiesIcons::passThrough.id()) {
             newPassThroughValue = prop.state.toBool();
         }
         if (prop.id == KisLayerPropertiesIcons::visible.id()) {
             newVisibilityValue = prop.state.toBool();
         }
     }
 
     if (oldPassThroughValue && !newPassThroughValue) {
         KisLayerSP layer(qobject_cast<KisLayer*>(m_node.data()));
         KisImageSP image = layer->image().toStrongRef();
         if (image) {
             image->refreshGraphAsync(layer);
         }
     } else if ((m_node->parent() && !oldPassThroughValue && newPassThroughValue) ||
                (oldPassThroughValue && newPassThroughValue &&
                 !oldVisibilityValue && newVisibilityValue)) {
 
         KisLayerSP layer(qobject_cast<KisLayer*>(m_node->parent().data()));
         KisImageSP image = layer->image().toStrongRef();
         if (image) {
             image->refreshGraphAsync(layer);
         }
     } else if (checkOnionSkinChanged(oldPropertyList, newPropertyList)) {
         m_node->setDirtyDontResetAnimationCache(totalUpdateExtent);
     } else {
         m_node->setDirty(totalUpdateExtent); // TODO check if visibility was actually changed or not
     }
 }
 
 void KisNodePropertyListCommand::setNodePropertiesNoUndo(KisNodeSP node, KisImageSP image, PropertyList proplist)
 {
     QVector<bool> undo;
 
     Q_FOREACH (const KisBaseNode::Property &prop, proplist) {
 
         if (prop.isInStasis) undo << false;
 
         if (prop.name == i18n("Visible") && node->visible() != prop.state.toBool()) {
             undo << false;
             continue;
         }
         else if (prop.name == i18n("Locked") && node->userLocked() != prop.state.toBool()) {
             undo << false;
             continue;
         }
         else if (prop.name == i18n("Active")) {
             if (KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data())) {
                 if (m->active() != prop.state.toBool()) {
                     undo << false;
                     continue;
                 }
             }
         }
         else if (prop.name == i18n("Alpha Locked")) {
             if (KisPaintLayer* l = dynamic_cast<KisPaintLayer*>(node.data())) {
                 if (l->alphaLocked() != prop.state.toBool()) {
                     undo << false;
                     continue;
                 }
             }
         }
 
         // This property is known, but it hasn't got the same value, and it isn't one of
         // the previous properties, so we need to add the command to the undo list.
         Q_FOREACH(const KisBaseNode::Property &p2, node->sectionModelProperties()) {
             if (p2.name == prop.name && p2.state != prop.state) {
                 undo << true;
                 break;
             }
         }
 
 
     }
 
     QScopedPointer<KUndo2Command> cmd(new KisNodePropertyListCommand(node, proplist));
 
     image->setModified();
 
     if (undo.contains(true)) {
         image->undoAdapter()->addCommand(cmd.take());
     }
     else {
         /**
          * HACK ALERT!
          *
          * Here we start a fake legacy stroke, so that all the LoD planes would
          * be invalidated. Ideally, we should refactor this method and avoid
          * resetting LoD planes when node visibility changes, Instead there should
          * be two commands executes: LoD agnostic one (which sets the properties
          * themselves), and two LoD-specific update commands: one for lodN and
          * another one for lod0.
          */
 
         struct SimpleLodResettingStroke : public KisSimpleStrokeStrategy {
             SimpleLodResettingStroke(KUndo2Command *cmd)
-                : m_cmd(cmd)
+                : KisSimpleStrokeStrategy(QLatin1String("SimpleLodResettingStroke")),
+                  m_cmd(cmd)
             {
                 setClearsRedoOnStart(false);
                 this->enableJob(JOB_INIT, true);
             }
 
             void initStrokeCallback() {
                 m_cmd->redo();
             }
 
         private:
             QScopedPointer<KUndo2Command> m_cmd;
         };
 
         KisStrokeId strokeId = image->startStroke(new SimpleLodResettingStroke(cmd.take()));
         image->endStroke(strokeId);
     }
 
 }
diff --git a/libs/image/commands_new/kis_saved_commands.cpp b/libs/image/commands_new/kis_saved_commands.cpp
index b6e04b57a5..3308ed5765 100644
--- a/libs/image/commands_new/kis_saved_commands.cpp
+++ b/libs/image/commands_new/kis_saved_commands.cpp
@@ -1,317 +1,319 @@
 /*
  *  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_saved_commands.h"
 
 #include <QVector>
 
 #include "kis_image_interfaces.h"
 #include "kis_stroke_strategy_undo_command_based.h"
 
 
 KisSavedCommandBase::KisSavedCommandBase(const KUndo2MagicString &name,
                                          KisStrokesFacade *strokesFacade)
     : KUndo2Command(name),
       m_strokesFacade(strokesFacade),
       m_skipOneRedo(true)
 {
 }
 
 KisSavedCommandBase::~KisSavedCommandBase()
 {
 }
 
 KisStrokesFacade* KisSavedCommandBase::strokesFacade()
 {
     return m_strokesFacade;
 }
 
 void KisSavedCommandBase::runStroke(bool undo)
 {
     KisStrokeStrategyUndoCommandBased *strategy =
         new KisStrokeStrategyUndoCommandBased(text(), undo, 0);
     strategy->setUsedWhileUndoRedo(true);
 
     KisStrokeId id = m_strokesFacade->startStroke(strategy);
     addCommands(id, undo);
     m_strokesFacade->endStroke(id);
 }
 
 void KisSavedCommandBase::undo()
 {
 
     runStroke(true);
 }
 
 
 
 void KisSavedCommandBase::redo()
 {
     /**
      * All the commands are first executed in the stroke and then
      * added to the undo stack. It means that the first redo should be
      * skipped
      */
 
     if(m_skipOneRedo) {
         m_skipOneRedo = false;
         return;
     }
 
     runStroke(false);
 }
 
 
 KisSavedCommand::KisSavedCommand(KUndo2CommandSP command,
                                  KisStrokesFacade *strokesFacade)
     : KisSavedCommandBase(command->text(), strokesFacade),
       m_command(command)
 {
 }
 
 int KisSavedCommand::id() const
 {
     return m_command->id();
 }
 
 bool KisSavedCommand::mergeWith(const KUndo2Command* command)
 {
     const KisSavedCommand *other =
         dynamic_cast<const KisSavedCommand*>(command);
 
     if (other) {
         command = other->m_command.data();
     }
 
     return m_command->mergeWith(command);
 }
 
 void KisSavedCommand::addCommands(KisStrokeId id, bool undo)
 {
     strokesFacade()->
         addJob(id, new KisStrokeStrategyUndoCommandBased::Data(m_command, undo));
 }
 int KisSavedCommand::timedId()
 {
     return m_command->timedId();
 }
 void KisSavedCommand::setTimedID(int timedID)
 {
     m_command->setTimedID(timedID);
 }
 
 bool KisSavedCommand::timedMergeWith(KUndo2Command *other)
 {
     return m_command->timedMergeWith(other);
 }
 QVector<KUndo2Command*> KisSavedCommand::mergeCommandsVector()
 {
     return m_command->mergeCommandsVector();
 }
 void KisSavedCommand::setTime()
 {
     m_command->setTime();
 }
 
 QTime KisSavedCommand::time()
 {
     return m_command->time();
 }
 void KisSavedCommand::setEndTime()
 {
     m_command->setEndTime();
 }
 
 QTime KisSavedCommand::endTime()
 {
     return m_command->endTime();
 }
 bool KisSavedCommand::isMerged()
 {
     return m_command->isMerged();
 }
 
 
 
 struct KisSavedMacroCommand::Private
 {
     struct SavedCommand {
         KUndo2CommandSP command;
         KisStrokeJobData::Sequentiality sequentiality;
         KisStrokeJobData::Exclusivity exclusivity;
     };
 
     QVector<SavedCommand> commands;
     int macroId = -1;
 
     const KisSavedMacroCommand *overriddenCommand = 0;
     QVector<const KUndo2Command*> skipWhenOverride;
 };
 
 KisSavedMacroCommand::KisSavedMacroCommand(const KUndo2MagicString &name,
                                            KisStrokesFacade *strokesFacade)
     : KisSavedCommandBase(name, strokesFacade),
       m_d(new Private())
 {
 }
 
 KisSavedMacroCommand::~KisSavedMacroCommand()
 {
     delete m_d;
 }
 
 void KisSavedMacroCommand::setMacroId(int value)
 {
     m_d->macroId = value;
 }
 
 int KisSavedMacroCommand::id() const
 {
     return m_d->macroId;
 }
 
 bool KisSavedMacroCommand::mergeWith(const KUndo2Command* command)
 {
     const KisSavedMacroCommand *other =
         dynamic_cast<const KisSavedMacroCommand*>(command);
 
     if (!other || other->id() != id() || id() < 0 || other->id() < 0) return false;
 
     QVector<Private::SavedCommand> &otherCommands = other->m_d->commands;
 
     if (other->m_d->overriddenCommand == this) {
         m_d->commands.clear();
 
         Q_FOREACH (Private::SavedCommand cmd, other->m_d->commands) {
             if (!other->m_d->skipWhenOverride.contains(cmd.command.data())) {
                 m_d->commands.append(cmd);
             }
         }
 
         if (other->extraData()) {
             setExtraData(other->extraData()->clone());
         } else {
             setExtraData(0);
         }
         return true;
     }
 
     if (m_d->commands.size() != otherCommands.size()) return false;
 
     auto it = m_d->commands.constBegin();
     auto end = m_d->commands.constEnd();
 
     auto otherIt = otherCommands.constBegin();
     auto otherEnd = otherCommands.constEnd();
 
     bool sameCommands = true;
     while (it != end && otherIt != otherEnd) {
         if (it->command->id() < 0 ||
             otherIt->command->id() < 0 ||
             it->command->id() != otherIt->command->id() ||
             it->sequentiality != otherIt->sequentiality ||
             it->exclusivity != otherIt->exclusivity) {
 
             sameCommands = false;
             break;
         }
         ++it;
         ++otherIt;
     }
 
     if (!sameCommands) return false;
 
     it = m_d->commands.constBegin();
     otherIt = otherCommands.constBegin();
 
     while (it != end && otherIt != otherEnd) {
         if (it->command->id() != -1) {
             bool result = it->command->mergeWith(otherIt->command.data());
             KIS_ASSERT_RECOVER(result) { return false; }
         }
         ++it;
         ++otherIt;
     }
 
     if (other->extraData()) {
         setExtraData(other->extraData()->clone());
     } else {
         setExtraData(0);
     }
 
     return true;
 }
 
 void KisSavedMacroCommand::addCommand(KUndo2CommandSP command,
                                       KisStrokeJobData::Sequentiality sequentiality,
                                       KisStrokeJobData::Exclusivity exclusivity)
 {
     Private::SavedCommand item;
     item.command = command;
     item.sequentiality = sequentiality;
     item.exclusivity = exclusivity;
 
     m_d->commands.append(item);
 }
 
 void KisSavedMacroCommand::performCancel(KisStrokeId id, bool strokeUndo)
 {
     addCommands(id, !strokeUndo);
 }
 
-void KisSavedMacroCommand::getCommandExecutionJobs(QVector<KisStrokeJobData *> *jobs, bool undo) const
+void KisSavedMacroCommand::getCommandExecutionJobs(QVector<KisStrokeJobData *> *jobs, bool undo, bool shouldGoToHistory) const
 {
     QVector<Private::SavedCommand>::iterator it;
 
     if(!undo) {
         for(it = m_d->commands.begin(); it != m_d->commands.end(); it++) {
             *jobs << new KisStrokeStrategyUndoCommandBased::
                        Data(it->command,
                             undo,
                             it->sequentiality,
-                            it->exclusivity);
+                            it->exclusivity,
+                            shouldGoToHistory);
         }
     }
     else {
         for(it = m_d->commands.end(); it != m_d->commands.begin();) {
             --it;
 
             *jobs << new KisStrokeStrategyUndoCommandBased::
                      Data(it->command,
                           undo,
                           it->sequentiality,
-                          it->exclusivity);
+                          it->exclusivity,
+                          shouldGoToHistory);
         }
     }
 }
 
 void KisSavedMacroCommand::setOverrideInfo(const KisSavedMacroCommand *overriddenCommand, const QVector<const KUndo2Command*> &skipWhileOverride)
 {
     m_d->overriddenCommand = overriddenCommand;
     m_d->skipWhenOverride = skipWhileOverride;
 }
 
 void KisSavedMacroCommand::addCommands(KisStrokeId id, bool undo)
 {
     QVector<KisStrokeJobData *> jobs;
     getCommandExecutionJobs(&jobs, undo);
 
     Q_FOREACH (KisStrokeJobData *job, jobs) {
         strokesFacade()->addJob(id, job);
     }
 }
diff --git a/libs/image/commands_new/kis_saved_commands.h b/libs/image/commands_new/kis_saved_commands.h
index d1b805c847..4f23de43fc 100644
--- a/libs/image/commands_new/kis_saved_commands.h
+++ b/libs/image/commands_new/kis_saved_commands.h
@@ -1,105 +1,105 @@
 /*
  *  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_SAVED_COMMANDS_H
 #define __KIS_SAVED_COMMANDS_H
 
 #include <kundo2command.h>
 #include "kis_types.h"
 #include "kis_stroke_job_strategy.h"
 
 class KisStrokesFacade;
 
 
 class KRITAIMAGE_EXPORT KisSavedCommandBase : public KUndo2Command
 {
 public:
     KisSavedCommandBase(const KUndo2MagicString &name, KisStrokesFacade *strokesFacade);
     ~KisSavedCommandBase() override;
 
 
     void undo() override;
     void redo() override;
 
 protected:
     virtual void addCommands(KisStrokeId id, bool undo) = 0;
     KisStrokesFacade* strokesFacade();
 
 private:
     void runStroke(bool undo);
 
 private:
     KisStrokesFacade *m_strokesFacade;
     bool m_skipOneRedo;
 };
 
 class KRITAIMAGE_EXPORT KisSavedCommand : public KisSavedCommandBase
 {
 public:
     KisSavedCommand(KUndo2CommandSP command, KisStrokesFacade *strokesFacade);
     int timedId() override;
     void setTimedID(int timedID) override;
 
     int id() const override;
     bool mergeWith(const KUndo2Command* command) override;
 
     bool timedMergeWith(KUndo2Command *other) override;
     QVector<KUndo2Command*> mergeCommandsVector() override;
     void setTime() override;
     QTime time() override;
     void setEndTime() override;
     QTime endTime() override;
     bool isMerged() override;
 
 protected:
     void addCommands(KisStrokeId id, bool undo) override;
 
 private:
     KUndo2CommandSP m_command;
 };
 
 class KRITAIMAGE_EXPORT KisSavedMacroCommand : public KisSavedCommandBase
 {
 public:
     KisSavedMacroCommand(const KUndo2MagicString &name, KisStrokesFacade *strokesFacade);
     ~KisSavedMacroCommand() override;
 
     int id() const override;
     bool mergeWith(const KUndo2Command* command) override;
 
     void setMacroId(int value);
 
     void addCommand(KUndo2CommandSP command,
                     KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                     KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     void performCancel(KisStrokeId id, bool strokeUndo);
 
-    void getCommandExecutionJobs(QVector<KisStrokeJobData*> *jobs, bool undo) const;
+    void getCommandExecutionJobs(QVector<KisStrokeJobData*> *jobs, bool undo, bool shouldGoToHistory = true) const;
 
     void setOverrideInfo(const KisSavedMacroCommand *overriddenCommand, const QVector<const KUndo2Command *> &skipWhileOverride);
 
 protected:
     void addCommands(KisStrokeId id, bool undo) override;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* __KIS_SAVED_COMMANDS_H */
diff --git a/libs/image/kis_clone_layer.cpp b/libs/image/kis_clone_layer.cpp
index 6f1ec35f69..7ae7424dc9 100644
--- a/libs/image/kis_clone_layer.cpp
+++ b/libs/image/kis_clone_layer.cpp
@@ -1,327 +1,337 @@
 /*
  *  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.
  */
 
 #include "kis_clone_layer.h"
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoIcon.h>
 #include <kis_icon.h>
 
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_default_bounds.h"
 #include "kis_paint_device.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_paint_layer.h"
 
 #include <QStack>
 #include <kis_effect_mask.h>
 #include "kis_lod_capable_layer_offset.h"
 
 
 struct Q_DECL_HIDDEN KisCloneLayer::Private
 {
     Private(KisDefaultBoundsBaseSP defaultBounds)
         : offset(defaultBounds)
     {
     }
 
     KisPaintDeviceSP fallback;
     KisLodCapableLayerOffset offset;
 
     KisLayerSP copyFrom;
     KisNodeUuidInfo copyFromInfo;
     CopyLayerType type;
 };
 
 KisCloneLayer::KisCloneLayer(KisLayerSP from, KisImageWSP image, const QString &name, quint8 opacity)
         : KisLayer(image, name, opacity)
         , m_d(new Private(new KisDefaultBounds(image)))
 {
     KisImageSP imageSP = image.toStrongRef();
     if (!imageSP) {
         return;
     }
-    m_d->fallback = new KisPaintDevice(imageSP->colorSpace());
+    m_d->fallback = new KisPaintDevice(this,
+                                       imageSP->colorSpace(),
+                                       new KisDefaultBounds(imageSP));
     m_d->copyFrom = from;
     m_d->type = COPY_PROJECTION;
 
     // When loading the layer we copy from might not exist yet
     if (m_d->copyFrom) {
         m_d->copyFrom->registerClone(this);
     }
 }
 
 KisCloneLayer::KisCloneLayer(const KisCloneLayer& rhs)
         : KisLayer(rhs)
         , m_d(new Private(new KisDefaultBounds(rhs.image())))
 {
-    m_d->fallback = new KisPaintDevice(rhs.m_d->fallback->colorSpace());
+    m_d->fallback = new KisPaintDevice(this,
+                                       rhs.m_d->fallback->colorSpace(),
+                                       new KisDefaultBounds(rhs.image()));
     m_d->copyFrom = rhs.copyFrom();
     m_d->type = rhs.copyType();
     m_d->offset = rhs.m_d->offset;
 
     if (m_d->copyFrom) {
         m_d->copyFrom->registerClone(this);
     }
 }
 
 KisCloneLayer::~KisCloneLayer()
 {
     if (m_d->copyFrom) {
         m_d->copyFrom->unregisterClone(this);
     }
     delete m_d;
 }
 
 KisLayerSP KisCloneLayer::reincarnateAsPaintLayer() const
 {
     KisPaintDeviceSP newOriginal = new KisPaintDevice(*original());
     KisPaintLayerSP newLayer = new KisPaintLayer(image(), name(), opacity(), newOriginal);
     newLayer->setX(newLayer->x() + x());
     newLayer->setY(newLayer->y() + y());
     newLayer->setCompositeOpId(compositeOpId());
     newLayer->mergeNodeProperties(nodeProperties());
 
     return newLayer;
 }
 
+void KisCloneLayer::setImage(KisImageWSP image)
+{
+    m_d->fallback->setDefaultBounds(new KisDefaultBounds(image));
+    KisLayer::setImage(image);
+}
+
 bool KisCloneLayer::allowAsChild(KisNodeSP node) const
 {
     return node->inherits("KisMask");
 }
 
 KisPaintDeviceSP KisCloneLayer::paintDevice() const
 {
     return 0;
 }
 
 KisPaintDeviceSP KisCloneLayer::original() const
 {
     if (!m_d->copyFrom || !m_d->copyFrom->projection()) return m_d->fallback;
     KisPaintDeviceSP retval;
     switch (m_d->type) {
     case COPY_PROJECTION:
         retval = m_d->copyFrom->projection();
         break;
 
     case COPY_ORIGINAL:
     default:
         retval = m_d->copyFrom->original();
     }
 
     return retval;
 }
 
 bool KisCloneLayer::needProjection() const
 {
 return m_d->offset.x() || m_d->offset.y();
 }
 
 void KisCloneLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
         KisPaintDeviceSP projection,
         const QRect& rect) const
 {
     QRect copyRect = rect;
     copyRect.translate(-m_d->offset.x(), -m_d->offset.y());
 
     KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, copyRect);
 }
 
 void KisCloneLayer::setDirtyOriginal(const QRect &rect)
 {
     /**
      * The original will be updated when the clone becomes visible
      * again.
      */
     if (!visible(true)) return;
 
     /**
      *  HINT: this method is present for historical reasons only.
      *        Long time ago the updates were calculated in
      *        "copyOriginalToProjection" coordinate system. Now
      *        everything is done in "original()" space.
      */
     KisLayer::setDirty(rect);
 }
 
 void KisCloneLayer::notifyParentVisibilityChanged(bool value)
 {
     KisImageSP imageSP = image().toStrongRef();
     if (!imageSP) {
         return;
     }
     KisLayer::setDirty(imageSP->bounds());
     KisLayer::notifyParentVisibilityChanged(value);
 }
 
 QRect KisCloneLayer::needRectOnSourceForMasks(const QRect &rc) const
 {
     QStack<QRect> applyRects_unused;
     bool rectVariesFlag;
 
     QList<KisEffectMaskSP> effectMasks = this->effectMasks();
     if (effectMasks.isEmpty()) return QRect();
 
     QRect needRect = this->masksNeedRect(effectMasks,
                                          rc,
                                          applyRects_unused,
                                          rectVariesFlag);
 
     if (needRect.isEmpty() ||
         (!rectVariesFlag && needRect == rc)) {
 
         return QRect();
     }
 
     return needRect;
 }
 
 qint32 KisCloneLayer::x() const
 {
     return m_d->offset.x();
 }
 qint32 KisCloneLayer::y() const
 {
     return m_d->offset.y();
 }
 void KisCloneLayer::setX(qint32 x)
 {
     m_d->offset.setX(x);
 }
 void KisCloneLayer::setY(qint32 y)
 {
     m_d->offset.setY(y);
 }
 
 QRect KisCloneLayer::extent() const
 {
     QRect rect = original()->extent();
 
     // HINT: no offset now. See a comment in setDirtyOriginal()
     return rect | projection()->extent();
 }
 
 QRect KisCloneLayer::exactBounds() const
 {
     QRect rect = original()->exactBounds();
 
     // HINT: no offset now. See a comment in setDirtyOriginal()
     return rect | projection()->exactBounds();
 }
 
 QRect KisCloneLayer::accessRect(const QRect &rect, PositionToFilthy pos) const
 {
     QRect resultRect = rect;
 
     if(pos & (N_FILTHY_PROJECTION | N_FILTHY)) {
         if (m_d->offset.x() || m_d->offset.y()) {
             resultRect |= rect.translated(-m_d->offset.x(), -m_d->offset.y());
         }
 
         /**
          * KisUpdateOriginalVisitor will try to recalculate some area
          * on the clone's source, so this extra rectangle should also
          * be taken into account
          */
         resultRect |= needRectOnSourceForMasks(rect);
     }
 
     return resultRect;
 }
 
 QRect KisCloneLayer::outgoingChangeRect(const QRect &rect) const
 {
     return rect.translated(m_d->offset.x(), m_d->offset.y());
 }
 
 bool KisCloneLayer::accept(KisNodeVisitor & v)
 {
     return v.visit(this);
 }
 
 void KisCloneLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 void KisCloneLayer::setCopyFrom(KisLayerSP fromLayer)
 {
     if (m_d->copyFrom) {
         m_d->copyFrom->unregisterClone(this);
     }
 
     m_d->copyFrom = fromLayer;
 
     if (m_d->copyFrom) {
         m_d->copyFrom->registerClone(this);
     }
 }
 
 KisLayerSP KisCloneLayer::copyFrom() const
 {
     return m_d->copyFrom;
 }
 
 void KisCloneLayer::setCopyType(CopyLayerType type)
 {
     m_d->type = type;
 }
 
 CopyLayerType KisCloneLayer::copyType() const
 {
     return m_d->type;
 }
 
 KisNodeUuidInfo KisCloneLayer::copyFromInfo() const
 {
     return m_d->copyFrom ? KisNodeUuidInfo(m_d->copyFrom) : m_d->copyFromInfo;
 }
 
 void KisCloneLayer::setCopyFromInfo(KisNodeUuidInfo info)
 {
     Q_ASSERT(!m_d->copyFrom);
     m_d->copyFromInfo = info;
 }
 
 QIcon KisCloneLayer::icon() const
 {
     return KisIconUtils::loadIcon("cloneLayer");
 }
 
 KisBaseNode::PropertyList KisCloneLayer::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisLayer::sectionModelProperties();
     if (m_d->copyFrom)
         l << KisBaseNode::Property(KoID("copy_from", i18n("Copy From")), m_d->copyFrom->name());
 
     return l;
 }
 
 void KisCloneLayer::syncLodCache()
 {
     KisLayer::syncLodCache();
     m_d->offset.syncLodOffset();
 }
 
diff --git a/libs/image/kis_clone_layer.h b/libs/image/kis_clone_layer.h
index 785099684c..60e8ebf3bd 100644
--- a/libs/image/kis_clone_layer.h
+++ b/libs/image/kis_clone_layer.h
@@ -1,135 +1,137 @@
 /*
  *  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_CLONE_LAYER_H_
 #define KIS_CLONE_LAYER_H_
 
 #include <QObject>
 #include "kis_types.h"
 #include "kis_layer.h"
 
 #include <kritaimage_export.h>
 #include "kis_node_uuid_info.h"
 
 class KisNodeVisitor;
 
 enum CopyLayerType {
     COPY_PROJECTION,
     COPY_ORIGINAL
 };
 
 
 /**
  * A copy layer adds the contents of another layer in another place in
  * the layer stack. It is possible to add more effect masks to the
  * copy. You can either copy the original data or the projection data
  * produced by the original layer + original effect masks. There is no
  * physical copy of the data; if the original changes, the copy
  * changes too. The copy layer can be positioned differently from the
  * original layer.
  **/
 class KRITAIMAGE_EXPORT KisCloneLayer : public KisLayer
 {
 
     Q_OBJECT
 
 public:
 
     KisCloneLayer(KisLayerSP from, KisImageWSP image, const QString &name, quint8 opacity);
     KisCloneLayer(const KisCloneLayer& rhs);
     ~KisCloneLayer() override;
 
     KisNodeSP clone() const override {
         return KisNodeSP(new KisCloneLayer(*this));
     }
 
     /**
      * When the source layer of the clone is removed from the stack
      * we should substitute the clone with a usual paint layer,
      * because the source might become unreachable quite soon. This
      * method builds a paint layer representation of this clone.
      */
     KisLayerSP reincarnateAsPaintLayer() const;
 
+    void setImage(KisImageWSP image) override;
+
     bool allowAsChild(KisNodeSP) const override;
 
     KisPaintDeviceSP original() const override;
     KisPaintDeviceSP paintDevice() const override;
     bool needProjection() const override;
 
     QIcon icon() const override;
     KisBaseNode::PropertyList sectionModelProperties() const override;
 
     qint32 x() const override;
     qint32 y() const override;
 
     void setX(qint32) override;
     void setY(qint32) override;
 
     /// Returns an approximation of where the bounds on actual data are in this layer
     QRect extent() const override;
 
     /// Returns the exact bounds of where the actual data resides in this layer
     QRect exactBounds() const override;
 
     bool accept(KisNodeVisitor &) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     /**
      * Used when loading: loading is done in two passes, and the copy
      * from layer is set when all layers have been created, not during
      * loading.
      */
     void setCopyFromInfo(KisNodeUuidInfo info);
     KisNodeUuidInfo copyFromInfo() const;
 
     void setCopyFrom(KisLayerSP layer);
     KisLayerSP copyFrom() const;
 
     void setCopyType(CopyLayerType type);
     CopyLayerType copyType() const;
 
     /**
      * This function is called by the original to notify
      * us that it is dirty
      */
     void setDirtyOriginal(const QRect &rect);
 
     QRect needRectOnSourceForMasks(const QRect &rc) const;
 
     void syncLodCache() override;
 
 protected:
     // override from KisNode
     QRect accessRect(const QRect &rect, PositionToFilthy pos) const override;
 
     // override from KisLayer
     void copyOriginalToProjection(const KisPaintDeviceSP original,
                                   KisPaintDeviceSP projection,
                                   const QRect& rect) const override;
 
     void notifyParentVisibilityChanged(bool value) override;
     QRect outgoingChangeRect(const QRect &rect) const override;
 private:
 
     struct Private;
     Private * const m_d;
 
 };
 
 #endif // KIS_CLONE_LAYER_H_
 
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index 52b76a3dcc..1baa06810b 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,2223 +1,2236 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  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.
  */
 
 #include "kis_image.h"
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QPainter>
 #include <QSize>
 #include <QDateTime>
 #include <QRect>
 #include <QRegion>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorProfile.h"
 #include <KoCompositeOpRegistry.h>
 #include "KisProofingConfiguration.h"
 
 #include "kis_adjustment_layer.h"
 #include "kis_annotation.h"
 #include "kis_count_visitor.h"
 #include "kis_filter_strategy.h"
 #include "kis_group_layer.h"
 #include "commands/kis_image_commands.h"
 #include "kis_layer.h"
 #include "kis_meta_data_merge_strategy_registry.h"
 #include "kis_name_server.h"
 #include "kis_paint_layer.h"
 #include "kis_projection_leaf.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_transaction.h"
 #include "kis_meta_data_merge_strategy.h"
 #include "kis_memory_statistics_server.h"
 
 #include "kis_image_config.h"
 #include "kis_update_scheduler.h"
 #include "kis_image_signal_router.h"
 #include "kis_image_animation_interface.h"
 #include "kis_stroke_strategy.h"
 #include "kis_simple_stroke_strategy.h"
 #include "kis_image_barrier_locker.h"
 
 
 #include "kis_undo_stores.h"
 #include "kis_legacy_undo_adapter.h"
 #include "kis_post_execution_undo_adapter.h"
 
 #include "kis_transform_worker.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "processing/kis_crop_selections_processing_visitor.h"
 #include "processing/kis_transform_processing_visitor.h"
 #include "processing/kis_convert_color_space_processing_visitor.h"
 #include "processing/kis_assign_profile_processing_visitor.h"
 #include "commands_new/kis_image_resize_command.h"
 #include "commands_new/kis_image_set_resolution_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "kis_do_something_command.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_layer_composition.h"
 #include "kis_wrapped_rect.h"
 #include "kis_crop_saved_extra_data.h"
 #include "kis_layer_utils.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_suspend_projection_updates_stroke_strategy.h"
 #include "kis_sync_lod_cache_stroke_strategy.h"
 
 #include "kis_projection_updates_filter.h"
 
 #include "kis_layer_projection_plane.h"
 
 #include "kis_update_time_monitor.h"
 #include "tiles3/kis_lockless_stack.h"
 
 #include <QtCore>
 
 #include <functional>
 
 #include "kis_time_range.h"
 
 #include "KisRunnableBasedStrokeStrategy.h"
 #include "KisRunnableStrokeJobData.h"
 #include "KisRunnableStrokeJobUtils.h"
 #include "KisRunnableStrokeJobsInterface.h"
 
 // #define SANITY_CHECKS
 
 #ifdef SANITY_CHECKS
 #define SANITY_CHECK_LOCKED(name)                                       \
     if (!locked()) warnKrita() << "Locking policy failed:" << name          \
                                << "has been called without the image"       \
                                   "being locked";
 #else
 #define SANITY_CHECK_LOCKED(name)
 #endif
 
 
 struct KisImageSPStaticRegistrar {
     KisImageSPStaticRegistrar() {
         qRegisterMetaType<KisImageSP>("KisImageSP");
     }
 };
 static KisImageSPStaticRegistrar __registrar;
 
 class KisImage::KisImagePrivate
 {
 public:
     KisImagePrivate(KisImage *_q, qint32 w, qint32 h,
                     const KoColorSpace *c,
                     KisUndoStore *undo,
                     KisImageAnimationInterface *_animationInterface)
         : q(_q)
         , lockedForReadOnly(false)
         , width(w)
         , height(h)
         , colorSpace(c ? c : KoColorSpaceRegistry::instance()->rgb8())
         , nserver(1)
         , undoStore(undo ? undo : new KisDumbUndoStore())
         , legacyUndoAdapter(undoStore.data(), _q)
         , postExecutionUndoAdapter(undoStore.data(), _q)
         , signalRouter(_q)
         , animationInterface(_animationInterface)
         , scheduler(_q, _q)
         , axesCenter(QPointF(0.5, 0.5))
     {
         {
             KisImageConfig cfg(true);
             if (cfg.enableProgressReporting()) {
                 scheduler.setProgressProxy(&compositeProgressProxy);
             }
 
             // Each of these lambdas defines a new factory function.
             scheduler.setLod0ToNStrokeStrategyFactory(
                 [=](bool forgettable) {
                     return KisLodSyncPair(
                         new KisSyncLodCacheStrokeStrategy(KisImageWSP(q), forgettable),
                         KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setSuspendUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), true),
                         KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setResumeUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), false),
                         KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP(q)));
                 });
         }
 
         connect(q, SIGNAL(sigImageModified()), KisMemoryStatisticsServer::instance(), SLOT(notifyImageChanged()));
     }
 
     ~KisImagePrivate() {
         /**
          * Stop animation interface. It may use the rootLayer.
          */
         delete animationInterface;
 
         /**
          * First delete the nodes, while strokes
          * and undo are still alive
          */
         rootLayer.clear();
     }
 
     KisImage *q;
 
     quint32 lockCount = 0;
     bool lockedForReadOnly;
 
     qint32 width;
     qint32 height;
 
     double xres = 1.0;
     double yres = 1.0;
 
     const KoColorSpace * colorSpace;
     KisProofingConfigurationSP proofingConfig;
 
     KisSelectionSP deselectedGlobalSelection;
     KisGroupLayerSP rootLayer; // The layers are contained in here
     KisSelectionMaskSP targetOverlaySelectionMask; // the overlay switching stroke will try to switch into this mask
     KisSelectionMaskSP overlaySelectionMask;
     QList<KisLayerCompositionSP> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted = false;
 
     KisNameServer nserver;
 
     QScopedPointer<KisUndoStore> undoStore;
     KisLegacyUndoAdapter legacyUndoAdapter;
     KisPostExecutionUndoAdapter postExecutionUndoAdapter;
 
     vKisAnnotationSP annotations;
 
     QAtomicInt disableUIUpdateSignals;
     KisLocklessStack<QRect> savedDisabledUIUpdates;
 
     KisProjectionUpdatesFilterSP projectionUpdatesFilter;
     KisImageSignalRouter signalRouter;
     KisImageAnimationInterface *animationInterface;
     KisUpdateScheduler scheduler;
     QAtomicInt disableDirtyRequests;
 
 
     KisCompositeProgressProxy compositeProgressProxy;
 
     bool blockLevelOfDetail = false;
 
     QPointF axesCenter;
     bool allowMasksOnRootNode = false;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc, QVector<KisRunnableStrokeJobData *> &jobs);
 
     void convertImageColorSpaceImpl(const KoColorSpace *dstColorSpace,
                                     bool convertLayers,
                                     KoColorConversionTransformation::Intent renderingIntent,
                                     KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     struct SetImageProjectionColorSpace;
 };
 
 KisImage::KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name)
         : QObject(0)
         , KisShared()
         , m_d(new KisImagePrivate(this, width, height,
                                   colorSpace, undoStore,
                                   new KisImageAnimationInterface(this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     setObjectName(name);
     setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
 }
 
 KisImage::~KisImage()
 {
     dbgImage << "deleting kisimage" << objectName();
 
     /**
      * Request the tools to end currently running strokes
      */
     waitForDone();
 
     delete m_d;
     disconnect(); // in case Qt gets confused
 }
 
 KisImageSP KisImage::fromQImage(const QImage &image, KisUndoStore *undoStore)
 {
     const KoColorSpace *colorSpace = 0;
 
     switch (image.format()) {
     case QImage::Format_Invalid:
     case QImage::Format_Mono:
     case QImage::Format_MonoLSB:
         colorSpace = KoColorSpaceRegistry::instance()->graya8();
         break;
     case QImage::Format_Indexed8:
     case QImage::Format_RGB32:
     case QImage::Format_ARGB32:
     case QImage::Format_ARGB32_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_RGB16:
         colorSpace = KoColorSpaceRegistry::instance()->rgb16();
         break;
     case QImage::Format_ARGB8565_Premultiplied:
     case QImage::Format_RGB666:
     case QImage::Format_ARGB6666_Premultiplied:
     case QImage::Format_RGB555:
     case QImage::Format_ARGB8555_Premultiplied:
     case QImage::Format_RGB888:
     case QImage::Format_RGB444:
     case QImage::Format_ARGB4444_Premultiplied:
     case QImage::Format_RGBX8888:
     case QImage::Format_RGBA8888:
     case QImage::Format_RGBA8888_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_BGR30:
     case QImage::Format_A2BGR30_Premultiplied:
     case QImage::Format_RGB30:
     case QImage::Format_A2RGB30_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_Alpha8:
         colorSpace = KoColorSpaceRegistry::instance()->alpha8();
         break;
     case QImage::Format_Grayscale8:
         colorSpace = KoColorSpaceRegistry::instance()->graya8();
         break;
 #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
     case QImage::Format_Grayscale16:
         colorSpace = KoColorSpaceRegistry::instance()->graya16();
         break;
 #endif
 #if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
     case QImage::Format_RGBX64:
     case QImage::Format_RGBA64:
     case QImage::Format_RGBA64_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), 0);
         break;
 #endif
     default:
         colorSpace = 0;
     }
 
     KisImageSP img = new KisImage(undoStore, image.width(), image.height(), colorSpace, i18n("Imported Image"));
     KisPaintLayerSP layer = new KisPaintLayer(img, img->nextLayerName(), 255);
     layer->paintDevice()->convertFromQImage(image, 0, 0, 0);
     img->addNode(layer.data(), img->rootLayer().data());
 
     return img;
 }
 
 KisImage *KisImage::clone(bool exactCopy)
 {
     return new KisImage(*this, 0, exactCopy);
 }
 
 void KisImage::copyFromImage(const KisImage &rhs)
 {
     copyFromImageImpl(rhs, REPLACE);
 }
 
 void KisImage::copyFromImageImpl(const KisImage &rhs, int policy)
 {
     // make sure we choose exactly one from REPLACE and CONSTRUCT
     KIS_ASSERT_RECOVER_RETURN((policy & REPLACE) != (policy & CONSTRUCT));
 
     // only when replacing do we need to emit signals
 #define EMIT_IF_NEEDED if (!(policy & REPLACE)) {} else emit
 
     if (policy & REPLACE) { // if we are constructing the image, these are already set
         if (m_d->width != rhs.width() || m_d->height != rhs.height()) {
             m_d->width = rhs.width();
             m_d->height = rhs.height();
             emit sigSizeChanged(QPointF(), QPointF());
         }
         if (m_d->colorSpace != rhs.colorSpace()) {
             m_d->colorSpace = rhs.colorSpace();
             emit sigColorSpaceChanged(m_d->colorSpace);
         }
     }
 
     // from KisImage::KisImage(const KisImage &, KisUndoStore *, bool)
     setObjectName(rhs.objectName());
 
     if (m_d->xres != rhs.m_d->xres || m_d->yres != rhs.m_d->yres) {
         m_d->xres = rhs.m_d->xres;
         m_d->yres = rhs.m_d->yres;
         EMIT_IF_NEEDED sigResolutionChanged(m_d->xres, m_d->yres);
     }
 
     m_d->allowMasksOnRootNode = rhs.m_d->allowMasksOnRootNode;
 
     if (rhs.m_d->proofingConfig) {
         KisProofingConfigurationSP proofingConfig(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
         if (policy & REPLACE) {
             setProofingConfiguration(proofingConfig);
         } else {
             m_d->proofingConfig = proofingConfig;
         }
     }
 
     KisNodeSP newRoot = rhs.root()->clone();
     newRoot->setGraphListener(this);
     newRoot->setImage(this);
     m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
     setRoot(newRoot);
 
     bool exactCopy = policy & EXACT_COPY;
 
-    if (exactCopy || rhs.m_d->isolatedRootNode) {
+    if (exactCopy || rhs.m_d->isolatedRootNode || rhs.m_d->overlaySelectionMask) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.root(),
                                            [&linearizedNodes](KisNodeSP node) {
                                                linearizedNodes.enqueue(node);
                                            });
         KisLayerUtils::recursiveApplyNodes(newRoot,
                                            [&linearizedNodes, exactCopy, &rhs, this](KisNodeSP node) {
                                                KisNodeSP refNode = linearizedNodes.dequeue();
 
                                                if (exactCopy) {
                                                    node->setUuid(refNode->uuid());
                                                }
 
                                                if (rhs.m_d->isolatedRootNode &&
                                                    rhs.m_d->isolatedRootNode == refNode) {
                                                    m_d->isolatedRootNode = node;
                                                }
+
+                                               if (rhs.m_d->overlaySelectionMask &&
+                                                   KisNodeSP(rhs.m_d->overlaySelectionMask) == refNode) {
+                                                   m_d->targetOverlaySelectionMask = dynamic_cast<KisSelectionMask*>(node.data());
+                                                   m_d->overlaySelectionMask = m_d->targetOverlaySelectionMask;
+                                                   m_d->rootLayer->notifyChildMaskChanged();
+                                               }
                                            });
     }
 
     KisLayerUtils::recursiveApplyNodes(newRoot,
                                        [](KisNodeSP node) {
                                            dbgImage << "Node: " << (void *)node.data();
                                        });
 
     m_d->compositions.clear();
 
     Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
         m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
     }
 
     EMIT_IF_NEEDED sigLayersChangedAsync();
 
     m_d->nserver = rhs.m_d->nserver;
 
     vKisAnnotationSP newAnnotations;
     Q_FOREACH (KisAnnotationSP annotation, rhs.m_d->annotations) {
         newAnnotations << annotation->clone();
     }
     m_d->annotations = newAnnotations;
 
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->projectionUpdatesFilter);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableUIUpdateSignals);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableDirtyRequests);
 
     m_d->blockLevelOfDetail = rhs.m_d->blockLevelOfDetail;
 
-    /**
-     * The overlay device is not inherited when cloning the image!
-     */
-    if (rhs.m_d->overlaySelectionMask) {
-        const QRect dirtyRect = rhs.m_d->overlaySelectionMask->extent();
-        m_d->rootLayer->setDirty(dirtyRect);
-    }
 #undef EMIT_IF_NEEDED
 }
 
 KisImage::KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy)
     : KisNodeFacade(),
       KisNodeGraphListener(),
       KisShared(),
       m_d(new KisImagePrivate(this,
                               rhs.width(), rhs.height(),
                               rhs.colorSpace(),
                               undoStore ? undoStore : new KisDumbUndoStore(),
                               new KisImageAnimationInterface(*rhs.animationInterface(), this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     copyFromImageImpl(rhs, CONSTRUCT | (exactCopy ? EXACT_COPY : 0));
 }
 
 void KisImage::aboutToAddANode(KisNode *parent, int index)
 {
     KisNodeGraphListener::aboutToAddANode(parent, index);
     SANITY_CHECK_LOCKED("aboutToAddANode");
 }
 
 void KisImage::nodeHasBeenAdded(KisNode *parent, int index)
 {
     KisNodeGraphListener::nodeHasBeenAdded(parent, index);
 
     SANITY_CHECK_LOCKED("nodeHasBeenAdded");
     m_d->signalRouter.emitNodeHasBeenAdded(parent, index);
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data()) &&
         deletedNode == m_d->isolatedRootNode) {
 
         emit sigInternalStopIsolatedModeRequested();
     }
 
     KisNodeGraphListener::aboutToRemoveANode(parent, index);
 
     SANITY_CHECK_LOCKED("aboutToRemoveANode");
     m_d->signalRouter.emitAboutToRemoveANode(parent, index);
 }
 
 void KisImage::nodeChanged(KisNode* node)
 {
     KisNodeGraphListener::nodeChanged(node);
     requestStrokeEnd();
     m_d->signalRouter.emitNodeChanged(node);
 }
 
 void KisImage::invalidateAllFrames()
 {
     invalidateFrames(KisTimeRange::infinite(0), QRect());
 }
 
 void KisImage::setOverlaySelectionMask(KisSelectionMaskSP mask)
 {
     if (m_d->targetOverlaySelectionMask == mask) return;
 
     m_d->targetOverlaySelectionMask = mask;
 
     struct UpdateOverlaySelectionStroke : public KisSimpleStrokeStrategy {
         UpdateOverlaySelectionStroke(KisImageSP image)
-            : KisSimpleStrokeStrategy("update-overlay-selection-mask", kundo2_noi18n("update-overlay-selection-mask")),
+            : KisSimpleStrokeStrategy(QLatin1String("update-overlay-selection-mask"), kundo2_noi18n("update-overlay-selection-mask")),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             KisSelectionMaskSP oldMask = m_image->m_d->overlaySelectionMask;
             KisSelectionMaskSP newMask = m_image->m_d->targetOverlaySelectionMask;
             if (oldMask == newMask) return;
 
             KIS_SAFE_ASSERT_RECOVER_RETURN(!newMask || newMask->graphListener() == m_image);
 
             m_image->m_d->overlaySelectionMask = newMask;
 
             if (oldMask || newMask) {
                 m_image->m_d->rootLayer->notifyChildMaskChanged();
             }
 
             if (oldMask) {
                 m_image->m_d->rootLayer->setDirtyDontResetAnimationCache(oldMask->extent());
             }
 
             if (newMask) {
                 newMask->setDirty();
             }
 
             m_image->undoAdapter()->emitSelectionChanged();
         }
 
     private:
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new UpdateOverlaySelectionStroke(this));
     endStroke(id);
 }
 
 KisSelectionMaskSP KisImage::overlaySelectionMask() const
 {
     return m_d->overlaySelectionMask;
 }
 
 bool KisImage::hasOverlaySelectionMask() const
 {
     return m_d->overlaySelectionMask;
 }
 
 KisSelectionSP KisImage::globalSelection() const
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
     if (selectionMask) {
         return selectionMask->selection();
     } else {
         return 0;
     }
 }
 
 void KisImage::setGlobalSelection(KisSelectionSP globalSelection)
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
 
     if (!globalSelection) {
         if (selectionMask) {
             removeNode(selectionMask);
         }
     }
     else {
         if (!selectionMask) {
             selectionMask = new KisSelectionMask(this);
             selectionMask->initSelection(m_d->rootLayer);
             addNode(selectionMask);
             // If we do not set the selection now, the setActive call coming next
             // can be very, very expensive, depending on the size of the image.
             selectionMask->setSelection(globalSelection);
             selectionMask->setActive(true);
         }
         else {
             selectionMask->setSelection(globalSelection);
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->rootLayer->childCount() > 0);
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->rootLayer->selectionMask());
     }
 
     m_d->deselectedGlobalSelection = 0;
     m_d->legacyUndoAdapter.emitSelectionChanged();
 }
 
 void KisImage::deselectGlobalSelection()
 {
     KisSelectionSP savedSelection = globalSelection();
     setGlobalSelection(0);
     m_d->deselectedGlobalSelection = savedSelection;
 }
 
 bool KisImage::canReselectGlobalSelection()
 {
     return m_d->deselectedGlobalSelection;
 }
 
 void KisImage::reselectGlobalSelection()
 {
     if(m_d->deselectedGlobalSelection) {
         setGlobalSelection(m_d->deselectedGlobalSelection);
     }
 }
 
 QString KisImage::nextLayerName(const QString &_baseName) const
 {
     QString baseName = _baseName;
 
     if (m_d->nserver.currentSeed() == 0) {
         m_d->nserver.number();
         return i18n("background");
     }
 
     if (baseName.isEmpty()) {
         baseName = i18n("Layer");
     }
 
     return QString("%1 %2").arg(baseName).arg(m_d->nserver.number());
 }
 
 void KisImage::rollBackLayerName()
 {
     m_d->nserver.rollback();
 }
 
 KisCompositeProgressProxy* KisImage::compositeProgressProxy()
 {
     return &m_d->compositeProgressProxy;
 }
 
 bool KisImage::locked() const
 {
     return m_d->lockCount != 0;
 }
 
 void KisImage::barrierLock(bool readOnly)
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.barrierLock();
         m_d->lockedForReadOnly = readOnly;
     } else {
         m_d->lockedForReadOnly &= readOnly;
     }
 
     m_d->lockCount++;
 }
 
 bool KisImage::tryBarrierLock(bool readOnly)
 {
     bool result = true;
 
     if (!locked()) {
         result = m_d->scheduler.tryBarrierLock();
         m_d->lockedForReadOnly = readOnly;
     }
 
     if (result) {
         m_d->lockCount++;
         m_d->lockedForReadOnly &= readOnly;
     }
 
     return result;
 }
 
 bool KisImage::isIdle(bool allowLocked)
 {
     return (allowLocked || !locked()) && m_d->scheduler.isIdle();
 }
 
 void KisImage::lock()
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.lock();
     }
     m_d->lockCount++;
     m_d->lockedForReadOnly = false;
 }
 
 void KisImage::unlock()
 {
     Q_ASSERT(locked());
 
     if (locked()) {
         m_d->lockCount--;
 
         if (m_d->lockCount == 0) {
             m_d->scheduler.unlock(!m_d->lockedForReadOnly);
         }
     }
 }
 
 void KisImage::blockUpdates()
 {
     m_d->scheduler.blockUpdates();
 }
 
 void KisImage::unblockUpdates()
 {
     m_d->scheduler.unblockUpdates();
 }
 
 void KisImage::setSize(const QSize& size)
 {
     m_d->width = size.width();
     m_d->height = size.height();
 }
 
 void KisImage::resizeImageImpl(const QRect& newRect, bool cropLayers)
 {
     if (newRect == bounds() && !cropLayers) return;
 
     KUndo2MagicString actionName = cropLayers ?
         kundo2_i18n("Crop Image") :
         kundo2_i18n("Resize Image");
 
     KisImageSignalVector emitSignals;
     emitSignals << ComplexSizeChangedSignal(newRect, newRect.size());
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(cropLayers ?
                                   KisCropSavedExtraData::CROP_IMAGE :
                                   KisCropSavedExtraData::RESIZE_IMAGE,
                                   newRect);
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName, extraData);
 
     if (cropLayers || !newRect.topLeft().isNull()) {
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(newRect, cropLayers, true);
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
     applicator.applyCommand(new KisImageResizeCommand(this, newRect.size()));
     applicator.end();
 }
 
 void KisImage::resizeImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, false);
 }
 
 void KisImage::cropImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, true);
 }
 
 
 void KisImage::cropNode(KisNodeSP node, const QRect& newRect)
 {
     bool isLayer = qobject_cast<KisLayer*>(node.data());
     KUndo2MagicString actionName = isLayer ?
         kundo2_i18n("Crop Layer") :
         kundo2_i18n("Crop Mask");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(KisCropSavedExtraData::CROP_LAYER,
                                   newRect, node);
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName, extraData);
 
     KisProcessingVisitorSP visitor =
         new KisCropProcessingVisitor(newRect, true, false);
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     bool resolutionChanged = xres != xRes() && yres != yRes();
     bool sizeChanged = size != this->size();
 
     if (!resolutionChanged && !sizeChanged) return;
 
     KisImageSignalVector emitSignals;
     if (resolutionChanged) emitSignals << ResolutionChangedSignal;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), size);
     emitSignals << ModifiedSignal;
 
     KUndo2MagicString actionName = sizeChanged ?
         kundo2_i18n("Scale Image") :
         kundo2_i18n("Change Image Resolution");
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         (resolutionChanged || sizeChanged) ?
                 KisProcessingApplicator::NO_UI_UPDATES :
                 KisProcessingApplicator::NONE;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     qreal sx = qreal(size.width()) / this->size().width();
     qreal sy = qreal(size.height()) / this->size().height();
 
     QTransform shapesCorrection;
 
     if (resolutionChanged) {
         shapesCorrection = QTransform::fromScale(xRes() / xres, yRes() / yres);
     }
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(sx, sy,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy,
                                           shapesCorrection);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resolutionChanged) {
         KUndo2Command *parent =
             new KisResetShapesCommand(m_d->rootLayer);
         new KisImageSetResolutionCommand(this, xres, yres, parent);
         applicator.applyCommand(parent);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, size));
     }
 
     applicator.end();
 }
 
 void KisImage::scaleNode(KisNodeSP node, const QPointF &center, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy, KisSelectionSP selection)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     QPointF offset;
     {
         KisTransformWorker worker(0,
                                   scaleX, scaleY,
                                   0, 0, 0, 0,
                                   0.0,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         offset = center - transform.map(center);
     }
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisTransformProcessingVisitor *visitor =
         new KisTransformProcessingVisitor(scaleX, scaleY,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           offset.x(), offset.y(),
                                           filterStrategy);
 
     visitor->setSelection(selection);
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           double radians,
                           bool resizeImage,
                           KisSelectionSP selection)
 {
     // we can either transform (and resize) the whole image or
     // transform a selection, we cannot do both at the same time
     KIS_SAFE_ASSERT_RECOVER(!(bool(selection) && resizeImage)) {
         selection = 0;
     }
 
     const QRect baseBounds =
         resizeImage ? bounds() :
         selection ? selection->selectedExactRect() :
         rootNode->exactBounds();
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   0, 0, 0, 0,
                                   radians,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         if (resizeImage) {
             QRect newRect = transform.mapRect(baseBounds);
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(baseBounds).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != baseBounds.width() ||
          newSize.height() != baseBounds.height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(baseBounds, newSize);
     emitSignals << ModifiedSignal;
 
     // These flags determine whether updates are transferred to the UI during processing
     KisProcessingApplicator::ProcessingFlags signalFlags =
         sizeChanged ?
         KisProcessingApplicator::NO_UI_UPDATES :
         KisProcessingApplicator::NONE;
 
 
     KisProcessingApplicator applicator(this, rootNode,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bicubic");
 
     KisTransformProcessingVisitor *visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
     if (selection) {
         visitor->setSelection(selection);
     }
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
     applicator.end();
 }
 
 
 void KisImage::rotateImage(double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Image"), root(), radians, true, 0);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians, KisSelectionSP selection)
 {
     if (node->inherits("KisMask")) {
         rotateImpl(kundo2_i18n("Rotate Mask"), node, radians, false, selection);
     } else {
         rotateImpl(kundo2_i18n("Rotate Layer"), node, radians, false, selection);
     }
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          KisSelectionSP selection)
 {
     const QRect baseBounds =
         resizeImage ? bounds() :
         selection ? selection->selectedExactRect() :
         rootNode->exactBounds();
 
     const QPointF origin = QRectF(baseBounds).center();
 
     //angleX, angleY are in degrees
     const qreal pi = 3.1415926535897932385;
     const qreal deg2rad = pi / 180.0;
 
     qreal tanX = tan(angleX * deg2rad);
     qreal tanY = tan(angleY * deg2rad);
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   tanX, tanY, origin.x(), origin.y(),
                                   0,
                                   0, 0, 0, 0);
 
         QRect newRect = worker.transform().mapRect(baseBounds);
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == baseBounds.size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(baseBounds, newSize);
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         KisProcessingApplicator::RECURSIVE;
     if (resizeImage) signalFlags |= KisProcessingApplicator::NO_UI_UPDATES;
 
     KisProcessingApplicator applicator(this, rootNode,
                                        signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bilinear");
 
     KisTransformProcessingVisitor *visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     if (selection) {
         visitor->setSelection(selection);
     }
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY, KisSelectionSP selection)
 {
     if (node->inherits("KisMask")) {
         shearImpl(kundo2_i18n("Shear Mask"), node, false,
                   angleX, angleY, selection);
     } else {
         shearImpl(kundo2_i18n("Shear Layer"), node, false,
                   angleX, angleY, selection);
     }
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, 0);
 }
 
 void KisImage::convertLayerColorSpace(KisNodeSP node,
                                       const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!node->projectionLeaf()->isLayer()) return;
 
     const KoColorSpace *srcColorSpace = node->colorSpace();
 
     if (!dstColorSpace || *srcColorSpace == *dstColorSpace) return;
 
     KUndo2MagicString actionName =
         kundo2_i18n("Convert Layer Color Space");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName);
 
     applicator.applyVisitor(
         new KisConvertColorSpaceProcessingVisitor(
             srcColorSpace, dstColorSpace,
             renderingIntent, conversionFlags),
         KisStrokeJobData::CONCURRENT);
 
     applicator.end();
 }
 
 struct KisImage::KisImagePrivate::SetImageProjectionColorSpace : public KisCommandUtils::FlipFlopCommand
 {
     SetImageProjectionColorSpace(const KoColorSpace *cs, KisImageWSP image,
                                  State initialState, KUndo2Command *parent = 0)
         : KisCommandUtils::FlipFlopCommand(initialState, parent),
           m_cs(cs),
           m_image(image)
     {
     }
 
     void partA() override {
         KisImageSP image = m_image;
 
         if (image) {
             image->setProjectionColorSpace(m_cs);
         }
     }
 
 private:
     const KoColorSpace *m_cs;
     KisImageWSP m_image;
 };
 
 void KisImage::KisImagePrivate::convertImageColorSpaceImpl(const KoColorSpace *dstColorSpace,
                                                            bool convertLayers,
                                                            KoColorConversionTransformation::Intent renderingIntent,
                                                            KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     const KoColorSpace *srcColorSpace = this->colorSpace;
 
     if (!dstColorSpace || *srcColorSpace == *dstColorSpace) return;
 
     const KUndo2MagicString actionName =
         convertLayers ?
         kundo2_i18n("Convert Image Color Space") :
         kundo2_i18n("Convert Projection Color Space");
 
     KisImageSignalVector emitSignals;
     emitSignals << ColorSpaceChangedSignal;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(q, this->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName);
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(dstColorSpace,
                                                           KisImageWSP(q),
                                                           KisCommandUtils::FlipFlopCommand::INITIALIZING),
         KisStrokeJobData::BARRIER);
 
     if (convertLayers) {
         applicator.applyVisitor(
                     new KisConvertColorSpaceProcessingVisitor(
                         srcColorSpace, dstColorSpace,
                         renderingIntent, conversionFlags),
                     KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyCommand(
             new KisDoSomethingCommand<
                     KisDoSomethingCommandOps::ResetOp, KisGroupLayerSP>
                     (this->rootLayer, false));
         applicator.applyCommand(
             new KisDoSomethingCommand<
                     KisDoSomethingCommandOps::ResetOp, KisGroupLayerSP>
                     (this->rootLayer, true));
     }
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(srcColorSpace,
                                                           KisImageWSP(q),
                                                           KisCommandUtils::FlipFlopCommand::FINALIZING),
         KisStrokeJobData::BARRIER);
 
 
     applicator.end();
 }
 
 void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     m_d->convertImageColorSpaceImpl(dstColorSpace, true, renderingIntent, conversionFlags);
 }
 
 void KisImage::convertImageProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     m_d->convertImageColorSpaceImpl(dstColorSpace, false,
                                     KoColorConversionTransformation::internalRenderingIntent(),
                                     KoColorConversionTransformation::internalConversionFlags());
 }
 
 
 bool KisImage::assignLayerProfile(KisNodeSP node, const KoColorProfile *profile)
 {
     const KoColorSpace *srcColorSpace = node->colorSpace();
 
     if (!node->projectionLeaf()->isLayer()) return false;
     if (!profile || *srcColorSpace->profile() == *profile) return false;
 
     KUndo2MagicString actionName = kundo2_i18n("Assign Profile to Layer");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName);
 
     applicator.applyVisitor(
         new KisAssignProfileProcessingVisitor(
             srcColorSpace, dstColorSpace),
         KisStrokeJobData::CONCURRENT);
 
     applicator.end();
 
     return true;
 }
 
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile, bool blockAllUpdates)
 {
+    if (!profile) return false;
+
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
+    bool imageProfileIsSame = *srcColorSpace->profile() == *profile;
 
-    if (!profile || *srcColorSpace->profile() == *profile) return false;
+    imageProfileIsSame &=
+        !KisLayerUtils::recursiveFindNode(m_d->rootLayer,
+            [profile] (KisNodeSP node) {
+                return *node->colorSpace()->profile() != *profile;
+            });
+
+    if (imageProfileIsSame) {
+        dbgImage << "Trying to set the same image profile again" << ppVar(srcColorSpace->profile()->name()) << ppVar(profile->name());
+        return true;
+    }
 
     KUndo2MagicString actionName = kundo2_i18n("Assign Profile");
 
     KisImageSignalVector emitSignals;
     emitSignals << ProfileChangedSignal;
     emitSignals << ModifiedSignal;
 
     const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        (!blockAllUpdates ?
                                             KisProcessingApplicator::NO_UI_UPDATES :
                                             KisProcessingApplicator::NO_IMAGE_UPDATES),
                                        emitSignals, actionName);
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(dstColorSpace,
                                                           KisImageWSP(this),
                                                           KisCommandUtils::FlipFlopCommand::INITIALIZING),
         KisStrokeJobData::BARRIER);
 
     applicator.applyVisitor(
         new KisAssignProfileProcessingVisitor(
             srcColorSpace, dstColorSpace),
         KisStrokeJobData::CONCURRENT);
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(srcColorSpace,
                                                           KisImageWSP(this),
                                                           KisCommandUtils::FlipFlopCommand::FINALIZING),
         KisStrokeJobData::BARRIER);
 
 
     applicator.end();
 
     return true;
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
 }
 
 const KoColorSpace * KisImage::colorSpace() const
 {
     return m_d->colorSpace;
 }
 
 const KoColorProfile * KisImage::profile() const
 {
     return colorSpace()->profile();
 }
 
 double KisImage::xRes() const
 {
     return m_d->xres;
 }
 
 double KisImage::yRes() const
 {
     return m_d->yres;
 }
 
 void KisImage::setResolution(double xres, double yres)
 {
     m_d->xres = xres;
     m_d->yres = yres;
     m_d->signalRouter.emitNotification(ResolutionChangedSignal);
 }
 
 QPointF KisImage::documentToPixel(const QPointF &documentCoord) const
 {
     return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
 }
 
 QPoint KisImage::documentToImagePixelFloored(const QPointF &documentCoord) const
 {
     QPointF pixelCoord = documentToPixel(documentCoord);
     return QPoint(qFloor(pixelCoord.x()), qFloor(pixelCoord.y()));
 }
 
 QRectF KisImage::documentToPixel(const QRectF &documentRect) const
 {
     return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
 }
 
 QPointF KisImage::pixelToDocument(const QPointF &pixelCoord) const
 {
     return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
 }
 
 QPointF KisImage::pixelToDocument(const QPoint &pixelCoord) const
 {
     return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
 }
 
 QRectF KisImage::pixelToDocument(const QRectF &pixelCoord) const
 {
     return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
 }
 
 qint32 KisImage::width() const
 {
     return m_d->width;
 }
 
 qint32 KisImage::height() const
 {
     return m_d->height;
 }
 
 KisGroupLayerSP KisImage::rootLayer() const
 {
     Q_ASSERT(m_d->rootLayer);
     return m_d->rootLayer;
 }
 
 KisPaintDeviceSP KisImage::projection() const
 {
     if (m_d->isolatedRootNode) {
         return m_d->isolatedRootNode->projection();
     }
 
 
     Q_ASSERT(m_d->rootLayer);
     KisPaintDeviceSP projection = m_d->rootLayer->projection();
     Q_ASSERT(projection);
     return projection;
 }
 
 qint32 KisImage::nlayers() const
 {
     QStringList list;
     list << "KisLayer";
 
     KisCountVisitor visitor(list, KoProperties());
     m_d->rootLayer->accept(visitor);
     return visitor.count();
 }
 
 qint32 KisImage::nHiddenLayers() const
 {
     QStringList list;
     list << "KisLayer";
     KoProperties properties;
     properties.setProperty("visible", false);
     KisCountVisitor visitor(list, properties);
     m_d->rootLayer->accept(visitor);
 
     return visitor.count();
 }
 
 void KisImage::flatten(KisNodeSP activeNode)
 {
     KisLayerUtils::flattenImage(this, activeNode);
 }
 
 void KisImage::mergeMultipleLayers(QList<KisNodeSP> mergedNodes, KisNodeSP putAfter)
 {
     if (!KisLayerUtils::tryMergeSelectionMasks(this, mergedNodes, putAfter)) {
         KisLayerUtils::mergeMultipleLayers(this, mergedNodes, putAfter);
     }
 }
 
 void KisImage::mergeDown(KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
 {
     KisLayerUtils::mergeDown(this, layer, strategy);
 }
 
 void KisImage::flattenLayer(KisLayerSP layer)
 {
     KisLayerUtils::flattenLayer(this, layer);
 }
 
 
 void KisImage::setModified()
 {
     m_d->signalRouter.emitNotification(ModifiedSignal);
 }
 
 QImage KisImage::convertToQImage(QRect imageRect,
                                  const KoColorProfile * profile)
 {
     qint32 x;
     qint32 y;
     qint32 w;
     qint32 h;
     imageRect.getRect(&x, &y, &w, &h);
     return convertToQImage(x, y, w, h, profile);
 }
 
 QImage KisImage::convertToQImage(qint32 x,
                                  qint32 y,
                                  qint32 w,
                                  qint32 h,
                                  const KoColorProfile * profile)
 {
     KisPaintDeviceSP dev = projection();
     if (!dev) return QImage();
     QImage image = dev->convertToQImage(const_cast<KoColorProfile*>(profile), x, y, w, h,
                                         KoColorConversionTransformation::internalRenderingIntent(),
                                         KoColorConversionTransformation::internalConversionFlags());
 
     return image;
 }
 
 
 
 QImage KisImage::convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile)
 {
     if (scaledImageSize.isEmpty()) {
         return QImage();
     }
 
     KisPaintDeviceSP dev = new KisPaintDevice(colorSpace());
     KisPainter gc;
     gc.copyAreaOptimized(QPoint(0, 0), projection(), dev, bounds());
     gc.end();
     double scaleX = qreal(scaledImageSize.width()) / width();
     double scaleY = qreal(scaledImageSize.height()) / height();
 
     QPointer<KoUpdater> updater = new KoDummyUpdater();
 
     KisTransformWorker worker(dev, scaleX, scaleY, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, updater, KisFilterStrategyRegistry::instance()->value("Bicubic"));
     worker.run();
 
     delete updater;
 
     return dev->convertToQImage(profile);
 }
 void KisImage::notifyLayersChanged()
 {
     m_d->signalRouter.emitNotification(LayersChangedSignal);
 }
 
 QRect KisImage::bounds() const
 {
     return QRect(0, 0, width(), height());
 }
 
 QRect KisImage::effectiveLodBounds() const
 {
     QRect boundRect = bounds();
 
     const int lod = currentLevelOfDetail();
     if (lod > 0) {
         KisLodTransform t(lod);
         boundRect = t.map(boundRect);
     }
 
     return boundRect;
 }
 
 KisPostExecutionUndoAdapter* KisImage::postExecutionUndoAdapter() const
 {
     const int lod = currentLevelOfDetail();
     return lod > 0 ?
         m_d->scheduler.lodNPostExecutionUndoAdapter() :
         &m_d->postExecutionUndoAdapter;
 }
 
 const KUndo2Command* KisImage::lastExecutedCommand() const
 {
     return m_d->undoStore->presentCommand();
 }
 
 void KisImage::setUndoStore(KisUndoStore *undoStore)
 {
 
     m_d->legacyUndoAdapter.setUndoStore(undoStore);
     m_d->postExecutionUndoAdapter.setUndoStore(undoStore);
     m_d->undoStore.reset(undoStore);
 }
 
 KisUndoStore* KisImage::undoStore()
 {
     return m_d->undoStore.data();
 }
 
 KisUndoAdapter* KisImage::undoAdapter() const
 {
     return &m_d->legacyUndoAdapter;
 }
 
 void KisImage::setDefaultProjectionColor(const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->rootLayer);
     m_d->rootLayer->setDefaultProjectionColor(color);
 }
 
 KoColor KisImage::defaultProjectionColor() const
 {
     KIS_ASSERT_RECOVER(m_d->rootLayer) {
         return KoColor(Qt::transparent, m_d->colorSpace);
     }
 
     return m_d->rootLayer->defaultProjectionColor();
 }
 
 void KisImage::setRootLayer(KisGroupLayerSP rootLayer)
 {
     emit sigInternalStopIsolatedModeRequested();
 
     KoColor defaultProjectionColor(Qt::transparent, m_d->colorSpace);
 
     if (m_d->rootLayer) {
         m_d->rootLayer->setGraphListener(0);
         m_d->rootLayer->disconnect();
 
         KisPaintDeviceSP original = m_d->rootLayer->original();
         defaultProjectionColor = original->defaultPixel();
     }
 
     m_d->rootLayer = rootLayer;
     m_d->rootLayer->disconnect();
     m_d->rootLayer->setGraphListener(this);
     m_d->rootLayer->setImage(this);
 
     setRoot(m_d->rootLayer.data());
     this->setDefaultProjectionColor(defaultProjectionColor);
 }
 
 void KisImage::addAnnotation(KisAnnotationSP annotation)
 {
     // Find the icc annotation, if there is one
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == annotation->type()) {
             *it = annotation;
             return;
         }
         ++it;
     }
     m_d->annotations.push_back(annotation);
 }
 
 KisAnnotationSP KisImage::annotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             return *it;
         }
         ++it;
     }
     return KisAnnotationSP(0);
 }
 
 void KisImage::removeAnnotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             m_d->annotations.erase(it);
             return;
         }
         ++it;
     }
 }
 
 vKisAnnotationSP_it KisImage::beginAnnotations()
 {
     return m_d->annotations.begin();
 }
 
 vKisAnnotationSP_it KisImage::endAnnotations()
 {
     return m_d->annotations.end();
 }
 
 void KisImage::notifyAboutToBeDeleted()
 {
     emit sigAboutToBeDeleted();
 }
 
 KisImageSignalRouter* KisImage::signalRouter()
 {
     return &m_d->signalRouter;
 }
 
 void KisImage::waitForDone()
 {
     requestStrokeEnd();
     m_d->scheduler.waitForDone();
 }
 
 KisStrokeId KisImage::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     /**
      * Ask open strokes to end gracefully. All the strokes clients
      * (including the one calling this method right now) will get
      * a notification that they should probably end their strokes.
      * However this is purely their choice whether to end a stroke
      * or not.
      */
     if (strokeStrategy->requestsOtherStrokesToEnd()) {
         requestStrokeEnd();
     }
 
     /**
      * Some of the strokes can cancel their work with undoing all the
      * changes they did to the paint devices. The problem is that undo
      * stack will know nothing about it. Therefore, just notify it
      * explicitly
      */
     if (strokeStrategy->clearsRedoOnStart()) {
         m_d->undoStore->purgeRedoState();
     }
 
     return m_d->scheduler.startStroke(strokeStrategy);
 }
 
 void KisImage::KisImagePrivate::notifyProjectionUpdatedInPatches(const QRect &rc, QVector<KisRunnableStrokeJobData*> &jobs)
 {
     KisImageConfig imageConfig(true);
     int patchWidth = imageConfig.updatePatchWidth();
     int patchHeight = imageConfig.updatePatchHeight();
 
     for (int y = 0; y < rc.height(); y += patchHeight) {
         for (int x = 0; x < rc.width(); x += patchWidth) {
             QRect patchRect(x, y, patchWidth, patchHeight);
             patchRect &= rc;
 
             KritaUtils::addJobConcurrent(jobs, std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
     struct StartIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
         StartIsolatedModeStroke(KisNodeSP node, KisImageSP image)
-            : KisRunnableBasedStrokeStrategy("start-isolated-mode", kundo2_noi18n("start-isolated-mode")),
+            : KisRunnableBasedStrokeStrategy(QLatin1String("start-isolated-mode"),
+                                             kundo2_noi18n("start-isolated-mode")),
               m_node(node),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             this->enableJob(JOB_DOSTROKE, true);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             // pass-though node don't have any projection prepared, so we should
             // explicitly regenerate it before activating isolated mode.
             m_node->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
 
             m_image->m_d->isolatedRootNode = m_node;
             emit m_image->sigIsolatedModeChanged();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             QVector<KisRunnableStrokeJobData*> jobs;
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
             this->runnableJobsInterface()->addRunnableJobs(jobs);
 
 
             m_image->invalidateAllFrames();
         }
 
     private:
         KisNodeSP m_node;
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StartIsolatedModeStroke(node, this));
     endStroke(id);
 
     return true;
 }
 
 void KisImage::stopIsolatedMode()
 {
     if (!m_d->isolatedRootNode)  return;
 
     struct StopIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
         StopIsolatedModeStroke(KisImageSP image)
-            : KisRunnableBasedStrokeStrategy("stop-isolated-mode", kundo2_noi18n("stop-isolated-mode")),
+            : KisRunnableBasedStrokeStrategy(QLatin1String("stop-isolated-mode"), kundo2_noi18n("stop-isolated-mode")),
               m_image(image)
         {
             this->enableJob(JOB_INIT);
             this->enableJob(JOB_DOSTROKE, true);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             if (!m_image->m_d->isolatedRootNode)  return;
 
             //KisNodeSP oldRootNode = m_image->m_d->isolatedRootNode;
             m_image->m_d->isolatedRootNode = 0;
 
             emit m_image->sigIsolatedModeChanged();
 
             m_image->invalidateAllFrames();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             QVector<KisRunnableStrokeJobData*> jobs;
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
             this->runnableJobsInterface()->addRunnableJobs(jobs);
 
             // TODO: Substitute notifyProjectionUpdated() with this code
             // when update optimization is implemented
             //
             // QRect updateRect = bounds() | oldRootNode->extent();
             // oldRootNode->setDirty(updateRect);
         }
 
     private:
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StopIsolatedModeStroke(this));
     endStroke(id);
 }
 
 KisNodeSP KisImage::isolatedModeRoot() const
 {
     return m_d->isolatedRootNode;
 }
 
 void KisImage::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     KisUpdateTimeMonitor::instance()->reportJobStarted(data);
     m_d->scheduler.addJob(id, data);
 }
 
 void KisImage::endStroke(KisStrokeId id)
 {
     m_d->scheduler.endStroke(id);
 }
 
 bool KisImage::cancelStroke(KisStrokeId id)
 {
     return m_d->scheduler.cancelStroke(id);
 }
 
 bool KisImage::KisImagePrivate::tryCancelCurrentStrokeAsync()
 {
     return scheduler.tryCancelCurrentStrokeAsync();
 }
 
 void KisImage::requestUndoDuringStroke()
 {
     emit sigUndoDuringStrokeRequested();
 }
 
 void KisImage::requestStrokeCancellation()
 {
     if (!m_d->tryCancelCurrentStrokeAsync()) {
         emit sigStrokeCancellationRequested();
     }
 }
 
 UndoResult KisImage::tryUndoUnfinishedLod0Stroke()
 {
     return m_d->scheduler.tryUndoLastStrokeAsync();
 }
 
 void KisImage::requestStrokeEnd()
 {
     emit sigStrokeEndRequested();
     emit sigStrokeEndRequestedActiveNodeFiltered();
 }
 
 void KisImage::requestStrokeEndActiveNode()
 {
     emit sigStrokeEndRequested();
 }
 
 void KisImage::refreshGraph(KisNodeSP root)
 {
     refreshGraph(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraph(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefresh(root, rc, cropRect);
 }
 
 void KisImage::initialRefreshGraph()
 {
     /**
      * NOTE: Tricky part. We set crop rect to null, so the clones
      * will not rely on precalculated projections of their sources
      */
 
     refreshGraphAsync(0, bounds(), QRect());
     waitForDone();
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root)
 {
     refreshGraphAsync(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc)
 {
     refreshGraphAsync(root, rc, bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefreshAsync(root, rc, cropRect);
 }
 
 void KisImage::requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect)
 {
     KIS_ASSERT_RECOVER_RETURN(pseudoFilthy);
 
     m_d->animationInterface->notifyNodeChanged(pseudoFilthy.data(), rc, false);
     m_d->scheduler.updateProjectionNoFilthy(pseudoFilthy, rc, cropRect);
 }
 
 void KisImage::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_d->scheduler.addSpontaneousJob(spontaneousJob);
 }
 
 bool KisImage::hasUpdatesRunning() const
 {
     return m_d->scheduler.hasUpdatesRunning();
 }
 
 void KisImage::setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter)
 {
     // update filters are *not* recursive!
     KIS_ASSERT_RECOVER_NOOP(!filter || !m_d->projectionUpdatesFilter);
 
     m_d->projectionUpdatesFilter = filter;
 }
 
 KisProjectionUpdatesFilterSP KisImage::projectionUpdatesFilter() const
 {
     return m_d->projectionUpdatesFilter;
 }
 
 void KisImage::disableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP(new KisDropAllProjectionUpdatesFilter()));
 }
 
 void KisImage::enableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
 }
 
 void KisImage::disableUIUpdates()
 {
     m_d->disableUIUpdateSignals.ref();
 }
 
 void KisImage::notifyBatchUpdateStarted()
 {
     m_d->signalRouter.emitNotifyBatchUpdateStarted();
 }
 
 void KisImage::notifyBatchUpdateEnded()
 {
     m_d->signalRouter.emitNotifyBatchUpdateEnded();
 }
 
 void KisImage::notifyUIUpdateCompleted(const QRect &rc)
 {
     notifyProjectionUpdated(rc);
 }
 
 QVector<QRect> KisImage::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
 
     QRect rect;
     QVector<QRect> postponedUpdates;
 
     while (m_d->savedDisabledUIUpdates.pop(rect)) {
         postponedUpdates.append(rect);
     }
 
     return postponedUpdates;
 }
 
 void KisImage::notifyProjectionUpdated(const QRect &rc)
 {
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(rc);
 
     if (!m_d->disableUIUpdateSignals) {
         int lod = currentLevelOfDetail();
         QRect dirtyRect = !lod ? rc : KisLodTransform::upscaledRect(rc, lod);
 
         if (dirtyRect.isEmpty()) return;
 
         emit sigImageUpdated(dirtyRect);
     } else {
         m_d->savedDisabledUIUpdates.push(rc);
     }
 }
 
 void KisImage::setWorkingThreadsLimit(int value)
 {
     m_d->scheduler.setThreadsLimit(value);
 }
 
 int KisImage::workingThreadsLimit() const
 {
     return m_d->scheduler.threadsLimit();
 }
 
 void KisImage::notifySelectionChanged()
 {
     /**
      * The selection is calculated asynchronously, so it is not
      * handled by disableUIUpdates() and other special signals of
      * KisImageSignalRouter
      */
     m_d->legacyUndoAdapter.emitSelectionChanged();
 
     /**
      * Editing of selection masks doesn't necessary produce a
      * setDirty() call, so in the end of the stroke we need to request
      * direct update of the UI's cache.
      */
     if (m_d->isolatedRootNode &&
         dynamic_cast<KisSelectionMask*>(m_d->isolatedRootNode.data())) {
 
         notifyProjectionUpdated(bounds());
     }
 }
 
 void KisImage::requestProjectionUpdateImpl(KisNode *node,
                                            const QVector<QRect> &rects,
                                            const QRect &cropRect)
 {
     if (rects.isEmpty()) return;
 
     m_d->scheduler.updateProjection(node, rects, cropRect);
 }
 
 void KisImage::requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache)
 {
     if (m_d->projectionUpdatesFilter
         && m_d->projectionUpdatesFilter->filter(this, node, rects, resetAnimationCache)) {
 
         return;
     }
 
     if (resetAnimationCache) {
         m_d->animationInterface->notifyNodeChanged(node, rects, false);
     }
 
     /**
      * Here we use 'permitted' instead of 'active' intentively,
      * because the updates may come after the actual stroke has been
      * finished. And having some more updates for the stroke not
      * supporting the wrap-around mode will not make much harm.
      */
     if (m_d->wrapAroundModePermitted) {
         QVector<QRect> allSplitRects;
 
         const QRect boundRect = effectiveLodBounds();
         Q_FOREACH (const QRect &rc, rects) {
             KisWrappedRect splitRect(rc, boundRect);
             allSplitRects.append(splitRect);
         }
 
         requestProjectionUpdateImpl(node, allSplitRects, boundRect);
 
     } else {
         requestProjectionUpdateImpl(node, rects, bounds());
     }
 
     KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 }
 
 void KisImage::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->animationInterface->invalidateFrames(range, rect);
 }
 
 void KisImage::requestTimeSwitch(int time)
 {
     m_d->animationInterface->requestTimeSwitchNonGUI(time);
 }
 
 KisNode *KisImage::graphOverlayNode() const
 {
     return m_d->overlaySelectionMask.data();
 }
 
 QList<KisLayerCompositionSP> KisImage::compositions()
 {
     return m_d->compositions;
 }
 
 void KisImage::addComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.append(composition);
 }
 
 void KisImage::removeComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.removeAll(composition);
 }
 
 bool checkMasksNeedConversion(KisNodeSP root, const QRect &bounds)
 {
     KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(root.data());
     if (mask &&
         (!bounds.contains(mask->paintDevice()->exactBounds()) ||
          mask->selection()->hasShapeSelection())) {
 
         return true;
     }
 
     KisNodeSP node = root->firstChild();
 
     while (node) {
         if (checkMasksNeedConversion(node, bounds)) {
             return true;
         }
 
         node = node->nextSibling();
     }
 
     return false;
 }
 
 void KisImage::setWrapAroundModePermitted(bool value)
 {
     if (m_d->wrapAroundModePermitted != value) {
         requestStrokeEnd();
     }
 
     m_d->wrapAroundModePermitted = value;
 
     if (m_d->wrapAroundModePermitted &&
         checkMasksNeedConversion(root(), bounds())) {
 
         KisProcessingApplicator applicator(this, root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Crop Selections"));
 
         KisProcessingVisitorSP visitor =
             new KisCropSelectionsProcessingVisitor(bounds());
 
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
         applicator.end();
     }
 }
 
 bool KisImage::wrapAroundModePermitted() const
 {
     return m_d->wrapAroundModePermitted;
 }
 
 bool KisImage::wrapAroundModeActive() const
 {
     return m_d->wrapAroundModePermitted &&
         m_d->scheduler.wrapAroundModeSupported();
 }
 
 void KisImage::setDesiredLevelOfDetail(int lod)
 {
     if (m_d->blockLevelOfDetail) {
         qWarning() << "WARNING: KisImage::setDesiredLevelOfDetail()"
                    << "was called while LoD functionality was being blocked!";
         return;
     }
 
     m_d->scheduler.setDesiredLevelOfDetail(lod);
 }
 
 int KisImage::currentLevelOfDetail() const
 {
     if (m_d->blockLevelOfDetail) {
         return 0;
     }
 
     return m_d->scheduler.currentLevelOfDetail();
 }
 
 void KisImage::setLevelOfDetailBlocked(bool value)
 {
     KisImageBarrierLockerRaw l(this);
 
     if (value && !m_d->blockLevelOfDetail) {
         m_d->scheduler.setDesiredLevelOfDetail(0);
     }
 
     m_d->blockLevelOfDetail = value;
 }
 
 void KisImage::explicitRegenerateLevelOfDetail()
 {
     if (!m_d->blockLevelOfDetail) {
         m_d->scheduler.explicitRegenerateLevelOfDetail();
     }
 }
 
 bool KisImage::levelOfDetailBlocked() const
 {
     return m_d->blockLevelOfDetail;
 }
 
 void KisImage::nodeCollapsedChanged(KisNode * node)
 {
     Q_UNUSED(node);
     emit sigNodeCollapsedChanged();
 }
 
 KisImageAnimationInterface* KisImage::animationInterface() const
 {
     return m_d->animationInterface;
 }
 
 void KisImage::setProofingConfiguration(KisProofingConfigurationSP proofingConfig)
 {
     m_d->proofingConfig = proofingConfig;
     emit sigProofingConfigChanged();
 }
 
 KisProofingConfigurationSP KisImage::proofingConfiguration() const
 {
     if (m_d->proofingConfig) {
         return m_d->proofingConfig;
     }
     return KisProofingConfigurationSP();
 }
 
 QPointF KisImage::mirrorAxesCenter() const
 {
     return m_d->axesCenter;
 }
 
 void KisImage::setMirrorAxesCenter(const QPointF &value) const
 {
     m_d->axesCenter = value;
 }
 
 void KisImage::setAllowMasksOnRootNode(bool value)
 {
     m_d->allowMasksOnRootNode = value;
 }
 
 bool KisImage::allowMasksOnRootNode() const
 {
     return m_d->allowMasksOnRootNode;
 }
diff --git a/libs/image/kis_recalculate_generator_layer_job.cpp b/libs/image/kis_recalculate_generator_layer_job.cpp
index f0e2b2fab6..9e614b6af4 100644
--- a/libs/image/kis_recalculate_generator_layer_job.cpp
+++ b/libs/image/kis_recalculate_generator_layer_job.cpp
@@ -1,55 +1,63 @@
 /*
  *  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_recalculate_generator_layer_job.h"
 
 #include "generator/kis_generator_layer.h"
 #include "kis_debug.h"
 #include "kis_layer.h"
 #include "kis_image.h"
 
 
 KisRecalculateGeneratorLayerJob::KisRecalculateGeneratorLayerJob(KisGeneratorLayerSP layer)
     : m_layer(layer)
 {
     setExclusive(true);
 }
 
 bool KisRecalculateGeneratorLayerJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisRecalculateGeneratorLayerJob *otherJob =
         dynamic_cast<const KisRecalculateGeneratorLayerJob*>(_otherJob);
 
     return otherJob && otherJob->m_layer == m_layer;
 }
 
 void KisRecalculateGeneratorLayerJob::run()
 {
     /**
      * The layer might have been deleted from the layers stack. In
      * such a case, don't try do update it.
      */
     if (!m_layer->parent()) return;
 
     m_layer->update();
 }
 
 int KisRecalculateGeneratorLayerJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisRecalculateGeneratorLayerJob::debugName() const
+{
+    QString result;
+    QDebug dbg(&result);
+    dbg << "KisRecalculateGeneratorLayerJob" << m_layer;
+    return result;
+}
diff --git a/libs/image/kis_recalculate_generator_layer_job.h b/libs/image/kis_recalculate_generator_layer_job.h
index d98b68777a..3e9fd51515 100644
--- a/libs/image/kis_recalculate_generator_layer_job.h
+++ b/libs/image/kis_recalculate_generator_layer_job.h
@@ -1,39 +1,41 @@
 /*
  *  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_RECALCULATE_GENERATOR_LAYER_JOB_H
 #define __KIS_RECALCULATE_GENERATOR_LAYER_JOB_H
 
 #include "kis_types.h"
 #include "kis_spontaneous_job.h"
 
 
 class KRITAIMAGE_EXPORT KisRecalculateGeneratorLayerJob : public KisSpontaneousJob
 {
 public:
     KisRecalculateGeneratorLayerJob(KisGeneratorLayerSP layer);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 private:
     KisGeneratorLayerSP m_layer;
 };
 
 #endif /* __KIS_RECALCULATE_GENERATOR_LAYER_JOB_H */
diff --git a/libs/image/kis_recalculate_transform_mask_job.cpp b/libs/image/kis_recalculate_transform_mask_job.cpp
index 7a448ca78f..a5a492c36f 100644
--- a/libs/image/kis_recalculate_transform_mask_job.cpp
+++ b/libs/image/kis_recalculate_transform_mask_job.cpp
@@ -1,92 +1,100 @@
 /*
  *  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_recalculate_transform_mask_job.h"
 
 #include "kis_transform_mask.h"
 #include "kis_debug.h"
 #include "kis_layer.h"
 #include "kis_image.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_transform_mask_params_interface.h"
 
 KisRecalculateTransformMaskJob::KisRecalculateTransformMaskJob(KisTransformMaskSP mask)
     : m_mask(mask)
 {
     setExclusive(true);
 }
 
 bool KisRecalculateTransformMaskJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisRecalculateTransformMaskJob *otherJob =
         dynamic_cast<const KisRecalculateTransformMaskJob*>(_otherJob);
 
     return otherJob && otherJob->m_mask == m_mask;
 }
 
 void KisRecalculateTransformMaskJob::run()
 {
     /**
      * The mask might have been deleted from the layers stack. In
      * such a case, don't try do update it.
      */
     if (!m_mask->parent()) return;
 
     m_mask->recaclulateStaticImage();
 
     KisLayerSP layer = qobject_cast<KisLayer*>(m_mask->parent().data());
 
     if (!layer) {
         warnKrita << "WARNING: KisRecalculateTransformMaskJob::run() Mask has no parent layer! Skipping projection update!";
         return;
     }
 
     KisImageSP image = layer->image();
     Q_ASSERT(image);
 
 
     /**
      * Depending on whether the mask is hidden we should either
      * update it entirely via the setDirty() call, or we can use a
      * lightweight approach by directly regenerating the
      * precalculated static image using
      * KisRecalculateTransformMaskJob.
      */
     if (m_mask->transformParams()->isHidden()) {
         QRect updateRect = m_mask->extent();
 
         if (layer->original()) {
             updateRect |= layer->original()->defaultBounds()->bounds();
         }
         m_mask->setDirty(updateRect);
     } else {
         /**
          * When we call requestProjectionUpdateNoFilthy() on a layer,
          * its masks' change rect is not counted, because it is considered
          * to be N_ABOVE_FILTHY. Therefore, we should expand the dirty
          * rect manually to get the correct update
          */
         QRect updateRect = layer->projectionPlane()->changeRect(layer->extent(), KisLayer::N_FILTHY);
         image->requestProjectionUpdateNoFilthy(layer, updateRect, image->bounds());
     }
 }
 
 int KisRecalculateTransformMaskJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisRecalculateTransformMaskJob::debugName() const
+{
+    QString result;
+    QDebug dbg(&result);
+    dbg << "KisRecalculateTransformMaskJob" << m_mask;
+    return result;
+}
diff --git a/libs/image/kis_recalculate_transform_mask_job.h b/libs/image/kis_recalculate_transform_mask_job.h
index f770d5079f..90e4beebea 100644
--- a/libs/image/kis_recalculate_transform_mask_job.h
+++ b/libs/image/kis_recalculate_transform_mask_job.h
@@ -1,39 +1,41 @@
 /*
  *  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_RECALCULATE_TRANSFORM_MASK_JOB_H
 #define __KIS_RECALCULATE_TRANSFORM_MASK_JOB_H
 
 #include "kis_types.h"
 #include "kis_spontaneous_job.h"
 
 
 class KRITAIMAGE_EXPORT KisRecalculateTransformMaskJob : public KisSpontaneousJob
 {
 public:
     KisRecalculateTransformMaskJob(KisTransformMaskSP mask);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 private:
     KisTransformMaskSP m_mask;
 };
 
 #endif /* __KIS_RECALCULATE_TRANSFORM_MASK_JOB_H */
diff --git a/libs/image/kis_regenerate_frame_stroke_strategy.cpp b/libs/image/kis_regenerate_frame_stroke_strategy.cpp
index efd43a4471..f8ac05c824 100644
--- a/libs/image/kis_regenerate_frame_stroke_strategy.cpp
+++ b/libs/image/kis_regenerate_frame_stroke_strategy.cpp
@@ -1,251 +1,251 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_regenerate_frame_stroke_strategy.h"
 
 #include <QRegion>
 #include "kis_image_interfaces.h"
 #include "kis_image_animation_interface.h"
 #include "kis_node.h"
 #include "kis_image.h"
 #include "krita_utils.h"
 
 #include "kis_full_refresh_walker.h"
 #include "kis_async_merger.h"
 #include "kis_projection_updates_filter.h"
 
 
 struct KisRegenerateFrameStrokeStrategy::Private
 {
     Type type;
     int frameId;
     int previousFrameId;
     QRegion dirtyRegion;
     KisImageAnimationInterface *interface;
     KisProjectionUpdatesFilterSP prevUpdatesFilter;
 
     class Data : public KisStrokeJobData {
     public:
         Data(KisNodeSP _root, const QRect &_rect, const QRect &_cropRect)
             : KisStrokeJobData(CONCURRENT),
               root(_root), rect(_rect), cropRect(_cropRect)
             {}
 
         KisStrokeJobData* createLodClone(int levelOfDetail) override {
             Q_UNUSED(levelOfDetail);
             return new KisStrokeJobData(CONCURRENT);
         }
 
         KisNodeSP root;
         QRect rect;
         QRect cropRect;
     };
 
     void saveAndResetUpdatesFilter() {
         KisImageSP image = interface->image().toStrongRef();
         if (!image) {
             return;
         }
         prevUpdatesFilter = image->projectionUpdatesFilter();
         image->setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
     }
 
     void restoreUpdatesFilter() {
         KisImageSP image = interface->image().toStrongRef();
         if (!image) {
             return;
         }
         image->setProjectionUpdatesFilter(prevUpdatesFilter);
         prevUpdatesFilter.clear();
     }
 };
 
 KisRegenerateFrameStrokeStrategy::KisRegenerateFrameStrokeStrategy(int frameId,
                                                                    const QRegion &dirtyRegion,
                                                                    KisImageAnimationInterface *interface)
-    : KisSimpleStrokeStrategy("regenerate_external_frame_stroke"),
+    : KisSimpleStrokeStrategy(QLatin1String("regenerate_external_frame_stroke")),
       m_d(new Private)
 {
     m_d->type = EXTERNAL_FRAME;
 
     m_d->frameId = frameId;
     m_d->dirtyRegion = dirtyRegion;
     m_d->interface = interface;
 
     enableJob(JOB_INIT);
     enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
     enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
 
     enableJob(JOB_DOSTROKE);
 
     enableJob(JOB_SUSPEND);
     enableJob(JOB_RESUME);
 
     setRequestsOtherStrokesToEnd(false);
     setClearsRedoOnStart(false);
     setCanForgetAboutMe(true);
 }
 
 KisRegenerateFrameStrokeStrategy::KisRegenerateFrameStrokeStrategy(KisImageAnimationInterface *interface)
-    : KisSimpleStrokeStrategy("regenerate_current_frame_stroke", kundo2_i18n("Render Animation")),
+    : KisSimpleStrokeStrategy(QLatin1String("regenerate_current_frame_stroke"), kundo2_i18n("Render Animation")),
       m_d(new Private)
 {
     m_d->type = CURRENT_FRAME;
 
     m_d->frameId = 0;
     m_d->dirtyRegion = QRegion();
     m_d->interface = interface;
 
     enableJob(JOB_INIT);
     enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
     enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
 
     enableJob(JOB_SUSPEND);
     enableJob(JOB_RESUME);
 
     // switching frames is a distinct user action, so it should
     // cancel the playback or any action easily
     setRequestsOtherStrokesToEnd(true);
     setClearsRedoOnStart(false);
 }
 
 KisRegenerateFrameStrokeStrategy::~KisRegenerateFrameStrokeStrategy()
 {
 }
 
 void KisRegenerateFrameStrokeStrategy::initStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->saveAndResetUpdatesFilter();
         image->disableUIUpdates();
         m_d->interface->saveAndResetCurrentTime(m_d->frameId, &m_d->previousFrameId);
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(true);
         m_d->interface->updatesFacade()->refreshGraphAsync(KisNodeSP());
     }
 }
 
 void KisRegenerateFrameStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Private::Data *d = dynamic_cast<Private::Data*>(data);
     KIS_ASSERT(d);
     KIS_ASSERT(!m_d->dirtyRegion.isEmpty());
     KIS_ASSERT(m_d->type == EXTERNAL_FRAME);
 
     KisBaseRectsWalkerSP walker = new KisFullRefreshWalker(d->cropRect);
     walker->collectRects(d->root, d->rect);
 
     KisAsyncMerger merger;
     merger.startMerge(*walker);
 }
 
 void KisRegenerateFrameStrokeStrategy::finishStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->interface->notifyFrameReady();
         m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
         image->enableUIUpdates();
         m_d->restoreUpdatesFilter();
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(false);
     }
 }
 
 void KisRegenerateFrameStrokeStrategy::cancelStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->interface->notifyFrameCancelled();
         m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
         image->enableUIUpdates();
         m_d->restoreUpdatesFilter();
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(false);
     }
 }
 
 KisStrokeStrategy* KisRegenerateFrameStrokeStrategy::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
 
     /**
      * We need to regenerate animation frames on LodN level only if
      * we are processing current frame. Return dummy stroke otherwise
      */
     return m_d->type == CURRENT_FRAME ?
         new KisRegenerateFrameStrokeStrategy(m_d->interface) :
-        new KisSimpleStrokeStrategy("dumb-lodn-KisRegenerateFrameStrokeStrategy");
+        new KisSimpleStrokeStrategy(QLatin1String("dumb-lodn-KisRegenerateFrameStrokeStrategy"));
 }
 
 void KisRegenerateFrameStrokeStrategy::suspendStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
         image->enableUIUpdates();
         m_d->restoreUpdatesFilter();
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(false);
     }
 }
 
 void KisRegenerateFrameStrokeStrategy::resumeStrokeCallback()
 {
     KisImageSP image = m_d->interface->image().toStrongRef();
     if (!image) {
         return;
     }
     if (m_d->type == EXTERNAL_FRAME) {
         m_d->saveAndResetUpdatesFilter();
         image->disableUIUpdates();
         m_d->interface->saveAndResetCurrentTime(m_d->frameId, &m_d->previousFrameId);
     } else if (m_d->type == CURRENT_FRAME) {
         m_d->interface->blockFrameInvalidation(true);
     }
 }
 
 QList<KisStrokeJobData*> KisRegenerateFrameStrokeStrategy::createJobsData(KisImageWSP _image)
 {
     using KritaUtils::splitRectIntoPatches;
     using KritaUtils::optimalPatchSize;
     KisImageSP image = _image;
 
     const QRect cropRect = image->bounds();
     QVector<QRect> rects = splitRectIntoPatches(image->bounds(), optimalPatchSize());
     QList<KisStrokeJobData*> jobsData;
 
     Q_FOREACH (const QRect &rc, rects) {
         jobsData << new Private::Data(image->root(), rc, cropRect);
     }
 
     return jobsData;
 }
diff --git a/libs/image/kis_spontaneous_job.cpp b/libs/image/kis_runnable_with_debug_name.h
similarity index 68%
rename from libs/image/kis_spontaneous_job.cpp
rename to libs/image/kis_runnable_with_debug_name.h
index cb612d41a9..f4ecee9263 100644
--- a/libs/image/kis_spontaneous_job.cpp
+++ b/libs/image/kis_runnable_with_debug_name.h
@@ -1,30 +1,31 @@
 /*
- *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *  Copyright (c) 2019 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_spontaneous_job.h"
+#ifndef KIS_RUNNABLE_WITH_DEBUG_NAME_H
+#define KIS_RUNNABLE_WITH_DEBUG_NAME_H
 
+#include "kis_runnable.h"
+#include <QString>
 
-bool KisSpontaneousJob::isExclusive() const
+class KRITAIMAGE_EXPORT KisRunnableWithDebugName : public KisRunnable
 {
-    return m_isExclusive;
-}
+public:
+    virtual QString debugName() const = 0;
+};
 
-void KisSpontaneousJob::setExclusive(bool value)
-{
-
-}
+#endif // KIS_RUNNABLE_WITH_DEBUG_NAME_H
diff --git a/libs/image/kis_selection_mask.cpp b/libs/image/kis_selection_mask.cpp
index 6a3474dd26..a735460946 100644
--- a/libs/image/kis_selection_mask.cpp
+++ b/libs/image/kis_selection_mask.cpp
@@ -1,321 +1,327 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_mask.h"
 
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_selection.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoProperties.h>
 #include "kis_fill_painter.h"
 #include <KoCompositeOp.h>
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_pixel_selection.h"
 #include "kis_undo_adapter.h"
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include "kis_thread_safe_signal_compressor.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_cached_paint_device.h"
 
 #include "kis_image_config.h"
 #include "KisImageConfigNotifier.h"
 
 
 struct Q_DECL_HIDDEN KisSelectionMask::Private
 {
 public:
     Private(KisSelectionMask *_q)
         : q(_q)
         , updatesCompressor(0)
         , maskColor(Qt::green, KoColorSpaceRegistry::instance()->rgb8())
     {}
     KisSelectionMask *q;
     KisImageWSP image;
     KisCachedPaintDevice paintDeviceCache;
     KisCachedSelection cachedSelection;
     KisThreadSafeSignalCompressor *updatesCompressor;
     KoColor maskColor;
 
     void slotSelectionChangedCompressed();
+    void slotConfigChangedImpl(bool blockUpdates);
     void slotConfigChanged();
 };
 
 KisSelectionMask::KisSelectionMask(KisImageWSP image)
     : KisEffectMask()
     , m_d(new Private(this))
 {
     setName("selection");
     setActive(false);
     setSupportsLodMoves(false);
 
     m_d->image = image;
 
     m_d->updatesCompressor =
             new KisThreadSafeSignalCompressor(50, KisSignalCompressor::FIRST_ACTIVE);
 
     connect(m_d->updatesCompressor, SIGNAL(timeout()), SLOT(slotSelectionChangedCompressed()));
     this->moveToThread(image->thread());
 
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
-    m_d->slotConfigChanged();
+    m_d->slotConfigChangedImpl(false);
 }
 
 KisSelectionMask::KisSelectionMask(const KisSelectionMask& rhs)
     : KisEffectMask(rhs)
     , m_d(new Private(this))
 {
     m_d->image = rhs.image();
     m_d->updatesCompressor =
             new KisThreadSafeSignalCompressor(300, KisSignalCompressor::POSTPONE);
 
     connect(m_d->updatesCompressor, SIGNAL(timeout()), SLOT(slotSelectionChangedCompressed()));
     this->moveToThread(m_d->image->thread());
 
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
-    m_d->slotConfigChanged();
+    m_d->slotConfigChangedImpl(false);
 }
 
 KisSelectionMask::~KisSelectionMask()
 {
     m_d->updatesCompressor->deleteLater();
     delete m_d;
 }
 
 QIcon KisSelectionMask::icon() const {
     return KisIconUtils::loadIcon("selectionMask");
 }
 
 void KisSelectionMask::mergeInMaskInternal(KisPaintDeviceSP projection,
                                            KisSelectionSP effectiveSelection,
                                            const QRect &applyRect,
                                            const QRect &preparedNeedRect,
                                            KisNode::PositionToFilthy maskPos) const
 {
     Q_UNUSED(maskPos);
     Q_UNUSED(preparedNeedRect);
     if (!effectiveSelection) return;
 
     {
         KisSelectionSP mainMaskSelection = this->selection();
         if (mainMaskSelection &&
             (!mainMaskSelection->isVisible() ||
              mainMaskSelection->pixelSelection()->defaultBounds()->externalFrameActive())) {
 
             return;
         }
     }
 
     KisCachedPaintDevice::Guard d1(projection, m_d->paintDeviceCache);
     KisPaintDeviceSP fillDevice = d1.device();
     fillDevice->setDefaultPixel(m_d->maskColor);
 
     const QRect selectionExtent = effectiveSelection->selectedRect();
 
     if (selectionExtent.contains(applyRect) || selectionExtent.intersects(applyRect)) {
         KisCachedSelection::Guard s1(m_d->cachedSelection);
         KisSelectionSP invertedSelection = s1.selection();
 
         invertedSelection->pixelSelection()->makeCloneFromRough(effectiveSelection->pixelSelection(), applyRect);
         invertedSelection->pixelSelection()->invert();
 
         KisPainter gc(projection);
         gc.setSelection(invertedSelection);
         gc.bitBlt(applyRect.topLeft(), fillDevice, applyRect);
 
     } else {
         KisPainter gc(projection);
         gc.bitBlt(applyRect.topLeft(), fillDevice, applyRect);
     }
 }
 
 bool KisSelectionMask::paintsOutsideSelection() const
 {
     return true;
 }
 
 void KisSelectionMask::setSelection(KisSelectionSP selection)
 {
     if (selection) {
         KisEffectMask::setSelection(selection);
     } else {
         KisEffectMask::setSelection(new KisSelection());
 
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->alpha8();
         KisFillPainter gc(KisPaintDeviceSP(this->selection()->pixelSelection().data()));
         gc.fillRect(image()->bounds(), KoColor(Qt::white, cs), MAX_SELECTED);
         gc.end();
     }
     setDirty();
 }
 
 KisImageWSP KisSelectionMask::image() const
 {
     return m_d->image;
 }
 
 bool KisSelectionMask::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisSelectionMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 KisBaseNode::PropertyList KisSelectionMask::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisBaseNode::sectionModelProperties();
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::selectionActive, active());
     return l;
 }
 
 void KisSelectionMask::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisEffectMask::setSectionModelProperties(properties);
     setActive(properties.at(2).state.toBool());
 }
 
 void KisSelectionMask::setVisible(bool visible, bool isLoading)
 {
     const bool oldVisible = this->visible(false);
     setNodeProperty("visible", visible);
 
     if (!isLoading && visible != oldVisible) {
         if (selection())
             selection()->setVisible(visible);
     }
 }
 
 bool KisSelectionMask::active() const
 {
     return nodeProperties().boolProperty("active", true);
 }
 
 void KisSelectionMask::setActive(bool active)
 {
     KisImageWSP image = this->image();
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
 
     if (active && parentLayer) {
         KisSelectionMaskSP activeMask = parentLayer->selectionMask();
         if (activeMask && activeMask != this) {
             activeMask->setActive(false);
         }
     }
 
     const bool oldActive = this->active();
     setNodeProperty("active", active);
 
 
     /**
      * WARNING: we have a direct link to the image here, but we
      * must not use it for notification until we are a part of
      * the nore graph! Notifications should be emitted iff we
      * have graph listener link set up.
      */
     if (graphListener() &&
         image && oldActive != active) {
 
         baseNodeChangedCallback();
         image->undoAdapter()->emitSelectionChanged();
     }
 }
 
 QRect KisSelectionMask::needRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     // selection masks just add an overlay, so the needed rect is simply passed through
     return rect;
 }
 
 QRect KisSelectionMask::changeRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     // selection masks just add an overlay, so the changed rect is simply passed through
     return rect;
 }
 
 QRect KisSelectionMask::extent() const
 {
     // since mask overlay is inverted, the mask paints over
     // the entire image bounds
 
     QRect resultRect;
 
     KisSelectionSP selection = this->selection();
 
     if (selection) {
         resultRect = selection->pixelSelection()->defaultBounds()->bounds();
     } else if (KisNodeSP parent = this->parent()) {
         KisPaintDeviceSP dev = parent->projection();
         if (dev) {
             resultRect = dev->defaultBounds()->bounds();
         }
     }
 
     return resultRect;
 }
 
 QRect KisSelectionMask::exactBounds() const
 {
     return extent();
 }
 
 void KisSelectionMask::notifySelectionChangedCompressed()
 {
     m_d->updatesCompressor->start();
 }
 
 void KisSelectionMask::flattenSelectionProjection(KisSelectionSP selection, const QRect &dirtyRect) const
 {
     Q_UNUSED(selection);
     Q_UNUSED(dirtyRect);
 }
 
 void KisSelectionMask::Private::slotSelectionChangedCompressed()
 {
     KisSelectionSP currentSelection = q->selection();
     if (!currentSelection) return;
 
     currentSelection->notifySelectionChanged();
 }
 
-void KisSelectionMask::Private::slotConfigChanged()
+void KisSelectionMask::Private::slotConfigChangedImpl(bool doUpdates)
 {
     const KoColorSpace *cs = image ?
         image->colorSpace() :
         KoColorSpaceRegistry::instance()->rgb8();
 
     KisImageConfig cfg(true);
 
     maskColor = KoColor(cfg.selectionOverlayMaskColor(), cs);
 
-    if (image && image->overlaySelectionMask() == q) {
+    if (doUpdates && image && image->overlaySelectionMask() == q) {
         q->setDirty();
     }
 }
 
+void KisSelectionMask::Private::slotConfigChanged()
+{
+    slotConfigChangedImpl(true);
+}
+
 #include "moc_kis_selection_mask.cpp"
diff --git a/libs/image/kis_simple_stroke_strategy.cpp b/libs/image/kis_simple_stroke_strategy.cpp
index 253462a07b..5fc12ede4c 100644
--- a/libs/image/kis_simple_stroke_strategy.cpp
+++ b/libs/image/kis_simple_stroke_strategy.cpp
@@ -1,197 +1,233 @@
 /*
  *  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_simple_stroke_strategy.h"
 
 
 /***************************************************************/
 /*         private class: SimpleStrokeJobStrategy              */
 /***************************************************************/
 
 class SimpleStrokeJobStrategy : public KisStrokeJobStrategy
 {
 public:
     SimpleStrokeJobStrategy(KisSimpleStrokeStrategy::JobType type,
                             KisSimpleStrokeStrategy *parentStroke)
         : m_type(type),
           m_parentStroke(parentStroke)
     {
     }
 
     void run(KisStrokeJobData *data) override {
         switch(m_type) {
         case KisSimpleStrokeStrategy::JOB_INIT:
             Q_UNUSED(data);
             m_parentStroke->initStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_FINISH:
             Q_UNUSED(data);
             m_parentStroke->finishStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_CANCEL:
             Q_UNUSED(data);
             m_parentStroke->cancelStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_DOSTROKE:
             m_parentStroke->doStrokeCallback(data);
             break;
         case KisSimpleStrokeStrategy::JOB_SUSPEND:
             m_parentStroke->suspendStrokeCallback();
             break;
         case KisSimpleStrokeStrategy::JOB_RESUME:
             m_parentStroke->resumeStrokeCallback();
             break;
         default:
             break;
         }
     }
 
+    QString debugId() const override {
+        return QString("%1/%2")
+            .arg(m_parentStroke->id())
+            .arg(KisSimpleStrokeStrategy::jobTypeToString(m_type));
+    }
+
 private:
     KisSimpleStrokeStrategy::JobType m_type;
     KisSimpleStrokeStrategy *m_parentStroke;
 };
 
 
 /***************************************************************/
 /*                 KisSimpleStrokeStrategy                     */
 /***************************************************************/
 
-KisSimpleStrokeStrategy::KisSimpleStrokeStrategy(QString id, const KUndo2MagicString &name)
+KisSimpleStrokeStrategy::KisSimpleStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name)
     : KisStrokeStrategy(id, name),
       m_jobEnabled(NJOBS, false),
       m_jobSequentiality(NJOBS, KisStrokeJobData::SEQUENTIAL),
       m_jobExclusivity(NJOBS, KisStrokeJobData::NORMAL)
 {
 }
 
 KisSimpleStrokeStrategy::KisSimpleStrokeStrategy(const KisSimpleStrokeStrategy &rhs)
     : KisStrokeStrategy(rhs),
       m_jobEnabled(rhs.m_jobEnabled),
       m_jobSequentiality(rhs.m_jobSequentiality),
       m_jobExclusivity(rhs.m_jobExclusivity)
 {
 }
 
 void KisSimpleStrokeStrategy::enableJob(JobType type, bool enable,
                                         KisStrokeJobData::Sequentiality sequentiality,
                                         KisStrokeJobData::Exclusivity exclusivity)
 {
     m_jobEnabled[(int)type] = enable;
     m_jobSequentiality[(int)type] = sequentiality;
     m_jobExclusivity[(int)type] = exclusivity;
 }
 
 KisStrokeJobStrategy*
 KisSimpleStrokeStrategy::createStrategy(JobType type)
 {
     KisStrokeJobStrategy *strategy = 0;
 
     if(m_jobEnabled[(int)type]) {
         strategy = new SimpleStrokeJobStrategy(type, this);
     }
 
     return strategy;
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createInitStrategy()
 {
     return createStrategy(JOB_INIT);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createFinishStrategy()
 {
     return createStrategy(JOB_FINISH);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createCancelStrategy()
 {
     return createStrategy(JOB_CANCEL);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createDabStrategy()
 {
     return createStrategy(JOB_DOSTROKE);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createSuspendStrategy()
 {
     return createStrategy(JOB_SUSPEND);
 }
 
 KisStrokeJobStrategy* KisSimpleStrokeStrategy::createResumeStrategy()
 {
     return createStrategy(JOB_RESUME);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createData(JobType type)
 {
     KisStrokeJobData::Sequentiality sequentiality = m_jobSequentiality[(int)type];
     KisStrokeJobData::Exclusivity exclusivity = m_jobExclusivity[(int)type];
 
     return new KisStrokeJobData(sequentiality, exclusivity);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createInitData()
 {
     return createData(JOB_INIT);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createFinishData()
 {
     return createData(JOB_FINISH);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createCancelData()
 {
     return createData(JOB_CANCEL);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createSuspendData()
 {
     return createData(JOB_SUSPEND);
 }
 
 KisStrokeJobData* KisSimpleStrokeStrategy::createResumeData()
 {
     return createData(JOB_RESUME);
 }
 
 void KisSimpleStrokeStrategy::initStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::finishStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::cancelStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Q_UNUSED(data);
 }
 
 void KisSimpleStrokeStrategy::suspendStrokeCallback()
 {
 }
 
 void KisSimpleStrokeStrategy::resumeStrokeCallback()
 {
 }
+
+QLatin1String KisSimpleStrokeStrategy::jobTypeToString(KisSimpleStrokeStrategy::JobType type)
+{
+    QLatin1String result;
+
+    switch (type) {
+    case JOB_INIT:
+        result = QLatin1String("init");
+        break;
+    case JOB_DOSTROKE:
+        result = QLatin1String("dostroke");
+        break;
+    case JOB_FINISH:
+        result = QLatin1String("finish");
+        break;
+    case JOB_CANCEL:
+        result = QLatin1String("cancel");
+        break;
+    case JOB_SUSPEND:
+        result = QLatin1String("suspend");
+        break;
+    case JOB_RESUME:
+        result = QLatin1String("resume");
+        break;
+    case NJOBS:
+        qFatal("Undefined stroke job type: %d", type);
+    }
+
+    return result;
+}
diff --git a/libs/image/kis_simple_stroke_strategy.h b/libs/image/kis_simple_stroke_strategy.h
index de599f6a6a..f97cef60bb 100644
--- a/libs/image/kis_simple_stroke_strategy.h
+++ b/libs/image/kis_simple_stroke_strategy.h
@@ -1,82 +1,84 @@
 /*
  *  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_SIMPLE_STROKE_STRATEGY_H
 #define __KIS_SIMPLE_STROKE_STRATEGY_H
 
 #include <QVector>
 #include "kis_stroke_strategy.h"
 #include "kis_stroke_job_strategy.h"
 
 
 class KRITAIMAGE_EXPORT KisSimpleStrokeStrategy : public KisStrokeStrategy
 {
 public:
     enum JobType {
         JOB_INIT = 0,
         JOB_CANCEL,
         JOB_FINISH,
         JOB_DOSTROKE,
         JOB_SUSPEND,
         JOB_RESUME,
 
         NJOBS
     };
 
 public:
-    KisSimpleStrokeStrategy(QString id = QString(), const KUndo2MagicString &name = KUndo2MagicString());
+    KisSimpleStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name = KUndo2MagicString());
 
     KisStrokeJobStrategy* createInitStrategy() override;
     KisStrokeJobStrategy* createFinishStrategy() override;
     KisStrokeJobStrategy* createCancelStrategy() override;
     KisStrokeJobStrategy* createDabStrategy() override;
     KisStrokeJobStrategy* createSuspendStrategy() override;
     KisStrokeJobStrategy* createResumeStrategy() override;
 
     KisStrokeJobData* createInitData() override;
     KisStrokeJobData* createFinishData() override;
     KisStrokeJobData* createCancelData() override;
     KisStrokeJobData* createSuspendData() override;
     KisStrokeJobData* createResumeData() override;
 
     virtual void initStrokeCallback();
     virtual void finishStrokeCallback();
     virtual void cancelStrokeCallback();
     virtual void doStrokeCallback(KisStrokeJobData *data);
     virtual void suspendStrokeCallback();
     virtual void resumeStrokeCallback();
 
+    static QLatin1String jobTypeToString(JobType type);
+
 protected:
     void enableJob(JobType type, bool enable = true,
                    KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                    KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
 protected:
     KisSimpleStrokeStrategy(const KisSimpleStrokeStrategy &rhs);
 
 private:
     KisStrokeJobStrategy* createStrategy(JobType type);
     KisStrokeJobData* createData(JobType type);
 
 private:
     QVector<bool> m_jobEnabled;
     QVector<KisStrokeJobData::Sequentiality> m_jobSequentiality;
     QVector<KisStrokeJobData::Exclusivity> m_jobExclusivity;
 };
 
 #endif /* __KIS_SIMPLE_STROKE_STRATEGY_H */
diff --git a/libs/image/kis_spontaneous_job.h b/libs/image/kis_spontaneous_job.h
index 033eac24e6..594ac73485 100644
--- a/libs/image/kis_spontaneous_job.h
+++ b/libs/image/kis_spontaneous_job.h
@@ -1,48 +1,48 @@
 /*
  *  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_SPONTANEOUS_JOB_H
 #define __KIS_SPONTANEOUS_JOB_H
 
-#include "kis_runnable.h"
+#include "kis_runnable_with_debug_name.h"
 
 /**
  * This class represents a simple update just that should be
  * executed by the updates system from time to time, without
  * any undo support. Just some useful update that
  * can be run concurrently with other types updates.
  */
-class KRITAIMAGE_EXPORT KisSpontaneousJob : public KisRunnable
+class KRITAIMAGE_EXPORT KisSpontaneousJob : public KisRunnableWithDebugName
 {
 public:
     virtual bool overrides(const KisSpontaneousJob *otherJob) = 0;
     virtual int levelOfDetail() const = 0;
     bool isExclusive() const {
         return m_isExclusive;
     }
 
 protected:
     void setExclusive(bool value) {
         m_isExclusive = value;
     }
 
 private:
     bool m_isExclusive = false;
 };
 
 #endif /* __KIS_SPONTANEOUS_JOB_H */
diff --git a/libs/image/kis_stroke_job.h b/libs/image/kis_stroke_job.h
index 2a2b2adaa1..55a0c9e5df 100644
--- a/libs/image/kis_stroke_job.h
+++ b/libs/image/kis_stroke_job.h
@@ -1,103 +1,108 @@
 /*
  *  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_STROKE_JOB_H
 #define __KIS_STROKE_JOB_H
 
-#include "kis_runnable.h"
+#include "kis_runnable_with_debug_name.h"
 #include "kis_stroke_job_strategy.h"
 
-class KisStrokeJob : public KisRunnable
+class KisStrokeJob : public KisRunnableWithDebugName
 {
 public:
     KisStrokeJob(KisStrokeJobStrategy *strategy,
                  KisStrokeJobData *data,
                  int levelOfDetail,
                  bool isOwnJob)
         : m_dabStrategy(strategy),
           m_dabData(data),
           m_levelOfDetail(levelOfDetail),
           m_isOwnJob(isOwnJob)
     {
     }
 
     ~KisStrokeJob() override {
         delete m_dabData;
     }
 
     void run() override {
         m_dabStrategy->run(m_dabData);
     }
 
     KisStrokeJobData::Sequentiality sequentiality() const {
         return m_dabData ? m_dabData->sequentiality() : KisStrokeJobData::SEQUENTIAL;
     }
 
     bool isSequential() const {
         // Default value is 'SEQUENTIAL'
         return m_dabData ? m_dabData->isSequential() : true;
     }
 
     bool isBarrier() const {
         // Default value is simply 'SEQUENTIAL', *not* 'BARRIER'
         return m_dabData ? m_dabData->isBarrier() : false;
     }
 
     bool isExclusive() const {
         // Default value is 'NORMAL'
         return m_dabData ? m_dabData->isExclusive() : false;
     }
 
     int levelOfDetail() const {
         return m_levelOfDetail;
     }
 
     bool isCancellable() const {
-        return m_isOwnJob;
+        return m_isOwnJob &&
+            (!m_dabData || m_dabData->isCancellable());
     }
 
     bool isOwnJob() const {
         return m_isOwnJob;
     }
 
+    QString debugName() const override {
+        return m_dabStrategy->debugId();
+    }
+
 private:
     // for testing use only, do not use in real code
     friend QString getJobName(KisStrokeJob *job);
     friend QString getCommandName(KisStrokeJob *job);
     friend int cancelSeqNo(KisStrokeJob *job);
 
     KisStrokeJobStrategy* testingGetDabStrategy() {
         return m_dabStrategy;
     }
 
     KisStrokeJobData* testingGetDabData() {
         return m_dabData;
     }
 
 private:
     // Shared between different jobs
     KisStrokeJobStrategy *m_dabStrategy;
 
     // Owned by the job
     KisStrokeJobData *m_dabData;
 
     int m_levelOfDetail;
     bool m_isOwnJob;
 };
 
 #endif /* __KIS_STROKE_JOB_H */
diff --git a/libs/image/kis_stroke_job_strategy.cpp b/libs/image/kis_stroke_job_strategy.cpp
index 93800bc71d..c70fdaf20e 100644
--- a/libs/image/kis_stroke_job_strategy.cpp
+++ b/libs/image/kis_stroke_job_strategy.cpp
@@ -1,70 +1,82 @@
 /*
  *  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_stroke_job_strategy.h"
 
 #include <QtGlobal>
 
 
 KisStrokeJobData::KisStrokeJobData(Sequentiality sequentiality,
                                    Exclusivity exclusivity)
     : m_sequentiality(sequentiality),
-      m_exclusivity(exclusivity)
+      m_exclusivity(exclusivity),
+      m_isCancellable(true)
 {
 }
 
 KisStrokeJobData::KisStrokeJobData(const KisStrokeJobData &rhs)
     : m_sequentiality(rhs.m_sequentiality),
-      m_exclusivity(rhs.m_exclusivity)
+      m_exclusivity(rhs.m_exclusivity),
+      m_isCancellable(rhs.m_isCancellable)
 {
 }
 
 KisStrokeJobData::~KisStrokeJobData()
 {
 }
 
 bool KisStrokeJobData::isBarrier() const
 {
     return m_sequentiality == BARRIER;
 }
 
 bool KisStrokeJobData::isSequential() const
 {
     return m_sequentiality == SEQUENTIAL;
 }
 
 bool KisStrokeJobData::isExclusive() const
 {
     return m_exclusivity == EXCLUSIVE;
 }
 
 KisStrokeJobData* KisStrokeJobData::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
     return 0;
 }
 
+bool KisStrokeJobData::isCancellable() const
+{
+    return m_isCancellable;
+}
+
+void KisStrokeJobData::setCancellable(bool value)
+{
+    m_isCancellable = value;
+}
+
 KisStrokeJobStrategy::KisStrokeJobStrategy()
 {
 }
 
 KisStrokeJobStrategy::~KisStrokeJobStrategy()
 {
 }
 
 
diff --git a/libs/image/kis_stroke_job_strategy.h b/libs/image/kis_stroke_job_strategy.h
index 45bb6eecc5..28031deb84 100644
--- a/libs/image/kis_stroke_job_strategy.h
+++ b/libs/image/kis_stroke_job_strategy.h
@@ -1,75 +1,81 @@
 /*
  *  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_STROKE_JOB_STRATEGY_H
 #define __KIS_STROKE_JOB_STRATEGY_H
 
 #include "kritaimage_export.h"
+#include <QLatin1String>
 
 
 class KRITAIMAGE_EXPORT KisStrokeJobData
 {
 public:
     enum Sequentiality {
         CONCURRENT,
         SEQUENTIAL,
         BARRIER,
         UNIQUELY_CONCURRENT
     };
 
     enum Exclusivity {
         NORMAL,
         EXCLUSIVE
     };
 
 public:
     KisStrokeJobData(Sequentiality sequentiality = SEQUENTIAL,
                      Exclusivity exclusivity = NORMAL);
     virtual ~KisStrokeJobData();
 
     bool isBarrier() const;
     bool isSequential() const;
     bool isExclusive() const;
 
     Sequentiality sequentiality() { return m_sequentiality; }
     Exclusivity exclusivity() { return m_exclusivity; }
 
     virtual KisStrokeJobData* createLodClone(int levelOfDetail);
 
+    bool isCancellable() const;
+    void setCancellable(bool value);
+
 protected:
     KisStrokeJobData(const KisStrokeJobData &rhs);
 
 private:
     Sequentiality m_sequentiality;
     Exclusivity m_exclusivity;
+    bool m_isCancellable;
 };
 
 
 class KRITAIMAGE_EXPORT KisStrokeJobStrategy
 {
 public:
     KisStrokeJobStrategy();
     virtual ~KisStrokeJobStrategy();
 
     virtual void run(KisStrokeJobData *data) = 0;
+    virtual QString debugId() const = 0;
 
 
 private:
 };
 
 #endif /* __KIS_STROKE_JOB_STRATEGY_H */
diff --git a/libs/image/kis_stroke_strategy.cpp b/libs/image/kis_stroke_strategy.cpp
index 51fc84ca3c..cec29bd135 100644
--- a/libs/image/kis_stroke_strategy.cpp
+++ b/libs/image/kis_stroke_strategy.cpp
@@ -1,226 +1,226 @@
 /*
  *  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_stroke_strategy.h"
 #include <KoCompositeOpRegistry.h>
 #include "kis_stroke_job_strategy.h"
 #include "KisStrokesQueueMutatedJobInterface.h"
 
 
-KisStrokeStrategy::KisStrokeStrategy(QString id, const KUndo2MagicString &name)
+KisStrokeStrategy::KisStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name)
     : m_exclusive(false),
       m_supportsWrapAroundMode(false),
       m_clearsRedoOnStart(true),
       m_requestsOtherStrokesToEnd(true),
       m_canForgetAboutMe(false),
       m_needsExplicitCancel(false),
       m_balancingRatioOverride(-1.0),
       m_id(id),
       m_name(name),
       m_mutatedJobsInterface(0)
 {
 }
 
 KisStrokeStrategy::KisStrokeStrategy(const KisStrokeStrategy &rhs)
     : m_exclusive(rhs.m_exclusive),
       m_supportsWrapAroundMode(rhs.m_supportsWrapAroundMode),
       m_clearsRedoOnStart(rhs.m_clearsRedoOnStart),
       m_requestsOtherStrokesToEnd(rhs.m_requestsOtherStrokesToEnd),
       m_canForgetAboutMe(rhs.m_canForgetAboutMe),
       m_needsExplicitCancel(rhs.m_needsExplicitCancel),
       m_balancingRatioOverride(rhs.m_balancingRatioOverride),
       m_id(rhs.m_id),
       m_name(rhs.m_name),
       m_mutatedJobsInterface(0)
 {
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_cancelStrokeId && !m_mutatedJobsInterface &&
                             "After the stroke has been started, no copying must happen");
 }
 
 KisStrokeStrategy::~KisStrokeStrategy()
 {
 }
 
 void KisStrokeStrategy::notifyUserStartedStroke()
 {
 }
 
 void KisStrokeStrategy::notifyUserEndedStroke()
 {
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createInitStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createFinishStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createCancelStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createDabStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createSuspendStrategy()
 {
     return 0;
 }
 
 KisStrokeJobStrategy* KisStrokeStrategy::createResumeStrategy()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createInitData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createFinishData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createCancelData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createSuspendData()
 {
     return 0;
 }
 
 KisStrokeJobData* KisStrokeStrategy::createResumeData()
 {
     return 0;
 }
 
 KisStrokeStrategy* KisStrokeStrategy::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
     return 0;
 }
 
 bool KisStrokeStrategy::isExclusive() const
 {
     return m_exclusive;
 }
 
 bool KisStrokeStrategy::supportsWrapAroundMode() const
 {
     return m_supportsWrapAroundMode;
 }
 
 QString KisStrokeStrategy::id() const
 {
     return m_id;
 }
 
 KUndo2MagicString KisStrokeStrategy::name() const
 {
     return m_name;
 }
 
 void KisStrokeStrategy::setMutatedJobsInterface(KisStrokesQueueMutatedJobInterface *mutatedJobsInterface)
 {
     m_mutatedJobsInterface = mutatedJobsInterface;
 }
 
 void KisStrokeStrategy::addMutatedJobs(const QVector<KisStrokeJobData *> list)
 {
     KIS_SAFE_ASSERT_RECOVER(m_mutatedJobsInterface && m_cancelStrokeId) {
         qDeleteAll(list);
         return;
     }
 
     m_mutatedJobsInterface->addMutatedJobs(m_cancelStrokeId, list);
 }
 
 void KisStrokeStrategy::addMutatedJob(KisStrokeJobData *data)
 {
     addMutatedJobs({data});
 }
 
 void KisStrokeStrategy::setExclusive(bool value)
 {
     m_exclusive = value;
 }
 
 void KisStrokeStrategy::setSupportsWrapAroundMode(bool value)
 {
     m_supportsWrapAroundMode = value;
 }
 
 bool KisStrokeStrategy::clearsRedoOnStart() const
 {
     return m_clearsRedoOnStart;
 }
 
 void KisStrokeStrategy::setClearsRedoOnStart(bool value)
 {
     m_clearsRedoOnStart = value;
 }
 
 bool KisStrokeStrategy::requestsOtherStrokesToEnd() const
 {
     return m_requestsOtherStrokesToEnd;
 }
 
 void KisStrokeStrategy::setRequestsOtherStrokesToEnd(bool value)
 {
     m_requestsOtherStrokesToEnd = value;
 }
 
 bool KisStrokeStrategy::canForgetAboutMe() const
 {
     return m_canForgetAboutMe;
 }
 
 void KisStrokeStrategy::setCanForgetAboutMe(bool value)
 {
     m_canForgetAboutMe = value;
 }
 
 bool KisStrokeStrategy::needsExplicitCancel() const
 {
     return m_needsExplicitCancel;
 }
 
 void KisStrokeStrategy::setNeedsExplicitCancel(bool value)
 {
     m_needsExplicitCancel = value;
 }
 
 qreal KisStrokeStrategy::balancingRatioOverride() const
 {
     return m_balancingRatioOverride;
 }
 
 void KisStrokeStrategy::setBalancingRatioOverride(qreal value)
 {
     m_balancingRatioOverride = value;
 }
diff --git a/libs/image/kis_stroke_strategy.h b/libs/image/kis_stroke_strategy.h
index b3cb98aa7c..b5dce84c68 100644
--- a/libs/image/kis_stroke_strategy.h
+++ b/libs/image/kis_stroke_strategy.h
@@ -1,209 +1,209 @@
 /*
  *  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_STROKE_STRATEGY_H
 #define __KIS_STROKE_STRATEGY_H
 
 #include <QString>
 #include "kis_types.h"
 #include "kundo2magicstring.h"
 #include "kritaimage_export.h"
 
 
 class KisStrokeJobStrategy;
 class KisStrokeJobData;
 class KisStrokesQueueMutatedJobInterface;
 
 class KRITAIMAGE_EXPORT KisStrokeStrategy
 {
 public:
-    KisStrokeStrategy(QString id = QString(), const KUndo2MagicString &name = KUndo2MagicString());
+    KisStrokeStrategy(const QLatin1String &id, const KUndo2MagicString &name = KUndo2MagicString());
     virtual ~KisStrokeStrategy();
 
     /**
      * notifyUserStartedStroke() is a callback used by the strokes system to notify
      * when the user adds the stroke to the strokes queue. That moment corresponds
      * to the user calling strokesFacade->startStroke(strategy) and might happen much
      * earlier than the first job being executed.
      *
      * NOTE: this method will be executed in the context of the GUI thread!
      */
     virtual void notifyUserStartedStroke();
 
     /**
      * notifyUserEndedStroke() is a callback used by the strokes system to notify
      * when the user ends the stroke. That moment corresponds to the user calling
      * strokesFacade->endStroke(id) and might happen much earlier when the stroke
      * even started its execution.
      *
      * NOTE: this method will be executed in the context of the GUI thread!
      */
     virtual void notifyUserEndedStroke();
 
     virtual KisStrokeJobStrategy* createInitStrategy();
     virtual KisStrokeJobStrategy* createFinishStrategy();
     virtual KisStrokeJobStrategy* createCancelStrategy();
     virtual KisStrokeJobStrategy* createDabStrategy();
     virtual KisStrokeJobStrategy* createSuspendStrategy();
     virtual KisStrokeJobStrategy* createResumeStrategy();
 
     virtual KisStrokeJobData* createInitData();
     virtual KisStrokeJobData* createFinishData();
     virtual KisStrokeJobData* createCancelData();
     virtual KisStrokeJobData* createSuspendData();
     virtual KisStrokeJobData* createResumeData();
 
     virtual KisStrokeStrategy* createLodClone(int levelOfDetail);
 
     bool isExclusive() const;
     bool supportsWrapAroundMode() const;
 
 
     /**
      * Returns true if mere start of the stroke should cancel all the
      * pending redo tasks.
      *
      * This method should return true in almost all circumstances
      * except if we are running an undo or redo stroke.
      */
     bool clearsRedoOnStart() const;
 
     /**
      * Returns true if the other currently running strokes should be
      * politely asked to exit. The default value is 'true'.
      *
      * The only known exception right now is
      * KisRegenerateFrameStrokeStrategy which does not requests ending
      * of any actions, since it performs purely background action.
      */
     bool requestsOtherStrokesToEnd() const;
 
     /**
      * Returns true if the update scheduler can cancel this stroke
      * when some other stroke is going to be started. This makes the
      * "forgettable" stroke very low priority.
      *
      * Default is 'false'.
      */
     bool canForgetAboutMe() const;
 
     bool needsExplicitCancel() const;
 
     /**
      * \see setBalancingRatioOverride() for details
      */
     qreal balancingRatioOverride() const;
 
     QString id() const;
     KUndo2MagicString name() const;
 
     /**
      * Set up by the strokes queue during the stroke initialization
      */
     void setCancelStrokeId(KisStrokeId id) { m_cancelStrokeId = id; }
 
     void setMutatedJobsInterface(KisStrokesQueueMutatedJobInterface *mutatedJobsInterface);
 
 protected:
     // testing surrogate class
     friend class KisMutatableDabStrategy;
 
     /**
      * The cancel job may populate the stroke with some new jobs
      * for cancelling. To achieve this it needs the stroke id.
      *
      * WARNING: you can't add new jobs in any places other than
      * cancel job, because the stroke may be ended in any moment
      * by the user and the sequence of jobs will be broken
      */
     KisStrokeId cancelStrokeId() { return m_cancelStrokeId; }
 
     /**
      * This function is supposed to be called by internal asynchronous
      * jobs. It allows adding subtasks that may be executed concurrently.
      *
      * Requirements:
      *   * must be called *only* from within the context of the strokes
      *     worker thread during execution of one of its jobs
      *
      * Guarantees:
      *   * the added job is guaranteed to be executed in some time after
      *     the currently executed job, *before* the next SEQUENTIAL or
      *     BARRIER job
      *   * if the currently executed job is CUNCURRENTthe mutated job *may*
      *     start execution right after adding to the queue without waiting for
      *     its parent to complete. Though this behavior is *not* guaranteed,
      *     because addMutatedJob does not initiate processQueues(), because
      *     it may lead to a deadlock.
      */
     void addMutatedJobs(const QVector<KisStrokeJobData*> list);
 
     /**
      * Convenience override for addMutatedJobs()
      */
     void addMutatedJob(KisStrokeJobData *data);
 
 
     // you are not supposed to change these parameters
     // after the KisStroke object has been created
 
     void setExclusive(bool value);
     void setSupportsWrapAroundMode(bool value);
     void setClearsRedoOnStart(bool value);
     void setRequestsOtherStrokesToEnd(bool value);
     void setCanForgetAboutMe(bool value);
     void setNeedsExplicitCancel(bool value);
 
     /**
      * Set override for the desired scheduler balancing ratio:
      *
      * ratio = stroke jobs / update jobs
      *
      * If \p value < 1.0, then the priority is given to updates, if
      * the value is higher than 1.0, then the priority is given
      * to stroke jobs.
      *
      * Special value -1.0, suggests the scheduler to use the default value
      * set by the user's config file (which is 100.0 by default).
      */
     void setBalancingRatioOverride(qreal value);
 
 protected:
     /**
      * Protected c-tor, used for cloning of hi-level strategies
      */
     KisStrokeStrategy(const KisStrokeStrategy &rhs);
 
 private:
     bool m_exclusive;
     bool m_supportsWrapAroundMode;
 
     bool m_clearsRedoOnStart;
     bool m_requestsOtherStrokesToEnd;
     bool m_canForgetAboutMe;
     bool m_needsExplicitCancel;
     qreal m_balancingRatioOverride;
 
-    QString m_id;
+    QLatin1String m_id;
     KUndo2MagicString m_name;
 
     KisStrokeId m_cancelStrokeId;
     KisStrokesQueueMutatedJobInterface *m_mutatedJobsInterface;
 };
 
 #endif /* __KIS_STROKE_STRATEGY_H */
diff --git a/libs/image/kis_stroke_strategy_undo_command_based.cpp b/libs/image/kis_stroke_strategy_undo_command_based.cpp
index 37560264ee..32ef12c95c 100644
--- a/libs/image/kis_stroke_strategy_undo_command_based.cpp
+++ b/libs/image/kis_stroke_strategy_undo_command_based.cpp
@@ -1,185 +1,189 @@
 /*
  *  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_stroke_strategy_undo_command_based.h"
 
 #include <QMutexLocker>
 #include "kis_image_interfaces.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "commands_new/kis_saved_commands.h"
 
 
 KisStrokeStrategyUndoCommandBased::
 KisStrokeStrategyUndoCommandBased(const KUndo2MagicString &name,
                                   bool undo,
                                   KisStrokeUndoFacade *undoFacade,
                                   KUndo2CommandSP initCommand,
                                   KUndo2CommandSP finishCommand)
-  : KisRunnableBasedStrokeStrategy("STROKE_UNDO_COMMAND_BASED", name),
+  : KisRunnableBasedStrokeStrategy(QLatin1String("STROKE_UNDO_COMMAND_BASED"), name),
     m_undo(undo),
     m_initCommand(initCommand),
     m_finishCommand(finishCommand),
     m_undoFacade(undoFacade),
     m_macroId(-1),
     m_macroCommand(0)
 {
     enableJob(KisSimpleStrokeStrategy::JOB_INIT);
     enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
     enableJob(KisSimpleStrokeStrategy::JOB_CANCEL);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 }
 
 KisStrokeStrategyUndoCommandBased::
 KisStrokeStrategyUndoCommandBased(const KisStrokeStrategyUndoCommandBased &rhs)
   : KisRunnableBasedStrokeStrategy(rhs),
     m_undo(false),
     m_initCommand(rhs.m_initCommand),
     m_finishCommand(rhs.m_finishCommand),
     m_undoFacade(rhs.m_undoFacade),
     m_macroCommand(0)
 {
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_macroCommand &&
                             !rhs.m_undo &&
                             "After the stroke has been started, no copying must happen");
 }
 
 void KisStrokeStrategyUndoCommandBased::setUsedWhileUndoRedo(bool value)
 {
     setClearsRedoOnStart(!value);
 }
 
 void KisStrokeStrategyUndoCommandBased::executeCommand(KUndo2CommandSP command, bool undo)
 {
     if(!command) return;
 
     if (MutatedCommandInterface *mutatedCommand = dynamic_cast<MutatedCommandInterface*>(command.data())) {
         mutatedCommand->setRunnableJobsInterface(this->runnableJobsInterface());
     }
 
     if(undo) {
         command->undo();
     } else {
         command->redo();
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::initStrokeCallback()
 {
     if(m_undoFacade) {
         m_macroCommand = m_undoFacade->postExecutionUndoAdapter()->createMacro(name());
     }
 
     executeCommand(m_initCommand, m_undo);
     notifyCommandDone(m_initCommand,
                       KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::NORMAL);
 }
 
 void KisStrokeStrategyUndoCommandBased::finishStrokeCallback()
 {
     executeCommand(m_finishCommand, m_undo);
     notifyCommandDone(m_finishCommand,
                       KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::NORMAL);
 
     QMutexLocker locker(&m_mutex);
     if(m_macroCommand) {
         Q_ASSERT(m_undoFacade);
         postProcessToplevelCommand(m_macroCommand);
         m_undoFacade->postExecutionUndoAdapter()->addMacro(m_macroCommand);
         m_macroCommand = 0;
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::cancelStrokeCallback()
 {
     QMutexLocker locker(&m_mutex);
     if(m_macroCommand) {
         m_macroCommand->performCancel(cancelStrokeId(), m_undo);
         delete m_macroCommand;
         m_macroCommand = 0;
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::doStrokeCallback(KisStrokeJobData *data)
 {
     Data *d = dynamic_cast<Data*>(data);
 
     if (d) {
         executeCommand(d->command, d->undo);
-        notifyCommandDone(d->command, d->sequentiality(), d->exclusivity());
+        if (d->shouldGoToHistory) {
+            notifyCommandDone(d->command,
+                              d->sequentiality(),
+                              d->exclusivity());
+        }
     } else {
         KisRunnableBasedStrokeStrategy::doStrokeCallback(data);
     }
 
 }
 
 void KisStrokeStrategyUndoCommandBased::runAndSaveCommand(KUndo2CommandSP command,
                                                           KisStrokeJobData::Sequentiality sequentiality,
                                                           KisStrokeJobData::Exclusivity exclusivity)
 {
     if (!command) return;
 
     executeCommand(command, false);
     notifyCommandDone(command, sequentiality, exclusivity);
 }
 
 void KisStrokeStrategyUndoCommandBased::notifyCommandDone(KUndo2CommandSP command,
                                                           KisStrokeJobData::Sequentiality sequentiality,
                                                           KisStrokeJobData::Exclusivity exclusivity)
 {
     if(!command) return;
 
     QMutexLocker locker(&m_mutex);
     if(m_macroCommand) {
         m_macroCommand->addCommand(command, sequentiality, exclusivity);
     }
 }
 
 void KisStrokeStrategyUndoCommandBased::setCommandExtraData(KUndo2CommandExtraData *data)
 {
     if (m_undoFacade && m_macroCommand) {
         warnKrita << "WARNING: KisStrokeStrategyUndoCommandBased::setCommandExtraData():"
                    << "the extra data is set while the stroke has already been started!"
                    << "The result is undefined, continued actions may not work!";
     }
 
     m_commandExtraData.reset(data);
 }
 
 void KisStrokeStrategyUndoCommandBased::setMacroId(int value)
 {
     m_macroId = value;
 }
 
 void KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(KUndo2Command *command)
 {
     if (m_commandExtraData) {
         command->setExtraData(m_commandExtraData.take());
     }
 
     KisSavedMacroCommand *savedCommand = dynamic_cast<KisSavedMacroCommand*>(command);
     if (savedCommand) {
         savedCommand->setMacroId(m_macroId);
     }
 }
 
  KisStrokeUndoFacade* KisStrokeStrategyUndoCommandBased::undoFacade() const
  {
      return m_undoFacade;
  }
diff --git a/libs/image/kis_stroke_strategy_undo_command_based.h b/libs/image/kis_stroke_strategy_undo_command_based.h
index 41ca43c3fd..e4e46e364e 100644
--- a/libs/image/kis_stroke_strategy_undo_command_based.h
+++ b/libs/image/kis_stroke_strategy_undo_command_based.h
@@ -1,162 +1,167 @@
 /*
  *  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_STROKE_STRATEGY_UNDO_COMMAND_BASED_H
 #define __KIS_STROKE_STRATEGY_UNDO_COMMAND_BASED_H
 
 #include <kundo2command.h>
 #include <QVector>
 #include <QMutex>
 
 #include "kis_types.h"
 #include "kis_simple_stroke_strategy.h"
 #include "KisRunnableBasedStrokeStrategy.h"
 
 
 class KisStrokeJob;
 class KisSavedMacroCommand;
 class KisStrokeUndoFacade;
 class KisStrokesQueueMutatedJobInterface;
 
 
 class KRITAIMAGE_EXPORT KisStrokeStrategyUndoCommandBased : public KisRunnableBasedStrokeStrategy
 {
 public:
     struct MutatedCommandInterface
     {
         virtual ~MutatedCommandInterface() {}
 
         void setRunnableJobsInterface(KisRunnableStrokeJobsInterface *interface) {
             m_mutatedJobsInterface = interface;
         }
 
         KisRunnableStrokeJobsInterface* runnableJobsInterface() const {
             return m_mutatedJobsInterface;
         }
 
     private:
         KisRunnableStrokeJobsInterface *m_mutatedJobsInterface;
     };
 
 
     class Data : public KisStrokeJobData {
     public:
         Data(KUndo2CommandSP _command,
              bool _undo = false,
              Sequentiality _sequentiality = SEQUENTIAL,
-             Exclusivity _exclusivity = NORMAL)
+             Exclusivity _exclusivity = NORMAL,
+             bool _shouldGoToHistory = true)
             : KisStrokeJobData(_sequentiality, _exclusivity),
               command(_command),
-              undo(_undo)
+              undo(_undo),
+              shouldGoToHistory(_shouldGoToHistory)
         {
         }
 
         Data(KUndo2Command *_command,
              bool _undo = false,
              Sequentiality _sequentiality = SEQUENTIAL,
-             Exclusivity _exclusivity = NORMAL)
+             Exclusivity _exclusivity = NORMAL,
+             bool _shouldGoToHistory = true)
             : KisStrokeJobData(_sequentiality, _exclusivity),
               command(_command),
-              undo(_undo)
+              undo(_undo),
+              shouldGoToHistory(_shouldGoToHistory)
         {
         }
 
         KUndo2CommandSP command;
         bool undo;
+        bool shouldGoToHistory = true;
     };
 
 public:
     KisStrokeStrategyUndoCommandBased(const KUndo2MagicString &name,
                                       bool undo,
                                       KisStrokeUndoFacade *undoFacade,
                                       KUndo2CommandSP initCommand = KUndo2CommandSP(0),
                                       KUndo2CommandSP finishCommand = KUndo2CommandSP(0));
 
     using KisSimpleStrokeStrategy::setExclusive;
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     /**
      * Set extra data that will be assigned to the command
      * representing this action. Using extra data has the following
      * restrictions:
      *
      * 1) The \p data must be set *before* the stroke has been started.
      *    Setting the \p data after the stroke has been started with
      *    image->startStroke(strokeId) leads to an undefined behaviour.
      *
      * 2) \p data becomes owned by the strategy/command right after
      *    setting it. Don't try to change it afterwards.
      */
     void setCommandExtraData(KUndo2CommandExtraData *data);
 
     /**
      * Sets the id of this action. Will be used for merging the undo commands
      *
      * The \p value must be set *before* the stroke has been started.
      * Setting the \p value after the stroke has been started with
      * image->startStroke(strokeId) leads to an undefined behaviour.
      */
     void setMacroId(int value);
 
     /**
      * The undo-command-based is a low-level strategy, so it allows
      * changing its wraparound mode status.
      *
      * WARNING: the switch must be called *before* the stroke has been
      * started! Otherwise the mode will not be activated.
      */
     using KisStrokeStrategy::setSupportsWrapAroundMode;
 
     void setUsedWhileUndoRedo(bool value);
 
 protected:
     void runAndSaveCommand(KUndo2CommandSP command,
                            KisStrokeJobData::Sequentiality sequentiality,
                            KisStrokeJobData::Exclusivity exclusivity);
     void notifyCommandDone(KUndo2CommandSP command,
                            KisStrokeJobData::Sequentiality sequentiality,
                            KisStrokeJobData::Exclusivity exclusivity);
 
     KisStrokeStrategyUndoCommandBased(const KisStrokeStrategyUndoCommandBased &rhs);
 
     virtual void postProcessToplevelCommand(KUndo2Command *command);
 
     KisStrokeUndoFacade* undoFacade() const;
 
 private:
     void executeCommand(KUndo2CommandSP command, bool undo);
 
 private:
     bool m_undo;
     KUndo2CommandSP m_initCommand;
     KUndo2CommandSP m_finishCommand;
     KisStrokeUndoFacade *m_undoFacade;
 
     QScopedPointer<KUndo2CommandExtraData> m_commandExtraData;
     int m_macroId;
 
     // protects done commands only
     QMutex m_mutex;
     KisSavedMacroCommand *m_macroCommand;
 };
 
 #endif /* __KIS_STROKE_STRATEGY_UNDO_COMMAND_BASED_H */
diff --git a/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp b/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
index aff271b066..e95792849c 100644
--- a/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
+++ b/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
@@ -1,555 +1,557 @@
 /*
  *  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_suspend_projection_updates_stroke_strategy.h"
 
 #include <kis_image.h>
 #include <krita_utils.h>
 #include <kis_projection_updates_filter.h>
 #include "kis_image_signal_router.h"
 
 #include "kundo2command.h"
 #include "KisRunnableStrokeJobDataBase.h"
 #include "KisRunnableStrokeJobsInterface.h"
 #include "kis_paintop_utils.h"
 
 
 inline uint qHash(const QRect &rc) {
     return rc.x() +
         (rc.y() << 16) +
         (rc.width() << 8) +
         (rc.height() << 24);
 }
 
 struct KisSuspendProjectionUpdatesStrokeStrategy::Private
 {
     KisImageWSP image;
     bool suspend;
     QVector<QRect> accumulatedDirtyRects;
     bool sanityResumingFinished = false;
     int updatesEpoch = 0;
     bool haveDisabledGUILodSync = false;
 
     void tryFetchUsedUpdatesFilter(KisImageSP image);
     void tryIssueRecordedDirtyRequests(KisImageSP image);
 
     class SuspendLod0Updates : public KisProjectionUpdatesFilter
     {
 
         struct Request {
             Request() : resetAnimationCache(false) {}
             Request(const QRect &_rect, bool _resetAnimationCache)
                 : rect(_rect), resetAnimationCache(_resetAnimationCache)
             {
             }
 
             QRect rect;
             bool resetAnimationCache;
         };
 
         typedef QHash<KisNodeSP, QVector<Request> > RectsHash;
     public:
         SuspendLod0Updates()
         {
         }
 
         bool filter(KisImage *image, KisNode *node, const QVector<QRect> &rects,  bool resetAnimationCache) override {
             if (image->currentLevelOfDetail() > 0) return false;
 
             QMutexLocker l(&m_mutex);
 
             Q_FOREACH(const QRect &rc, rects) {
                 m_requestsHash[KisNodeSP(node)].append(Request(rc, resetAnimationCache));
             }
 
             return true;
         }
 
         static inline QRect alignRect(const QRect &rc, const int step) {
             static const int decstep = step - 1;
             static const int invstep = ~decstep;
 
             int x0, y0, x1, y1;
             rc.getCoords(&x0, &y0, &x1, &y1);
 
             x0 &= invstep;
             y0 &= invstep;
             x1 |= decstep;
             y1 |= decstep;
 
             QRect result;
             result.setCoords(x0, y0, x1, y1);
             return result;
         }
 
         void notifyUpdates(KisNodeGraphListener *listener) {
             RectsHash::const_iterator it = m_requestsHash.constBegin();
             RectsHash::const_iterator end = m_requestsHash.constEnd();
 
             const int step = 64;
 
             for (; it != end; ++it) {
                 KisNodeSP node = it.key();
 
                 QRegion region;
 
                 bool resetAnimationCache = false;
                 Q_FOREACH (const Request &req, it.value()) {
                     region += alignRect(req.rect, step);
                     resetAnimationCache |= req.resetAnimationCache;
                 }
 
                 // FIXME: constness: port rPU to SP
                 listener->requestProjectionUpdate(const_cast<KisNode*>(node.data()), region.rects(), resetAnimationCache);
             }
         }
 
     private:
         RectsHash m_requestsHash;
         QMutex m_mutex;
     };
 
     QVector<QSharedPointer<SuspendLod0Updates>> usedFilters;
 
 
     struct StrokeJobCommand : public KUndo2Command
     {
         StrokeJobCommand(KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                          KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL)
             : m_sequentiality(sequentiality),
               m_exclusivity(exclusivity)
         {}
 
         KisStrokeJobData::Sequentiality m_sequentiality;
         KisStrokeJobData::Exclusivity m_exclusivity;
     };
 
     struct UndoableData : public KisRunnableStrokeJobDataBase
     {
         UndoableData(StrokeJobCommand *command)
             : KisRunnableStrokeJobDataBase(command->m_sequentiality, command->m_exclusivity),
               m_command(command)
         {
         }
 
         void run() override {
             KIS_SAFE_ASSERT_RECOVER_RETURN(m_command);
             m_command->redo();
         }
 
         QScopedPointer<StrokeJobCommand> m_command;
     };
 
     // Suspend job should be a barrier to ensure all
     // previous lodN strokes reach the GUI. Otherwise,
     // they will be blocked in
     // KisImage::notifyProjectionUpdated()
     struct SuspendUpdatesCommand : public StrokeJobCommand
     {
         SuspendUpdatesCommand(Private *d)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_d(d) {}
 
         void redo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(!image->projectionUpdatesFilter());
 
             image->setProjectionUpdatesFilter(
                 KisProjectionUpdatesFilterSP(new Private::SuspendLod0Updates()));
         }
 
 
         void undo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(image->projectionUpdatesFilter());
 
             m_d->tryFetchUsedUpdatesFilter(image);
         }
 
         Private *m_d;
     };
 
 
     struct ResumeAndIssueGraphUpdatesCommand : public StrokeJobCommand
     {
         ResumeAndIssueGraphUpdatesCommand(Private *d)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_d(d) {}
 
         void redo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(image->projectionUpdatesFilter());
 
             image->disableUIUpdates();
             m_d->tryFetchUsedUpdatesFilter(image);
             m_d->tryIssueRecordedDirtyRequests(image);
         }
 
         void undo() override {
             KisImageSP image = m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
             KIS_SAFE_ASSERT_RECOVER_RETURN(!image->projectionUpdatesFilter());
 
             image->setProjectionUpdatesFilter(
                 KisProjectionUpdatesFilterSP(new Private::SuspendLod0Updates()));
             image->enableUIUpdates();
         }
 
         Private *m_d;
     };
 
     struct UploadDataToUIData : public KisRunnableStrokeJobDataBase
     {
         UploadDataToUIData(const QRect &rc, int updateEpoch, KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : KisRunnableStrokeJobDataBase(KisStrokeJobData::CONCURRENT),
               m_strategy(strategy),
               m_rc(rc),
               m_updateEpoch(updateEpoch)
         {
         }
 
         void run() override {
             // check if we've already started stinking...
             if (m_strategy->m_d->updatesEpoch > m_updateEpoch) {
                 return;
             }
 
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->notifyProjectionUpdated(m_rc);
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
         QRect m_rc;
         int m_updateEpoch;
     };
 
     struct BlockUILodSync : public KisRunnableStrokeJobDataBase
     {
         BlockUILodSync(bool block, KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : KisRunnableStrokeJobDataBase(KisStrokeJobData::BARRIER),
               m_strategy(strategy),
               m_block(block)
         {}
 
         void run() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitRequestLodPlanesSyncBlocked(m_block);
             m_strategy->m_d->haveDisabledGUILodSync = m_block;
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
         bool m_block;
     };
 
     struct StartBatchUIUpdatesCommand : public StrokeJobCommand
     {
         StartBatchUIUpdatesCommand(KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_strategy(strategy) {}
 
         void redo() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             /**
              * We accumulate dirty rects from all(!) epochs, because some updates of the
              * previous epochs might have been cancelled without doing any real work.
              */
             const QVector<QRect> totalDirtyRects =
                 image->enableUIUpdates() + m_strategy->m_d->accumulatedDirtyRects;
 
             const QRect totalRect =
                 image->bounds() &
                 std::accumulate(totalDirtyRects.begin(), totalDirtyRects.end(), QRect(), std::bit_or<QRect>());
 
             m_strategy->m_d->accumulatedDirtyRects =
                 KisPaintOpUtils::splitAndFilterDabRect(totalRect,
                                                        totalDirtyRects,
                                                        KritaUtils::optimalPatchSize().width());
 
             image->signalRouter()->emitNotifyBatchUpdateStarted();
 
             QVector<KisRunnableStrokeJobDataBase*> jobsData;
             Q_FOREACH (const QRect &rc, m_strategy->m_d->accumulatedDirtyRects) {
                 jobsData << new Private::UploadDataToUIData(rc, m_strategy->m_d->updatesEpoch, m_strategy);
             }
 
             m_strategy->runnableJobsInterface()->addRunnableJobs(jobsData);
 
         }
 
         void undo() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitNotifyBatchUpdateEnded();
             image->disableUIUpdates();
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
     };
 
     struct EndBatchUIUpdatesCommand : public StrokeJobCommand
     {
         EndBatchUIUpdatesCommand(KisSuspendProjectionUpdatesStrokeStrategy *strategy)
             : StrokeJobCommand(KisStrokeJobData::BARRIER),
               m_strategy(strategy) {}
 
         void redo() override {
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitNotifyBatchUpdateEnded();
             m_strategy->m_d->sanityResumingFinished = true;
             m_strategy->m_d->accumulatedDirtyRects.clear();
             KIS_SAFE_ASSERT_RECOVER_NOOP(m_strategy->m_d->usedFilters.isEmpty());
         }
 
         void undo() override {
             /**
              * Even though this comand is the last command of the stroke is can
              * still be undone by suspendStrokeCallback(). It happens when a LodN
              * stroke is started right after the last job of resume strategy was
              * being executed. In such a case new stroke is placed right in front
              * of our resume strategy and all the resuming work is undone (mimicing
              * a normal suspend strategy).
              *
              * The only thing we should control here is whether the state of the
              * stroke is reset to default. Otherwise we'll do all the updates twice.
              */
 
             KIS_SAFE_ASSERT_RECOVER_NOOP(m_strategy->m_d->usedFilters.isEmpty());
             KIS_SAFE_ASSERT_RECOVER_NOOP(m_strategy->m_d->accumulatedDirtyRects.isEmpty());
 
             m_strategy->m_d->sanityResumingFinished = false;
 
             KisImageSP image = m_strategy->m_d->image.toStrongRef();
             KIS_SAFE_ASSERT_RECOVER_RETURN(image);
 
             image->signalRouter()->emitNotifyBatchUpdateStarted();
         }
 
         KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
     };
 
 
     QVector<StrokeJobCommand*> executedCommands;
 };
 
 KisSuspendProjectionUpdatesStrokeStrategy::KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP image, bool suspend)
-    : KisRunnableBasedStrokeStrategy(suspend ? "suspend_stroke_strategy" : "resume_stroke_strategy"),
+    : KisRunnableBasedStrokeStrategy(suspend ?
+                                     QLatin1String("suspend_stroke_strategy") :
+                                     QLatin1String("resume_stroke_strategy")),
       m_d(new Private)
 {
     m_d->image = image;
     m_d->suspend = suspend;
 
 
     /**
      * Here we add a dumb INIT job so that KisStrokesQueue would know that the
      * stroke has already started or not. When the queue reaches the resume
      * stroke and starts its execution, no Lod0 can execute anymore. So all the
      * new Lod0 strokes should go to the end of the queue and wrapped into
      * their own Suspend/Resume pair.
      */
     enableJob(JOB_INIT, true);
 
     enableJob(JOB_DOSTROKE, true);
     enableJob(JOB_CANCEL, true);
 
     enableJob(JOB_SUSPEND, true, KisStrokeJobData::BARRIER);
     enableJob(JOB_RESUME, true, KisStrokeJobData::BARRIER);
 
     setNeedsExplicitCancel(true);
 }
 
 KisSuspendProjectionUpdatesStrokeStrategy::~KisSuspendProjectionUpdatesStrokeStrategy()
 {
     qDeleteAll(m_d->executedCommands);
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::initStrokeCallback()
 {
     QVector<KisRunnableStrokeJobDataBase*> jobs;
 
     if (m_d->suspend) {
         jobs << new Private::UndoableData(new Private::SuspendUpdatesCommand(m_d.data()));
     } else {
         jobs << new Private::UndoableData(new Private::ResumeAndIssueGraphUpdatesCommand(m_d.data()));
         jobs << new Private::BlockUILodSync(true, this);
         jobs << new Private::UndoableData(new Private::StartBatchUIUpdatesCommand(this));
         jobs << new Private::UndoableData(new Private::EndBatchUIUpdatesCommand(this));
         jobs << new Private::BlockUILodSync(false, this);
     }
 
     runnableJobsInterface()->addRunnableJobs(jobs);
 }
 
 /**
  * When the Lod0 stroke is being recalculated in the background we
  * should block all the updates it issues to avoid user distraction.
  * The result of the final stroke should be shown to the user in the
  * very end when everything is fully ready. Ideally the use should not
  * notice that the image has changed :)
  *
  * (Don't mix this process with suspend/resume capabilities of a
  * single stroke. That is a different system!)
  *
  * The process of the Lod0 regeneration consists of the following:
  *
  * 1) Suspend stroke executes. It sets a special updates filter on the
  *    image. The filter blocks all the updates and saves them in an
  *    internal structure to be emitted in the future.
  *
  * 2) Lod0 strokes are being recalculated. All their updates are
  *    blocked and saved in the filter.
  *
  * 3) Resume stroke starts:
  *
  *     3.1) First it disables emitting of sigImageUpdated() so the gui
  *          will not get any update notifications.
  *
  *     3.2) Then it enables updates themselves.
  *
  *     3.3) Initiates all the updates that were requested by the Lod0
  *          stroke. The node graph is regenerated, but the GUI does
  *          not get this change.
  *
  *     3.4) Special barrier job waits for all the updates to finish
  *          and, when they are done, enables GUI notifications again.
  *
  *     3.5) In a multithreaded way emits the GUI notifications for the
  *          entire image. Multithreaded way is used to conform the
  *          double-stage update principle of KisCanvas2.
  */
 void KisSuspendProjectionUpdatesStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     KisRunnableStrokeJobDataBase *runnable = dynamic_cast<KisRunnableStrokeJobDataBase*>(data);
     if (runnable) {
         runnable->run();
 
         if (Private::UndoableData *undoable = dynamic_cast<Private::UndoableData*>(data)) {
             Private::StrokeJobCommand *command =  undoable->m_command.take();
             m_d->executedCommands.append(command);
         }
     }
 }
 
 QList<KisStrokeJobData*> KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP /*image*/)
 {
     return QList<KisStrokeJobData*>();
 }
 
 QList<KisStrokeJobData*> KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP /*_image*/)
 {
     return QList<KisStrokeJobData*>();
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::Private::tryFetchUsedUpdatesFilter(KisImageSP image)
 {
     KisProjectionUpdatesFilterSP filter =
         image->projectionUpdatesFilter();
 
     if (!filter) return;
 
     QSharedPointer<Private::SuspendLod0Updates> localFilter =
         filter.dynamicCast<Private::SuspendLod0Updates>();
 
     if (localFilter) {
         image->setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
         this->usedFilters.append(localFilter);
     }
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::Private::tryIssueRecordedDirtyRequests(KisImageSP image)
 {
     Q_FOREACH (QSharedPointer<Private::SuspendLod0Updates> filter, usedFilters) {
         filter->notifyUpdates(image.data());
     }
     usedFilters.clear();
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::cancelStrokeCallback()
 {
     KisImageSP image = m_d->image.toStrongRef();
     if (!image) {
         return;
     }
 
     for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
         (*it)->undo();
     }
 
     m_d->tryFetchUsedUpdatesFilter(image);
 
     if (m_d->haveDisabledGUILodSync) {
         image->signalRouter()->emitRequestLodPlanesSyncBlocked(false);
     }
 
     /**
      * We shouldn't emit any ad-hoc updates when cancelling the
      * stroke.  It generates weird temporary holes on the canvas,
      * making the user feel awful, thinking his image got
      * corrupted. We will just emit a common refreshGraphAsync() that
      * will do all the work in a beautiful way
      */
     if (!m_d->suspend) {
         // FIXME: optimize
         image->refreshGraphAsync();
     }
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::suspendStrokeCallback()
 {
     /**
      * The resume stroke can be suspended even when all its jobs are completed.
      * In such a case, we should just ensure that all the internal state is reset
      * to default.
      */
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->suspend ||
                                  !m_d->sanityResumingFinished ||
                                  (m_d->sanityResumingFinished &&
                                   m_d->usedFilters.isEmpty() &&
                                   m_d->accumulatedDirtyRects.isEmpty()));
 
     for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
         (*it)->undo();
     }
 
     // reset all the issued updates
     m_d->updatesEpoch++;
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::resumeStrokeCallback()
 {
     QVector<KisRunnableStrokeJobDataBase*> jobs;
 
     Q_FOREACH (Private::StrokeJobCommand *command, m_d->executedCommands) {
         jobs << new Private::UndoableData(command);
     }
     m_d->executedCommands.clear();
 
     runnableJobsInterface()->addRunnableJobs(jobs);
 }
diff --git a/libs/image/kis_switch_time_stroke_strategy.cpp b/libs/image/kis_switch_time_stroke_strategy.cpp
index 16c71098f3..76c12208af 100644
--- a/libs/image/kis_switch_time_stroke_strategy.cpp
+++ b/libs/image/kis_switch_time_stroke_strategy.cpp
@@ -1,150 +1,150 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_switch_time_stroke_strategy.h"
 
 #include <QMutex>
 
 #include "kis_image_animation_interface.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "commands_new/kis_switch_current_time_command.h"
 
 
 struct KisSwitchTimeStrokeStrategy::Private
 {
     Private(int frameId, bool needsRegeneration)
         : token(new SharedToken(frameId, needsRegeneration))
     {
     }
 
     KisImageAnimationInterface *interface;
     KisPostExecutionUndoAdapter *undoAdapter;
     SharedTokenSP token;
 };
 
 KisSwitchTimeStrokeStrategy::KisSwitchTimeStrokeStrategy(int frameId,
                                                          bool needsRegeneration,
                                                          KisImageAnimationInterface *interface,
                                                          KisPostExecutionUndoAdapter *undoAdapter)
-    : KisSimpleStrokeStrategy("switch_current_frame_stroke", kundo2_i18n("Switch Frames")),
+    : KisSimpleStrokeStrategy(QLatin1String("switch_current_frame_stroke"), kundo2_i18n("Switch Frames")),
       m_d(new Private(frameId, needsRegeneration))
 {
     m_d->interface = interface;
     m_d->undoAdapter = undoAdapter;
 
 
     enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     // switching frames is a distinct user action, so it should
     // cancel the playback or any action easily
     setRequestsOtherStrokesToEnd(true);
     setClearsRedoOnStart(false);
 }
 
 KisSwitchTimeStrokeStrategy::~KisSwitchTimeStrokeStrategy()
 {
 }
 void KisSwitchTimeStrokeStrategy::initStrokeCallback()
 {
     const int frameId = m_d->token->fetchTime();
 
     if (frameId == m_d->interface->currentTime()) return;
 
     const int oldTime = m_d->interface->currentTime();
     m_d->interface->explicitlySetCurrentTime(frameId);
 
     if (m_d->undoAdapter) {
         KUndo2CommandSP cmd(
             new KisSwitchCurrentTimeCommand(m_d->interface,
                                             oldTime,
                                             frameId));
         m_d->undoAdapter->addCommand(cmd);
     }
 }
 KisStrokeStrategy* KisSwitchTimeStrokeStrategy::createLodClone(int levelOfDetail)
 {
     Q_UNUSED(levelOfDetail);
 
     // This stroke is explicitly made LEGACY, so that it could create a barrier for
     // time switch. Theoretically, we can have separate time ids for Lod0 and LodN,
     // but currently this idea doesn't wotk for some reason. The consequences of
     // making this stroke a barrier:
     //
     // * LodSync stroke is started after every time switch (not slow, but still...)
     // * The frame switches only *after* all the pending strokes are finished
     // * LodSync stroke is started even when the image is not changed (not regeneration needed)!
 
     return 0;
 }
 
 KisSwitchTimeStrokeStrategy::SharedTokenSP KisSwitchTimeStrokeStrategy::token() const
 {
     return m_d->token;
 }
 
 
 /*****************************************************************/
 /*        KisSwitchTimeStrokeStrategy::SharedToken               */
 /*****************************************************************/
 
 struct KisSwitchTimeStrokeStrategy::SharedToken::Private {
     Private(int _time, bool _needsRegeneration)
         : time(_time),
           needsRegeneration(_needsRegeneration),
           isCompleted(false)
     {
     }
 
     QMutex mutex;
     int time;
     bool needsRegeneration;
     bool isCompleted;
 };
 
 KisSwitchTimeStrokeStrategy::SharedToken::SharedToken(int initialTime, bool needsRegeneration)
     : m_d(new Private(initialTime, needsRegeneration))
 {
 }
 
 KisSwitchTimeStrokeStrategy::SharedToken::~SharedToken()
 {
 }
 
 bool KisSwitchTimeStrokeStrategy::SharedToken::tryResetDestinationTime(int time, bool needsRegeneration)
 {
     QMutexLocker l(&m_d->mutex);
 
     const bool result =
         !m_d->isCompleted &&
         (m_d->needsRegeneration || !needsRegeneration);
 
     if (result) {
         m_d->time = time;
     }
 
     return result;
 }
 
 int KisSwitchTimeStrokeStrategy::SharedToken::fetchTime() const
 {
     QMutexLocker l(&m_d->mutex);
     KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->isCompleted);
 
     m_d->isCompleted = true;
     return m_d->time;
 }
diff --git a/libs/image/kis_sync_lod_cache_stroke_strategy.cpp b/libs/image/kis_sync_lod_cache_stroke_strategy.cpp
index 5715b7cd0f..8daf958387 100644
--- a/libs/image/kis_sync_lod_cache_stroke_strategy.cpp
+++ b/libs/image/kis_sync_lod_cache_stroke_strategy.cpp
@@ -1,171 +1,171 @@
 /*
  *  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_sync_lod_cache_stroke_strategy.h"
 
 #include <kis_image.h>
 #include <kundo2magicstring.h>
 #include "krita_utils.h"
 #include "kis_layer_utils.h"
 
 
 struct KisSyncLodCacheStrokeStrategy::Private
 {
     KisImageWSP image;
     QHash<KisPaintDeviceSP, KisPaintDevice::LodDataStruct*> dataObjects;
 
     ~Private() {
         qDeleteAll(dataObjects);
         dataObjects.clear();
     }
 
     class InitData : public KisStrokeJobData {
     public:
         InitData(KisPaintDeviceSP _device)
             : KisStrokeJobData(SEQUENTIAL),
               device(_device)
             {}
 
         KisPaintDeviceSP device;
     };
 
     class ProcessData : public KisStrokeJobData {
     public:
         ProcessData(KisPaintDeviceSP _device, const QRect &_rect)
             : KisStrokeJobData(CONCURRENT),
               device(_device), rect(_rect)
             {}
 
         KisPaintDeviceSP device;
         QRect rect;
     };
 
     class AdditionalProcessNode : public KisStrokeJobData {
     public:
         AdditionalProcessNode(KisNodeSP _node)
             : KisStrokeJobData(SEQUENTIAL),
               node(_node)
             {}
 
         KisNodeSP node;
     };
 };
 
 KisSyncLodCacheStrokeStrategy::KisSyncLodCacheStrokeStrategy(KisImageWSP image, bool forgettable)
-    : KisSimpleStrokeStrategy("SyncLodCacheStroke", kundo2_i18n("Instant Preview")),
+    : KisSimpleStrokeStrategy(QLatin1String("SyncLodCacheStroke"), kundo2_i18n("Instant Preview")),
       m_d(new Private)
 {
     m_d->image = image;
 
     /**
      * We shouldn't start syncing before all the updates are
      * done. Otherwise we might get artifacts!
      */
     enableJob(KisSimpleStrokeStrategy::JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
     enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
     enableJob(KisSimpleStrokeStrategy::JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     setRequestsOtherStrokesToEnd(false);
     setClearsRedoOnStart(false);
     setCanForgetAboutMe(forgettable);
 }
 
 KisSyncLodCacheStrokeStrategy::~KisSyncLodCacheStrokeStrategy()
 {
 }
 
 void KisSyncLodCacheStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Private::InitData *initData = dynamic_cast<Private::InitData*>(data);
     Private::ProcessData *processData = dynamic_cast<Private::ProcessData*>(data);
     Private::AdditionalProcessNode *additionalProcessNode = dynamic_cast<Private::AdditionalProcessNode*>(data);
 
     if (initData) {
         KisPaintDeviceSP dev = initData->device;
         const int lod = dev->defaultBounds()->currentLevelOfDetail();
         m_d->dataObjects.insert(dev, dev->createLodDataStruct(lod));
     } else if (processData) {
         KisPaintDeviceSP dev = processData->device;
         KIS_ASSERT(m_d->dataObjects.contains(dev));
 
         KisPaintDevice::LodDataStruct *data = m_d->dataObjects.value(dev);
         dev->updateLodDataStruct(data, processData->rect);
     } else if (additionalProcessNode) {
         additionalProcessNode->node->syncLodCache();
     }
 }
 
 void KisSyncLodCacheStrokeStrategy::finishStrokeCallback()
 {
     auto it = m_d->dataObjects.begin();
     auto end = m_d->dataObjects.end();
 
     for (; it != end; ++it) {
         KisPaintDeviceSP dev = it.key();
         dev->uploadLodDataStruct(it.value());
     }
 
     qDeleteAll(m_d->dataObjects);
     m_d->dataObjects.clear();
 }
 
 void KisSyncLodCacheStrokeStrategy::cancelStrokeCallback()
 {
     qDeleteAll(m_d->dataObjects);
     m_d->dataObjects.clear();
 }
 
 QList<KisStrokeJobData*> KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP _image)
 {
     using KisLayerUtils::recursiveApplyNodes;
     using KritaUtils::splitRegionIntoPatches;
     using KritaUtils::optimalPatchSize;
 
     KisImageSP image = _image;
 
     KisPaintDeviceList deviceList;
     QList<KisStrokeJobData*> jobsData;
 
     recursiveApplyNodes(image->root(),
                         [&deviceList](KisNodeSP node) {
                             deviceList << node->getLodCapableDevices();
                         });
 
     KritaUtils::makeContainerUnique(deviceList);
 
     Q_FOREACH (KisPaintDeviceSP device, deviceList) {
         jobsData << new Private::InitData(device);
     }
 
     Q_FOREACH (KisPaintDeviceSP device, deviceList) {
         QRegion region = device->regionForLodSyncing();
         QVector<QRect> rects = splitRegionIntoPatches(region, optimalPatchSize());
 
         Q_FOREACH (const QRect &rc, rects) {
             jobsData << new Private::ProcessData(device, rc);
         }
     }
 
     recursiveApplyNodes(image->root(),
                         [&jobsData](KisNodeSP node) {
                             jobsData << new Private::AdditionalProcessNode(node);
                         });
 
     return jobsData;
 }
diff --git a/libs/image/kis_update_job_item.h b/libs/image/kis_update_job_item.h
index ba68ab70c4..3a6f41b27c 100644
--- a/libs/image/kis_update_job_item.h
+++ b/libs/image/kis_update_job_item.h
@@ -1,251 +1,271 @@
 /*
  *  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_UPDATE_JOB_ITEM_H
 #define __KIS_UPDATE_JOB_ITEM_H
 
 #include <atomic>
 
 #include <QRunnable>
 #include <QReadWriteLock>
 
 #include "kis_stroke_job.h"
 #include "kis_spontaneous_job.h"
 #include "kis_base_rects_walker.h"
 #include "kis_async_merger.h"
 #include "kis_updater_context.h"
 
+//#define DEBUG_JOBS_SEQUENCE
+
 
 class KisUpdateJobItem :  public QObject, public QRunnable
 {
     Q_OBJECT
 public:
     enum class Type : int {
         EMPTY = 0,
         WAITING,
         MERGE,
         STROKE,
         SPONTANEOUS
     };
 
 public:
     KisUpdateJobItem(KisUpdaterContext *updaterContext)
         : m_updaterContext(updaterContext),
           m_atomicType(Type::EMPTY),
           m_runnableJob(0)
     {
         setAutoDelete(false);
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_atomicType.is_lock_free());
     }
     ~KisUpdateJobItem() override
     {
         delete m_runnableJob;
     }
 
     void run() override {
         if (!isRunning()) return;
 
         /**
          * Here we break the idea of QThreadPool a bit. Ideally, we should split the
          * jobs into distinct QRunnable objects and pass all of them to QThreadPool.
          * That is a nice idea, but it doesn't work well when the jobs are small enough
          * and the number of available cores is high (>4 cores). It this case the
          * threads just tend to execute the job very quickly and go to sleep, which is
          * an expensive operation.
          *
          * To overcome this problem we try to bulk-process the jobs. In sigJobFinished()
          * signal (which is DirectConnection), the context may add the job to ourselves(!!!),
          * so we switch from "done" state into "running" again.
          */
 
         while (1) {
             KIS_SAFE_ASSERT_RECOVER_RETURN(isRunning());
 
             if(m_exclusive) {
                 m_updaterContext->m_exclusiveJobLock.lockForWrite();
             } else {
                 m_updaterContext->m_exclusiveJobLock.lockForRead();
             }
 
             if(m_atomicType == Type::MERGE) {
                 runMergeJob();
             } else {
                 KIS_ASSERT(m_atomicType == Type::STROKE ||
                            m_atomicType == Type::SPONTANEOUS);
 
-                if (m_runnableJob) m_runnableJob->run();
+                if (m_runnableJob) {
+#ifdef DEBUG_JOBS_SEQUENCE
+                    if (m_atomicType == Type::STROKE) {
+                        qDebug() << "running: stroke" << m_runnableJob->debugName();
+                    } else if (m_atomicType == Type::SPONTANEOUS) {
+                        qDebug() << "running: spont " << m_runnableJob->debugName();
+                    } else {
+                        qDebug() << "running: unkn. " << m_runnableJob->debugName();
+                    }
+#endif
+
+                    m_runnableJob->run();
+                }
             }
 
             setDone();
 
             m_updaterContext->doSomeUsefulWork();
 
             // may flip the current state from Waiting -> Running again
             m_updaterContext->jobFinished();
 
             m_updaterContext->m_exclusiveJobLock.unlock();
 
             // try to exit the loop. Please note, that no one can flip the state from
             // WAITING to EMPTY except ourselves!
             Type expectedValue = Type::WAITING;
             if (m_atomicType.compare_exchange_strong(expectedValue, Type::EMPTY)) {
                 break;
             }
         }
     }
 
     inline void runMergeJob() {
         KIS_SAFE_ASSERT_RECOVER_RETURN(m_atomicType == Type::MERGE);
         KIS_SAFE_ASSERT_RECOVER_RETURN(m_walker);
         // dbgKrita << "Executing merge job" << m_walker->changeRect()
         //          << "on thread" << QThread::currentThreadId();
+
+#ifdef DEBUG_JOBS_SEQUENCE
+        qDebug() << "running: merge " << m_walker->startNode() << m_walker->changeRect();
+
+#endif
+
         m_merger.startMerge(*m_walker);
 
         QRect changeRect = m_walker->changeRect();
         m_updaterContext->continueUpdate(changeRect);
     }
 
     // return true if the thread should actually be started
     inline bool setWalker(KisBaseRectsWalkerSP walker) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_accessRect = walker->accessRect();
         m_changeRect = walker->changeRect();
         m_walker = walker;
 
         m_exclusive = false;
         m_runnableJob = 0;
 
         const Type oldState = m_atomicType.exchange(Type::MERGE);
         return oldState == Type::EMPTY;
     }
 
     // return true if the thread should actually be started
     inline bool setStrokeJob(KisStrokeJob *strokeJob) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_runnableJob = strokeJob;
         m_strokeJobSequentiality = strokeJob->sequentiality();
 
         m_exclusive = strokeJob->isExclusive();
         m_walker = 0;
         m_accessRect = m_changeRect = QRect();
 
         const Type oldState = m_atomicType.exchange(Type::STROKE);
         return oldState == Type::EMPTY;
     }
 
     // return true if the thread should actually be started
     inline bool setSpontaneousJob(KisSpontaneousJob *spontaneousJob) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_runnableJob = spontaneousJob;
 
         m_exclusive = spontaneousJob->isExclusive();
         m_walker = 0;
         m_accessRect = m_changeRect = QRect();
 
         const Type oldState = m_atomicType.exchange(Type::SPONTANEOUS);
         return oldState == Type::EMPTY;
     }
 
     inline void setDone() {
         m_walker = 0;
         delete m_runnableJob;
         m_runnableJob = 0;
         m_atomicType = Type::WAITING;
     }
 
     inline bool isRunning() const {
         return m_atomicType >= Type::MERGE;
     }
 
     inline Type type() const {
         return m_atomicType;
     }
 
     inline const QRect& accessRect() const {
         return m_accessRect;
     }
 
     inline const QRect& changeRect() const {
         return m_changeRect;
     }
 
     inline KisStrokeJobData::Sequentiality strokeJobSequentiality() const {
         return m_strokeJobSequentiality;
     }
 
 private:
     /**
      * Open walker and stroke job for the testing suite.
      * Please, do not use it in production code.
      */
     friend class KisTestableUpdaterContext;
     friend class KisSimpleUpdateQueueTest;
     friend class KisStrokesQueueTest;
     friend class KisUpdateSchedulerTest;
     friend class KisUpdaterContext;
 
     inline KisBaseRectsWalkerSP walker() const {
         return m_walker;
     }
 
     inline KisStrokeJob* strokeJob() const {
         KisStrokeJob *job = dynamic_cast<KisStrokeJob*>(m_runnableJob);
         Q_ASSERT(job);
 
         return job;
     }
 
     inline void testingSetDone() {
         setDone();
     }
 
 private:
     KisUpdaterContext *m_updaterContext;
 
     bool m_exclusive;
 
     std::atomic<Type> m_atomicType;
 
     volatile KisStrokeJobData::Sequentiality m_strokeJobSequentiality;
 
     /**
      * Runnable jobs part
      * The job is owned by the context and deleted after completion
      */
-    KisRunnable *m_runnableJob;
+    KisRunnableWithDebugName *m_runnableJob;
 
     /**
      * Merge jobs part
      */
 
     KisBaseRectsWalkerSP m_walker;
     KisAsyncMerger m_merger;
 
     /**
      * These rects cache actual values from the walker
      * to eliminate concurrent access to a walker structure
      */
     QRect m_accessRect;
     QRect m_changeRect;
 };
 
 
 #endif /* __KIS_UPDATE_JOB_ITEM_H */
diff --git a/libs/image/kis_update_outline_job.cpp b/libs/image/kis_update_outline_job.cpp
index 6f1122aa88..dbe877690d 100644
--- a/libs/image/kis_update_outline_job.cpp
+++ b/libs/image/kis_update_outline_job.cpp
@@ -1,46 +1,51 @@
 /*
  *  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_update_outline_job.h"
 
 
 KisUpdateOutlineJob::KisUpdateOutlineJob(KisSelectionSP selection, bool updateThumbnail, const QColor &maskColor)
     : m_selection(selection),
       m_updateThumbnail(updateThumbnail),
       m_maskColor(maskColor)
 {
 }
 
 bool KisUpdateOutlineJob::overrides(const KisSpontaneousJob *otherJob)
 {
     return dynamic_cast<const KisUpdateOutlineJob*>(otherJob);
 }
 
 void KisUpdateOutlineJob::run()
 {
     m_selection->recalculateOutlineCache();
     if (m_updateThumbnail) {
         m_selection->recalculateThumbnailImage(m_maskColor);
     }
     m_selection->notifySelectionChanged();
 }
 
 int KisUpdateOutlineJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisUpdateOutlineJob::debugName() const
+{
+    return "KisUpdateOutlineJob";
+}
diff --git a/libs/image/kis_update_outline_job.h b/libs/image/kis_update_outline_job.h
index e64dc01bf0..071f8d5b85 100644
--- a/libs/image/kis_update_outline_job.h
+++ b/libs/image/kis_update_outline_job.h
@@ -1,42 +1,43 @@
 /*
  *  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_UPDATE_OUTLINE_JOB_H
 #define __KIS_UPDATE_OUTLINE_JOB_H
 
 #include <QColor>
 
 #include "kis_spontaneous_job.h"
 #include "kis_selection.h"
 
 class KRITAIMAGE_EXPORT KisUpdateOutlineJob : public KisSpontaneousJob
 {
 public:
     KisUpdateOutlineJob(KisSelectionSP selection, bool updateThumbnail, const QColor &maskColor);
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
+    QString debugName() const override;
 
 private:
     KisSelectionSP m_selection;
     bool m_updateThumbnail;
     QColor m_maskColor;
 };
 
 #endif /* __KIS_UPDATE_OUTLINE_JOB_H */
diff --git a/libs/image/kis_update_selection_job.cpp b/libs/image/kis_update_selection_job.cpp
index f555c72d8d..6b328a6211 100644
--- a/libs/image/kis_update_selection_job.cpp
+++ b/libs/image/kis_update_selection_job.cpp
@@ -1,88 +1,93 @@
 /*
  *  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_update_selection_job.h"
 #include "kis_image.h"
 #include "kis_projection_leaf.h"
 
 
 KisUpdateSelectionJob::KisUpdateSelectionJob(KisSelectionSP selection, const QRect &updateRect)
     : m_selection(selection),
       m_updateRect(updateRect)
 {
     /**
      * TODO: we should implement correct KisShapeSelectionCanvas for
      * projection. See a comment in KisUpdateSelectionJob::run().
      *
      * Right now, since this job accesses some projections for write, we
      * should declare it as exclusive
      */
 
     setExclusive(true);
 }
 
 bool KisUpdateSelectionJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisUpdateSelectionJob *otherJob =
         dynamic_cast<const KisUpdateSelectionJob*>(_otherJob);
 
     bool retval = false;
 
     if (otherJob && otherJob->m_selection == m_selection) {
         if (!m_updateRect.isEmpty()) {
             m_updateRect |= otherJob->m_updateRect;
         }
         retval = true;
     }
 
     return retval;
 }
 
 void KisUpdateSelectionJob::run()
 {
     QRect dirtyRect;
 
     KisNodeSP parentNode = m_selection->parentNode();
     if (parentNode) {
         dirtyRect = parentNode->extent();
     }
 
     if (!m_updateRect.isEmpty()) {
         m_selection->updateProjection(m_updateRect);
     } else {
         m_selection->updateProjection();
     }
 
     m_selection->notifySelectionChanged();
 
     /**
      * TODO: in the future we should remove selection projection calculation
      *       from this job and to reuse a fully-featured shape layer canvas
      *       from KisShapeLayer. Then projection calculation will be a little
      *       bit more efficient.
      */
     if (parentNode && parentNode->projectionLeaf()->isOverlayProjectionLeaf()) {
         dirtyRect |= parentNode->extent();
         parentNode->setDirty(dirtyRect);
     }
 }
 
 int KisUpdateSelectionJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisUpdateSelectionJob::debugName() const
+{
+    return "KisUpdateSelectionJob";
+}
diff --git a/libs/image/kis_update_selection_job.h b/libs/image/kis_update_selection_job.h
index 60401491b7..16aba0ac5a 100644
--- a/libs/image/kis_update_selection_job.h
+++ b/libs/image/kis_update_selection_job.h
@@ -1,39 +1,40 @@
 /*
  *  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_UPDATE_SELECTION_JOB_H
 #define __KIS_UPDATE_SELECTION_JOB_H
 
 #include "kis_spontaneous_job.h"
 #include "kis_selection.h"
 
 class KRITAIMAGE_EXPORT KisUpdateSelectionJob : public KisSpontaneousJob
 {
 public:
     KisUpdateSelectionJob(KisSelectionSP selection, const QRect &updateRect = QRect());
 
     bool overrides(const KisSpontaneousJob *otherJob) override;
     void run() override;
     int levelOfDetail() const override;
+    QString debugName() const override;
 
 private:
     KisSelectionSP m_selection;
     QRect m_updateRect;
 };
 
 #endif /* __KIS_UPDATE_SELECTION_JOB_H */
diff --git a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
index ba301df874..66fcc6d8a7 100644
--- a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
+++ b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
@@ -1,282 +1,282 @@
 /*
  *  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_colorize_stroke_strategy.h"
 
 #include <QBitArray>
 
 #include "krita_utils.h"
 #include "kis_paint_device.h"
 #include "kis_lazy_fill_tools.h"
 #include "kis_gaussian_kernel.h"
 #include "kis_painter.h"
 #include "kis_default_bounds_base.h"
 #include "kis_lod_transform.h"
 #include "kis_node.h"
 #include "kis_image_config.h"
 #include "KisWatershedWorker.h"
 #include "kis_processing_visitor.h"
 
 #include "kis_transaction.h"
 
 #include <KisRunnableStrokeJobData.h>
 #include <KisRunnableStrokeJobUtils.h>
 #include <KisRunnableStrokeJobsInterface.h>
 
 using namespace KisLazyFillTools;
 
 struct KisColorizeStrokeStrategy::Private
 {
     Private() : filteredSourceValid(false) {}
     Private(const Private &rhs, int _levelOfDetail)
         : progressNode(rhs.progressNode)
         , src(rhs.src)
         , dst(rhs.dst)
         , filteredSource(rhs.filteredSource)
         , internalFilteredSource(rhs.internalFilteredSource)
         , filteredSourceValid(rhs.filteredSourceValid)
         , boundingRect(rhs.boundingRect)
         , prefilterOnly(rhs.prefilterOnly)
         , levelOfDetail(_levelOfDetail)
         , keyStrokes(rhs.keyStrokes)
         , filteringOptions(rhs.filteringOptions)
     {}
 
     KisNodeSP progressNode;
     KisPaintDeviceSP src;
     KisPaintDeviceSP dst;
     KisPaintDeviceSP filteredSource;
     KisPaintDeviceSP heightMap;
     KisPaintDeviceSP internalFilteredSource;
     bool filteredSourceValid;
     QRect boundingRect;
 
     bool prefilterOnly = false;
     int levelOfDetail = 0;
 
     QVector<KeyStroke> keyStrokes;
 
     // default values: disabled
     FilteringOptions filteringOptions;
 };
 
 KisColorizeStrokeStrategy::KisColorizeStrokeStrategy(KisPaintDeviceSP src,
                                                      KisPaintDeviceSP dst,
                                                      KisPaintDeviceSP filteredSource,
                                                      bool filteredSourceValid,
                                                      const QRect &boundingRect,
                                                      KisNodeSP progressNode,
                                                      bool prefilterOnly)
-    : KisRunnableBasedStrokeStrategy("colorize-stroke", prefilterOnly ? kundo2_i18n("Prefilter Colorize Mask") : kundo2_i18n("Colorize")),
+    : KisRunnableBasedStrokeStrategy(QLatin1String("colorize-stroke"), prefilterOnly ? kundo2_i18n("Prefilter Colorize Mask") : kundo2_i18n("Colorize")),
       m_d(new Private)
 {
     m_d->progressNode = progressNode;
     m_d->src = src;
     m_d->dst = dst;
     m_d->filteredSource = filteredSource;
     m_d->boundingRect = boundingRect;
     m_d->filteredSourceValid = filteredSourceValid;
     m_d->prefilterOnly = prefilterOnly;
 
     enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     enableJob(JOB_DOSTROKE, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     enableJob(JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     setNeedsExplicitCancel(true);
 }
 
 KisColorizeStrokeStrategy::KisColorizeStrokeStrategy(const KisColorizeStrokeStrategy &rhs, int levelOfDetail)
     : KisRunnableBasedStrokeStrategy(rhs),
       m_d(new Private(*rhs.m_d, levelOfDetail))
 {
     KisLodTransform t(levelOfDetail);
     m_d->boundingRect = t.map(rhs.m_d->boundingRect);
 }
 
 KisColorizeStrokeStrategy::~KisColorizeStrokeStrategy()
 {
 }
 
 void KisColorizeStrokeStrategy::setFilteringOptions(const FilteringOptions &value)
 {
     m_d->filteringOptions = value;
 }
 
 FilteringOptions KisColorizeStrokeStrategy::filteringOptions() const
 {
     return m_d->filteringOptions;
 }
 
 void KisColorizeStrokeStrategy::addKeyStroke(KisPaintDeviceSP dev, const KoColor &color)
 {
     KoColor convertedColor(color);
     convertedColor.convertTo(m_d->dst->colorSpace());
 
     m_d->keyStrokes << KeyStroke(dev, convertedColor);
 }
 
 void KisColorizeStrokeStrategy::initStrokeCallback()
 {
     using namespace KritaUtils;
 
     QVector<KisRunnableStrokeJobData*> jobs;
 
     const QVector<QRect> patchRects =
         splitRectIntoPatches(m_d->boundingRect, optimalPatchSize());
 
     if (!m_d->filteredSourceValid) {
         // TODO: make this conversion concurrent!!!
         KisPaintDeviceSP filteredMainDev = KisPainter::convertToAlphaAsAlpha(m_d->src);
         filteredMainDev->setDefaultBounds(m_d->src->defaultBounds());
 
         struct PrefilterSharedState {
             QRect boundingRect;
             KisPaintDeviceSP filteredMainDev;
             KisPaintDeviceSP filteredMainDevSavedCopy;
             QScopedPointer<KisTransaction> activeTransaction;
             FilteringOptions filteringOptions;
         };
 
         QSharedPointer<PrefilterSharedState> state(new PrefilterSharedState());
         state->boundingRect = m_d->boundingRect;
         state->filteredMainDev = filteredMainDev;
         state->filteringOptions = m_d->filteringOptions;
 
         if (m_d->filteringOptions.useEdgeDetection &&
             m_d->filteringOptions.edgeDetectionSize > 0.0) {
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
             });
 
             Q_FOREACH (const QRect &rc, patchRects) {
                 addJobConcurrent(jobs, [state, rc] () {
                     KisLodTransformScalar t(state->filteredMainDev);
                     KisGaussianKernel::applyLoG(state->filteredMainDev,
                                                 rc,
                                                 t.scale(0.5 * state->filteringOptions.edgeDetectionSize),
                                                 -1.0,
                                                 QBitArray(), 0);
                 });
             }
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset();
                 normalizeAlpha8Device(state->filteredMainDev, state->boundingRect);
                 state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
             });
 
             Q_FOREACH (const QRect &rc, patchRects) {
                 addJobConcurrent(jobs, [state, rc] () {
                     KisLodTransformScalar t(state->filteredMainDev);
                     KisGaussianKernel::applyGaussian(state->filteredMainDev,
                                                      rc,
                                                      t.scale(state->filteringOptions.edgeDetectionSize),
                                                      t.scale(state->filteringOptions.edgeDetectionSize),
                                                      QBitArray(), 0);
                 });
             }
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset();
             });
         }
 
         if (m_d->filteringOptions.fuzzyRadius > 0) {
 
             addJobSequential(jobs, [state] () {
                 state->filteredMainDevSavedCopy = new KisPaintDevice(*state->filteredMainDev);
                 state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
             });
 
             Q_FOREACH (const QRect &rc, patchRects) {
                 addJobConcurrent(jobs, [state, rc] () {
                     KisLodTransformScalar t(state->filteredMainDev);
                     KisGaussianKernel::applyGaussian(state->filteredMainDev,
                                                      rc,
                                                      t.scale(state->filteringOptions.fuzzyRadius),
                                                      t.scale(state->filteringOptions.fuzzyRadius),
                                                      QBitArray(), 0);
                     KisPainter gc(state->filteredMainDev);
                     gc.bitBlt(rc.topLeft(), state->filteredMainDevSavedCopy, rc);
                 });
             }
 
             addJobSequential(jobs, [state] () {
                 state->activeTransaction.reset();
             });
         }
 
         addJobSequential(jobs, [this, state] () {
             normalizeAndInvertAlpha8Device(state->filteredMainDev, state->boundingRect);
 
             KisDefaultBoundsBaseSP oldBounds = m_d->filteredSource->defaultBounds();
             m_d->filteredSource->makeCloneFrom(state->filteredMainDev, m_d->boundingRect);
             m_d->filteredSource->setDefaultBounds(oldBounds);
             m_d->filteredSourceValid = true;
         });
     }
 
     if (!m_d->prefilterOnly) {
         addJobSequential(jobs, [this] () {
             m_d->heightMap = new KisPaintDevice(*m_d->filteredSource);
         });
 
         Q_FOREACH (const QRect &rc, patchRects) {
             addJobConcurrent(jobs, [this, rc] () {
                 KritaUtils::filterAlpha8Device(m_d->heightMap, rc,
                                                [](quint8 pixel) {
                                                    return quint8(255 - pixel);
                                                });
             });
         }
 
         addJobSequential(jobs, [this] () {
             KisProcessingVisitor::ProgressHelper helper(m_d->progressNode);
 
             KisWatershedWorker worker(m_d->heightMap, m_d->dst, m_d->boundingRect, helper.updater());
             Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
                 KoColor color =
                     !stroke.isTransparent ?
                         stroke.color : KoColor(Qt::transparent, m_d->dst->colorSpace());
 
                 worker.addKeyStroke(stroke.dev, color);
             }
             worker.run(m_d->filteringOptions.cleanUpAmount);
         });
     }
 
     addJobSequential(jobs, [this] () {
         emit sigFinished(m_d->prefilterOnly);
     });
 
     runnableJobsInterface()->addRunnableJobs(jobs);
 }
 
 void KisColorizeStrokeStrategy::cancelStrokeCallback()
 {
     emit sigCancelled();
 }
 
 KisStrokeStrategy* KisColorizeStrokeStrategy::createLodClone(int levelOfDetail)
 {
     KisImageConfig cfg(true);
     if (!cfg.useLodForColorizeMask()) return 0;
 
     KisColorizeStrokeStrategy *clone = new KisColorizeStrokeStrategy(*this, levelOfDetail);
     return clone;
 }
diff --git a/libs/image/tests/kis_image_test.cpp b/libs/image/tests/kis_image_test.cpp
index d9145a3696..e6e70feb8b 100644
--- a/libs/image/tests/kis_image_test.cpp
+++ b/libs/image/tests/kis_image_test.cpp
@@ -1,1287 +1,1293 @@
 /*
  *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.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_image_test.h"
 #include <QApplication>
 
 #include <QTest>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 
 #include "kis_image.h"
 #include "kis_paint_layer.h"
 #include "kis_group_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_selection.h"
 #include <kis_debug.h>
 #include <kis_layer_composition.h>
 #include "kis_keyframe_channel.h"
 #include "kis_selection_mask.h"
 #include "kis_layer_utils.h"
 #include "kis_annotation.h"
 #include "KisProofingConfiguration.h"
 
 #include "kis_undo_stores.h"
 
 
 #define IMAGE_WIDTH 128
 #define IMAGE_HEIGHT 128
 
 void KisImageTest::layerTests()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
 
     QVERIFY(image->rootLayer()->firstChild()->objectName() == layer->objectName());
 }
 
 void KisImageTest::benchmarkCreation()
 {
     const QRect imageRect(0,0,3000,2000);
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     QList<KisImageSP> images;
     QList<KisSurrogateUndoStore*> stores;
 
 
     QBENCHMARK {
         for (int i = 0; i < 10; i++) {
             stores << new KisSurrogateUndoStore();
         }
 
         for (int i = 0; i < 10; i++) {
             KisImageSP image = new KisImage(stores.takeLast(), imageRect.width(), imageRect.height(), cs, "test image");
             images << image;
         }
     }
 }
 
 #include "testutil.h"
 #include "kis_stroke_strategy.h"
 #include <functional>
 
 
 class ForbiddenLodStrokeStrategy : public KisStrokeStrategy
 {
 public:
     ForbiddenLodStrokeStrategy(std::function<void()> lodCallback)
-        : m_lodCallback(lodCallback)
+        : KisStrokeStrategy(QLatin1String("ForbiddenLodStrokeStrategy")),
+          m_lodCallback(lodCallback)
     {
     }
 
     KisStrokeStrategy* createLodClone(int levelOfDetail) override {
         Q_UNUSED(levelOfDetail);
         m_lodCallback();
         return 0;
     }
 
 private:
     std::function<void()> m_lodCallback;
 };
 
 void notifyVar(bool *value) {
     *value = true;
 }
 
 void KisImageTest::testBlockLevelOfDetail()
 {
     TestUtil::MaskParent p;
 
     QCOMPARE(p.image->currentLevelOfDetail(), 0);
 
     p.image->setDesiredLevelOfDetail(1);
     p.image->waitForDone();
 
     QCOMPARE(p.image->currentLevelOfDetail(), 0);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(lodCreated);
     }
 
     p.image->setLevelOfDetailBlocked(true);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(!lodCreated);
     }
 
     p.image->setLevelOfDetailBlocked(false);
     p.image->setDesiredLevelOfDetail(1);
 
     {
         bool lodCreated = false;
         KisStrokeId id = p.image->startStroke(
             new ForbiddenLodStrokeStrategy(
                 std::bind(&notifyVar, &lodCreated)));
         p.image->endStroke(id);
         p.image->waitForDone();
 
         QVERIFY(lodCreated);
     }
 }
 
 void KisImageTest::testConvertImageColorSpace()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     KisPaintDeviceSP device1 = new KisPaintDevice(cs8);
     KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
 
     KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
     Q_ASSERT(filter);
     KisFilterConfigurationSP configuration = filter->defaultConfiguration();
     Q_ASSERT(configuration);
 
     KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
 
     image->addNode(paint1, image->root());
     image->addNode(blur1, image->root());
 
     image->refreshGraph();
 
     const KoColorSpace *cs16 = KoColorSpaceRegistry::instance()->rgb16();
     image->convertImageColorSpace(cs16,
                                   KoColorConversionTransformation::internalRenderingIntent(),
                                   KoColorConversionTransformation::internalConversionFlags());
     image->waitForDone();
 
     QVERIFY(*cs16 == *image->colorSpace());
     QVERIFY(*cs16 == *image->root()->colorSpace());
     QVERIFY(*cs16 == *paint1->colorSpace());
     QVERIFY(*cs16 == *blur1->colorSpace());
 
     QVERIFY(!image->root()->compositeOp());
     QVERIFY(*cs16 == *paint1->compositeOp()->colorSpace());
     QVERIFY(*cs16 == *blur1->compositeOp()->colorSpace());
 
     image->refreshGraph();
 }
 
 void KisImageTest::testAssignImageProfile()
 {
     const KoColorSpace *rgb8 = KoColorSpaceRegistry::instance()->rgb8();
     const KoColorSpace *gray8 = KoColorSpaceRegistry::instance()->graya8();
     KisImageSP image = new KisImage(0, 1000, 1000, rgb8, "stest");
 
     KisPaintDeviceSP device1 = new KisPaintDevice(rgb8);
     KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
 
     KisPaintDeviceSP device2 = new KisPaintDevice(gray8);
     KisLayerSP paint2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8, device2);
 
 
     KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
     Q_ASSERT(filter);
     KisFilterConfigurationSP configuration = filter->defaultConfiguration();
     Q_ASSERT(configuration);
 
     KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
 
     image->addNode(paint1, image->root());
     image->addNode(paint2, image->root());
     image->addNode(blur1, image->root());
 
     QCOMPARE(*image->colorSpace(), *rgb8);
     QCOMPARE(*image->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p709SRGBProfile());
 
     QCOMPARE(*paint1->colorSpace(), *rgb8);
     QCOMPARE(*paint1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p709SRGBProfile());
 
     QCOMPARE(*paint2->colorSpace(), *gray8);
 
     QCOMPARE(*blur1->colorSpace(), *rgb8);
     QCOMPARE(*blur1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p709SRGBProfile());
 
 
     image->assignImageProfile(KoColorSpaceRegistry::instance()->p2020G10Profile());
     image->waitForDone();
 
     QVERIFY(*image->colorSpace() != *rgb8);
     QCOMPARE(*image->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p2020G10Profile());
 
     QVERIFY(*paint1->colorSpace() != *rgb8);
     QCOMPARE(*paint1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p2020G10Profile());
 
     QCOMPARE(*paint2->colorSpace(), *gray8);
 
     QVERIFY(*blur1->colorSpace() != *rgb8);
     QCOMPARE(*blur1->colorSpace()->profile(), *KoColorSpaceRegistry::instance()->p2020G10Profile());
 }
 
 void KisImageTest::testGlobalSelection()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 0U);
 
     KisSelectionSP selection1 = new KisSelection(new KisDefaultBounds(image));
     KisSelectionSP selection2 = new KisSelection(new KisDefaultBounds(image));
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->setGlobalSelection(selection2);
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->reselectGlobalSelection();
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     // mixed deselecting/setting/reselecting
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 }
 
 void KisImageTest::testCloneImage()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisAnnotationSP annotation = new KisAnnotation("mytype", "mydescription", QByteArray());
     image->addAnnotation(annotation);
     QVERIFY(image->annotation("mytype"));
 
     KisProofingConfigurationSP proofing = toQShared(new KisProofingConfiguration());
     image->setProofingConfiguration(proofing);
     QVERIFY(image->proofingConfiguration());
 
     const KoColor defaultColor(Qt::green, image->colorSpace());
     image->setDefaultProjectionColor(defaultColor);
     QCOMPARE(image->defaultProjectionColor(), defaultColor);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
     KisLayerSP layer2 = new KisPaintLayer(image, "layer2", OPACITY_OPAQUE_U8);
     image->addNode(layer2);
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     QVERIFY(TestUtil::findNode(image->root(), "layer1"));
     QVERIFY(TestUtil::findNode(image->root(), "layer2"));
 
     QUuid uuid1 = layer->uuid();
     QUuid uuid2 = layer2->uuid();
 
     {
         KisImageSP newImage = image->clone();
 
         KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
         KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
         QVERIFY(newLayer1);
         QVERIFY(newLayer2);
 
         QVERIFY(newLayer1->uuid() != uuid1);
         QVERIFY(newLayer2->uuid() != uuid2);
 
         KisAnnotationSP newAnnotation = newImage->annotation("mytype");
         QVERIFY(newAnnotation);
         QVERIFY(newAnnotation != annotation);
 
 
         KisProofingConfigurationSP newProofing = newImage->proofingConfiguration();
         QVERIFY(newProofing);
         QVERIFY(newProofing != proofing);
 
         QCOMPARE(newImage->defaultProjectionColor(), defaultColor);
     }
 
     {
         KisImageSP newImage = image->clone(true);
 
         KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
         KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
         QVERIFY(newLayer1);
         QVERIFY(newLayer2);
 
         QVERIFY(newLayer1->uuid() == uuid1);
         QVERIFY(newLayer2->uuid() == uuid2);
     }
 }
 
 void KisImageTest::testLayerComposition()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
     KisLayerSP layer2 = new KisPaintLayer(image, "layer2", OPACITY_OPAQUE_U8);
     image->addNode(layer2);
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     KisLayerComposition comp(image, "comp 1");
     comp.store();
 
     layer2->setVisible(false);
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 
     KisLayerComposition comp2(image, "comp 2");
     comp2.store();
 
     KisLayerCompositionSP comp3 = toQShared(new KisLayerComposition(image, "comp 3"));
     comp3->store();
     image->addComposition(comp3);
 
     comp.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     comp2.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 
     comp.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     KisImageSP newImage = image->clone();
 
     KisNodeSP newLayer1 = TestUtil::findNode(newImage->root(), "layer1");
     KisNodeSP newLayer2 = TestUtil::findNode(newImage->root(), "layer2");
 
     QVERIFY(newLayer1);
     QVERIFY(newLayer2);
 
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     KisLayerComposition newComp1(comp, newImage);
     newComp1.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     KisLayerComposition newComp2(comp2, newImage);
     newComp2.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(!newLayer2->visible());
 
     newComp1.apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(newLayer2->visible());
 
     QVERIFY(!newImage->compositions().isEmpty());
     KisLayerCompositionSP newComp3 = newImage->compositions().first();
     newComp3->apply();
     QVERIFY(newLayer1->visible());
     QVERIFY(!newLayer2->visible());
 }
 
 #include "kis_transparency_mask.h"
 #include "kis_psd_layer_style.h"
 
 struct FlattenTestImage
 {
     FlattenTestImage()
         : refRect(0,0,512,512)
         , p(refRect)
     {
 
         image = p.image;
         undoStore = p.undoStore;
         layer1 = p.layer;
 
         layer5 = new KisPaintLayer(p.image, "paint5", 0.4 * OPACITY_OPAQUE_U8);
         layer5->disableAlphaChannel(true);
 
         layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
         tmask = new KisTransparencyMask();
 
         // check channel flags
         // make addition composite op
         group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
         layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
         layer4 = new KisPaintLayer(p.image, "paint4", OPACITY_OPAQUE_U8);
 
         layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
 
         layer7 = new KisPaintLayer(p.image, "paint7", OPACITY_OPAQUE_U8);
         layer8 = new KisPaintLayer(p.image, "paint8", OPACITY_OPAQUE_U8);
         layer7->setCompositeOpId(COMPOSITE_ADD);
         layer8->setCompositeOpId(COMPOSITE_ADD);
 
         QRect rect1(100, 100, 100, 100);
         QRect rect2(150, 150, 150, 150);
         QRect tmaskRect(200,200,100,100);
 
         QRect rect3(400, 100, 100, 100);
         QRect rect4(500, 100, 100, 100);
 
         QRect rect5(50, 50, 100, 100);
 
         QRect rect6(50, 250, 100, 100);
 
         QRect rect7(50, 350, 50, 50);
         QRect rect8(50, 400, 50, 50);
 
         layer1->paintDevice()->fill(rect1, KoColor(Qt::red, p.image->colorSpace()));
 
         layer2->paintDevice()->fill(rect2, KoColor(Qt::green, p.image->colorSpace()));
         tmask->testingInitSelection(tmaskRect, layer2);
 
         layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, p.image->colorSpace()));
         layer4->paintDevice()->fill(rect4, KoColor(Qt::yellow, p.image->colorSpace()));
         layer5->paintDevice()->fill(rect5, KoColor(Qt::green, p.image->colorSpace()));
 
         layer6->paintDevice()->fill(rect6, KoColor(Qt::cyan, p.image->colorSpace()));
 
         layer7->paintDevice()->fill(rect7, KoColor(Qt::red, p.image->colorSpace()));
         layer8->paintDevice()->fill(rect8, KoColor(Qt::green, p.image->colorSpace()));
 
         KisPSDLayerStyleSP style(new KisPSDLayerStyle());
         style->dropShadow()->setEffectEnabled(true);
         style->dropShadow()->setDistance(10.0);
         style->dropShadow()->setSpread(80.0);
         style->dropShadow()->setSize(10);
         style->dropShadow()->setNoise(0);
         style->dropShadow()->setKnocksOut(false);
         style->dropShadow()->setOpacity(80.0);
         layer2->setLayerStyle(style);
 
         layer2->setCompositeOpId(COMPOSITE_ADD);
         group1->setCompositeOpId(COMPOSITE_ADD);
 
         p.image->addNode(layer5);
 
         p.image->addNode(layer2);
         p.image->addNode(tmask, layer2);
 
         p.image->addNode(group1);
         p.image->addNode(layer3, group1);
         p.image->addNode(layer4, group1);
 
         p.image->addNode(layer6);
 
         p.image->addNode(layer7);
         p.image->addNode(layer8);
 
         p.image->initialRefreshGraph();
 
         // dbgKrita << ppVar(layer1->exactBounds());
         // dbgKrita << ppVar(layer5->exactBounds());
         // dbgKrita << ppVar(layer2->exactBounds());
         // dbgKrita << ppVar(group1->exactBounds());
         // dbgKrita << ppVar(layer3->exactBounds());
         // dbgKrita << ppVar(layer4->exactBounds());
 
         TestUtil::ReferenceImageChecker chk("flatten", "imagetest");
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     QRect refRect;
     TestUtil::MaskParent p;
 
     KisImageSP image;
     KisSurrogateUndoStore *undoStore;
     KisPaintLayerSP layer1;
 
     KisPaintLayerSP layer2;
     KisTransparencyMaskSP tmask;
 
     KisGroupLayerSP group1;
     KisPaintLayerSP layer3;
     KisPaintLayerSP layer4;
 
     KisPaintLayerSP layer5;
 
     KisPaintLayerSP layer6;
 
     KisPaintLayerSP layer7;
     KisPaintLayerSP layer8;
 };
 
 template<class ContainerTest>
 KisLayerSP flattenLayerHelper(ContainerTest &p, KisLayerSP layer, bool nothingHappens = false)
 {
     QSignalSpy spy(p.image.data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)));
 
     //p.image->flattenLayer(layer);
     KisLayerUtils::flattenLayer(p.image, layer);
     p.image->waitForDone();
 
     if (nothingHappens) {
         Q_ASSERT(!spy.count());
         return layer;
     }
 
     Q_ASSERT(spy.count() == 1);
     QList<QVariant> arguments = spy.takeFirst();
     KisNodeSP newNode = arguments.first().value<KisNodeSP>();
 
     KisLayerSP newLayer = qobject_cast<KisLayer*>(newNode.data());
     return newLayer;
 }
 
 void KisImageTest::testFlattenLayer()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker chk("flatten", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.layer2);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.layer2);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.group1);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(400, 100, 200, 100));
     }
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.layer5, true);
 
         //KisLayerSP newLayer = p.image->flattenLayer(p.layer5);
         //p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 50, 100, 100));
 
         QCOMPARE(newLayer->alphaChannelDisabled(), true);
     }
 }
 
 #include <kis_meta_data_merge_strategy_registry.h>
 
 template<class ContainerTest>
 KisLayerSP mergeHelper(ContainerTest &p, KisLayerSP layer)
 {
     KisNodeSP parent = layer->parent();
     const int newIndex = parent->index(layer) - 1;
 
     p.image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
 
     //KisLayerUtils::mergeDown(p.image, layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
     p.image->waitForDone();
 
     KisLayerSP newLayer = qobject_cast<KisLayer*>(parent->at(newIndex).data());
     return newLayer;
 }
 
 void KisImageTest::testMergeDown()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_simple", "imagetest");
 
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer5);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer2);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 213, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.group1);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_group1_mergedown_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 500, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationInheritsAlpha()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_dst_inheritsalpha", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer2);
 
         // WARN: this check is suspicious!
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_proj_merged_layer2_over_layer5_IA"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50,50, 263, 267));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationCustomCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_dst_customop", "imagetest");
 
     {
         QCOMPARE(p.layer6->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer6->alphaChannelDisabled(), false);
 
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer6);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer6_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOpLayerStyle()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_sameop_ls", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.group1);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(197, 100, 403, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_sameop_fastpath", "imagetest");
 
     {
         QCOMPARE(p.layer8->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer8->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer7->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer7->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer8);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 350, 50, 100));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 #include "kis_image_animation_interface.h"
 void KisImageTest::testMergeDownMultipleFrames()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergedown_simple", "imagetest");
 
     QSet<int> initialFrames;
     {
         KisLayerSP l = p.layer5;
         l->enableAnimation();
         KisKeyframeChannel *channel = l->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
         channel->addKeyframe(10);
         channel->addKeyframe(20);
         channel->addKeyframe(30);
 
         QCOMPARE(channel->keyframeCount(), 4);
         initialFrames = KisLayerUtils::fetchLayerFramesRecursive(l);
         QCOMPARE(initialFrames.size(), 4);
     }
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.layer5);
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
 
         QVERIFY(newLayer->isAnimated());
 
         QSet<int> newFrames = KisLayerUtils::fetchLayerFramesRecursive(newLayer);
         QCOMPARE(newFrames, initialFrames);
 
         foreach (int frame, newFrames) {
             KisImageAnimationInterface *interface = p.image->animationInterface();
             int savedSwitchedTime = 0;
             interface->saveAndResetCurrentTime(frame, &savedSwitchedTime);
             QCOMPARE(newLayer->exactBounds(), QRect(100,100,100,100));
             interface->restoreCurrentTime(&savedSwitchedTime);
         }
 
         p.undoStore->undo();
         p.image->waitForDone();
 
          QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 }
 
 template<class ContainerTest>
 KisNodeSP mergeMultipleHelper(ContainerTest &p, QList<KisNodeSP> selectedNodes, KisNodeSP putAfter)
 {
     QSignalSpy spy(p.image.data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)));
 
     p.image->mergeMultipleLayers(selectedNodes, putAfter);
     //KisLayerUtils::mergeMultipleLayers(p.image, selectedNodes, putAfter);
     p.image->waitForDone();
 
     Q_ASSERT(spy.count() == 1);
     QList<QVariant> arguments = spy.takeFirst();
     KisNodeSP newNode = arguments.first().value<KisNodeSP>();
     return newNode;
 }
 void KisImageTest::testMergeMultiple()
 {
     FlattenTestImage p;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
     TestUtil::ReferenceImageChecker chk("mergemultiple", "imagetest");
 
     {
         QList<KisNodeSP> selectedNodes;
 
         selectedNodes << p.layer2
                       << p.group1
                       << p.layer6;
 
         {
             KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
 
             //KisNodeSP newLayer = p.image->mergeMultipleLayers(selectedNodes, 0);
             //p.image->waitForDone();
 
             QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
             QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
             QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
             QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         }
     }
 
     p.p.undoStore->undo();
     p.image->waitForDone();
 
 
     // Test reversed order, the result must be the same
 
     {
         QList<KisNodeSP> selectedNodes;
 
         selectedNodes << p.layer6
                       << p.group1
                       << p.layer2;
 
         {
             KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
 
             //KisNodeSP newLayer = p.image->mergeMultipleLayers(selectedNodes, 0);
             //p.image->waitForDone();
 
             QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
             QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
             QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
             QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         }
     }
 
 }
 
 void testMergeCrossColorSpaceImpl(bool useProjectionColorSpace, bool swapSpaces)
 {
     TestUtil::MaskParent p;
 
     KisPaintLayerSP layer1;
     KisPaintLayerSP layer2;
     KisPaintLayerSP layer3;
 
     const KoColorSpace *cs2 = useProjectionColorSpace ?
         p.image->colorSpace() : KoColorSpaceRegistry::instance()->lab16();
 
     const KoColorSpace *cs3 = KoColorSpaceRegistry::instance()->rgb16();
 
     if (swapSpaces) {
         std::swap(cs2, cs3);
     }
 
     dbgKrita << "Testing testMergeCrossColorSpaceImpl:";
     dbgKrita << "    " << ppVar(cs2);
     dbgKrita << "    " << ppVar(cs3);
 
     layer1 = p.layer;
     layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8, cs2);
     layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8, cs3);
 
     QRect rect1(100, 100, 100, 100);
     QRect rect2(150, 150, 150, 150);
     QRect rect3(250, 250, 200, 200);
 
     layer1->paintDevice()->fill(rect1, KoColor(Qt::red, layer1->colorSpace()));
     layer2->paintDevice()->fill(rect2, KoColor(Qt::green, layer2->colorSpace()));
     layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, layer3->colorSpace()));
 
     p.image->addNode(layer2);
     p.image->addNode(layer3);
 
     p.image->initialRefreshGraph();
 
     {
         KisLayerSP newLayer = mergeHelper(p, layer3);
 
         QCOMPARE(newLayer->colorSpace(), p.image->colorSpace());
 
         p.undoStore->undo();
         p.image->waitForDone();
     }
 
     {
         layer2->disableAlphaChannel(true);
 
         KisLayerSP newLayer = mergeHelper(p, layer3);
 
         QCOMPARE(newLayer->colorSpace(), p.image->colorSpace());
 
         p.undoStore->undo();
         p.image->waitForDone();
     }
 }
 
 void KisImageTest::testMergeCrossColorSpace()
 {
     testMergeCrossColorSpaceImpl(true, false);
     testMergeCrossColorSpaceImpl(true, true);
     testMergeCrossColorSpaceImpl(false, false);
     testMergeCrossColorSpaceImpl(false, true);
 }
 
 void KisImageTest::testMergeSelectionMasks()
 {
     TestUtil::MaskParent p;
 
     QRect rect1(100, 100, 100, 100);
     QRect rect2(150, 150, 150, 150);
     QRect rect3(50, 50, 100, 100);
 
     KisPaintLayerSP layer1 = p.layer;
     layer1->paintDevice()->fill(rect1, KoColor(Qt::red, layer1->colorSpace()));
 
     p.image->initialRefreshGraph();
 
     KisSelectionSP sel = new KisSelection(layer1->paintDevice()->defaultBounds());
 
     sel->pixelSelection()->select(rect2, MAX_SELECTED);
     KisSelectionMaskSP mask1 = new KisSelectionMask(p.image);
     mask1->initSelection(sel, layer1);
     p.image->addNode(mask1, layer1);
 
     QVERIFY(!layer1->selection());
 
     mask1->setActive(true);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(150,150,150,150));
 
     sel->pixelSelection()->select(rect3, MAX_SELECTED);
     KisSelectionMaskSP mask2 = new KisSelectionMask(p.image);
     mask2->initSelection(sel, layer1);
     p.image->addNode(mask2, layer1);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(150,150,150,150));
 
     mask2->setActive(true);
 
     QCOMPARE(layer1->selection()->selectedExactRect(), QRect(50,50,250,250));
 
     QList<KisNodeSP> selectedNodes;
 
     selectedNodes << mask2
                   << mask1;
 
     {
         KisNodeSP newLayer = mergeMultipleHelper(p, selectedNodes, 0);
         QCOMPARE(newLayer->parent(), KisNodeSP(layer1));
         QCOMPARE((int)layer1->childCount(), 1);
         QCOMPARE(layer1->selection()->selectedExactRect(), QRect(50,50,250,250));
     }
 }
 
 void KisImageTest::testFlattenImage()
 {
     FlattenTestImage p;
     KisImageSP image = p.image;
 
     TestUtil::ReferenceImageChecker img("flatten", "imagetest");
 
     {
         KisLayerUtils::flattenImage(p.image, 0);
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer5); // flatten with active layer just under the root (not inside any group)
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer2); // flatten with active layer just under the root (not inside any group), but with a mask
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     {
         KisLayerUtils::flattenImage(p.image, p.layer3); // flatten with active layer inside of a group
         p.image->waitForDone();
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         p.undoStore->undo();
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 }
 
 struct FlattenPassThroughTestImage
 {
     FlattenPassThroughTestImage()
         : refRect(0,0,512,512)
         , p(refRect)
     {
 
         image = p.image;
         undoStore = p.undoStore;
 
         group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
         layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
         layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
 
         group4 = new KisGroupLayer(p.image, "group4", OPACITY_OPAQUE_U8);
         layer5 = new KisPaintLayer(p.image, "paint5", OPACITY_OPAQUE_U8);
         layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
 
         QRect rect2(100, 100, 100, 100);
         QRect rect3(150, 150, 100, 100);
 
         QRect rect5(200, 200, 100, 100);
         QRect rect6(250, 250, 100, 100);
 
         group1->setPassThroughMode(true);
         layer2->paintDevice()->fill(rect2, KoColor(Qt::red, p.image->colorSpace()));
         layer3->paintDevice()->fill(rect3, KoColor(Qt::green, p.image->colorSpace()));
 
         group4->setPassThroughMode(true);
         layer5->paintDevice()->fill(rect5, KoColor(Qt::blue, p.image->colorSpace()));
         layer6->paintDevice()->fill(rect6, KoColor(Qt::yellow, p.image->colorSpace()));
 
 
         p.image->addNode(group1);
         p.image->addNode(layer2, group1);
         p.image->addNode(layer3, group1);
 
         p.image->addNode(group4);
         p.image->addNode(layer5, group4);
         p.image->addNode(layer6, group4);
 
         p.image->initialRefreshGraph();
 
         TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     QRect refRect;
     TestUtil::MaskParent p;
 
     KisImageSP image;
     KisSurrogateUndoStore *undoStore;
 
     KisGroupLayerSP group1;
     KisPaintLayerSP layer2;
     KisPaintLayerSP layer3;
 
     KisGroupLayerSP group4;
     KisPaintLayerSP layer5;
     KisPaintLayerSP layer6;
 };
 
 void KisImageTest::testFlattenPassThroughLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 void KisImageTest::testMergeTwoPassThroughLayers()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = mergeHelper(p, p.group4);
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QVERIFY(newLayer->inherits("KisGroupLayer"));
     }
 }
 
 void KisImageTest::testMergePaintOverPassThroughLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group4);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
 
         newLayer = mergeHelper(p, newLayer);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 void KisImageTest::testMergePassThroughOverPaintLayer()
 {
     FlattenPassThroughTestImage p;
 
     TestUtil::ReferenceImageChecker chk("passthrough", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.group1->passThroughMode(), true);
 
         KisLayerSP newLayer = flattenLayerHelper(p, p.group1);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
 
         newLayer = mergeHelper(p, p.group4);
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(newLayer->inherits("KisPaintLayer"));
     }
 }
 
 #include "kis_paint_device_debug_utils.h"
 #include "kis_algebra_2d.h"
 
 void KisImageTest::testPaintOverlayMask()
 {
     QRect refRect(0, 0, 512, 512);
     TestUtil::MaskParent p(refRect);
 
     QRect fillRect(50, 50, 412, 412);
     QRect selectionRect(200, 200, 100, 50);
 
     KisPaintLayerSP layer1 = p.layer;
     layer1->paintDevice()->fill(fillRect, KoColor(Qt::yellow, layer1->colorSpace()));
 
     KisSelectionMaskSP mask = new KisSelectionMask(p.image);
     KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(layer1->paintDevice()));
 
     selection->pixelSelection()->select(selectionRect, 128);
     selection->pixelSelection()->select(KisAlgebra2D::blowRect(selectionRect,-0.3), 255);
 
     mask->setSelection(selection);
 
     //mask->setVisible(false);
     //mask->setActive(false);
 
     p.image->addNode(mask, layer1);
 
     // a simple layer to disable oblidge child mechanism
     KisPaintLayerSP layer2 = new KisPaintLayer(p.image, "layer2", OPACITY_OPAQUE_U8);
     p.image->addNode(layer2);
 
     p.image->initialRefreshGraph();
 
     KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "00_initial", "dd");
 
     p.image->setOverlaySelectionMask(mask);
     p.image->waitForDone();
 
-    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "01_activated", "dd");
+    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "01_activated_00_image", "dd");
+    KIS_DUMP_DEVICE_2(p.image->root()->original(), refRect, "01_activated_01_root_original", "dd");
+    KIS_DUMP_DEVICE_2(p.image->root()->projection(), refRect, "01_activated_02_root_projection", "dd");
+
+    KisImageSP clonedImage = p.image->clone();
+    clonedImage->waitForDone();
+    KIS_DUMP_DEVICE_2(clonedImage->projection(), refRect, "02_cloned_when_activated_00_image", "dd");
+    KIS_DUMP_DEVICE_2(clonedImage->root()->original(), refRect, "02_cloned_when_activated_01_root_original", "dd");
+    KIS_DUMP_DEVICE_2(clonedImage->root()->projection(), refRect, "02_cloned_when_activated_02_root_projection", "dd");
 
     p.image->setOverlaySelectionMask(0);
     p.image->waitForDone();
 
-    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "02_deactivated", "dd");
-
-
-
+    KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "03_deactivated", "dd");
 }
 
 KISTEST_MAIN(KisImageTest)
diff --git a/libs/image/tests/kis_simple_stroke_strategy_test.cpp b/libs/image/tests/kis_simple_stroke_strategy_test.cpp
index 4e6d332f42..7d17d68d97 100644
--- a/libs/image/tests/kis_simple_stroke_strategy_test.cpp
+++ b/libs/image/tests/kis_simple_stroke_strategy_test.cpp
@@ -1,95 +1,96 @@
 /*
  *  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_simple_stroke_strategy_test.h"
 #include <QTest>
 
 #include "kis_image.h"
 #include "kis_simple_stroke_strategy.h"
 
 
 class TestingSimpleStrokeStrategy : public KisSimpleStrokeStrategy
 {
 public:
     TestingSimpleStrokeStrategy()
-        : m_stageCounter(0)
+        : KisSimpleStrokeStrategy(QLatin1String("TestingSimpleStrokeStrategy")),
+          m_stageCounter(0)
     {
         enableJob(KisSimpleStrokeStrategy::JOB_INIT);
         enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
         enableJob(KisSimpleStrokeStrategy::JOB_CANCEL);
         enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
     }
 
     ~TestingSimpleStrokeStrategy() override {
         QCOMPARE(m_stageCounter, 3);
     }
 
     void initStrokeCallback() override {
         QCOMPARE(m_stageCounter, 0);
         m_stageCounter++;
     }
 
     void finishStrokeCallback() override {
         QCOMPARE(m_stageCounter, 2);
         m_stageCounter++;
     }
 
     void cancelStrokeCallback() override {
         QCOMPARE(m_stageCounter, 2);
         m_stageCounter++;
     }
 
     void doStrokeCallback(KisStrokeJobData *data) override {
         Q_UNUSED(data);
 
         QCOMPARE(m_stageCounter, 1);
         m_stageCounter++;
     }
 
 private:
     int m_stageCounter;
 };
 
 void KisSimpleStrokeStrategyTest::testFinish()
 {
     KisImageSP image = new KisImage(0, 100, 100, 0, "test executor image");
 
     KisStrokeId id = image->startStroke(new TestingSimpleStrokeStrategy());
     image->addJob(id, 0);
     image->endStroke(id);
     image->waitForDone();
 }
 
 void KisSimpleStrokeStrategyTest::testCancel()
 {
     KisImageSP image = new KisImage(0, 100, 100, 0, "test executor image");
 
     KisStrokeId id = image->startStroke(new TestingSimpleStrokeStrategy());
     image->addJob(id, 0);
 
     /**
      * We add a delay to ensure the job is finished before the cancel
      * is requested, the cancel job will abort it otherwise
      */
     QTest::qSleep(500);
 
     image->cancelStroke(id);
     image->waitForDone();
 }
 
 QTEST_MAIN(KisSimpleStrokeStrategyTest)
diff --git a/libs/image/tests/kis_strokes_queue_test.cpp b/libs/image/tests/kis_strokes_queue_test.cpp
index 55ac7a8de2..67d130401e 100644
--- a/libs/image/tests/kis_strokes_queue_test.cpp
+++ b/libs/image/tests/kis_strokes_queue_test.cpp
@@ -1,839 +1,839 @@
 /*
  *  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_strokes_queue_test.h"
 #include <QTest>
 
 #include "scheduler_utils.h"
 #include "kis_strokes_queue.h"
 #include "kis_updater_context.h"
 #include "kis_update_job_item.h"
 #include "kis_merge_walker.h"
 
 
 void KisStrokesQueueTest::testSequentialJobs()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("tri_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("tri_"), false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_init");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     COMPARE_NAME(jobs[1], "tri_dab");
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_finish");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testConcurrentSequentialBarrier()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("tri_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("tri_"), false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // make the number of threads higher
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_init");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     COMPARE_NAME(jobs[1], "tri_dab");
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_finish");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testExclusiveStrokes()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("excl_", true));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("excl_"), true));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // well, this walker is not initialized... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_init");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_dab");
     COMPARE_NAME(jobs[1], "excl_dab");
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_finish");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     QCOMPARE(queue.needsExclusiveAccess(), false);
 }
 
 void KisStrokesQueueTest::testBarrierStrokeJobs()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("nor_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("nor_"), false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::BARRIER));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // yes, this walker is not initialized again... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
     bool externalJobsPending = false;
 
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_init");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Now some updates has come...
     context.addMergeJob(walker);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // No difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // Even more updates has come...
     externalJobsPending = true;
 
     // Still no difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // Now clear the context
     context.clear();
 
     // And still no difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Process the last update...
     context.addMergeJob(walker);
     externalJobsPending = false;
 
     // Yep, the queue is still waiting
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     // Finally, we can do our work. Barrier job is executed alone
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Barrier job has finished
     context.clear();
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // fetch the last (concurrent) one
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     // finish the stroke
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_finish");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 }
 
 void KisStrokesQueueTest::testStrokesOverlapping()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("1_", false, true));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("1_"), false, true));
     queue.addJob(id, 0);
 
     // comment out this line to catch an assert
     queue.endStroke(id);
 
-    id = queue.startStroke(new KisTestingStrokeStrategy("2_", false, true));
+    id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("2_"), false, true));
     queue.addJob(id, 0);
     queue.endStroke(id);
 
     // uncomment this line to catch an assert
     // queue.addJob(id, 0);
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "1_dab");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "2_dab");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testImmediateCancel()
 {
     KisStrokesQueue queue;
     KisTestableUpdaterContext context(2);
 
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("1_", false, false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("1_"), false, false));
     queue.cancelStroke(id);
 
     // this should not crash
     queue.processQueue(context, false);
 }
 
 void KisStrokesQueueTest::testOpenedStrokeCounter()
 {
     KisStrokesQueue queue;
 
     QVERIFY(!queue.hasOpenedStrokes());
-    KisStrokeId id0 = queue.startStroke(new KisTestingStrokeStrategy("0"));
+    KisStrokeId id0 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("0")));
     QVERIFY(queue.hasOpenedStrokes());
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("1"));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("1")));
     QVERIFY(queue.hasOpenedStrokes());
     queue.endStroke(id0);
     QVERIFY(queue.hasOpenedStrokes());
     queue.endStroke(id1);
     QVERIFY(!queue.hasOpenedStrokes());
 
     KisTestableUpdaterContext context(2);
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
 }
 
 void KisStrokesQueueTest::testAsyncCancelWhileOpenedStroke()
 {
     KisStrokesQueue queue;
-    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("nor_", false));
+    KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("nor_"), false));
     queue.addJob(id, 0);
     queue.addJob(id, 0);
     queue.addJob(id, 0);
 
     // no async cancelling until the stroke is ended by the owner
     QVERIFY(!queue.tryCancelCurrentStrokeAsync());
 
     queue.endStroke(id);
 
     QVERIFY(queue.tryCancelCurrentStrokeAsync());
 
     bool externalJobsPending = false;
 
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, externalJobsPending);
 
     // no? really?
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 }
 
 struct KisStrokesQueueTest::LodStrokesQueueTester {
 
     LodStrokesQueueTester(bool real = false)
         : fakeContext(2),
           realContext(2),
           context(!real ? fakeContext : realContext)
     {
         queue.setSuspendUpdatesStrokeStrategyFactory(
             []() {
                 return KisSuspendResumePair(
-                    new KisTestingStrokeStrategy("susp_u_", false, true, true),
+                    new KisTestingStrokeStrategy(QLatin1String("susp_u_"), false, true, true),
                     QList<KisStrokeJobData*>());
             });
 
         queue.setResumeUpdatesStrokeStrategyFactory(
             []() {
                 return KisSuspendResumePair(
-                    new KisTestingStrokeStrategy("resu_u_", false, true, true),
+                    new KisTestingStrokeStrategy(QLatin1String("resu_u_"), false, true, true),
                     QList<KisStrokeJobData*>());
             });
         queue.setLod0ToNStrokeStrategyFactory(
             [](bool forgettable) {
                 Q_UNUSED(forgettable);
                 return KisSuspendResumePair(
-                    new KisTestingStrokeStrategy("sync_u_", false, true, true),
+                    new KisTestingStrokeStrategy(QLatin1String("sync_u_"), false, true, true),
                     QList<KisStrokeJobData*>());
             });
     }
 
     KisStrokesQueue queue;
 
     KisTestableUpdaterContext fakeContext;
     KisUpdaterContext realContext;
     KisUpdaterContext &context;
     QVector<KisUpdateJobItem*> jobs;
 
     void processQueueNoAdd() {
         if (&context != &fakeContext) return;
 
         fakeContext.clear();
 
         jobs = fakeContext.getJobs();
         VERIFY_EMPTY(jobs[0]);
         VERIFY_EMPTY(jobs[1]);
     }
 
     void processQueueNoContextClear() {
         queue.processQueue(context, false);
 
         if (&context == &realContext) {
             context.waitForDone();
         }
     }
 
     void processQueue() {
         processQueueNoAdd();
         queue.processQueue(context, false);
 
         if (&context == &realContext) {
             context.waitForDone();
         }
     }
 
     void checkNothing() {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
         VERIFY_EMPTY(jobs[0]);
         VERIFY_EMPTY(jobs[1]);
     }
 
     void checkJobs(const QStringList &list) {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
 
         for (int i = 0; i < 2; i++) {
             if (list.size() <= i) {
                 VERIFY_EMPTY(jobs[i]);
             } else {
                 QVERIFY(jobs[i]->isRunning());
                 COMPARE_NAME(jobs[i], list[i]);
             }
         }
 
         QCOMPARE(queue.needsExclusiveAccess(), false);
     }
 
     void checkOnlyJob(const QString &name) {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
         COMPARE_NAME(jobs[0], name);
         VERIFY_EMPTY(jobs[1]);
         QCOMPARE(queue.needsExclusiveAccess(), false);
     }
 
     void checkOnlyExecutedJob(const QString &name) {
         realContext.waitForDone();
         QVERIFY(!globalExecutedDabs.isEmpty());
         QCOMPARE(globalExecutedDabs[0], name);
 
         QCOMPARE(globalExecutedDabs.size(), 1);
         globalExecutedDabs.clear();
     }
 
     void checkExecutedJobs(const QStringList &list) {
         realContext.waitForDone();
 
         QCOMPARE(globalExecutedDabs, list);
         globalExecutedDabs.clear();
     }
 
     void checkNothingExecuted() {
         realContext.waitForDone();
         QVERIFY(globalExecutedDabs.isEmpty());
     }
 };
 
 
 void KisStrokesQueueTest::testStrokesLevelOfDetail()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
 
     // process sync-lodn-planes stroke
     t.processQueue();
     t.checkOnlyJob("sync_u_init");
 
-    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("lod_", false, true));
+    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("lod_"), false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     // create a update with LOD == 0 (default one)
     // well, this walker is not initialized... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "clone2_lod_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     // walker of a different LOD must not be allowed
     QCOMPARE(context.isJobAllowed(walker), false);
 
     context.clear();
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     COMPARE_NAME(jobs[1], "susp_u_init");
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "lod_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "resu_u_init");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
 }
 
 #include <kundo2command.h>
 #include <kis_post_execution_undo_adapter.h>
 struct TestUndoCommand : public KUndo2Command
 {
     TestUndoCommand(const QString &text) : KUndo2Command(kundo2_noi18n(text)) {}
 
     void undo() override {
         ENTER_FUNCTION();
         undoCount++;
     }
 
     void redo() override {
         ENTER_FUNCTION();
         redoCount++;
     }
 
     int undoCount = 0;
     int redoCount = 0;
 };
 
 void KisStrokesQueueTest::testLodUndoBase()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
 
     // process sync-lodn-planes stroke
     t.processQueue();
     t.checkOnlyJob("sync_u_init");
 
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id1);
 
-    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("str2_", false, true));
+    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str2_"), false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     t.processQueue();
     t.checkOnlyJob("clone2_str1_dab");
 
 
     QSharedPointer<TestUndoCommand> undoStr1(new TestUndoCommand("str1_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr1);
 
     t.processQueue();
     t.checkOnlyJob("clone2_str2_dab");
 
     QSharedPointer<TestUndoCommand> undoStr2(new TestUndoCommand("str2_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr2);
 
     t.processQueue();
     t.checkOnlyJob("susp_u_init");
 
     t.processQueue();
     t.checkOnlyJob("str1_dab");
 
     t.processQueue();
     t.checkOnlyJob("str2_dab");
 
     t.processQueue();
     t.checkOnlyJob("resu_u_init");
 }
 
 void KisStrokesQueueTest::testLodUndoBase2()
 {
     LodStrokesQueueTester t(true);
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true, false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true, false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id1);
 
-    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("str2_", false, true, false, true));
+    KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str2_"), false, true, false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     t.processQueue();
     t.checkOnlyExecutedJob("sync_u_init");
 
     t.processQueue();
     t.checkOnlyExecutedJob("clone2_str1_dab");
 
     QSharedPointer<TestUndoCommand> undoStr1(new TestUndoCommand("str1_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr1);
 
     t.processQueue();
     t.checkOnlyExecutedJob("clone2_str2_dab");
 
     QSharedPointer<TestUndoCommand> undoStr2(new TestUndoCommand("str2_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr2);
 
     t.processQueue();
     t.checkOnlyExecutedJob("susp_u_init");
 
     queue.tryUndoLastStrokeAsync();
     t.processQueue();
 
     while (queue.currentStrokeName() == kundo2_noi18n("str2_undo")) {
         //queue.debugPrintStrokes();
         t.processQueue();
     }
 
     QCOMPARE(undoStr2->undoCount, 1);
 
     t.checkOnlyExecutedJob("str1_dab");
 
     t.processQueue();
     t.checkOnlyExecutedJob("str2_cancel");
 
     t.processQueue();
     t.checkOnlyExecutedJob("resu_u_init");
 }
 
 void KisStrokesQueueTest::testMutatedJobs()
 {
     LodStrokesQueueTester t(true);
     KisStrokesQueue &queue = t.queue;
 
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true, false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true, false, true));
 
     queue.addJob(id1,
                  new KisTestingStrokeJobData(
                      KisStrokeJobData::CONCURRENT,
                      KisStrokeJobData::NORMAL,
                      true, "1"));
 
     queue.addJob(id1,
                  new KisTestingStrokeJobData(
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::NORMAL,
                      false, "2"));
 
     queue.endStroke(id1);
 
     t.processQueue();
 
     t.checkOnlyExecutedJob("str1_dab_1");
 
     t.processQueue();
 
     QStringList refList;
     refList << "str1_dab_mutated" << "str1_dab_mutated";
     t.checkExecutedJobs(refList);
 
     t.processQueue();
     t.checkOnlyExecutedJob("str1_dab_mutated");
 
     t.processQueue();
     t.checkOnlyExecutedJob("str1_dab_2");
 
     t.processQueue();
     t.checkNothingExecuted();
 }
 
 QString sequentialityToString(KisStrokeJobData::Sequentiality seq) {
     QString result = "<unknown>";
 
     switch (seq) {
     case KisStrokeJobData::SEQUENTIAL:
         result = "SEQUENTIAL";
         break;
     case KisStrokeJobData::UNIQUELY_CONCURRENT:
         result = "UNIQUELY_CONCURRENT";
         break;
     case KisStrokeJobData::BARRIER:
         result = "BARRIER";
         break;
     case KisStrokeJobData::CONCURRENT:
         result = "CONCURRENT";
         break;
     }
 
     return result;
 }
 
 void KisStrokesQueueTest::checkJobsOverlapping(LodStrokesQueueTester &t,
                                                KisStrokeId id,
                                                KisStrokeJobData::Sequentiality first,
                                                KisStrokeJobData::Sequentiality second,
                                                bool allowed)
 {
     t.queue.addJob(id, new KisTestingStrokeJobData(first,
                                                    KisStrokeJobData::NORMAL, false, "first"));
     t.processQueue();
     t.checkJobs({"str1_dab_first"});
 
     t.queue.addJob(id, new KisTestingStrokeJobData(second,
                                                    KisStrokeJobData::NORMAL, false, "second"));
 
     qDebug() << QString("  test %1 after %2 allowed: %3 ")
                 .arg(sequentialityToString(second), 24)
                 .arg(sequentialityToString(first), 24)
                 .arg(allowed);
 
     if (allowed) {
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab_first", "str1_dab_second"});
     } else {
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab_first"});
 
         t.processQueue();
         t.checkJobs({"str1_dab_second"});
     }
 
     t.processQueueNoAdd();
     t.checkNothing();
 }
 
 void KisStrokesQueueTest::testUniquelyConcurrentJobs()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
-    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true));
+    KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy(QLatin1String("str1_"), false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
 
     { // manual test
         t.processQueue();
         t.checkJobs({"str1_dab", "str1_dab"});
 
         queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
         t.processQueue();
         t.checkJobs({"str1_dab"});
 
         queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT,
                                                   KisStrokeJobData::NORMAL, false, "ucon"));
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab", "str1_dab_ucon"});
 
         t.processQueueNoAdd();
         t.checkNothing();
     }
 
     // Test various cases of overlapping
 
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::CONCURRENT, true);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::SEQUENTIAL, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::BARRIER, false);
 
     checkJobsOverlapping(t, id1, KisStrokeJobData::CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT , true);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::BARRIER, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
 
     queue.endStroke(id1);
 }
 
 
 QTEST_MAIN(KisStrokesQueueTest)
diff --git a/libs/image/tests/kis_update_scheduler_test.cpp b/libs/image/tests/kis_update_scheduler_test.cpp
index f4e6bebae9..bda1e77872 100644
--- a/libs/image/tests/kis_update_scheduler_test.cpp
+++ b/libs/image/tests/kis_update_scheduler_test.cpp
@@ -1,431 +1,431 @@
 /*
  *  Copyright (c) 2010 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_update_scheduler_test.h"
 #include <QTest>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_adjustment_layer.h"
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_selection.h"
 
 #include "scheduler_utils.h"
 #include "kis_update_scheduler.h"
 #include "kis_updater_context.h"
 #include "kis_update_job_item.h"
 #include "kis_simple_update_queue.h"
 
 #include "../../sdk/tests/testutil.h"
 
 
 KisImageSP KisUpdateSchedulerTest::buildTestingImage()
 {
     QImage sourceImage1(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     QImage sourceImage2(QString(FILES_DATA_DIR) + QDir::separator() + "inverted_hakonepa.png");
 
     QRect imageRect = QRect(QPoint(0,0), sourceImage1.size());
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
 
     KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
     Q_ASSERT(filter);
     KisFilterConfigurationSP configuration = filter->defaultConfiguration();
     Q_ASSERT(configuration);
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
     KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8 / 3);
     KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
 
     paintLayer1->paintDevice()->convertFromQImage(sourceImage1, 0, 0, 0);
     paintLayer2->paintDevice()->convertFromQImage(sourceImage2, 0, 0, 0);
 
     image->lock();
     image->addNode(paintLayer1);
     image->addNode(paintLayer2);
     image->addNode(blur1);
     image->unlock();
 
     return image;
 }
 
 void KisUpdateSchedulerTest::testMerge()
 {
     KisImageSP image = buildTestingImage();
     QRect imageRect = image->bounds();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
 
 
     KisUpdateScheduler scheduler(image.data());
 
     /**
      * Test synchronous Full Refresh
      */
 
     scheduler.fullRefresh(rootLayer, image->bounds(), image->bounds());
     QCOMPARE(rootLayer->exactBounds(), image->bounds());
 
     QImage resultFRProjection = rootLayer->projection()->convertToQImage(0);
     resultFRProjection.save(QString(FILES_OUTPUT_DIR) + QDir::separator() + "scheduler_fr_merge_result.png");
 
     /**
      * Test incremental updates
      */
 
     rootLayer->projection()->clear();
 
     const qint32 num = 4;
     qint32 width = imageRect.width() / num;
     qint32 lastWidth = imageRect.width() - width;
 
     QVector<QRect> dirtyRects(num);
 
     for(qint32 i = 0; i < num-1; i++) {
         dirtyRects[i] = QRect(width*i, 0, width, imageRect.height());
     }
     dirtyRects[num-1] = QRect(width*(num-1), 0, lastWidth, imageRect.height());
 
     for(qint32 i = 0; i < num; i+=2) {
         scheduler.updateProjection(paintLayer1, dirtyRects[i], image->bounds());
     }
 
     for(qint32 i = 1; i < num; i+=2) {
         scheduler.updateProjection(paintLayer1, dirtyRects[i], image->bounds());
     }
 
     scheduler.waitForDone();
 
     QCOMPARE(rootLayer->exactBounds(), image->bounds());
 
     QImage resultDirtyProjection = rootLayer->projection()->convertToQImage(0);
     resultDirtyProjection.save(QString(FILES_OUTPUT_DIR) + QDir::separator() + "scheduler_dp_merge_result.png");
 
     QPoint pt;
     QVERIFY(TestUtil::compareQImages(pt, resultFRProjection, resultDirtyProjection));
 }
 
 void KisUpdateSchedulerTest::benchmarkOverlappedMerge()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
     QRect imageRect = image->bounds();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
     QCOMPARE(imageRect, QRect(0,0,640,441));
 
     KisUpdateScheduler scheduler(image.data());
 
     const qint32 xShift = 10;
     const qint32 yShift = 0;
     const qint32 numShifts = 64;
 
     QBENCHMARK{
         QRect dirtyRect(0, 0, 200, imageRect.height());
 
         for(int i = 0; i < numShifts; i++) {
             // dbgKrita << dirtyRect;
             scheduler.updateProjection(paintLayer1, dirtyRect, image->bounds());
             dirtyRect.translate(xShift, yShift);
         }
 
         scheduler.waitForDone();
     }
 }
 
 void KisUpdateSchedulerTest::testLocking()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
     QRect imageRect = image->bounds();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
     QCOMPARE(imageRect, QRect(0,0,640,441));
 
     KisTestableUpdateScheduler scheduler(image.data(), 2);
     KisUpdaterContext *context = scheduler.updaterContext();
     QVERIFY(context);
     QVector<KisUpdateJobItem*> jobs;
 
     QRect dirtyRect1(0,0,50,100);
     QRect dirtyRect2(0,0,100,100);
     QRect dirtyRect3(50,0,50,100);
     QRect dirtyRect4(150,150,50,50);
 
     scheduler.updateProjection(paintLayer1, imageRect, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), imageRect));
 
     context->clear();
 
     scheduler.lock();
 
     scheduler.updateProjection(paintLayer1, dirtyRect1, imageRect);
     scheduler.updateProjection(paintLayer1, dirtyRect2, imageRect);
     scheduler.updateProjection(paintLayer1, dirtyRect3, imageRect);
     scheduler.updateProjection(paintLayer1, dirtyRect4, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), false);
     QCOMPARE(jobs[1]->isRunning(), false);
 
     scheduler.unlock();
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), true);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect2));
     QVERIFY(checkWalker(jobs[1]->walker(), dirtyRect4));
 }
 
 void KisUpdateSchedulerTest::testExclusiveStrokes()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
     QRect imageRect = image->bounds();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
     QCOMPARE(imageRect, QRect(0,0,640,441));
 
     QRect dirtyRect1(0,0,50,100);
 
     KisTestableUpdateScheduler scheduler(image.data(), 2);
     KisUpdaterContext *context = scheduler.updaterContext();
     QVector<KisUpdateJobItem*> jobs;
 
     scheduler.updateProjection(paintLayer1, dirtyRect1, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect1));
 
-    KisStrokeId id = scheduler.startStroke(new KisTestingStrokeStrategy("excl_", true, false));
+    KisStrokeId id = scheduler.startStroke(new KisTestingStrokeStrategy(QLatin1String("excl_"), true, false));
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect1));
 
     context->clear();
     scheduler.endStroke(id);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     COMPARE_NAME(jobs[0], "excl_init");
 
     scheduler.updateProjection(paintLayer1, dirtyRect1, imageRect);
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     COMPARE_NAME(jobs[0], "excl_init");
 
     context->clear();
     scheduler.processQueues();
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     COMPARE_NAME(jobs[0], "excl_finish");
 
     context->clear();
     scheduler.processQueues();
 
     jobs = context->getJobs();
     QCOMPARE(jobs[0]->isRunning(), true);
     QCOMPARE(jobs[1]->isRunning(), false);
     QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect1));
 }
 
 void KisUpdateSchedulerTest::testEmptyStroke()
 {
     KisImageSP image = buildTestingImage();
 
-    KisStrokeId id = image->startStroke(new KisStrokeStrategy());
+    KisStrokeId id = image->startStroke(new KisStrokeStrategy(QLatin1String()));
     image->addJob(id, 0);
     image->endStroke(id);
     image->waitForDone();
 }
 
 #include "kis_lazy_wait_condition.h"
 
 void KisUpdateSchedulerTest::testLazyWaitCondition()
 {
     {
         dbgKrita << "Not initialized";
         KisLazyWaitCondition condition;
         QVERIFY(!condition.wait(50));
     }
 
     {
         dbgKrita << "Initialized, not awake";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         QVERIFY(!condition.wait(50));
         condition.endWaiting();
     }
 
     {
         dbgKrita << "Initialized, awake";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         condition.wakeAll();
         QVERIFY(condition.wait(50));
         condition.endWaiting();
     }
 
     {
         dbgKrita << "Initialized, not awake, then awake";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         QVERIFY(!condition.wait(50));
         condition.wakeAll();
         QVERIFY(condition.wait(50));
         condition.endWaiting();
     }
 
     {
         dbgKrita << "Doublewait";
         KisLazyWaitCondition condition;
         condition.initWaiting();
         condition.initWaiting();
         QVERIFY(!condition.wait(50));
         condition.wakeAll();
         QVERIFY(condition.wait(50));
         QVERIFY(condition.wait(50));
         condition.endWaiting();
     }
 }
 
 #define NUM_THREADS 10
 #define NUM_CYCLES 500
 #define NTH_CHECK 3
 
 class UpdatesBlockTester : public QRunnable
 {
 public:
     UpdatesBlockTester(KisUpdateScheduler *scheduler, KisNodeSP node)
         : m_scheduler(scheduler), m_node(node)
     {
     }
 
     void run() override {
         for (int i = 0; i < NUM_CYCLES; i++) {
             if(i % NTH_CHECK == 0) {
                 m_scheduler->blockUpdates();
                 QTest::qSleep(1); // a bit of salt for crashiness ;)
                 Q_ASSERT(!m_scheduler->haveUpdatesRunning());
                 m_scheduler->unblockUpdates();
             }
             else {
                 QRect updateRect(0,0,100,100);
                 updateRect.moveTopLeft(QPoint((i%10)*100, (i%10)*100));
                 m_scheduler->updateProjection(m_node, updateRect, QRect(0,0,1100,1100));
             }
         }
     }
 private:
     KisUpdateScheduler *m_scheduler;
     KisNodeSP m_node;
 };
 
 void KisUpdateSchedulerTest::testBlockUpdates()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->rootLayer();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
 
     KisUpdateScheduler scheduler(image.data());
 
     QThreadPool threadPool;
     threadPool.setMaxThreadCount(NUM_THREADS);
 
     for(int i = 0; i< NUM_THREADS; i++) {
         UpdatesBlockTester *tester =
             new UpdatesBlockTester(&scheduler, paintLayer1);
 
         threadPool.start(tester);
     }
 
     threadPool.waitForDone();
 }
 
 #include "kis_update_time_monitor.h"
 
 void KisUpdateSchedulerTest::testTimeMonitor()
 {
     QVector<QRect> dirtyRects;
 
     KisUpdateTimeMonitor::instance()->startStrokeMeasure();
     KisUpdateTimeMonitor::instance()->reportMouseMove(QPointF(100, 0));
 
     KisUpdateTimeMonitor::instance()->reportJobStarted((void*) 10);
     QTest::qSleep(300);
     KisUpdateTimeMonitor::instance()->reportJobStarted((void*) 20);
     QTest::qSleep(100);
     dirtyRects << QRect(10,10,10,10);
     KisUpdateTimeMonitor::instance()->reportJobFinished((void*) 10, dirtyRects);
     QTest::qSleep(100);
     dirtyRects.clear();
     dirtyRects << QRect(30,30,10,10);
     KisUpdateTimeMonitor::instance()->reportJobFinished((void*) 20, dirtyRects);
     QTest::qSleep(500);
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(QRect(10,10,10,10));
     QTest::qSleep(300);
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(QRect(30,30,10,10));
 
     KisUpdateTimeMonitor::instance()->reportMouseMove(QPointF(130, 0));
 
     KisUpdateTimeMonitor::instance()->endStrokeMeasure();
 }
 
 void KisUpdateSchedulerTest::testLodSync()
 {
     KisImageSP image = buildTestingImage();
     KisNodeSP rootLayer = image->root();
     KisNodeSP paintLayer1 = rootLayer->firstChild();
 
     QCOMPARE(paintLayer1->name(), QString("paint1"));
 
 
     image->setLevelOfDetailBlocked(false);
     image->setDesiredLevelOfDetail(2);
 
     image->explicitRegenerateLevelOfDetail();
 
     image->waitForDone();
 }
 
 QTEST_MAIN(KisUpdateSchedulerTest)
 
diff --git a/libs/image/tests/kis_updater_context_test.cpp b/libs/image/tests/kis_updater_context_test.cpp
index 9d00d02650..3559b8128a 100644
--- a/libs/image/tests/kis_updater_context_test.cpp
+++ b/libs/image/tests/kis_updater_context_test.cpp
@@ -1,245 +1,249 @@
 /*
  *  Copyright (c) 2010 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_updater_context_test.h"
 #include <QTest>
 
 #include <QAtomicInt>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_paint_layer.h"
 
 #include "kis_merge_walker.h"
 #include "kis_updater_context.h"
 #include "kis_image.h"
 
 #include "scheduler_utils.h"
 
 #include "lod_override.h"
 #include "config-limit-long-tests.h"
 
 void KisUpdaterContextTest::testJobInterference()
 {
     KisTestableUpdaterContext context(3);
 
     QRect imageRect(0,0,100,100);
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);
 
     image->lock();
     image->addNode(paintLayer);
     image->unlock();
 
     QRect dirtyRect1(0,0,50,100);
     KisBaseRectsWalkerSP walker1 = new KisMergeWalker(imageRect);
     walker1->collectRects(paintLayer, dirtyRect1);
 
     context.lock();
     context.addMergeJob(walker1);
     context.unlock();
 
     // overlapping job --- forbidden
     {
         QRect dirtyRect(30,0,100,100);
         KisBaseRectsWalkerSP walker = new KisMergeWalker(imageRect);
         walker->collectRects(paintLayer, dirtyRect);
 
         context.lock();
         QVERIFY(!context.isJobAllowed(walker));
         context.unlock();
     }
 
     // not overlapping job --- allowed
     {
         QRect dirtyRect(60,0,100,100);
         KisBaseRectsWalkerSP walker = new KisMergeWalker(imageRect);
         walker->collectRects(paintLayer, dirtyRect);
 
         context.lock();
         QVERIFY(context.isJobAllowed(walker));
         context.unlock();
     }
 
     // not overlapping job, conflicting LOD --- forbidden
     {
         TestUtil::LodOverride l(1, image);
 
         QCOMPARE(paintLayer->paintDevice()->defaultBounds()->currentLevelOfDetail(), 1);
 
         QRect dirtyRect(60,0,100,100);
         KisBaseRectsWalkerSP walker = new KisMergeWalker(imageRect);
         walker->collectRects(paintLayer, dirtyRect);
 
         context.lock();
         QVERIFY(!context.isJobAllowed(walker));
         context.unlock();
     }
 }
 
 void KisUpdaterContextTest::testSnapshot()
 {
     KisTestableUpdaterContext context(3);
 
     QRect imageRect(0,0,100,100);
 
     KisBaseRectsWalkerSP walker1 = new KisMergeWalker(imageRect);
 
     qint32 numMergeJobs = -777;
     qint32 numStrokeJobs = -777;
 
     context.lock();
 
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 0);
     QCOMPARE(numStrokeJobs, 0);
     QCOMPARE(context.currentLevelOfDetail(), -1);
 
     context.addMergeJob(walker1);
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 1);
     QCOMPARE(numStrokeJobs, 0);
     QCOMPARE(context.currentLevelOfDetail(), 0);
 
 
     KisStrokeJobData *data =
         new KisStrokeJobData(KisStrokeJobData::SEQUENTIAL,
                              KisStrokeJobData::NORMAL);
 
     QScopedPointer<KisStrokeJobStrategy> strategy(
         new KisNoopDabStrategy("test"));
 
     context.addStrokeJob(new KisStrokeJob(strategy.data(), data, 0, true));
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 1);
     QCOMPARE(numStrokeJobs, 1);
     QCOMPARE(context.currentLevelOfDetail(), 0);
 
 
     context.addSpontaneousJob(new KisNoopSpontaneousJob());
     context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
     QCOMPARE(numMergeJobs, 2);
     QCOMPARE(numStrokeJobs, 1);
     QCOMPARE(context.currentLevelOfDetail(), 0);
 
     context.unlock();
 
     {
         context.lock();
         context.clear();
 
         context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
         QCOMPARE(numMergeJobs, 0);
         QCOMPARE(numStrokeJobs, 0);
         QCOMPARE(context.currentLevelOfDetail(), -1);
 
         data =
             new KisStrokeJobData(KisStrokeJobData::SEQUENTIAL,
                                  KisStrokeJobData::NORMAL);
 
         context.addStrokeJob(new KisStrokeJob(strategy.data(), data, 2, true));
         context.getJobsSnapshot(numMergeJobs, numStrokeJobs);
         QCOMPARE(numMergeJobs, 0);
         QCOMPARE(numStrokeJobs, 1);
         QCOMPARE(context.currentLevelOfDetail(), 2);
 
         context.unlock();
     }
 }
 
 #define NUM_THREADS 10
 #ifdef LIMIT_LONG_TESTS
 #   define NUM_JOBS 60
 #else
 #   define NUM_JOBS 6000
 #endif
 #define EXCLUSIVE_NTH 3
 #define NUM_CHECKS 10
 #define CHECK_DELAY 3 // ms
 
 class ExclusivenessCheckerStrategy : public KisStrokeJobStrategy
 {
 public:
     ExclusivenessCheckerStrategy(QAtomicInt &counter,
                                  QAtomicInt &hadConcurrency)
         : m_counter(counter),
           m_hadConcurrency(hadConcurrency)
     {
     }
 
     void run(KisStrokeJobData *data) override {
         Q_UNUSED(data);
 
         m_counter.ref();
 
         for(int i = 0; i < NUM_CHECKS; i++) {
             if(data->isExclusive()) {
                 Q_ASSERT(m_counter == 1);
             }
             else if (m_counter > 1) {
                 m_hadConcurrency.ref();
             }
             QTest::qSleep(CHECK_DELAY);
         }
 
         m_counter.deref();
     }
 
+    QString debugId() const override {
+        return "ExclusivenessCheckerStrategy";
+    }
+
 private:
     QAtomicInt &m_counter;
     QAtomicInt &m_hadConcurrency;
 };
 
 void KisUpdaterContextTest::stressTestExclusiveJobs()
 {
     KisUpdaterContext context(NUM_THREADS);
     QAtomicInt counter;
     QAtomicInt hadConcurrency;
 
     for(int i = 0; i < NUM_JOBS; i++) {
         if(context.hasSpareThread()) {
             bool isExclusive = i % EXCLUSIVE_NTH == 0;
 
             KisStrokeJobData *data =
                 new KisStrokeJobData(KisStrokeJobData::SEQUENTIAL,
                                      isExclusive ?
                                      KisStrokeJobData::EXCLUSIVE :
                                      KisStrokeJobData::NORMAL);
 
             KisStrokeJobStrategy *strategy =
                 new ExclusivenessCheckerStrategy(counter, hadConcurrency);
 
             context.addStrokeJob(new KisStrokeJob(strategy, data, 0, true));
         }
         else {
             QTest::qSleep(CHECK_DELAY);
         }
     }
 
     context.waitForDone();
 
     QVERIFY(!counter);
     dbgKrita << "Concurrency observed:" << hadConcurrency
              << "/" << NUM_CHECKS * NUM_JOBS;
 }
 
 QTEST_MAIN(KisUpdaterContextTest)
 
diff --git a/libs/image/tests/scheduler_utils.h b/libs/image/tests/scheduler_utils.h
index 3c28f6e0de..c35e2d70cc 100644
--- a/libs/image/tests/scheduler_utils.h
+++ b/libs/image/tests/scheduler_utils.h
@@ -1,281 +1,293 @@
 /*
  *  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 __SCHEDULER_UTILS_H
 #define __SCHEDULER_UTILS_H
 
 #include <QRect>
 #include "kis_merge_walker.h"
 #include "kis_stroke_strategy.h"
 #include "kis_stroke_job.h"
 #include "kis_spontaneous_job.h"
 #include "kis_stroke.h"
 #include "kis_image.h"
 
 
 #define SCOMPARE(s1, s2) QCOMPARE(QString(s1), QString(s2))
 
 #define COMPARE_WALKER(item, walker)            \
     QCOMPARE(item->walker(), walker)
 #define COMPARE_NAME(item, name)                                \
     QCOMPARE(getJobName(item->strokeJob()), QString(name))
 #define VERIFY_EMPTY(item)                                      \
     QVERIFY(!item->isRunning())
 
 void executeStrokeJobs(KisStroke *stroke) {
     KisStrokeJob *job;
 
     while((job = stroke->popOneJob())) {
         job->run();
         delete job;
     }
 }
 
 bool checkWalker(KisBaseRectsWalkerSP walker, const QRect &rect, int lod = 0) {
     if(walker->requestedRect() == rect && walker->levelOfDetail() == lod) {
         return true;
     }
     else {
         dbgKrita << "walker rect:" << walker->requestedRect();
         dbgKrita << "expected rect:" << rect;
         dbgKrita << "walker lod:" << walker->levelOfDetail();
         dbgKrita << "expected lod:" << lod;
         return false;
     }
 }
 
 class KisNoopSpontaneousJob : public KisSpontaneousJob
 {
 public:
     KisNoopSpontaneousJob(bool overridesEverything = false, int lod = 0)
         : m_overridesEverything(overridesEverything),
           m_lod(lod)
     {
     }
 
     void run() override {
     }
 
     bool overrides(const KisSpontaneousJob *otherJob) override {
         Q_UNUSED(otherJob);
         return m_overridesEverything;
     }
 
     int levelOfDetail() const override {
         return m_lod;
     }
 
+    QString debugName() const override {
+        return "KisNoopSpontaneousJob";
+    }
+
 private:
     bool m_overridesEverything;
     int m_lod;
 };
 
 static QStringList globalExecutedDabs;
 
 class KisNoopDabStrategy : public KisStrokeJobStrategy
 {
 public:
     KisNoopDabStrategy(QString name)
     : m_name(name),
       m_isMarked(false)
     {}
 
     void run(KisStrokeJobData *data) override {
         Q_UNUSED(data);
 
         globalExecutedDabs << m_name;
     }
 
     virtual QString name(KisStrokeJobData *data) const {
         Q_UNUSED(data);
         return m_name;
     }
 
     void setMarked() {
         m_isMarked = true;
     }
 
     bool isMarked() const {
         return m_isMarked;
     }
 
+    QString debugId() const override {
+        return "KisNoopDabStrategy";
+    }
+
 private:
     QString m_name;
     bool m_isMarked;
 };
 
 class KisTestingStrokeJobData : public KisStrokeJobData
 {
 public:
     KisTestingStrokeJobData(Sequentiality sequentiality = SEQUENTIAL,
                             Exclusivity exclusivity = NORMAL,
                             bool addMutatedJobs = false,
                             const QString &customSuffix = QString())
         : KisStrokeJobData(sequentiality, exclusivity),
           m_addMutatedJobs(addMutatedJobs),
           m_customSuffix(customSuffix)
     {
     }
 
     KisTestingStrokeJobData(const KisTestingStrokeJobData &rhs)
         : KisStrokeJobData(rhs),
           m_addMutatedJobs(rhs.m_addMutatedJobs)
     {
     }
 
     KisStrokeJobData* createLodClone(int levelOfDetail) override {
         Q_UNUSED(levelOfDetail);
         return new KisTestingStrokeJobData(*this);
     }
 
     bool m_addMutatedJobs = false;
     bool m_isMutated = false;
     QString m_customSuffix;
 };
 
 class KisMutatableDabStrategy : public KisNoopDabStrategy
 {
 public:
     KisMutatableDabStrategy(const QString &name, KisStrokeStrategy *parentStrokeStrategy)
         : KisNoopDabStrategy(name),
           m_parentStrokeStrategy(parentStrokeStrategy)
     {
     }
 
     void run(KisStrokeJobData *data) override {
         KisTestingStrokeJobData *td = dynamic_cast<KisTestingStrokeJobData*>(data);
 
         if (td && td->m_isMutated) {
             globalExecutedDabs << QString("%1_mutated").arg(name(data));
         } else if (td && td->m_addMutatedJobs) {
             globalExecutedDabs << name(data);
 
             for (int i = 0; i < 3; i++) {
                 KisTestingStrokeJobData *newData =
                     new KisTestingStrokeJobData(td->sequentiality(), td->exclusivity(), false);
                 newData->m_isMutated = true;
                 m_parentStrokeStrategy->addMutatedJob(newData);
             }
         } else {
             globalExecutedDabs << name(data);
         }
     }
 
     virtual QString name(KisStrokeJobData *data) const override {
         const QString baseName = KisNoopDabStrategy::name(data);
 
         KisTestingStrokeJobData *td = dynamic_cast<KisTestingStrokeJobData*>(data);
         return !td || td->m_customSuffix.isEmpty() ? baseName : QString("%1_%2").arg(baseName).arg(td->m_customSuffix);
     }
 
+    QString debugId() const override {
+        return "KisMutatableDabStrategy";
+    }
+
 private:
     KisStrokeStrategy *m_parentStrokeStrategy = 0;
 };
 
 
 class KisTestingStrokeStrategy : public KisStrokeStrategy
 {
 public:
-    KisTestingStrokeStrategy(const QString &prefix = QString(),
+    KisTestingStrokeStrategy(const QLatin1String &prefix = QLatin1String(),
                              bool exclusive = false,
                              bool inhibitServiceJobs = false,
                              bool forceAllowInitJob = false,
                              bool forceAllowCancelJob = false)
         : KisStrokeStrategy(prefix, kundo2_noi18n(prefix)),
           m_prefix(prefix),
           m_inhibitServiceJobs(inhibitServiceJobs),
           m_forceAllowInitJob(forceAllowInitJob),
           m_forceAllowCancelJob(forceAllowCancelJob),
           m_cancelSeqNo(0)
     {
         setExclusive(exclusive);
     }
 
     KisTestingStrokeStrategy(const KisTestingStrokeStrategy &rhs, int levelOfDetail)
         : KisStrokeStrategy(rhs),
           m_prefix(rhs.m_prefix),
           m_inhibitServiceJobs(rhs.m_inhibitServiceJobs),
           m_forceAllowInitJob(rhs.m_forceAllowInitJob),
           m_cancelSeqNo(rhs.m_cancelSeqNo)
     {
         m_prefix = QString("clone%1_%2").arg(levelOfDetail).arg(m_prefix);
     }
 
     KisStrokeJobStrategy* createInitStrategy() override {
         return m_forceAllowInitJob || !m_inhibitServiceJobs ?
             new KisNoopDabStrategy(m_prefix + "init") : 0;
     }
 
     KisStrokeJobStrategy* createFinishStrategy() override {
         return !m_inhibitServiceJobs ?
             new KisNoopDabStrategy(m_prefix + "finish") : 0;
     }
 
     KisStrokeJobStrategy* createCancelStrategy() override {
         return m_forceAllowCancelJob || !m_inhibitServiceJobs ?
             new KisNoopDabStrategy(m_prefix + "cancel") : 0;
     }
 
     KisStrokeJobStrategy* createDabStrategy() override {
         return new KisMutatableDabStrategy(m_prefix + "dab", this);
     }
 
     KisStrokeStrategy* createLodClone(int levelOfDetail) override {
         return new KisTestingStrokeStrategy(*this, levelOfDetail);
     }
 
     class CancelData : public KisStrokeJobData
     {
     public:
         CancelData(int seqNo) : m_seqNo(seqNo) {}
         int seqNo() const { return m_seqNo; }
 
     private:
         int m_seqNo;
     };
 
     KisStrokeJobData* createCancelData() override {
         return new CancelData(m_cancelSeqNo++);
     }
 
 private:
     QString m_prefix;
     bool m_inhibitServiceJobs;
     int m_forceAllowInitJob;
     bool m_forceAllowCancelJob;
     int m_cancelSeqNo;
 };
 
 inline QString getJobName(KisStrokeJob *job) {
     KisNoopDabStrategy *pointer =
         dynamic_cast<KisNoopDabStrategy*>(job->testingGetDabStrategy());
     KIS_ASSERT(pointer);
 
     return pointer->name(job->testingGetDabData());
 }
 
 inline int cancelSeqNo(KisStrokeJob *job) {
     KisTestingStrokeStrategy::CancelData *pointer =
         dynamic_cast<KisTestingStrokeStrategy::CancelData*>
         (job->testingGetDabData());
     Q_ASSERT(pointer);
 
     return pointer->seqNo();
 }
 
 #endif /* __SCHEDULER_UTILS_H */
diff --git a/libs/image/tiles3/kis_tile_hash_table2.h b/libs/image/tiles3/kis_tile_hash_table2.h
index 906fda1959..37a4ec9020 100644
--- a/libs/image/tiles3/kis_tile_hash_table2.h
+++ b/libs/image/tiles3/kis_tile_hash_table2.h
@@ -1,482 +1,482 @@
 /*
  *  Copyright (c) 2018 Andrey Kamakin <a.kamakin@icloud.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_TILEHASHTABLE_2_H
 #define KIS_TILEHASHTABLE_2_H
 
 #include "kis_shared.h"
 #include "kis_shared_ptr.h"
 #include "3rdparty/lock_free_map/concurrent_map.h"
 #include "kis_tile.h"
 #include "kis_debug.h"
 
 #define SANITY_CHECK
 
 /**
  * This is a  template for a hash table that stores  tiles (or some other
  * objects  resembling tiles).   Actually, this  object should  only have
  * col()/row() methods and be able to answer notifyDetachedFromDataManager() requests to
  * be   stored   here.    It   is   used   in   KisTiledDataManager   and
  * KisMementoManager.
  *
  * How to use:
  *   1) each hash must be unique, otherwise tiles would rewrite each-other
  *   2) 0 key is reserved, so can't be used
  *   3) col and row must be less than 0x7FFF to guarantee uniqueness of hash for each pair
  */
 
 template <class T>
 class KisTileHashTableIteratorTraits2;
 
 template <class T>
 class KisTileHashTableTraits2
 {
     static constexpr bool isInherited = std::is_convertible<T*, KisShared*>::value;
     Q_STATIC_ASSERT_X(isInherited, "Template must inherit KisShared");
 
 public:
     typedef T TileType;
     typedef KisSharedPtr<T> TileTypeSP;
     typedef KisWeakSharedPtr<T> TileTypeWSP;
 
     KisTileHashTableTraits2(KisMementoManager *mm);
     KisTileHashTableTraits2(const KisTileHashTableTraits2<T> &ht, KisMementoManager *mm);
     ~KisTileHashTableTraits2();
 
     bool isEmpty()
     {
         return !m_numTiles.load();
     }
 
     bool tileExists(qint32 col, qint32 row);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * returns null.
      * \param col column of the tile
      * \param row row of the tile
      */
     TileTypeSP getExistingTile(qint32 col, qint32 row);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * creates a new one, attaches it to the list and returns.
      * \param col column of the tile
      * \param row row of the tile
      * \param newTile out-parameter, returns true if a new tile
      *                was created
      */
     TileTypeSP getTileLazy(qint32 col, qint32 row, bool& newTile);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * creates nothing, but returns shared default tile object
      * of the table. Be careful, this object has column and row
      * parameters set to (qint32_MIN, qint32_MIN).
      * \param col column of the tile
      * \param row row of the tile
      * \param existingTile returns true if the tile actually exists in the table
      *                     and it is not a lazily created default wrapper tile
      */
     TileTypeSP getReadOnlyTileLazy(qint32 col, qint32 row, bool &existingTile);
     void addTile(TileTypeSP tile);
     bool deleteTile(TileTypeSP tile);
     bool deleteTile(qint32 col, qint32 row);
 
     void clear();
 
     void setDefaultTileData(KisTileData *defaultTileData);
     KisTileData* defaultTileData();
 
     qint32 numTiles()
     {
         return m_numTiles.load();
     }
 
     void debugPrintInfo();
     void debugMaxListLength(qint32 &min, qint32 &max);
 
     friend class KisTileHashTableIteratorTraits2<T>;
 
 private:
     struct MemoryReclaimer {
         MemoryReclaimer(TileType *data) : d(data) {}
 
         void destroy()
         {
             TileTypeSP::deref(reinterpret_cast<TileTypeSP*>(this), d);
             delete this;
         }
 
     private:
         TileType *d;
     };
 
     inline quint32 calculateHash(qint32 col, qint32 row)
     {
 #ifdef SANITY_CHECK
-        KIS_ASSERT_RECOVER_NOOP(row < 0x7FFF && col < 0x7FFF)
+        KIS_ASSERT_RECOVER_NOOP(row < 0x7FFF && col < 0x7FFF);
 #endif // SANITY_CHECK
 
         if (col == 0 && row == 0) {
             col = 0x7FFF;
             row = 0x7FFF;
         }
 
         return ((static_cast<quint32>(row) << 16) | (static_cast<quint32>(col) & 0xFFFF));
     }
 
     inline void insert(quint32 idx, TileTypeSP item)
     {
         TileTypeSP::ref(&item, item.data());
         TileType *tile = 0;
 
         {
             QReadLocker locker(&m_iteratorLock);
             m_map.getGC().lockRawPointerAccess();
             tile = m_map.assign(idx, item.data());
         }
 
         if (tile) {
             tile->notifyDeadWithoutDetaching();
             m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
         } else {
             m_numTiles.fetchAndAddRelaxed(1);
         }
 
         m_map.getGC().unlockRawPointerAccess();
 
         m_map.getGC().update();
     }
 
     inline bool erase(quint32 idx)
     {
         m_map.getGC().lockRawPointerAccess();
 
         bool wasDeleted = false;
         TileType *tile = m_map.erase(idx);
 
         if (tile) {
             tile->notifyDetachedFromDataManager();
 
             wasDeleted = true;
             m_numTiles.fetchAndSubRelaxed(1);
             m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
         }
 
         m_map.getGC().unlockRawPointerAccess();
 
         m_map.getGC().update();
         return wasDeleted;
     }
 
 private:
     typedef ConcurrentMap<quint32, TileType*> LockFreeTileMap;
     typedef typename LockFreeTileMap::Mutator LockFreeTileMapMutator;
     mutable LockFreeTileMap m_map;
 
     /**
      * We still need something to guard changes in m_defaultTileData,
      * otherwise there will be concurrent read/writes, resulting in broken memory.
      */
     QReadWriteLock m_defaultPixelDataLock;
     mutable QReadWriteLock m_iteratorLock;
 
     QAtomicInt m_numTiles;
     KisTileData *m_defaultTileData;
     KisMementoManager *m_mementoManager;
 };
 
 template <class T>
 class KisTileHashTableIteratorTraits2
 {
 public:
     typedef T TileType;
     typedef KisSharedPtr<T> TileTypeSP;
     typedef typename ConcurrentMap<quint32, TileType*>::Iterator Iterator;
 
     KisTileHashTableIteratorTraits2(KisTileHashTableTraits2<T> *ht) : m_ht(ht)
     {
         m_ht->m_iteratorLock.lockForWrite();
         m_iter.setMap(m_ht->m_map);
     }
 
     ~KisTileHashTableIteratorTraits2()
     {
         m_ht->m_iteratorLock.unlock();
     }
 
     void next()
     {
         m_iter.next();
     }
 
     TileTypeSP tile() const
     {
         return TileTypeSP(m_iter.getValue());
     }
 
     bool isDone() const
     {
         return !m_iter.isValid();
     }
 
     void deleteCurrent()
     {
         m_ht->erase(m_iter.getKey());
         next();
     }
 
     void moveCurrentToHashTable(KisTileHashTableTraits2<T> *newHashTable)
     {
         TileTypeSP tile = m_iter.getValue();
         next();
 
         quint32 idx = m_ht->calculateHash(tile->col(), tile->row());
         m_ht->erase(idx);
         newHashTable->insert(idx, tile);
     }
 
 private:
     KisTileHashTableTraits2<T> *m_ht;
     Iterator m_iter;
 };
 
 template <class T>
 KisTileHashTableTraits2<T>::KisTileHashTableTraits2(KisMementoManager *mm)
     : m_numTiles(0), m_defaultTileData(0), m_mementoManager(mm)
 {
 }
 
 template <class T>
 KisTileHashTableTraits2<T>::KisTileHashTableTraits2(const KisTileHashTableTraits2<T> &ht, KisMementoManager *mm)
     : KisTileHashTableTraits2(mm)
 {
     setDefaultTileData(ht.m_defaultTileData);
 
     QWriteLocker locker(&ht.m_iteratorLock);
     typename ConcurrentMap<quint32, TileType*>::Iterator iter(ht.m_map);
 
     while (iter.isValid()) {
         TileTypeSP tile = new TileType(*iter.getValue(), m_mementoManager);
         insert(iter.getKey(), tile);
         iter.next();
     }
 }
 
 template <class T>
 KisTileHashTableTraits2<T>::~KisTileHashTableTraits2()
 {
     clear();
     setDefaultTileData(0);
 }
 
 template<class T>
 bool KisTileHashTableTraits2<T>::tileExists(qint32 col, qint32 row)
 {
     return getExistingTile(col, row);
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getExistingTile(qint32 col, qint32 row)
 {
     quint32 idx = calculateHash(col, row);
 
     m_map.getGC().lockRawPointerAccess();
     TileTypeSP tile = m_map.get(idx);
     m_map.getGC().unlockRawPointerAccess();
 
     m_map.getGC().update();
     return tile;
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getTileLazy(qint32 col, qint32 row, bool &newTile)
 {
     newTile = false;
     quint32 idx = calculateHash(col, row);
 
     // we are going to assign a raw-pointer tile from the table
     // to a shared pointer...
     m_map.getGC().lockRawPointerAccess();
 
     TileTypeSP tile = m_map.get(idx);
 
     while (!tile) {
         // we shouldn't try to acquire **any** lock with
         // raw-pointer lock held
         m_map.getGC().unlockRawPointerAccess();
 
         {
             QReadLocker locker(&m_defaultPixelDataLock);
             tile = new TileType(col, row, m_defaultTileData, 0);
         }
 
         TileTypeSP::ref(&tile, tile.data());
         TileType *discardedTile = 0;
 
         // iterator lock should be taken **before**
         // the pointers are locked
         m_iteratorLock.lockForRead();
 
         // and now lock raw-pointers again
         m_map.getGC().lockRawPointerAccess();
 
         // mutator might have become invalidated when
         // we released raw pointers, so we need to reinitialize it
         LockFreeTileMapMutator mutator = m_map.insertOrFind(idx);
         if (!mutator.getValue()) {
             discardedTile = mutator.exchangeValue(tile.data());
         } else {
             discardedTile = tile.data();
         }
 
         m_iteratorLock.unlock();
 
         if (discardedTile) {
             // we've got our tile back, it didn't manage to
             // get into the table. Now release the allocated
             // tile and push TO/GA switch.
             tile = 0;
 
             discardedTile->notifyDeadWithoutDetaching();
             m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(discardedTile));
 
             tile = m_map.get(idx);
             continue;
 
         } else {
             newTile = true;
             m_numTiles.fetchAndAddRelaxed(1);
 
             tile->notifyAttachedToDataManager(m_mementoManager);
         }
     }
     m_map.getGC().unlockRawPointerAccess();
 
     m_map.getGC().update();
     return tile;
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getReadOnlyTileLazy(qint32 col, qint32 row, bool &existingTile)
 {
     quint32 idx = calculateHash(col, row);
 
     m_map.getGC().lockRawPointerAccess();
     TileTypeSP tile = m_map.get(idx);
     m_map.getGC().unlockRawPointerAccess();
 
     existingTile = tile;
 
     if (!existingTile) {
         QReadLocker locker(&m_defaultPixelDataLock);
         tile = new TileType(col, row, m_defaultTileData, 0);
     }
 
     m_map.getGC().update();
     return tile;
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::addTile(TileTypeSP tile)
 {
     quint32 idx = calculateHash(tile->col(), tile->row());
     insert(idx, tile);
 }
 
 template <class T>
 bool KisTileHashTableTraits2<T>::deleteTile(TileTypeSP tile)
 {
     return deleteTile(tile->col(), tile->row());
 }
 
 template <class T>
 bool KisTileHashTableTraits2<T>::deleteTile(qint32 col, qint32 row)
 {
     quint32 idx = calculateHash(col, row);
     return erase(idx);
 }
 
 template<class T>
 void KisTileHashTableTraits2<T>::clear()
 {
     {
         QWriteLocker locker(&m_iteratorLock);
 
         typename ConcurrentMap<quint32, TileType*>::Iterator iter(m_map);
         TileType *tile = 0;
 
         while (iter.isValid()) {
             m_map.getGC().lockRawPointerAccess();
             tile = m_map.erase(iter.getKey());
 
             if (tile) {
                 tile->notifyDetachedFromDataManager();
                 m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
             }
             m_map.getGC().unlockRawPointerAccess();
 
             iter.next();
         }
 
         m_numTiles.store(0);
     }
 
     // garbage collection must **not** be run with locks held
     m_map.getGC().update();
 }
 
 template <class T>
 inline void KisTileHashTableTraits2<T>::setDefaultTileData(KisTileData *defaultTileData)
 {
     QWriteLocker locker(&m_defaultPixelDataLock);
 
     if (m_defaultTileData) {
         m_defaultTileData->release();
         m_defaultTileData = 0;
     }
 
     if (defaultTileData) {
         defaultTileData->acquire();
         m_defaultTileData = defaultTileData;
     }
 }
 
 template <class T>
 inline KisTileData* KisTileHashTableTraits2<T>::defaultTileData()
 {
     QReadLocker locker(&m_defaultPixelDataLock);
     return m_defaultTileData;
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::debugPrintInfo()
 {
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::debugMaxListLength(qint32 &/*min*/, qint32 &/*max*/)
 {
 }
 
 typedef KisTileHashTableTraits2<KisTile> KisTileHashTable;
 typedef KisTileHashTableIteratorTraits2<KisTile> KisTileHashTableIterator;
 typedef KisTileHashTableIteratorTraits2<KisTile> KisTileHashTableConstIterator;
 
 #endif // KIS_TILEHASHTABLE_2_H
diff --git a/libs/koplugin/KoPluginLoader.h b/libs/koplugin/KoPluginLoader.h
index 82aa0079ec..afd399fe42 100644
--- a/libs/koplugin/KoPluginLoader.h
+++ b/libs/koplugin/KoPluginLoader.h
@@ -1,130 +1,132 @@
 /*
  * Copyright (c) 2006-2016 Boudewijn Rempt (boud@valdyas.org)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KO_PLUGIN_LOADER_H
 #define KO_PLUGIN_LOADER_H
 
 #include <QObject>
 #include <QStringList>
 
 #include "kritaplugin_export.h"
 
+#ifndef Q_MOC_RUN
 /**
  * The pluginloader singleton is responsible for loading the plugins
  * that it's asked to load. It keeps track of which servicetypes it
  * has seen and doesn't reload them. The plugins need to inherit
  * a QObject with a default constructor. Inside the default
  * constructor you can create whatever object you want and add it to
  * whatever registry you prefer. After having been constructed, your plugin
  * will be deleted, so do all you need in the constructor.  Things like
  * adding a factory to a registry make sense there.
  * Example header file;
 @code
 #include <QObject>
 
 class MyPlugin : public QObject {
     Q_OBJECT
 public:
     MyPlugin(QObject *parent, const QVariantList & );
     ~MyPlugin() {}
 };
 @endcode
  * Example cpp file;
 @code
 #include "MyPlugin.h"
 #include <kpluginfactory.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(MyPluginFactory, "myplugin.json", registerPlugin<MyPlugin>();)
 
 MyPlugin::MyPlugin( QObject *parent, const QVariantList& ) : QObject(parent) {
     // do stuff like creating a factory and adding it to the
     // registry instance.
 }
 #include <MyPlugin.moc>
 @endcode
  */
+#endif
 class KRITAPLUGIN_EXPORT KoPluginLoader : public QObject
 {
 
     Q_OBJECT
 
 public:
     /**
      * Config object for load()
      * It is possible to limit which plugins will be loaded in the KConfig configuration file by
      * stating explicitly which plugins are wanted.
      */
     struct PluginsConfig {
         PluginsConfig() : group(0), whiteList(0), blacklist(0) {}
         /**
          * The properties are retrieved from the config using the following construct;
          * /code
          *  KConfigGroup configGroup =  KSharedConfig::openConfig()->group(config.group);
          * /endcode
          * For most cases you can pass the string "calligra" into this variable.
          */
         const char * group;
         /// This contains the variable name for the list of plugins (by library name) the user wants to load
         const char * whiteList;
         /// This contains the variable name for the list of plugins (by library name) that will not be loaded
         const char * blacklist;
         /// A registry can state it wants to load a default set of plugins instead of all plugins
         /// when the application starts the first time.  Append all such plugin (library) names to this list.
         QStringList defaults;
     };
 
     ~KoPluginLoader() override;
 
     /**
      * Return an instance of the KoPluginLoader
      * Creates an instance if that has never happened before and returns the singleton instance.
      */
     static KoPluginLoader * instance();
 
     /**
      * Load all plugins that conform to the versiontype and versionstring,
      * for instance:
      * KoPluginLoader::instance()->load("Calligra/Flake", "([X-Flake-PluginVersion] == 28)");
      * This method allows you to optionally limit the plugins that are loaded by version, but also
      * using a user configurable set of config options.
      * If you pass a PluginsConfig struct only those plugins are loaded that are specified in the
      * application config file.  New plugins found since last start will be automatically loaded.
      * @param serviceType The string used to identify the plugins.
      * @param versionString A string match that allows you to check for a specific version
      * @param config when passing a valid config only the wanted plugins are actually loaded
      * #param owner if 0, the plugin will be deleted after instantiation, if not, the given qobject will own the plugin in its qobject hierarchy
      * @param cache: if true, the plugin will only be loaded once
      * @return a list of services (by library name) that were not know in the config
      */
     void load(const QString & serviceType, const QString & versionString = QString(), const PluginsConfig &config = PluginsConfig(), QObject* owner = 0, bool cache = true);
 
 public:
     /// DO NOT USE! Use instance() instead
     // TODO: turn KoPluginLoader into namespace and do not expose object at all
     KoPluginLoader();
 private:
     KoPluginLoader(const KoPluginLoader&);
     KoPluginLoader operator=(const KoPluginLoader&);
 
 private:
     class Private;
     Private * const d;
 };
 
 #endif // KO_PLUGIN_LOADER_H
diff --git a/libs/pigment/KoColorProfile.h b/libs/pigment/KoColorProfile.h
index aca3df8493..5a2aea2c69 100644
--- a/libs/pigment/KoColorProfile.h
+++ b/libs/pigment/KoColorProfile.h
@@ -1,215 +1,216 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef _KO_COLOR_PROFILE_H_
 #define _KO_COLOR_PROFILE_H_
 
+#include <boost/operators.hpp>
 #include <QString>
 #include <QVector>
 #include <QVariant>
 
 #include "kritapigment_export.h"
 
 /**
  * Contains information needed for color transformation.
  */
-class KRITAPIGMENT_EXPORT KoColorProfile
+class KRITAPIGMENT_EXPORT KoColorProfile : public boost::equality_comparable<KoColorProfile>
 {
 
 public:
 
     /**
      * @param fileName file name to load or save that profile
      */
     explicit KoColorProfile(const QString &fileName = QString());
     KoColorProfile(const KoColorProfile& profile);
     virtual ~KoColorProfile();
 
     /**
      * @return the type of this profile (icc, ctlcs etc)
      */
     virtual QString type() const {
         return QString();
     }
 
     /**
      * Create a copy of this profile.
      * Data that shall not change during the life time of the profile shouldn't be
      * duplicated but shared, like for instance ICC data.
      *
      * Data that shall be changed like a palette or hdr information such as exposure
      * must be duplicated while cloning.
      */
     virtual KoColorProfile* clone() const = 0;
 
     /**
      * Load the profile in memory.
      * @return true if the profile has been successfully loaded
      */
     virtual bool load();
 
     /**
      * Override this function to save the profile.
      * @param fileName destination
      * @return true if the profile has been successfully saved
      */
     virtual bool save(const QString &fileName);
 
     /**
      * @return true if the profile is valid, false if it isn't been loaded in memory yet, or
      * if the loaded memory is a bad profile
      */
     virtual bool valid() const = 0;
 
     /**
      * @return the name of this profile
      */
     QString name() const;
     /**
      * @return the info of this profile
      */
     QString info() const;
     /** @return manufacturer of the profile
      */
     QString manufacturer() const;
     /**
      * @return the copyright of the profile
      */
     QString copyright() const;
     /**
      * @return the filename of the profile (it might be empty)
      */
     QString fileName() const;
     /**
      * @param filename new filename
      */
     void setFileName(const QString &filename);
 
     /**
      * Return version
      */
     virtual float version() const = 0;
     /**
      * @return true if you can use this profile can be used to convert color from a different
      * profile to this one
      */
     virtual bool isSuitableForOutput() const = 0;
     /**
      * @return true if this profile is suitable to use for printing
      */
     virtual bool isSuitableForPrinting() const = 0;
     /**
      * @return true if this profile is suitable to use for display
      */
     virtual bool isSuitableForDisplay() const = 0;
 
     /**
      * @return which rendering intents are supported
      */
     virtual bool supportsPerceptual() const = 0;
     virtual bool supportsSaturation() const = 0;
     virtual bool supportsAbsolute() const = 0;
     virtual bool supportsRelative() const = 0;
     /**
      * @return if the profile has colorants.
      */
     virtual bool hasColorants() const = 0;
     /**
      * @return a qvector <double>(9) with the RGB colorants in XYZ
      */
     virtual QVector <qreal> getColorantsXYZ() const = 0;
     /**
      * @return a qvector <double>(9) with the RGB colorants in xyY
      */
     virtual QVector <qreal> getColorantsxyY() const = 0;
     /**
      * @return a qvector <double>(3) with the whitepoint in XYZ
      */
     virtual QVector <qreal> getWhitePointXYZ() const = 0;
     /**
      * @return a qvector <double>(3) with the whitepoint in xyY
      */
     virtual QVector <qreal> getWhitePointxyY() const = 0;
     
     /**
      * @return estimated gamma for RGB and Grayscale profiles
      */
     virtual QVector <qreal> getEstimatedTRC() const = 0;
 
     /**
      * @return if the profile has a TRC(required for linearisation).
      */
     virtual bool hasTRC() const = 0;
     /**
      * @return if the profile's TRCs are linear.
      */
     virtual bool isLinear() const = 0;
     /**
      * Linearizes first 3 values of QVector, leaving other values unchanged.
      * Returns the same QVector if it is not possible to linearize.
      */
     virtual void linearizeFloatValue(QVector <qreal> & Value) const = 0;
     /**
      * Delinearizes first 3 values of QVector, leaving other values unchanged.
      * Returns the same QVector if it is not possible to delinearize.
      * Effectively undoes LinearizeFloatValue.
      */
     virtual void delinearizeFloatValue(QVector <qreal> & Value) const = 0;
     /**
      * More imprecise versions of the above(limited to 16bit, and can't
      * delinearize above 1.0.) Use this for filters and images.
      */
     virtual void linearizeFloatValueFast(QVector <qreal> & Value) const = 0;
     virtual void delinearizeFloatValueFast(QVector <qreal> & Value) const = 0;
 
     virtual QByteArray uniqueId() const = 0;
     
     virtual bool operator==(const KoColorProfile&) const = 0;
 
     /**
      * @return an array with the raw data of the profile
      */
     virtual QByteArray rawData() const {
         return QByteArray();
     }
 
 protected:
     /**
      * Allows to define the name of this profile.
      */
     void setName(const QString &name);
     /**
      * Allows to set the information string of that profile.
      */
     void setInfo(const QString &info);
     /**
      * Allows to set the manufacturer string of that profile.
      */
     void setManufacturer(const QString &manufacturer);
     /**
      * Allows to set the copyright string of that profile.
      */
     void setCopyright(const QString &copyright);
 
 private:
     struct Private;
     Private* const d;
 };
 
 #endif
diff --git a/libs/pigment/resources/KoColorSet.cpp b/libs/pigment/resources/KoColorSet.cpp
index e649679c65..722f221884 100644
--- a/libs/pigment/resources/KoColorSet.cpp
+++ b/libs/pigment/resources/KoColorSet.cpp
@@ -1,1644 +1,1646 @@
 /*  This file is part of the KDE project
    Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
    Copyright (c) 2016 L. E. Segovia <leo.segovia@siggraph.org>
 
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include <resources/KoColorSet.h>
 
 #include <sys/types.h>
 
 #include <QFile>
 #include <QFileInfo>
 #include <QBuffer>
 #include <QVector>
 #include <QTextStream>
 #include <QTextCodec>
 #include <QHash>
 #include <QList>
 #include <QByteArray>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QDomNodeList>
 #include <QString>
 #include <QStringList>
 #include <QImage>
 #include <QPainter>
 #include <QXmlStreamReader>
 #include <QXmlStreamAttributes>
 #include <QtEndian> // qFromLittleEndian
 
 #include <DebugPigment.h>
 #include <klocalizedstring.h>
 
 #include <KoStore.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 #include "KisSwatch.h"
 
 #include "KoColorSet.h"
 #include "KoColorSet_p.h"
 
 namespace {
 
 /**
  * readAllLinesSafe() reads all the lines in the byte array
  * using the automated UTF8 and CR/LF transformations. That
  * might be necessary for opening GPL palettes created on Linux
  * in Windows environment.
  */
 QStringList readAllLinesSafe(QByteArray *data)
 {
     QStringList lines;
 
     QBuffer buffer(data);
     buffer.open(QBuffer::ReadOnly);
     QTextStream stream(&buffer);
 
     QString line;
     while (stream.readLineInto(&line)) {
         lines << line;
     }
 
     return lines;
 }
 }
 
 
 const QString KoColorSet::GLOBAL_GROUP_NAME = QString();
 const QString KoColorSet::KPL_VERSION_ATTR = "version";
 const QString KoColorSet::KPL_GROUP_ROW_COUNT_ATTR = "rows";
 const QString KoColorSet::KPL_PALETTE_COLUMN_COUNT_ATTR = "columns";
 const QString KoColorSet::KPL_PALETTE_NAME_ATTR = "name";
 const QString KoColorSet::KPL_PALETTE_COMMENT_ATTR = "comment";
 const QString KoColorSet::KPL_PALETTE_FILENAME_ATTR = "filename";
 const QString KoColorSet::KPL_PALETTE_READONLY_ATTR = "readonly";
 const QString KoColorSet::KPL_COLOR_MODEL_ID_ATTR = "colorModelId";
 const QString KoColorSet::KPL_COLOR_DEPTH_ID_ATTR = "colorDepthId";
 const QString KoColorSet::KPL_GROUP_NAME_ATTR = "name";
 const QString KoColorSet::KPL_SWATCH_ROW_ATTR = "row";
 const QString KoColorSet::KPL_SWATCH_COL_ATTR = "column";
 const QString KoColorSet::KPL_SWATCH_NAME_ATTR = "name";
 const QString KoColorSet::KPL_SWATCH_ID_ATTR = "id";
 const QString KoColorSet::KPL_SWATCH_SPOT_ATTR = "spot";
 const QString KoColorSet::KPL_SWATCH_BITDEPTH_ATTR = "bitdepth";
 const QString KoColorSet::KPL_PALETTE_PROFILE_TAG = "Profile";
 const QString KoColorSet::KPL_SWATCH_POS_TAG = "Position";
 const QString KoColorSet::KPL_SWATCH_TAG = "ColorSetEntry";
 const QString KoColorSet::KPL_GROUP_TAG = "Group";
 const QString KoColorSet::KPL_PALETTE_TAG = "ColorSet";
 
 const int MAXIMUM_ALLOWED_COLUMNS = 4096;
 
 KoColorSet::KoColorSet(const QString& filename)
     : KoResource(filename)
     , d(new Private(this))
 {
     if (!filename.isEmpty()) {
         QFileInfo f(filename);
         setIsEditable(f.isWritable());
     }
 }
 
 /// Create an copied palette
 KoColorSet::KoColorSet(const KoColorSet& rhs)
     : QObject(0)
     , KoResource(rhs)
     , d(new Private(this))
 {
     d->paletteType = rhs.d->paletteType;
     d->data = rhs.d->data;
     d->comment = rhs.d->comment;
     d->groupNames = rhs.d->groupNames;
     d->groups = rhs.d->groups;
     d->isGlobal = rhs.d->isGlobal;
     d->isEditable = rhs.d->isEditable;
 }
 
 KoColorSet::~KoColorSet()
 { }
 
 bool KoColorSet::load()
 {
     QFile file(filename());
     if (file.size() == 0) return false;
     if (!file.open(QIODevice::ReadOnly)) {
         warnPigment << "Can't open file " << filename();
         return false;
     }
     bool res = loadFromDevice(&file);
     file.close();
     if (!QFileInfo(filename()).isWritable()) {
         setIsEditable(false);
     }
     return res;
 }
 
 bool KoColorSet::loadFromDevice(QIODevice *dev)
 {
     if (!dev->isOpen()) dev->open(QIODevice::ReadOnly);
 
     d->data = dev->readAll();
 
     Q_ASSERT(d->data.size() != 0);
 
     return d->init();
 }
 
 
 bool KoColorSet::save()
 {
     if (d->isGlobal) {
         // save to resource dir
         QFile file(filename());
         if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
             return false;
         }
         saveToDevice(&file);
         file.close();
         return true;
     } else {
         return true; // palette is not global, but still indicate that it's saved
     }
 }
 
 bool KoColorSet::saveToDevice(QIODevice *dev) const
 {
     bool res;
     switch(d->paletteType) {
     case GPL:
         res = d->saveGpl(dev);
         break;
     default:
         res = d->saveKpl(dev);
     }
     if (res) {
         KoResource::saveToDevice(dev);
     }
     return res;
 }
 
 QByteArray KoColorSet::toByteArray() const
 {
     QBuffer s;
     s.open(QIODevice::WriteOnly);
     if (!saveToDevice(&s)) {
         warnPigment << "saving palette failed:" << name();
         return QByteArray();
     }
     s.close();
     s.open(QIODevice::ReadOnly);
     QByteArray res = s.readAll();
     s.close();
     return res;
 }
 
 bool KoColorSet::fromByteArray(QByteArray &data)
 {
     QBuffer buf(&data);
     buf.open(QIODevice::ReadOnly);
     return loadFromDevice(&buf);
 }
 
 KoColorSet::PaletteType KoColorSet::paletteType() const
 {
     return d->paletteType;
 }
 
 void KoColorSet::setPaletteType(PaletteType paletteType)
 {
     d->paletteType = paletteType;
     QString suffix;
     switch(d->paletteType) {
     case GPL:
         suffix = ".gpl";
         break;
     case ACT:
         suffix = ".act";
         break;
     case RIFF_PAL:
     case PSP_PAL:
         suffix = ".pal";
         break;
     case ACO:
         suffix = ".aco";
         break;
     case XML:
         suffix = ".xml";
         break;
     case KPL:
         suffix = ".kpl";
         break;
     case SBZ:
         suffix = ".sbz";
         break;
     default:
         suffix = defaultFileExtension();
     }
     QStringList fileName = filename().split(".");
     fileName.last() = suffix.replace(".", "");
     setFilename(fileName.join("."));
 }
 
 
 quint32 KoColorSet::colorCount() const
 {
     int colorCount = 0;
     for (KisSwatchGroup &g : d->groups.values()) {
         colorCount += g.colorCount();
     }
     return colorCount;
 }
 
 void KoColorSet::add(const KisSwatch &c, const QString &groupName)
 {
     KisSwatchGroup &modifiedGroup = d->groups.contains(groupName)
             ? d->groups[groupName] : d->global();
     modifiedGroup.addEntry(c);
 }
 
 void KoColorSet::setEntry(const KisSwatch &e, int x, int y, const QString &groupName)
 {
     KisSwatchGroup &modifiedGroup = d->groups.contains(groupName)
             ? d->groups[groupName] : d->global();
     modifiedGroup.setEntry(e, x, y);
 }
 
 void KoColorSet::clear()
 {
     d->groups.clear();
     d->groupNames.clear();
     d->groups[GLOBAL_GROUP_NAME] = KisSwatchGroup();
     d->groupNames.append(GLOBAL_GROUP_NAME);
 }
 
 KisSwatch KoColorSet::getColorGlobal(quint32 x, quint32 y) const
 {
-    for (const QString &groupName : d->groupNames) {
-        if ((int)y < d->groups[groupName].rowCount()) {
-            return d->groups[groupName].getEntry(x, y);
-        } else {
-            y -= d->groups[groupName].rowCount();
+    for (const QString &groupName : getGroupNames()) {
+        if (d->groups.contains(groupName)) {
+            if ((int)y < d->groups[groupName].rowCount()) {
+                return d->groups[groupName].getEntry(x, y);
+            } else {
+                y -= d->groups[groupName].rowCount();
+            }
         }
     }
     return KisSwatch();
 }
 
 KisSwatch KoColorSet::getColorGroup(quint32 x, quint32 y, QString groupName)
 {
     KisSwatch e;
     const KisSwatchGroup &sourceGroup = groupName == QString()
             ? d->global() : d->groups[groupName];
     if (sourceGroup.checkEntry(x, y)) {
         e = sourceGroup.getEntry(x, y);
     }
     return e;
 }
 
-QStringList KoColorSet::getGroupNames()
+QStringList KoColorSet::getGroupNames() const
 {
     if (d->groupNames.size() != d->groups.size()) {
         warnPigment << "mismatch between groups and the groupnames list.";
         return QStringList(d->groups.keys());
     }
     return d->groupNames;
 }
 
 bool KoColorSet::changeGroupName(const QString &oldGroupName, const QString &newGroupName)
 {
     if (!d->groups.contains(oldGroupName)) {
         return false;
     }
     if (oldGroupName == newGroupName) {
         return true;
     }
     d->groups[newGroupName] = d->groups[oldGroupName];
     d->groups.remove(oldGroupName);
     d->groups[newGroupName].setName(newGroupName);
     //rename the string in the stringlist;
     int index = d->groupNames.indexOf(oldGroupName);
     d->groupNames.replace(index, newGroupName);
     return true;
 }
 
 void KoColorSet::setColumnCount(int columns)
 {
     d->groups[GLOBAL_GROUP_NAME].setColumnCount(columns);
     for (KisSwatchGroup &g : d->groups.values()) {
         g.setColumnCount(columns);
     }
 }
 
 int KoColorSet::columnCount() const
 {
     return d->groups[GLOBAL_GROUP_NAME].columnCount();
 }
 
 QString KoColorSet::comment()
 {
     return d->comment;
 }
 
 void KoColorSet::setComment(QString comment)
 {
     d->comment = comment;
 }
 
 bool KoColorSet::addGroup(const QString &groupName)
 {
-    if (d->groups.contains(groupName) || d->groupNames.contains(groupName)) {
+    if (d->groups.contains(groupName) || getGroupNames().contains(groupName)) {
         return false;
     }
     d->groupNames.append(groupName);
     d->groups[groupName] = KisSwatchGroup();
     d->groups[groupName].setName(groupName);
     return true;
 }
 
 bool KoColorSet::moveGroup(const QString &groupName, const QString &groupNameInsertBefore)
 {
-    if (d->groupNames.contains(groupName)==false || d->groupNames.contains(groupNameInsertBefore)==false) {
+    if (!d->groupNames.contains(groupName) || d->groupNames.contains(groupNameInsertBefore)==false) {
         return false;
     }
     if (groupNameInsertBefore != GLOBAL_GROUP_NAME && groupName != GLOBAL_GROUP_NAME) {
         d->groupNames.removeAt(d->groupNames.indexOf(groupName));
         int index = d->groupNames.indexOf(groupNameInsertBefore);
         d->groupNames.insert(index, groupName);
     }
     return true;
 }
 
 bool KoColorSet::removeGroup(const QString &groupName, bool keepColors)
 {
     if (!d->groups.contains(groupName)) {
         return false;
     }
 
     if (groupName == GLOBAL_GROUP_NAME) {
         return false;
     }
 
     if (keepColors) {
         // put all colors directly below global
         int startingRow = d->groups[GLOBAL_GROUP_NAME].rowCount();
         for (const KisSwatchGroup::SwatchInfo &info : d->groups[groupName].infoList()) {
             d->groups[GLOBAL_GROUP_NAME].setEntry(info.swatch,
                                                   info.column,
                                                   info.row + startingRow);
         }
     }
 
     d->groupNames.removeAt(d->groupNames.indexOf(groupName));
     d->groups.remove(groupName);
     return true;
 }
 
 QString KoColorSet::defaultFileExtension() const
 {
     return QString(".kpl");
 }
 
 
 int KoColorSet::rowCount() const
 {
     int res = 0;
-    for (const QString &name : d->groupNames) {
+    for (const QString &name : getGroupNames()) {
         res += d->groups[name].rowCount();
     }
     return res;
 }
 
 KisSwatchGroup *KoColorSet::getGroup(const QString &name)
 {
     if (!d->groups.contains(name)) {
         return 0;
     }
     return &(d->groups[name]);
 }
 
 KisSwatchGroup *KoColorSet::getGlobalGroup()
 {
     return getGroup(GLOBAL_GROUP_NAME);
 }
 
 bool KoColorSet::isGlobal() const
 {
     return d->isGlobal;
 }
 
 void KoColorSet::setIsGlobal(bool isGlobal)
 {
     d->isGlobal = isGlobal;
 }
 
 bool KoColorSet::isEditable() const
 {
     return d->isEditable;
 }
 
 void KoColorSet::setIsEditable(bool isEditable)
 {
     d->isEditable = isEditable;
 }
 
 KisSwatchGroup::SwatchInfo KoColorSet::getClosestColorInfo(KoColor compare, bool useGivenColorSpace)
 {
     KisSwatchGroup::SwatchInfo res;
 
     quint8 highestPercentage = 0;
     quint8 testPercentage = 0;
 
     for (const QString &groupName : getGroupNames()) {
         KisSwatchGroup *group = getGroup(groupName);
         for (const KisSwatchGroup::SwatchInfo &currInfo : group->infoList()) {
             KoColor color = currInfo.swatch.color();
             if (useGivenColorSpace == true && compare.colorSpace() != color.colorSpace()) {
                 color.convertTo(compare.colorSpace());
 
             } else if (compare.colorSpace() != color.colorSpace()) {
                 compare.convertTo(color.colorSpace());
             }
             testPercentage = (255 - compare.colorSpace()->difference(compare.data(), color.data()));
             if (testPercentage > highestPercentage)
             {
                 highestPercentage = testPercentage;
                 res = currInfo;
             }
         }
     }
     return res;
 }
 
 /********************************KoColorSet::Private**************************/
 
 KoColorSet::Private::Private(KoColorSet *a_colorSet)
     : colorSet(a_colorSet)
 {
     groups[KoColorSet::GLOBAL_GROUP_NAME] = KisSwatchGroup();
     groupNames.append(KoColorSet::GLOBAL_GROUP_NAME);
 }
 
 KoColorSet::PaletteType KoColorSet::Private::detectFormat(const QString &fileName, const QByteArray &ba)
 {
     QFileInfo fi(fileName);
 
     // .pal
     if (ba.startsWith("RIFF") && ba.indexOf("PAL data", 8)) {
         return KoColorSet::RIFF_PAL;
     }
     // .gpl
     else if (ba.startsWith("GIMP Palette")) {
         return KoColorSet::GPL;
     }
     // .pal
     else if (ba.startsWith("JASC-PAL")) {
         return KoColorSet::PSP_PAL;
     }
     else if (fi.suffix().toLower() == "aco") {
         return KoColorSet::ACO;
     }
     else if (fi.suffix().toLower() == "act") {
         return KoColorSet::ACT;
     }
     else if (fi.suffix().toLower() == "xml") {
         return KoColorSet::XML;
     }
     else if (fi.suffix().toLower() == "kpl") {
         return KoColorSet::KPL;
     }
     else if (fi.suffix().toLower() == "sbz") {
         return KoColorSet::SBZ;
     }
     return KoColorSet::UNKNOWN;
 }
 
 void KoColorSet::Private::scribusParseColor(KoColorSet *set, QXmlStreamReader *xml)
 {
     KisSwatch colorEntry;
     // It's a color, retrieve it
     QXmlStreamAttributes colorProperties = xml->attributes();
 
     QStringRef colorName = colorProperties.value("NAME");
     colorEntry.setName(colorName.isEmpty() || colorName.isNull() ? i18n("Untitled") : colorName.toString());
 
     // RGB or CMYK?
     if (colorProperties.hasAttribute("RGB")) {
         dbgPigment << "Color " << colorProperties.value("NAME") << ", RGB " << colorProperties.value("RGB");
 
         KoColor currentColor(KoColorSpaceRegistry::instance()->rgb8());
         QStringRef colorValue = colorProperties.value("RGB");
 
         if (colorValue.length() != 7 && colorValue.at(0) != '#') { // Color is a hexadecimal number
             xml->raiseError("Invalid rgb8 color (malformed): " + colorValue);
             return;
         } else {
             bool rgbOk;
             quint32 rgb = colorValue.mid(1).toUInt(&rgbOk, 16);
             if  (!rgbOk) {
                 xml->raiseError("Invalid rgb8 color (unable to convert): " + colorValue);
                 return;
             }
 
             quint8 r = rgb >> 16 & 0xff;
             quint8 g = rgb >> 8 & 0xff;
             quint8 b = rgb & 0xff;
 
             dbgPigment << "Color parsed: "<< r << g << b;
 
             currentColor.data()[0] = r;
             currentColor.data()[1] = g;
             currentColor.data()[2] = b;
             currentColor.setOpacity(OPACITY_OPAQUE_U8);
             colorEntry.setColor(currentColor);
 
             set->add(colorEntry);
 
             while(xml->readNextStartElement()) {
                 //ignore - these are all unknown or the /> element tag
                 xml->skipCurrentElement();
             }
             return;
         }
     }
     else if (colorProperties.hasAttribute("CMYK")) {
         dbgPigment << "Color " << colorProperties.value("NAME") << ", CMYK " << colorProperties.value("CMYK");
 
         KoColor currentColor(KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Integer8BitsColorDepthID.id(), QString()));
 
         QStringRef colorValue = colorProperties.value("CMYK");
         if (colorValue.length() != 9 && colorValue.at(0) != '#') { // Color is a hexadecimal number
             xml->raiseError("Invalid cmyk color (malformed): " % colorValue);
             return;
         }
         else {
             bool cmykOk;
             quint32 cmyk = colorValue.mid(1).toUInt(&cmykOk, 16); // cmyk uses the full 32 bits
             if  (!cmykOk) {
                 xml->raiseError("Invalid cmyk color (unable to convert): " % colorValue);
                 return;
             }
 
             quint8 c = cmyk >> 24 & 0xff;
             quint8 m = cmyk >> 16 & 0xff;
             quint8 y = cmyk >> 8 & 0xff;
             quint8 k = cmyk & 0xff;
 
             dbgPigment << "Color parsed: "<< c << m << y << k;
 
             currentColor.data()[0] = c;
             currentColor.data()[1] = m;
             currentColor.data()[2] = y;
             currentColor.data()[3] = k;
             currentColor.setOpacity(OPACITY_OPAQUE_U8);
             colorEntry.setColor(currentColor);
 
             set->add(colorEntry);
 
             while(xml->readNextStartElement()) {
                 //ignore - these are all unknown or the /> element tag
                 xml->skipCurrentElement();
             }
             return;
         }
     }
     else {
         xml->raiseError("Unknown color space for color " + colorEntry.name());
     }
 }
 
 bool KoColorSet::Private::loadScribusXmlPalette(KoColorSet *set, QXmlStreamReader *xml)
 {
 
     //1. Get name
     QXmlStreamAttributes paletteProperties = xml->attributes();
     QStringRef paletteName = paletteProperties.value("Name");
     dbgPigment << "Processed name of palette:" << paletteName;
     set->setName(paletteName.toString());
 
     //2. Inside the SCRIBUSCOLORS, there are lots of colors. Retrieve them
 
     while(xml->readNextStartElement()) {
         QStringRef currentElement = xml->name();
         if(QStringRef::compare(currentElement, "COLOR", Qt::CaseInsensitive) == 0) {
             scribusParseColor(set, xml);
         }
         else {
             xml->skipCurrentElement();
         }
     }
 
     if(xml->hasError()) {
         return false;
     }
 
     return true;
 }
 
 quint16 KoColorSet::Private::readShort(QIODevice *io) {
     quint16 val;
     quint64 read = io->read((char*)&val, 2);
     if (read != 2) return false;
     return qFromBigEndian(val);
 }
 
 bool KoColorSet::Private::init()
 {
     // just in case this is a reload (eg by KoEditColorSetDialog),
     groupNames.clear();
     groups.clear();
     groupNames.append(KoColorSet::GLOBAL_GROUP_NAME);
     groups[KoColorSet::GLOBAL_GROUP_NAME] = KisSwatchGroup();
 
     if (colorSet->filename().isNull()) {
         warnPigment << "Cannot load palette" << colorSet->name() << "there is no filename set";
         return false;
     }
     if (data.isNull()) {
         QFile file(colorSet->filename());
         if (file.size() == 0) {
             warnPigment << "Cannot load palette" << colorSet->name() << "there is no data available";
             return false;
         }
         file.open(QIODevice::ReadOnly);
         data = file.readAll();
         file.close();
     }
 
     bool res = false;
     paletteType = detectFormat(colorSet->filename(), data);
     switch(paletteType) {
     case GPL:
         res = loadGpl();
         break;
     case ACT:
         res = loadAct();
         break;
     case RIFF_PAL:
         res = loadRiff();
         break;
     case PSP_PAL:
         res = loadPsp();
         break;
     case ACO:
         res = loadAco();
         break;
     case XML:
         res = loadXml();
         break;
     case KPL:
         res = loadKpl();
         break;
     case SBZ:
         res = loadSbz();
         break;
     default:
         res = false;
     }
     colorSet->setValid(res);
 
     QImage img(global().columnCount() * 4, global().rowCount() * 4, QImage::Format_ARGB32);
     QPainter gc(&img);
     gc.fillRect(img.rect(), Qt::darkGray);
     for (const KisSwatchGroup::SwatchInfo &info : global().infoList()) {
         QColor c = info.swatch.color().toQColor();
         gc.fillRect(info.column * 4, info.row * 4, 4, 4, c);
     }
     colorSet->setImage(img);
     colorSet->setValid(res);
 
     data.clear();
     return res;
 }
 
 bool KoColorSet::Private::saveGpl(QIODevice *dev) const
 {
     Q_ASSERT(dev->isOpen());
     Q_ASSERT(dev->isWritable());
 
     QTextStream stream(dev);
     stream << "GIMP Palette\nName: " << colorSet->name() << "\nColumns: " << colorSet->columnCount() << "\n#\n";
 
     /*
      * Qt doesn't provide an interface to get a const reference to a QHash, that is
      * the underlying data structure of groups. Therefore, directly use
      * groups[KoColorSet::GLOBAL_GROUP_NAME] so that saveGpl can stay const
      */
 
     for (int y = 0; y < groups[KoColorSet::GLOBAL_GROUP_NAME].rowCount(); y++) {
         for (int x = 0; x < colorSet->columnCount(); x++) {
             if (!groups[KoColorSet::GLOBAL_GROUP_NAME].checkEntry(x, y)) {
                 continue;
             }
             const KisSwatch& entry = groups[KoColorSet::GLOBAL_GROUP_NAME].getEntry(x, y);
             QColor c = entry.color().toQColor();
             stream << c.red() << " " << c.green() << " " << c.blue() << "\t";
             if (entry.name().isEmpty())
                 stream << "Untitled\n";
             else
                 stream << entry.name() << "\n";
         }
     }
 
     return true;
 }
 
 bool KoColorSet::Private::loadGpl()
 {
     if (data.isEmpty() || data.isNull() || data.length() < 50) {
         warnPigment << "Illegal Gimp palette file: " << colorSet->filename();
         return false;
     }
 
     quint32 index = 0;
 
     QStringList lines = readAllLinesSafe(&data);
 
     if (lines.size() < 3) {
         warnPigment << "Not enough lines in palette file: " << colorSet->filename();
         return false;
     }
 
     QString columnsText;
     qint32 r, g, b;
     KisSwatch e;
 
     // Read name
     if (!lines[0].startsWith("GIMP") || !lines[1].toLower().contains("name")) {
         warnPigment << "Illegal Gimp palette file: " << colorSet->filename();
         return false;
     }
 
     colorSet->setName(i18n(lines[1].split(":")[1].trimmed().toLatin1()));
 
     index = 2;
 
     // Read columns
     int columns = 0;
     if (lines[index].toLower().contains("columns")) {
         columnsText = lines[index].split(":")[1].trimmed();
         columns = columnsText.toInt();
         if (columns > MAXIMUM_ALLOWED_COLUMNS) {
             warnPigment << "Refusing to set unreasonable number of columns (" << columns << ") in GIMP Palette file " << colorSet->filename() << " - using maximum number of allowed columns instead";
             global().setColumnCount(MAXIMUM_ALLOWED_COLUMNS);
         }
         else {
             global().setColumnCount(columns);
         }
         index = 3;
     }
 
 
     for (qint32 i = index; i < lines.size(); i++) {
         if (lines[i].startsWith('#')) {
             comment += lines[i].mid(1).trimmed() + ' ';
         } else if (!lines[i].isEmpty()) {
             QStringList a = lines[i].replace('\t', ' ').split(' ', QString::SkipEmptyParts);
 
             if (a.count() < 3) {
                 continue;
             }
 
             r = qBound(0, a[0].toInt(), 255);
             g = qBound(0, a[1].toInt(), 255);
             b = qBound(0, a[2].toInt(), 255);
 
             e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
 
             for (int i = 0; i != 3; i++) {
                 a.pop_front();
             }
             QString name = a.join(" ");
             e.setName(name.isEmpty() || name == "Untitled" ? i18n("Untitled") : name);
 
             global().addEntry(e);
         }
     }
     int rowCount = global().colorCount()/ global().columnCount();
     if (global().colorCount() % global().columnCount()>0) {
         rowCount ++;
     }
     global().setRowCount(rowCount);
     return true;
 }
 
 bool KoColorSet::Private::loadAct()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
     KisSwatch e;
     for (int i = 0; i < data.size(); i += 3) {
         quint8 r = data[i];
         quint8 g = data[i+1];
         quint8 b = data[i+2];
         e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
         global().addEntry(e);
     }
     return true;
 }
 
 bool KoColorSet::Private::loadRiff()
 {
     // http://worms2d.info/Palette_file
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
     KisSwatch e;
 
     RiffHeader header;
     memcpy(&header, data.constData(), sizeof(RiffHeader));
     header.colorcount = qFromBigEndian(header.colorcount);
 
     for (int i = sizeof(RiffHeader);
          (i < (int)(sizeof(RiffHeader) + header.colorcount) && i < data.size());
          i += 4) {
         quint8 r = data[i];
         quint8 g = data[i+1];
         quint8 b = data[i+2];
         e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
         groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
     }
     return true;
 }
 
 
 bool KoColorSet::Private::loadPsp()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
     KisSwatch e;
     qint32 r, g, b;
 
     QStringList l = readAllLinesSafe(&data);
     if (l.size() < 4) return false;
     if (l[0] != "JASC-PAL") return false;
     if (l[1] != "0100") return false;
 
     int entries = l[2].toInt();
 
     for (int i = 0; i < entries; ++i)  {
 
         QStringList a = l[i + 3].replace('\t', ' ').split(' ', QString::SkipEmptyParts);
 
         if (a.count() != 3) {
             continue;
         }
 
         r = qBound(0, a[0].toInt(), 255);
         g = qBound(0, a[1].toInt(), 255);
         b = qBound(0, a[2].toInt(), 255);
 
         e.setColor(KoColor(QColor(r, g, b),
                            KoColorSpaceRegistry::instance()->rgb8()));
 
         QString name = a.join(" ");
         e.setName(name.isEmpty() ? i18n("Untitled") : name);
 
         groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
     }
     return true;
 }
 
 bool KoColorSet::Private::loadKpl()
 {
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     QScopedPointer<KoStore> store(KoStore::createStore(&buf, KoStore::Read, "krita/x-colorset", KoStore::Zip));
     if (!store || store->bad()) { return false; }
 
     if (store->hasFile("profiles.xml")) {
         if (!store->open("profiles.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         QDomDocument doc;
         doc.setContent(ba);
         QDomElement e = doc.documentElement();
         QDomElement c = e.firstChildElement(KPL_PALETTE_PROFILE_TAG);
         while (!c.isNull()) {
             QString name = c.attribute(KPL_PALETTE_NAME_ATTR);
             QString filename = c.attribute(KPL_PALETTE_FILENAME_ATTR);
             QString colorModelId = c.attribute(KPL_COLOR_MODEL_ID_ATTR);
             QString colorDepthId = c.attribute(KPL_COLOR_DEPTH_ID_ATTR);
             if (!KoColorSpaceRegistry::instance()->profileByName(name)) {
                 store->open(filename);
                 QByteArray data;
                 data.resize(store->size());
                 data = store->read(store->size());
                 store->close();
 
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(colorModelId, colorDepthId, data);
                 if (profile && profile->valid()) {
                     KoColorSpaceRegistry::instance()->addProfile(profile);
                 }
             }
 
             c = c.nextSiblingElement();
         }
     }
 
     {
         if (!store->open("colorset.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         int desiredColumnCount;
 
         QDomDocument doc;
         doc.setContent(ba);
         QDomElement e = doc.documentElement();
         colorSet->setName(e.attribute(KPL_PALETTE_NAME_ATTR));
         colorSet->setIsEditable(e.attribute(KPL_PALETTE_READONLY_ATTR) != "true");
         comment = e.attribute(KPL_PALETTE_COMMENT_ATTR);
 
         desiredColumnCount = e.attribute(KPL_PALETTE_COLUMN_COUNT_ATTR).toInt();
         if (desiredColumnCount > MAXIMUM_ALLOWED_COLUMNS) {
             warnPigment << "Refusing to set unreasonable number of columns (" << desiredColumnCount << ") in KPL palette file " << colorSet->filename() << " - setting maximum allowed column count instead.";
             colorSet->setColumnCount(MAXIMUM_ALLOWED_COLUMNS);
         }
         else {
             colorSet->setColumnCount(desiredColumnCount);
         }
 
         loadKplGroup(doc, e, colorSet->getGlobalGroup());
 
         QDomElement g = e.firstChildElement(KPL_GROUP_TAG);
         while (!g.isNull()) {
             QString groupName = g.attribute(KPL_GROUP_NAME_ATTR);
             colorSet->addGroup(groupName);
             loadKplGroup(doc, g, colorSet->getGroup(groupName));
             g = g.nextSiblingElement(KPL_GROUP_TAG);
         }
     }
 
     buf.close();
     return true;
 }
 
 bool KoColorSet::Private::loadAco()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.completeBaseName());
 
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     quint16 version = readShort(&buf);
     quint16 numColors = readShort(&buf);
     KisSwatch e;
 
     if (version == 1 && buf.size() > 4+numColors*10) {
         buf.seek(4+numColors*10);
         version = readShort(&buf);
         numColors = readShort(&buf);
     }
 
     const quint16 quint16_MAX = 65535;
 
     for (int i = 0; i < numColors && !buf.atEnd(); ++i) {
 
         quint16 colorSpace = readShort(&buf);
         quint16 ch1 = readShort(&buf);
         quint16 ch2 = readShort(&buf);
         quint16 ch3 = readShort(&buf);
         quint16 ch4 = readShort(&buf);
 
         bool skip = false;
         if (colorSpace == 0) { // RGB
             const KoColorProfile *srgb = KoColorSpaceRegistry::instance()->rgb8()->profile();
             KoColor c(KoColorSpaceRegistry::instance()->rgb16(srgb));
             reinterpret_cast<quint16*>(c.data())[0] = ch3;
             reinterpret_cast<quint16*>(c.data())[1] = ch2;
             reinterpret_cast<quint16*>(c.data())[2] = ch1;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 1) { // HSB
             QColor qc;
             qc.setHsvF(ch1 / 65536.0, ch2 / 65536.0, ch3 / 65536.0);
             KoColor c(qc, KoColorSpaceRegistry::instance()->rgb16());
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 2) { // CMYK
             KoColor c(KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Integer16BitsColorDepthID.id(), QString()));
             reinterpret_cast<quint16*>(c.data())[0] = quint16_MAX - ch1;
             reinterpret_cast<quint16*>(c.data())[1] = quint16_MAX - ch2;
             reinterpret_cast<quint16*>(c.data())[2] = quint16_MAX - ch3;
             reinterpret_cast<quint16*>(c.data())[3] = quint16_MAX - ch4;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 7) { // LAB
             KoColor c = KoColor(KoColorSpaceRegistry::instance()->lab16());
             reinterpret_cast<quint16*>(c.data())[0] = ch3;
             reinterpret_cast<quint16*>(c.data())[1] = ch2;
             reinterpret_cast<quint16*>(c.data())[2] = ch1;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 8) { // GRAY
             KoColor c(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer16BitsColorDepthID.id(), QString()));
             reinterpret_cast<quint16*>(c.data())[0] = ch1 * (quint16_MAX / 10000);
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else {
             warnPigment << "Unsupported colorspace in palette" << colorSet->filename() << "(" << colorSpace << ")";
             skip = true;
         }
         if (version == 2) {
             quint16 v2 = readShort(&buf); //this isn't a version, it's a marker and needs to be skipped.
             Q_UNUSED(v2);
             quint16 size = readShort(&buf) -1; //then comes the length
             if (size>0) {
                 QByteArray ba = buf.read(size*2);
                 if (ba.size() == size*2) {
                     QTextCodec *Utf16Codec = QTextCodec::codecForName("UTF-16BE");
                     e.setName(Utf16Codec->toUnicode(ba));
                 } else {
                     warnPigment << "Version 2 name block is the wrong size" << colorSet->filename();
                 }
             }
             v2 = readShort(&buf); //end marker also needs to be skipped.
             Q_UNUSED(v2);
         }
         if (!skip) {
             groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
         }
     }
     return true;
 }
 
 bool KoColorSet::Private::loadSbz() {
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     // &buf is a subclass of QIODevice
     QScopedPointer<KoStore> store(KoStore::createStore(&buf, KoStore::Read, "application/x-swatchbook", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     if (store->hasFile("swatchbook.xml")) { // Try opening...
 
         if (!store->open("swatchbook.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         dbgPigment << "XML palette: " << colorSet->filename() << ", SwatchBooker format";
 
         QDomDocument doc;
         int errorLine, errorColumn;
         QString errorMessage;
         bool status = doc.setContent(ba, &errorMessage, &errorLine, &errorColumn);
         if (!status) {
             warnPigment << "Illegal XML palette:" << colorSet->filename();
             warnPigment << "Error (line" << errorLine << ", column" << errorColumn << "):" << errorMessage;
             return false;
         }
 
         QDomElement e = doc.documentElement(); // SwatchBook
 
         // Start reading properties...
         QDomElement metadata = e.firstChildElement("metadata");
 
         if (e.isNull()) {
             warnPigment << "Palette metadata not found";
             return false;
         }
 
         QDomElement title = metadata.firstChildElement("dc:title");
         QString colorName = title.text();
         colorName = colorName.isEmpty() ? i18n("Untitled") : colorName;
         colorSet->setName(colorName);
         dbgPigment << "Processed name of palette:" << colorSet->name();
         // End reading properties
 
         // Now read colors...
         QDomElement materials = e.firstChildElement("materials");
         if (materials.isNull()) {
             warnPigment << "Materials (color definitions) not found";
             return false;
         }
         // This one has lots of "color" elements
         QDomElement colorElement = materials.firstChildElement("color");
         if (colorElement.isNull()) {
             warnPigment << "Color definitions not found (line" << materials.lineNumber() << ", column" << materials.columnNumber() << ")";
             return false;
         }
 
         // Also read the swatch book...
         QDomElement book = e.firstChildElement("book");
         if (book.isNull()) {
             warnPigment << "Palette book (swatch composition) not found (line" << e.lineNumber() << ", column" << e.columnNumber() << ")";
             return false;
         }
         // Which has lots of "swatch"es (todo: support groups)
         QDomElement swatch = book.firstChildElement();
         if (swatch.isNull()) {
             warnPigment << "Swatches/groups definition not found (line" << book.lineNumber() << ", column" << book.columnNumber() << ")";
             return false;
         }
 
         // We'll store colors here, and as we process swatches
         // we'll add them to the palette
         QHash<QString, KisSwatch> materialsBook;
         QHash<QString, const KoColorSpace*> fileColorSpaces;
 
         // Color processing
         for(; !colorElement.isNull(); colorElement = colorElement.nextSiblingElement("color"))
         {
             KisSwatch currentEntry;
             // Set if color is spot
             currentEntry.setSpotColor(colorElement.attribute("usage") == "spot");
 
             // <metadata> inside contains id and name
             // one or more <values> define the color
             QDomElement currentColorMetadata = colorElement.firstChildElement("metadata");
             QDomNodeList currentColorValues = colorElement.elementsByTagName("values");
             // Get color name
             QDomElement colorTitle = currentColorMetadata.firstChildElement("dc:title");
             QDomElement colorId = currentColorMetadata.firstChildElement("dc:identifier");
             // Is there an id? (we need that at the very least for identifying a color)
             if (colorId.text().isEmpty()) {
                 warnPigment << "Unidentified color (line" << colorId.lineNumber()<< ", column" << colorId.columnNumber() << ")";
                 return false;
             }
             if (materialsBook.contains(colorId.text())) {
                 warnPigment << "Duplicated color definition (line" << colorId.lineNumber()<< ", column" << colorId.columnNumber() << ")";
                 return false;
             }
 
             // Get a valid color name
             currentEntry.setId(colorId.text());
             currentEntry.setName(colorTitle.text().isEmpty() ? colorId.text() : colorTitle.text());
 
             // Get a valid color definition
             if (currentColorValues.isEmpty()) {
                 warnPigment << "Color definitions not found (line" << colorElement.lineNumber() << ", column" << colorElement.columnNumber() << ")";
                 return false;
             }
 
             bool firstDefinition = false;
             const KoColorProfile *srgb = KoColorSpaceRegistry::instance()->rgb8()->profile();
             // Priority: Lab, otherwise the first definition found
             for(int j = 0; j < currentColorValues.size(); j++) {
                 QDomNode colorValue = currentColorValues.at(j);
                 QDomElement colorValueE = colorValue.toElement();
                 QString model = colorValueE.attribute("model", QString());
 
                 // sRGB,RGB,HSV,HSL,CMY,CMYK,nCLR: 0 -> 1
                 // YIQ: Y 0 -> 1 : IQ -0.5 -> 0.5
                 // Lab: L 0 -> 100 : ab -128 -> 127
                 // XYZ: 0 -> ~100
                 if (model == "Lab") {
                     QStringList lab = colorValueE.text().split(" ");
                     if (lab.length() != 3) {
                         warnPigment << "Invalid Lab color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float l = lab.at(0).toFloat(&status);
                     float a = lab.at(1).toFloat(&status);
                     float b = lab.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(LABAColorModelID.id(), Float32BitsColorDepthID.id(), QString()));
                     reinterpret_cast<float*>(c.data())[0] = l;
                     reinterpret_cast<float*>(c.data())[1] = a;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     firstDefinition = true;
                     currentEntry.setColor(c);
                     break; // Immediately add this one
                 }
                 else if (model == "sRGB" && !firstDefinition) {
                     QStringList rgb = colorValueE.text().split(" ");
                     if (rgb.length() != 3) {
                         warnPigment << "Invalid sRGB color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float r = rgb.at(0).toFloat(&status);
                     float g = rgb.at(1).toFloat(&status);
                     float b = rgb.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), srgb));
                     reinterpret_cast<float*>(c.data())[0] = r;
                     reinterpret_cast<float*>(c.data())[1] = g;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else if (model == "XYZ" && !firstDefinition) {
                     QStringList xyz = colorValueE.text().split(" ");
                     if (xyz.length() != 3) {
                         warnPigment << "Invalid XYZ color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float x = xyz.at(0).toFloat(&status);
                     float y = xyz.at(1).toFloat(&status);
                     float z = xyz.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(XYZAColorModelID.id(), Float32BitsColorDepthID.id(), QString()));
                     reinterpret_cast<float*>(c.data())[0] = x;
                     reinterpret_cast<float*>(c.data())[1] = y;
                     reinterpret_cast<float*>(c.data())[2] = z;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 // The following color spaces admit an ICC profile (in SwatchBooker)
                 else if (model == "CMYK" && !firstDefinition) {
                     QStringList cmyk = colorValueE.text().split(" ");
                     if (cmyk.length() != 4) {
                         warnPigment << "Invalid CMYK color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float c = cmyk.at(0).toFloat(&status);
                     float m = cmyk.at(1).toFloat(&status);
                     float y = cmyk.at(2).toFloat(&status);
                     float k = cmyk.at(3).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), QString());
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor color(colorSpace);
                     reinterpret_cast<float*>(color.data())[0] = c;
                     reinterpret_cast<float*>(color.data())[1] = m;
                     reinterpret_cast<float*>(color.data())[2] = y;
                     reinterpret_cast<float*>(color.data())[3] = k;
                     color.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(color);
                     firstDefinition = true;
                 }
                 else if (model == "GRAY" && !firstDefinition) {
                     QString gray = colorValueE.text();
 
                     float g = gray.toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Float32BitsColorDepthID.id(), QString());
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor c(colorSpace);
                     reinterpret_cast<float*>(c.data())[0] = g;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else if (model == "RGB" && !firstDefinition) {
                     QStringList rgb = colorValueE.text().split(" ");
                     if (rgb.length() != 3) {
                         warnPigment << "Invalid RGB color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float r = rgb.at(0).toFloat(&status);
                     float g = rgb.at(1).toFloat(&status);
                     float b = rgb.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), srgb);
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor c(colorSpace);
                     reinterpret_cast<float*>(c.data())[0] = r;
                     reinterpret_cast<float*>(c.data())[1] = g;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else {
                     warnPigment << "Color space not implemented:" << model << "(line" << colorValueE.lineNumber() << ", column "<< colorValueE.columnNumber() << ")";
                 }
             }
             if (firstDefinition) {
                 materialsBook.insert(currentEntry.id(), currentEntry);
             }
             else {
                 warnPigment << "No supported color  spaces for the current color (line" << colorElement.lineNumber() << ", column "<< colorElement.columnNumber() << ")";
                 return false;
             }
         }
         // End colors
         // Now decide which ones will go into the palette
 
         for(;!swatch.isNull(); swatch = swatch.nextSiblingElement()) {
             QString type = swatch.tagName();
             if (type.isEmpty() || type.isNull()) {
                 warnPigment << "Invalid swatch/group definition (no id) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                 return false;
             }
             else if (type == "swatch") {
                 QString id = swatch.attribute("material");
                 if (id.isEmpty() || id.isNull()) {
                     warnPigment << "Invalid swatch definition (no material id) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                     return false;
                 }
                 if (materialsBook.contains(id)) {
                     groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(materialsBook.value(id));
                 }
                 else {
                     warnPigment << "Invalid swatch definition (material not found) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                     return false;
                 }
             }
             else if (type == "group") {
                 QDomElement groupMetadata = swatch.firstChildElement("metadata");
                 if (groupMetadata.isNull()) {
                     warnPigment << "Invalid group definition (missing metadata) (line" << groupMetadata.lineNumber() << ", column" << groupMetadata.columnNumber() << ")";
                     return false;
                 }
                 QDomElement groupTitle = metadata.firstChildElement("dc:title");
                 if (groupTitle.isNull()) {
                     warnPigment << "Invalid group definition (missing title) (line" << groupTitle.lineNumber() << ", column" << groupTitle.columnNumber() << ")";
                     return false;
                 }
                 QString currentGroupName = groupTitle.text();
 
                 QDomElement groupSwatch = swatch.firstChildElement("swatch");
 
                 while(!groupSwatch.isNull()) {
                     QString id = groupSwatch.attribute("material");
                     if (id.isEmpty() || id.isNull()) {
                         warnPigment << "Invalid swatch definition (no material id) (line" << groupSwatch.lineNumber() << ", column" << groupSwatch.columnNumber() << ")";
                         return false;
                     }
                     if (materialsBook.contains(id)) {
                         groups[currentGroupName].addEntry(materialsBook.value(id));
                     }
                     else {
                         warnPigment << "Invalid swatch definition (material not found) (line" << groupSwatch.lineNumber() << ", column" << groupSwatch.columnNumber() << ")";
                         return false;
                     }
                     groupSwatch = groupSwatch.nextSiblingElement("swatch");
                 }
             }
         }
         // End palette
     }
 
     buf.close();
     return true;
 }
 
 bool KoColorSet::Private::loadXml() {
     bool res = false;
 
     QXmlStreamReader *xml = new QXmlStreamReader(data);
 
     if (xml->readNextStartElement()) {
         QStringRef paletteId = xml->name();
         if (QStringRef::compare(paletteId, "SCRIBUSCOLORS", Qt::CaseInsensitive) == 0) { // Scribus
             dbgPigment << "XML palette: " << colorSet->filename() << ", Scribus format";
             res = loadScribusXmlPalette(colorSet, xml);
         }
         else {
             // Unknown XML format
             xml->raiseError("Unknown XML palette format. Expected SCRIBUSCOLORS, found " + paletteId);
         }
     }
 
     // If there is any error (it should be returned through the stream)
     if (xml->hasError() || !res) {
         warnPigment << "Illegal XML palette:" << colorSet->filename();
         warnPigment << "Error (line"<< xml->lineNumber() << ", column" << xml->columnNumber() << "):" << xml->errorString();
         return false;
     }
     else {
         dbgPigment << "XML palette parsed successfully:" << colorSet->filename();
         return true;
     }
 }
 
 bool KoColorSet::Private::saveKpl(QIODevice *dev) const
 {
     QScopedPointer<KoStore> store(KoStore::createStore(dev, KoStore::Write, "krita/x-colorset", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     QSet<const KoColorSpace *> colorSpaces;
 
     {
         QDomDocument doc;
         QDomElement root = doc.createElement(KPL_PALETTE_TAG);
         root.setAttribute(KPL_VERSION_ATTR, "1.0");
         root.setAttribute(KPL_PALETTE_NAME_ATTR, colorSet->name());
         root.setAttribute(KPL_PALETTE_COMMENT_ATTR, comment);
         root.setAttribute(KPL_PALETTE_READONLY_ATTR,
                           (colorSet->isEditable() || !colorSet->isGlobal()) ? "false" : "true");
         root.setAttribute(KPL_PALETTE_COLUMN_COUNT_ATTR, colorSet->columnCount());
         root.setAttribute(KPL_GROUP_ROW_COUNT_ATTR, groups[KoColorSet::GLOBAL_GROUP_NAME].rowCount());
 
         saveKplGroup(doc, root, colorSet->getGroup(KoColorSet::GLOBAL_GROUP_NAME), colorSpaces);
 
         for (const QString &groupName : groupNames) {
             if (groupName == KoColorSet::GLOBAL_GROUP_NAME) { continue; }
             QDomElement gl = doc.createElement(KPL_GROUP_TAG);
             gl.setAttribute(KPL_GROUP_NAME_ATTR, groupName);
             root.appendChild(gl);
             saveKplGroup(doc, gl, colorSet->getGroup(groupName), colorSpaces);
         }
 
         doc.appendChild(root);
         if (!store->open("colorset.xml")) { return false; }
         QByteArray ba = doc.toByteArray();
         if (store->write(ba) != ba.size()) { return false; }
         if (!store->close()) { return false; }
     }
 
     QDomDocument doc;
     QDomElement profileElement = doc.createElement("Profiles");
 
     for (const KoColorSpace *colorSpace : colorSpaces) {
         QString fn = QFileInfo(colorSpace->profile()->fileName()).fileName();
         if (!store->open(fn)) { return false; }
         QByteArray profileRawData = colorSpace->profile()->rawData();
         if (!store->write(profileRawData)) { return false; }
         if (!store->close()) { return false; }
         QDomElement el = doc.createElement(KPL_PALETTE_PROFILE_TAG);
         el.setAttribute(KPL_PALETTE_FILENAME_ATTR, fn);
         el.setAttribute(KPL_PALETTE_NAME_ATTR, colorSpace->profile()->name());
         el.setAttribute(KPL_COLOR_MODEL_ID_ATTR, colorSpace->colorModelId().id());
         el.setAttribute(KPL_COLOR_DEPTH_ID_ATTR, colorSpace->colorDepthId().id());
         profileElement.appendChild(el);
 
     }
     doc.appendChild(profileElement);
     if (!store->open("profiles.xml")) { return false; }
     QByteArray ba = doc.toByteArray();
     if (store->write(ba) != ba.size()) { return false; }
     if (!store->close()) { return false; }
 
     return store->finalize();
 }
 
 void KoColorSet::Private::saveKplGroup(QDomDocument &doc,
                                        QDomElement &groupEle,
                                        const KisSwatchGroup *group,
                                        QSet<const KoColorSpace *> &colorSetSet) const
 {
     groupEle.setAttribute(KPL_GROUP_ROW_COUNT_ATTR, QString::number(group->rowCount()));
 
     for (const SwatchInfoType &info : group->infoList()) {
         const KoColorProfile *profile = info.swatch.color().colorSpace()->profile();
         // Only save non-builtin profiles.=
         if (!profile->fileName().isEmpty()) {
             colorSetSet.insert(info.swatch.color().colorSpace());
         }
         QDomElement swatchEle = doc.createElement(KPL_SWATCH_TAG);
         swatchEle.setAttribute(KPL_SWATCH_NAME_ATTR, info.swatch.name());
         swatchEle.setAttribute(KPL_SWATCH_ID_ATTR, info.swatch.id());
         swatchEle.setAttribute(KPL_SWATCH_SPOT_ATTR, info.swatch.spotColor() ? "true" : "false");
         swatchEle.setAttribute(KPL_SWATCH_BITDEPTH_ATTR, info.swatch.color().colorSpace()->colorDepthId().id());
         info.swatch.color().toXML(doc, swatchEle);
 
         QDomElement positionEle = doc.createElement(KPL_SWATCH_POS_TAG);
         positionEle.setAttribute(KPL_SWATCH_ROW_ATTR, info.row);
         positionEle.setAttribute(KPL_SWATCH_COL_ATTR, info.column);
         swatchEle.appendChild(positionEle);
 
         groupEle.appendChild(swatchEle);
     }
 }
 
 void KoColorSet::Private::loadKplGroup(const QDomDocument &doc, const QDomElement &parentEle, KisSwatchGroup *group)
 {
     Q_UNUSED(doc);
     if (!parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).isNull()) {
         group->setRowCount(parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).toInt());
     }
     group->setColumnCount(colorSet->columnCount());
 
     for (QDomElement swatchEle = parentEle.firstChildElement(KPL_SWATCH_TAG);
          !swatchEle.isNull();
          swatchEle = swatchEle.nextSiblingElement(KPL_SWATCH_TAG)) {
         QString colorDepthId = swatchEle.attribute(KPL_SWATCH_BITDEPTH_ATTR, Integer8BitsColorDepthID.id());
         KisSwatch entry;
 
         entry.setColor(KoColor::fromXML(swatchEle.firstChildElement(), colorDepthId));
         entry.setName(swatchEle.attribute(KPL_SWATCH_NAME_ATTR));
         entry.setId(swatchEle.attribute(KPL_SWATCH_ID_ATTR));
         entry.setSpotColor(swatchEle.attribute(KPL_SWATCH_SPOT_ATTR, "false") == "true" ? true : false);
         QDomElement positionEle = swatchEle.firstChildElement(KPL_SWATCH_POS_TAG);
         if (!positionEle.isNull()) {
             int rowNumber = positionEle.attribute(KPL_SWATCH_ROW_ATTR).toInt();
             int columnNumber = positionEle.attribute(KPL_SWATCH_COL_ATTR).toInt();
             if (columnNumber < 0 ||
                     columnNumber >= colorSet->columnCount() ||
                     rowNumber < 0
                     ) {
                 warnPigment << "Swatch" << entry.name()
                             << "of palette" << colorSet->name()
                             << "has invalid position.";
                 continue;
             }
             group->setEntry(entry, columnNumber, rowNumber);
         } else {
             group->addEntry(entry);
         }
     }
 
     if (parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).isNull()
             && group->colorCount() > 0
             && group->columnCount() > 0
             && (group->colorCount() / (group->columnCount()) + 1) < 20) {
         group->setRowCount((group->colorCount() / group->columnCount()) + 1);
     }
 
 }
diff --git a/libs/pigment/resources/KoColorSet.h b/libs/pigment/resources/KoColorSet.h
index 056c2d34be..700f07c57d 100644
--- a/libs/pigment/resources/KoColorSet.h
+++ b/libs/pigment/resources/KoColorSet.h
@@ -1,219 +1,219 @@
 /*  This file is part of the KDE project
     Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
     Copyright (c) 2016 L. E. Segovia <leo.segovia@siggraph.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
  */
 #ifndef KOCOLORSET
 #define KOCOLORSET
 
 #include <QObject>
 #include <QColor>
 #include <QVector>
 #include <QScopedPointer>
 
 #include <resources/KoResource.h>
 #include "KoColor.h"
 #include "KisSwatch.h"
 #include "KisSwatchGroup.h"
 
 /**
  * Also called palette.
  * Open Gimp, Photoshop or RIFF palette files. This is a straight port
  * from the Gimp.
  */
 class KRITAPIGMENT_EXPORT KoColorSet : public QObject, public KoResource
 {
     Q_OBJECT
 public:
     static const QString GLOBAL_GROUP_NAME;
     static const QString KPL_VERSION_ATTR;
     static const QString KPL_GROUP_ROW_COUNT_ATTR;
     static const QString KPL_PALETTE_COLUMN_COUNT_ATTR;
     static const QString KPL_PALETTE_NAME_ATTR;
     static const QString KPL_PALETTE_COMMENT_ATTR;
     static const QString KPL_PALETTE_FILENAME_ATTR;
     static const QString KPL_PALETTE_READONLY_ATTR;
     static const QString KPL_COLOR_MODEL_ID_ATTR;
     static const QString KPL_COLOR_DEPTH_ID_ATTR;
     static const QString KPL_GROUP_NAME_ATTR;
     static const QString KPL_SWATCH_ROW_ATTR;
     static const QString KPL_SWATCH_COL_ATTR;
     static const QString KPL_SWATCH_NAME_ATTR;
     static const QString KPL_SWATCH_SPOT_ATTR;
     static const QString KPL_SWATCH_ID_ATTR;
     static const QString KPL_SWATCH_BITDEPTH_ATTR;
     static const QString KPL_PALETTE_PROFILE_TAG;
     static const QString KPL_SWATCH_POS_TAG;
     static const QString KPL_SWATCH_TAG;
     static const QString KPL_GROUP_TAG;
     static const QString KPL_PALETTE_TAG;
 
 public:
     enum PaletteType {
         UNKNOWN = 0,
         GPL,                // GIMP
         RIFF_PAL,           // RIFF
         ACT,                // Photoshop binary
         PSP_PAL,            // PaintShop Pro
         ACO,                // Photoshop Swatches
         XML,                // XML palette (Scribus)
         KPL,                // KoColor-based XML palette
         SBZ                 // SwatchBooker
     };
 
 
     /**
      * Load a color set from a file. This can be a Gimp
      * palette, a RIFF palette, a Photoshop palette,
      * a Krita palette,
      * a Scribus palette or a SwatchBooker palette.
      */
     explicit KoColorSet(const QString &filename = QString());
 
     // Explicit copy constructor (KoResource copy constructor is private)
     KoColorSet(const KoColorSet& rhs);
 
 public /* overridden methods */: // KoResource
     ~KoColorSet() override;
 
     bool load() override;
     bool loadFromDevice(QIODevice *dev) override;
     bool save() override;
     bool saveToDevice(QIODevice* dev) const override;
     QString defaultFileExtension() const override;
 
 
 public /* methods */:
     void setColumnCount(int columns);
     int columnCount() const;
 
     void setComment(QString comment);
     QString comment();
 
     int rowCount() const;
     quint32 colorCount() const;
 
     PaletteType paletteType() const;
     void setPaletteType(PaletteType paletteType);
 
     /**
      * @brief isGlobal
      * A global color set is a set stored in the config directory
      * Such a color set would be opened every time Krita is launched.
      *
      * A non-global color set, on contrary, would be stored in a kra file,
      * and would only be opened when that file is opened by Krita.
      * @return @c true if the set is global
      */
     bool isGlobal() const;
     void setIsGlobal(bool);
 
     bool isEditable() const;
     void setIsEditable(bool isEditable);
 
     QByteArray toByteArray() const;
     bool fromByteArray(QByteArray &data);
 
     /**
      * @brief Add a color to the palette.
      * @param c the swatch
      * @param groupName color to add the group to. If empty, it will be added to the unsorted.
      */
     void add(const KisSwatch &, const QString &groupName = GLOBAL_GROUP_NAME);
     void setEntry(const KisSwatch &e, int x, int y, const QString &groupName = GLOBAL_GROUP_NAME);
 
     /**
      * @brief getColorGlobal
      * A function for getting a color based on a global index. Useful for iterating through all color entries.
      * @param x the global x index over the whole palette.
      * @param y the global y index over the whole palette.
      * @return the entry.
      */
     KisSwatch getColorGlobal(quint32 x, quint32 y) const;
 
     /**
      * @brief getColorGroup
      * A function for getting the color from a specific group.
      * @param x the x index over the group.
      * @param y the y index over the group.
      * @param groupName the name of the group, will give unsorted when not defined.
      * @return the entry
      */
     KisSwatch getColorGroup(quint32 x, quint32 y, QString groupName);
 
     /**
      * @brief getGroupNames
      * @return returns a list of group names, excluding the unsorted group.
      */
-    QStringList getGroupNames();
+    QStringList getGroupNames() const;
 
     /**
      * @brief getGroup
      * @param name
      * @return the group with the name given; global group if no parameter is given
      * null pointer if not found.
      */
     KisSwatchGroup *getGroup(const QString &name);
     KisSwatchGroup *getGlobalGroup();
 
     bool changeGroupName(const QString &oldGroupName, const QString &newGroupName);
 
 
     /**
      * @brief addGroup
      * Adds a new group.
      * @param groupName the name of the new group. When not specified, this will fail.
      * @return whether thegroup was made.
      */
     bool addGroup(const QString &groupName);
 
     /**
      * @brief moveGroup
      * Move a group in the internal stringlist.
      * @param groupName the groupname to move.
      * @param groupNameInsertBefore the groupname to insert before. Empty means it will be added to the end.
      * @return
      */
     bool moveGroup(const QString &groupName, const QString &groupNameInsertBefore = GLOBAL_GROUP_NAME);
     /**
      * @brief removeGroup
      * Remove a group from the KoColorSet
      * @param groupName the name of the group you want to remove.
      * @param keepColors Whether you wish to keep the colorsetentries. These will be added to the unsorted.
      * @return whether it could find the group to remove.
      */
     bool removeGroup(const QString &groupName, bool keepColors = true);
 
     void clear();
 
     /**
      * @brief getIndexClosestColor
      * function that matches the color to all colors in the colorset, and returns the index
      * of the closest match.
      * @param compare the color you wish to compare.
      * @param useGivenColorSpace whether to use the color space of the color given
      * when the two colors' colorspaces don't match. Else it'll use the entry's colorspace.
      * @return returns the int of the closest match.
      */
     KisSwatchGroup::SwatchInfo getClosestColorInfo(KoColor compare, bool useGivenColorSpace = true);
 
 private:
     class Private;
     const QScopedPointer<Private> d;
 
 };
 #endif // KOCOLORSET
diff --git a/libs/ui/KisCloneDocumentStroke.cpp b/libs/ui/KisCloneDocumentStroke.cpp
index 17071af1dc..5df3b3684f 100644
--- a/libs/ui/KisCloneDocumentStroke.cpp
+++ b/libs/ui/KisCloneDocumentStroke.cpp
@@ -1,60 +1,60 @@
 /*
  *  Copyright (c) 2018 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 "KisCloneDocumentStroke.h"
 
 #include "KisDocument.h"
 #include "kis_layer_utils.h"
 
 #include <QApplication>
 
 
 struct KRITAIMAGE_NO_EXPORT KisCloneDocumentStroke::Private
 {
     Private(KisDocument *_document)
         : document(_document)
     {
     }
 
     KisDocument *document = 0;
 };
 
 KisCloneDocumentStroke::KisCloneDocumentStroke(KisDocument *document)
-    : KisSimpleStrokeStrategy("clone-document-stroke", kundo2_i18n("Clone Document")),
+    : KisSimpleStrokeStrategy(QLatin1String("clone-document-stroke"), kundo2_i18n("Clone Document")),
       m_d(new Private(document))
 {
     setClearsRedoOnStart(false);
     setRequestsOtherStrokesToEnd(false);
     enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
 }
 
 KisCloneDocumentStroke::~KisCloneDocumentStroke()
 {
 }
 
 void KisCloneDocumentStroke::initStrokeCallback()
 {
     KisLayerUtils::forceAllDelayedNodesUpdate(m_d->document->image()->root());
 }
 
 void KisCloneDocumentStroke::finishStrokeCallback()
 {
     KisDocument *doc = m_d->document->clone();
     doc->moveToThread(qApp->thread());
     emit sigDocumentCloned(doc);
 }
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index 8d58b71c90..6f9bbb71da 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,2259 +1,2266 @@
 /* This file is part of the Krita project
  *
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisMainWindow.h" // XXX: remove
 #include <QMessageBox> // XXX: remove
 
 #include <KisMimeDatabase.h>
 
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfoDlg.h>
 #include <KoDocumentInfo.h>
 #include <KoDpi.h>
 #include <KoUnit.h>
 #include <KoID.h>
 #include <KoOdfReadStore.h>
 #include <KoProgressProxy.h>
 #include <KoProgressUpdater.h>
 #include <KoSelection.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoStore.h>
 #include <KoUpdater.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 #include <KoDialog.h>
 #include <KisImportExportErrorCode.h>
 #include <KoDocumentResourceManager.h>
 #include <KoMD5Generator.h>
 
 #include <KisUsageLogger.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kis_generator_layer.h>
 #include <kis_generator_registry.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <kbackup.h>
 
 #include <QTextBrowser>
 #include <QApplication>
 #include <QBuffer>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFileInfo>
 #include <QImage>
 #include <QList>
 #include <QPainter>
 #include <QRect>
 #include <QScopedPointer>
 #include <QSize>
 #include <QStringList>
 #include <QtGlobal>
 #include <QTimer>
 #include <QWidget>
 #include <QFuture>
 #include <QFutureWatcher>
 
 // Krita Image
 #include <kis_image_animation_interface.h>
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.h"
+#include "kis_selection_mask.h"
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include "KisReferenceImagesLayer.h"
 
 #include <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.h"
 
 #include <KisMirrorAxisConfig.h>
 #include <KisDecorationsWrapperLayer.h>
 #include "kis_simple_stroke_strategy.h"
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 namespace {
 constexpr int errorMessageTimeout = 5000;
 constexpr int successMessageTimeout = 1000;
 }
 
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : KUndo2Stack(doc),
           m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private(KisDocument *_q)
         : q(_q)
         , docInfo(new KoDocumentInfo(_q)) // deleted by QObject
         , importExportManager(new KisImportExportManager(_q)) // deleted manually
         , autoSaveTimer(new QTimer(_q))
         , undoStack(new UndoStack(_q)) // deleted by QObject
         , m_bAutoDetectedMime(false)
         , modified(false)
         , readwrite(true)
         , firstMod(QDateTime::currentDateTime())
         , lastMod(firstMod)
         , nserver(new KisNameServer(1))
         , imageIdleWatcher(2000 /*ms*/)
         , globalAssistantsColor(KisConfig(true).defaultAssistantsColor())
         , savingLock(&savingMutex)
         , batchMode(false)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     Private(const Private &rhs, KisDocument *_q)
         : q(_q)
         , docInfo(new KoDocumentInfo(*rhs.docInfo, _q))
         , importExportManager(new KisImportExportManager(_q))
         , autoSaveTimer(new QTimer(_q))
         , undoStack(new UndoStack(_q))
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , savingLock(&savingMutex)
     {
         copyFromImpl(rhs, _q, CONSTRUCT);
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KisDocument *q = 0;
     KoDocumentInfo *docInfo = 0;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager = 0; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     QTimer *autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     QString lastWarningMessage;
     int autoSaveDelay = 300; // in seconds, 0 to disable.
     bool modifiedAfterAutosave = false;
     bool isAutosaving = false;
     bool disregardAutosaveFailure = false;
     int autoSaveFailureCount = 0;
 
     KUndo2Stack *undoStack = 0;
 
     KisGuidesConfig guidesConfig;
     KisMirrorAxisConfig mirrorAxisConfig;
 
     bool m_bAutoDetectedMime = false; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
 
     QMutex savingMutex;
 
     bool modified = false;
     bool readwrite = false;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     KisNameServer *nserver;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeWSP preActivatedNode;
     KisShapeController* shapeController = 0;
     KoShapeController* koShapeController = 0;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     QList<KisPaintingAssistantSP> assistants;
 
     QColor globalAssistantsColor;
 
     QList<KoColorSet*> paletteList;
     bool ownsPaletteList = false;
 
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportErrorCode> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     void syncDecorationsWrapperLayerState();
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     void copyFrom(const Private &rhs, KisDocument *q);
     void copyFromImpl(const Private &rhs, KisDocument *q, KisDocument::CopyPolicy policy);
 
     /// clones the palette list oldList
     /// the ownership of the returned KoColorSet * belongs to the caller
     QList<KoColorSet *> clonePaletteList(const QList<KoColorSet *> &oldList);
 
     class StrippedSafeSavingLocker;
 };
 
 
 void KisDocument::Private::syncDecorationsWrapperLayerState()
 {
     if (!this->image) return;
 
     KisImageSP image = this->image;
     KisDecorationsWrapperLayerSP decorationsLayer =
         KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(image->root());
 
     const bool needsDecorationsWrapper =
             gridConfig.showGrid() || (guidesConfig.showGuides() && guidesConfig.hasGuides()) || !assistants.isEmpty();
 
     struct SyncDecorationsWrapperStroke : public KisSimpleStrokeStrategy {
         SyncDecorationsWrapperStroke(KisDocument *document, bool needsDecorationsWrapper)
-            : KisSimpleStrokeStrategy("sync-decorations-wrapper", kundo2_noi18n("start-isolated-mode")),
+            : KisSimpleStrokeStrategy(QLatin1String("sync-decorations-wrapper"),
+                                      kundo2_noi18n("start-isolated-mode")),
               m_document(document),
               m_needsDecorationsWrapper(needsDecorationsWrapper)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             KisDecorationsWrapperLayerSP decorationsLayer =
                 KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(m_document->image()->root());
 
             if (m_needsDecorationsWrapper && !decorationsLayer) {
                 m_document->image()->addNode(new KisDecorationsWrapperLayer(m_document));
             } else if (!m_needsDecorationsWrapper && decorationsLayer) {
                 m_document->image()->removeNode(decorationsLayer);
             }
         }
 
     private:
         KisDocument *m_document = 0;
         bool m_needsDecorationsWrapper = false;
     };
 
     KisStrokeId id = image->startStroke(new SyncDecorationsWrapperStroke(q, needsDecorationsWrapper));
     image->endStroke(id);
 }
 
 void KisDocument::Private::copyFrom(const Private &rhs, KisDocument *q)
 {
     copyFromImpl(rhs, q, KisDocument::REPLACE);
 }
 
 void KisDocument::Private::copyFromImpl(const Private &rhs, KisDocument *q, KisDocument::CopyPolicy policy)
 {
     if (policy == REPLACE) {
         delete docInfo;
     }
     docInfo = (new KoDocumentInfo(*rhs.docInfo, q));
     unit = rhs.unit;
     mimeType = rhs.mimeType;
     outputMimeType = rhs.outputMimeType;
 
     if (policy == REPLACE) {
         q->setGuidesConfig(rhs.guidesConfig);
         q->setMirrorAxisConfig(rhs.mirrorAxisConfig);
         q->setModified(rhs.modified);
         q->setAssistants(KisPaintingAssistant::cloneAssistantList(rhs.assistants));
         q->setGridConfig(rhs.gridConfig);
     } else {
         // in CONSTRUCT mode, we cannot use the functions of KisDocument
         // because KisDocument does not yet have a pointer to us.
         guidesConfig = rhs.guidesConfig;
         mirrorAxisConfig = rhs.mirrorAxisConfig;
         modified = rhs.modified;
         assistants = KisPaintingAssistant::cloneAssistantList(rhs.assistants);
         gridConfig = rhs.gridConfig;
     }
     m_bAutoDetectedMime = rhs.m_bAutoDetectedMime;
     m_url = rhs.m_url;
     m_file = rhs.m_file;
     readwrite = rhs.readwrite;
     firstMod = rhs.firstMod;
     lastMod = rhs.lastMod;
     // XXX: the display properties will be shared between different snapshots
     globalAssistantsColor = rhs.globalAssistantsColor;
 
     if (policy == REPLACE) {
         QList<KoColorSet *> newPaletteList = clonePaletteList(rhs.paletteList);
         q->setPaletteList(newPaletteList, /* emitSignal = */ true);
         // we still do not own palettes if we did not
     } else {
         paletteList = rhs.paletteList;
     }
 
     batchMode = rhs.batchMode;
 }
 
 QList<KoColorSet *> KisDocument::Private::clonePaletteList(const QList<KoColorSet *> &oldList)
 {
     QList<KoColorSet *> newList;
     Q_FOREACH (KoColorSet *palette, oldList) {
         newList << new KoColorSet(*palette);
     }
     return newList;
 }
 
 class KisDocument::Private::StrippedSafeSavingLocker {
 public:
     StrippedSafeSavingLocker(QMutex *savingMutex, KisImageSP image)
         : m_locked(false)
         , m_image(image)
         , m_savingLock(savingMutex)
         , m_imageLock(image, true)
 
     {
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
 
         if (!m_locked) {
             m_image->requestStrokeEnd();
             QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
             // one more try...
             m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
         }
     }
 
     ~StrippedSafeSavingLocker() {
         if (m_locked) {
             m_imageLock.unlock();
             m_savingLock.unlock();
         }
     }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     bool m_locked;
     KisImageSP m_image;
     StdLockableWrapper<QMutex> m_savingLock;
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument()
     : d(new Private(this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(newObjectName());
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->shapeController = new KisShapeController(this, d->nserver);
     d->koShapeController = new KoShapeController(0, d->shapeController);
     d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, this))
 {
     copyFromDocumentImpl(rhs, CONSTRUCT);
 }
 
 KisDocument::~KisDocument()
 {
     // wait until all the pending operations are in progress
     waitForSavingToComplete();
 
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer->disconnect(this);
     d->autoSaveTimer->stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
 
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
 
     if (d->ownsPaletteList) {
         qDeleteAll(d->paletteList);
     }
 
     delete d;
 }
 
 bool KisDocument::reload()
 {
     // XXX: reimplement!
     return false;
 }
 
 KisDocument *KisDocument::clone()
 {
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentImpl(const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration)
 {
     QFileInfo filePathInfo(job.filePath);
 
     if (filePathInfo.exists() && !filePathInfo.isWritable()) {
         slotCompleteSavingDocument(job, ImportExportCodes::NoAccessToWrite,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         //return ImportExportCodes::NoAccessToWrite;
         return false;
     }
 
     KisConfig cfg(true);
     if (cfg.backupFile() && filePathInfo.exists()) {
 
         QString backupDir;
 
         switch(cfg.readEntry<int>("backupfilelocation", 0)) {
         case 1:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
             break;
         case 2:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
             break;
         default:
             // Do nothing: the empty string is user file location
             break;
         }
 
         int numOfBackupsKept = cfg.readEntry<int>("numberofbackupfiles", 1);
         QString suffix = cfg.readEntry<QString>("backupfilesuffix", "~");
 
         if (numOfBackupsKept == 1) {
             if (!KBackup::simpleBackupFile(job.filePath, backupDir, suffix)) {
                 qWarning() << "Failed to create simple backup file!" << job.filePath << backupDir << suffix;
                 KisUsageLogger::log(QString("Failed to create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
                 return false;
             }
             else {
                 KisUsageLogger::log(QString("Create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
             }
         }
         else if (numOfBackupsKept > 2) {
             if (!KBackup::numberedBackupFile(job.filePath, backupDir, suffix, numOfBackupsKept)) {
                 qWarning() << "Failed to create numbered backup file!" << job.filePath << backupDir << suffix;
                 KisUsageLogger::log(QString("Failed to create a numbered backup for %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
                 return false;
             }
             else {
                 KisUsageLogger::log(QString("Create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
             }
         }
     }
 
     //KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
     if (job.mimeType.isEmpty()) {
 
         KisImportExportErrorCode error = ImportExportCodes::FileFormatIncorrect;
         slotCompleteSavingDocument(job, error, error.errorMessage());
         return false;
 
     }
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportErrorCode ,QString)),
                                    job, exportConfiguration);
     if (!started) {
         emit canceled(QString());
     }
 
     return started;
 }
 
 bool KisDocument::exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     SaveFlags flags = SaveIsExporting;
     if (showWarnings) {
         flags |= SaveShowWarnings;
     }
 
     KisUsageLogger::log(QString("Exporting Document: %1 as %2. %3 * %4 pixels, %5 layers, %6 frames, %7 framerate. Export configuration: %8")
                         .arg(url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration"));
 
     return exportDocumentImpl(KritaUtils::ExportFileJob(url.toLocalFile(),
                                                         mimeType,
                                                         flags),
                               exportConfiguration);
 
 }
 
 bool KisDocument::saveAs(const QUrl &_url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     KisUsageLogger::log(QString("Saving Document %9 as %1 (mime: %2). %3 * %4 pixels, %5 layers.  %6 frames, %7 framerate. Export configuration: %8")
                         .arg(_url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration")
                         .arg(url().toLocalFile()));
 
 
     return exportDocumentImpl(ExportFileJob(_url.toLocalFile(),
                                             mimeType,
                                             showWarnings ? SaveShowWarnings : SaveNone),
                               exportConfiguration);
 }
 
 bool KisDocument::save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     return saveAs(url(), mimeType(), showWarnings, exportConfiguration);
 }
 
 QByteArray KisDocument::serializeToNativeByteArray()
 {
     QByteArray byteArray;
     QBuffer buffer(&byteArray);
 
     QScopedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(nativeFormatMimeType(), KisImportExportManager::Export));
     filter->setBatchMode(true);
     filter->setMimeType(nativeFormatMimeType());
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return byteArray;
     }
 
     d->savingImage = d->image;
 
     if (!filter->convert(this, &buffer).isOk()) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage)
 {
     if (status.isCancelled())
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during saving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
 
         if (!fileBatchMode()) {
             const QString filePath = job.filePath;
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, exportErrorToUserMessage(status, errorMessage)));
         }
     } else {
         if (!(job.flags & KritaUtils::SaveIsExporting)) {
             const QString existingAutoSaveBaseName = localFilePath();
             const bool wasRecovered = isRecovered();
 
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 /**
                  * If undo stack is already clean/empty, it doesn't emit any
                  * signals, so we might forget update document modified state
                  * (which was set, e.g. while recovering an autosave file)
                  */
 
                 if (d->undoStack->isClean()) {
                     setModified(false);
                 } else {
                     d->undoStack->setClean();
                 }
             }
             setRecovered(false);
             removeAutoSaveFiles(existingAutoSaveBaseName, wasRecovered);
         }
 
         emit completed();
         emit sigSavingFinished();
 
         emit statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
     }
 }
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->batchMode;
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->batchMode = batchMode;
 }
 
 KisDocument* KisDocument::lockAndCloneForSaving()
 {
     // force update of all the asynchronous nodes before cloning
     QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
     KisLayerUtils::forceAllDelayedNodesUpdate(d->image->root());
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             if (!window->viewManager()->blockUntilOperationsFinished(d->image)) {
                 return 0;
             }
         }
     }
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return 0;
     }
 
     return new KisDocument(*this);
 }
 
 KisDocument *KisDocument::lockAndCreateSnapshot()
 {
     KisDocument *doc = lockAndCloneForSaving();
     if (doc) {
         // clone palette list
         doc->d->paletteList = doc->d->clonePaletteList(doc->d->paletteList);
         doc->d->ownsPaletteList = true;
     }
     return doc;
 }
 
 void KisDocument::copyFromDocument(const KisDocument &rhs)
 {
     copyFromDocumentImpl(rhs, REPLACE);
 }
 
 void KisDocument::copyFromDocumentImpl(const KisDocument &rhs, CopyPolicy policy)
 {
     if (policy == REPLACE) {
         d->copyFrom(*(rhs.d), this);
 
         d->undoStack->clear();
     } else {
         // in CONSTRUCT mode, d should be already initialized
         connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
         connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
         connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
 
         d->shapeController = new KisShapeController(this, d->nserver);
         d->koShapeController = new KoShapeController(0, d->shapeController);
         d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
     }
 
     setObjectName(rhs.objectName());
 
     slotConfigChanged();
 
     if (rhs.d->image) {
         if (policy == REPLACE) {
             d->image->barrierLock(/* readOnly = */ false);
             rhs.d->image->barrierLock(/* readOnly = */ true);
             d->image->copyFromImage(*(rhs.d->image));
             d->image->unlock();
             rhs.d->image->unlock();
             setCurrentImage(d->image, /* forceInitialUpdate = */ true);
         } else {
             // clone the image with keeping the GUIDs of the layers intact
             // NOTE: we expect the image to be locked!
             setCurrentImage(rhs.image()->clone(/* exactCopy = */ true), /* forceInitialUpdate = */ false);
         }
     }
 
     if (rhs.d->preActivatedNode) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.d->image->root(),
                                            [&linearizedNodes](KisNodeSP node) {
                                                linearizedNodes.enqueue(node);
                                            });
         KisLayerUtils::recursiveApplyNodes(d->image->root(),
                                            [&linearizedNodes, &rhs, this](KisNodeSP node) {
                                                KisNodeSP refNode = linearizedNodes.dequeue();
                                                if (rhs.d->preActivatedNode.data() == refNode.data()) {
                                                    d->preActivatedNode = node;
                                                }
                                            });
     }
 
     // reinitialize references' signal connection
     KisReferenceImagesLayerSP referencesLayer = this->referenceImagesLayer();
     setReferenceImagesLayer(referencesLayer, false);
 
     KisDecorationsWrapperLayerSP decorationsLayer =
         KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(d->image->root());
     if (decorationsLayer) {
         decorationsLayer->setDocument(this);
     }
 
 
     if (policy == REPLACE) {
         setModified(true);
     }
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     {
 
         /**
          * The caller guarantees that no one else uses the document (usually,
          * it is a temporary document created specifically for exporting), so
          * we don't need to copy or lock the document. Instead we should just
          * ensure the barrier lock is synced and then released.
          */
         Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
         if (!locker.successfullyLocked()) {
             return false;
         }
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportErrorCode status =
             d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status.isOk();
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration)
 {
     return initiateSavingInBackground(actionName, receiverObject, receiverMethod,
                                       job, exportConfiguration, std::unique_ptr<KisDocument>());
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration,
                                              std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     KIS_ASSERT_RECOVER_RETURN_VALUE(job.isValid(), false);
 
     QScopedPointer<KisDocument> clonedDocument;
 
     if (!optionalClonedDocument) {
         clonedDocument.reset(lockAndCloneForSaving());
     } else {
         clonedDocument.reset(optionalClonedDocument.release());
     }
 
     // we block saving until the current saving is finished!
     if (!clonedDocument || !d->savingMutex.tryLock()) {
         return false;
     }
 
     auto waitForImage = [] (KisImageSP image) {
         KisMainWindow *window = KisPart::instance()->currentMainwindow();
         if (window) {
             if (window->viewManager()) {
                 window->viewManager()->blockUntilOperationsFinishedForced(image);
             }
         }
     };
 
     {
         KisNodeSP newRoot = clonedDocument->image()->root();
         KIS_SAFE_ASSERT_RECOVER(!KisLayerUtils::hasDelayedNodeWithUpdates(newRoot)) {
             KisLayerUtils::forceAllDelayedNodesUpdate(newRoot);
             waitForImage(clonedDocument->image());
         }
     }
 
+    if (clonedDocument->image()->hasOverlaySelectionMask()) {
+        clonedDocument->image()->setOverlaySelectionMask(0);
+        waitForImage(clonedDocument->image());
+    }
+
     KIS_SAFE_ASSERT_RECOVER(clonedDocument->image()->isIdle()) {
         waitForImage(clonedDocument->image());
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveDocument, false);
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveJob.isValid(), false);
     d->backgroundSaveDocument.reset(clonedDocument.take());
     d->backgroundSaveJob = job;
     d->modifiedWhileSaving = false;
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = true;
     }
 
     connect(d->backgroundSaveDocument.data(),
             SIGNAL(sigBackgroundSavingFinished(KisImportExportErrorCode, QString)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportErrorCode, QString)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString)),
             receiverObject, receiverMethod, Qt::UniqueConnection);
 
     bool started =
             d->backgroundSaveDocument->startExportInBackground(actionName,
                                                                job.filePath,
                                                                job.filePath,
                                                                job.mimeType,
                                                                job.flags & KritaUtils::SaveShowWarnings,
                                                                exportConfiguration);
 
     if (!started) {
         // the state should have been deinitialized in slotChildCompletedSavingInBackground()
 
         KIS_SAFE_ASSERT_RECOVER (!d->backgroundSaveDocument && !d->backgroundSaveJob.isValid()) {
             d->backgroundSaveDocument.take()->deleteLater();
             d->savingMutex.unlock();
             d->backgroundSaveJob = KritaUtils::ExportFileJob();
         }
     }
 
     return started;
 }
 
 
 void KisDocument::slotChildCompletedSavingInBackground(KisImportExportErrorCode status, const QString &errorMessage)
 {
     KIS_ASSERT_RECOVER_RETURN(isSaving());
 
     KIS_ASSERT_RECOVER(d->backgroundSaveDocument) {
         d->savingMutex.unlock();
         return;
     }
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
 
     KIS_ASSERT_RECOVER(d->backgroundSaveJob.isValid()) {
         d->savingMutex.unlock();
         return;
     }
 
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     // unlock at the very end
     d->savingMutex.unlock();
 
 
     QFileInfo fi(job.filePath);
     KisUsageLogger::log(QString("Completed saving %1 (mime: %2). Result: %3. Size: %4. MD5 Hash: %5")
                         .arg(job.filePath)
                         .arg(QString::fromLatin1(job.mimeType))
                         .arg(!status.isOk() ? exportErrorToUserMessage(status, errorMessage) : "OK")
                         .arg(fi.size())
                         .arg(QString::fromLatin1(KoMD5Generator().generateHash(job.filePath).toHex())));
 
     emit sigCompleteBackgroundSaving(job, status, errorMessage);
 }
 
 void KisDocument::slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     if (!d->modified || !d->modifiedAfterAutosave) return;
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     emit statusBarMessage(i18n("Autosaving... %1", autoSaveFileName), successMessageTimeout);
 
     KisUsageLogger::log(QString("Autosaving: %1").arg(autoSaveFileName));
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString)),
                                              KritaUtils::ExportFileJob(autoSaveFileName, nativeFormatMimeType(), KritaUtils::SaveIsExporting | KritaUtils::SaveInAutosaveMode),
                                              0,
                                              std::move(optionalClonedDocument));
     } else {
         emit statusBarMessage(i18n("Autosaving postponed: document is busy..."), errorMessageTimeout);
     }
 
     if (!started && !hadClonedDocument && d->autoSaveFailureCount >= 3) {
         KisCloneDocumentStroke *stroke = new KisCloneDocumentStroke(this);
         connect(stroke, SIGNAL(sigDocumentCloned(KisDocument*)),
                 this, SLOT(slotInitiateAsyncAutosaving(KisDocument*)),
                 Qt::BlockingQueuedConnection);
 
         KisStrokeId strokeId = d->image->startStroke(stroke);
         d->image->endStroke(strokeId);
 
         setInfiniteAutoSaveInterval();
 
     } else if (!started) {
         setEmergencyAutoSaveInterval();
     } else {
         d->modifiedAfterAutosave = false;
     }
 }
 
 void KisDocument::slotAutoSave()
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>());
 }
 
 void KisDocument::slotInitiateAsyncAutosaving(KisDocument *clonedDocument)
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>(clonedDocument));
 }
 
 void KisDocument::slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         setEmergencyAutoSaveInterval();
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during autosaving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
     } else {
         KisConfig cfg(true);
         d->autoSaveDelay = cfg.autoSaveInterval();
 
         if (!d->modifiedWhileSaving) {
             d->autoSaveTimer->stop(); // until the next change
             d->autoSaveFailureCount = 0;
         } else {
             setNormalAutoSaveInterval();
         }
 
         emit statusBarMessage(i18n("Finished autosaving %1", fileName), successMessageTimeout);
     }
 }
 
 bool KisDocument::startExportInBackground(const QString &actionName,
                                           const QString &location,
                                           const QString &realLocation,
                                           const QByteArray &mimeType,
                                           bool showWarnings,
                                           KisPropertiesConfigurationSP exportConfiguration)
 {
     d->savingImage = d->image;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             d->savingUpdater = window->viewManager()->createThreadedUpdater(actionName);
             d->importExportManager->setUpdater(d->savingUpdater);
         }
     }
 
     KisImportExportErrorCode initializationStatus(ImportExportCodes::OK);
     d->childSavingFuture =
             d->importExportManager->exportDocumentAsyc(location,
                                                        realLocation,
                                                        mimeType,
                                                        initializationStatus,
                                                        showWarnings,
                                                        exportConfiguration);
 
     if (!initializationStatus.isOk()) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, initializationStatus.errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportErrorCode> StatusWatcher;
     StatusWatcher *watcher = new StatusWatcher();
     watcher->setFuture(d->childSavingFuture);
 
     connect(watcher, SIGNAL(finished()), SLOT(finishExportInBackground()));
     connect(watcher, SIGNAL(finished()), watcher, SLOT(deleteLater()));
 
     return true;
 }
 
 void KisDocument::finishExportInBackground()
 {
     KIS_SAFE_ASSERT_RECOVER(d->childSavingFuture.isFinished()) {
         emit sigBackgroundSavingFinished(ImportExportCodes::InternalError, "");
         return;
     }
 
    KisImportExportErrorCode status =
             d->childSavingFuture.result();
     const QString errorMessage = status.errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportErrorCode>();
     d->lastErrorMessage.clear();
 
     if (d->savingUpdater) {
         d->savingUpdater->setProgress(100);
     }
 
     emit sigBackgroundSavingFinished(status, errorMessage);
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setNormalAutoSaveInterval();
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     if (isReadWrite() && delay > 0) {
         d->autoSaveTimer->start(delay * 1000);
     } else {
         d->autoSaveTimer->stop();
     }
 }
 
 void KisDocument::setNormalAutoSaveInterval()
 {
     setAutoSaveDelay(d->autoSaveDelay);
     d->autoSaveFailureCount = 0;
 }
 
 void KisDocument::setEmergencyAutoSaveInterval()
 {
     const int emergencyAutoSaveInterval = 10; /* sec */
     setAutoSaveDelay(emergencyAutoSaveInterval);
     d->autoSaveFailureCount++;
 }
 
 void KisDocument::setInfiniteAutoSaveInterval()
 {
     setAutoSaveDelay(-1);
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
     QString prefix = KisConfig(true).readEntry<bool>("autosavefileshidden") ? QString(".") : QString();
     QRegularExpression autosavePattern1("^\\..+-autosave.kra$");
     QRegularExpression autosavePattern2("^.+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern1.match(filename).hasMatch() || autosavePattern2.match(filename).hasMatch() || !fi.isWritable()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2%7%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2%7%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #endif
     } else {
         retval = QString("%1%2%5%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension).arg(prefix);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, OpenFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //qDebug() <<"asf=" << asf;
             // ## TODO compare timestamps ?
             int res = QMessageBox::warning(0,
                                            i18nc("@title:window", "Krita"),
                                            i18n("An autosaved file exists for this document.\nDo you want to open the autosaved file instead?"),
                                            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
             switch (res) {
             case QMessageBox::Yes :
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case QMessageBox::No :
                 KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened || flags & RecoveryFile) {
         setReadWrite(true); // enable save button
         setModified(true);
         setRecovered(true);
     }
     else {
         if (ret) {
 
             if (!(flags & DontAddToRecent)) {
                 KisPart::instance()->addRecentURLToAllMainWindows(_url);
             }
 
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
 
         setRecovered(false);
     }
 
     return ret;
 }
 
 class DlgLoadMessages : public KoDialog {
 public:
     DlgLoadMessages(const QString &title, const QString &message, const QStringList &warnings) {
         setWindowTitle(title);
         setWindowIcon(KisIconUtils::loadIcon("warning"));
         QWidget *page = new QWidget(this);
         QVBoxLayout *layout = new QVBoxLayout(page);
         QHBoxLayout *hlayout = new QHBoxLayout();
         QLabel *labelWarning= new QLabel();
         labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
         hlayout->addWidget(labelWarning);
         hlayout->addWidget(new QLabel(message));
         layout->addLayout(hlayout);
         QTextBrowser *browser = new QTextBrowser();
         QString warning = "<html><body><p><b>";
         if (warnings.size() == 1) {
             warning += "</b> Reason:</p>";
         }
         else {
             warning += "</b> Reasons:</p>";
         }
         warning += "<p/><ul>";
 
         Q_FOREACH(const QString &w, warnings) {
             warning += "\n<li>" + w + "</li>";
         }
         warning += "</ul>";
         browser->setHtml(warning);
         browser->setMinimumHeight(200);
         browser->setMinimumWidth(400);
         layout->addWidget(browser);
         setMainWidget(page);
         setButtons(KoDialog::Ok);
         resize(minimumSize());
     }
 };
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath()) && !fileBatchMode()) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     KoUpdaterPtr updater;
     if (window && window->viewManager()) {
         updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportErrorCode status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (!status.isOk()) {
         if (window && window->viewManager()) {
             updater->cancel();
         }
         QString msg = status.errorMessage();
         if (!msg.isEmpty() && !fileBatchMode()) {
             DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, prettyPathOrUrl()),
                                 errorMessage().split("\n") + warningMessage().split("\n"));
             dlg.exec();
         }
         return false;
     }
     else if (!warningMessage().isEmpty() && !fileBatchMode()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     d->syncDecorationsWrapperLayerState();
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 void KisDocument::autoSaveOnPause()
 {
     if (!d->modified || !d->modifiedAfterAutosave)
         return;
 
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     QUrl url("file:/" + autoSaveFileName);
     bool started = exportDocumentSync(url, nativeFormatMimeType());
 
     if (started)
     {
         d->modifiedAfterAutosave = false;
         dbgAndroid << "autoSaveOnPause successful";
     }
     else
     {
         qWarning() << "Could not auto-save when paused";
     }
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified(bool mod)
 {
     if (mod) {
         updateEditingTime(false);
     }
 
     if (d->isAutosaving)   // ignore setModified calls due to autosaving
         return;
 
     if ( !d->readwrite && d->modified ) {
         errKrita << "Can't set a read-only document to 'modified' !" << endl;
         return;
     }
 
     //dbgUI<<" url:" << url.path();
     //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
     if (mod && !d->autoSaveTimer->isActive()) {
         // First change since last autosave -> start the autosave timer
         setNormalAutoSaveInterval();
     }
     d->modifiedAfterAutosave = mod;
     d->modifiedWhileSaving = mod;
 
     if (mod == isModified())
         return;
 
     d->modified = mod;
 
     if (mod) {
         documentInfo()->updateParameters();
     }
 
     // This influences the title
     setTitleModified();
     emit modified(mod);
 }
 
 void KisDocument::setRecovered(bool value)
 {
     d->isRecovered = value;
 }
 
 bool KisDocument::isRecovered() const
 {
     return d->isRecovered;
 }
 
 void KisDocument::updateEditingTime(bool forceStoreElapsed)
 {
     QDateTime now = QDateTime::currentDateTime();
     int firstModDelta = d->firstMod.secsTo(now);
     int lastModDelta = d->lastMod.secsTo(now);
 
     if (lastModDelta > 30) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
         d->firstMod = now;
     } else if (firstModDelta > 60 || forceStoreElapsed) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
         d->firstMod = now;
     }
 
     d->lastMod = now;
 }
 
 QString KisDocument::prettyPathOrUrl() const
 {
     QString _url(url().toDisplayString());
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         _url = QDir::toNativeSeparators(_url);
     }
 #endif
     return _url;
 }
 
 // Get caption from document info (title(), in about page)
 QString KisDocument::caption() const
 {
     QString c;
     const QString _url(url().fileName());
 
     // if URL is empty...it is probably an unsaved file
     if (_url.isEmpty()) {
         c = " [" + i18n("Not Saved") + "] ";
     } else {
         c = _url; // Fall back to document URL
     }
 
     return c;
 }
 
 void KisDocument::setTitleModified()
 {
     emit titleModified(caption(), isModified());
 }
 
 QDomDocument KisDocument::createDomDocument(const QString& tagName, const QString& version) const
 {
     return createDomDocument("krita", tagName, version);
 }
 
 //static
 QDomDocument KisDocument::createDomDocument(const QString& appName, const QString& tagName, const QString& version)
 {
     QDomImplementation impl;
     QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
     QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                      QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                      url);
     // The namespace URN doesn't need to include the version number.
     QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
     QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
     doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
     return doc;
 }
 
 bool KisDocument::isNativeFormat(const QByteArray& mimetype) const
 {
     if (mimetype == nativeFormatMimeType())
         return true;
     return extraNativeMimeTypes().contains(mimetype);
 }
 
 void KisDocument::setErrorMessage(const QString& errMsg)
 {
     d->lastErrorMessage = errMsg;
 }
 
 QString KisDocument::errorMessage() const
 {
     return d->lastErrorMessage;
 }
 
 void KisDocument::setWarningMessage(const QString& warningMsg)
 {
     d->lastWarningMessage = warningMsg;
 }
 
 QString KisDocument::warningMessage() const
 {
     return d->lastWarningMessage;
 }
 
 
 void KisDocument::removeAutoSaveFiles(const QString &autosaveBaseName, bool wasRecovered)
 {
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(autosaveBaseName);   // the one in the current dir
     if (QFile::exists(asf)) {
         KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
 
     if (QFile::exists(asf)) {
         KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
         QFile::remove(asf);
     }
 
     QList<QRegularExpression> expressions;
 
     expressions << QRegularExpression("^\\..+-autosave.kra$")
                 << QRegularExpression("^.+-autosave.kra$");
 
     Q_FOREACH(const QRegularExpression &rex, expressions) {
         if (wasRecovered &&
                 !autosaveBaseName.isEmpty() &&
                 rex.match(QFileInfo(autosaveBaseName).fileName()).hasMatch() &&
                 QFile::exists(autosaveBaseName)) {
 
             KisUsageLogger::log(QString("Removing autosave file: %1").arg(autosaveBaseName));
             QFile::remove(autosaveBaseName);
         }
     }
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackCleanChanged(bool value)
 {
     setModified(!value);
 }
 
 void KisDocument::slotConfigChanged()
 {
     KisConfig cfg(true);
 
     if (d->undoStack->undoLimit() != cfg.undoStackLimit()) {
         if (!d->undoStack->isClean()) {
             d->undoStack->clear();
         }
         d->undoStack->setUndoLimit(cfg.undoStackLimit());
     }
 
     d->autoSaveDelay = cfg.autoSaveInterval();
     setNormalAutoSaveInterval();
 }
 
 void KisDocument::slotImageRootChanged()
 {
     d->syncDecorationsWrapperLayerState();
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     if (d->gridConfig != config) {
         d->gridConfig = config;
         d->syncDecorationsWrapperLayerState();
         emit sigGridConfigChanged(config);
     }
 }
 
 QList<KoColorSet *> &KisDocument::paletteList()
 {
     return d->paletteList;
 }
 
 void KisDocument::setPaletteList(const QList<KoColorSet *> &paletteList, bool emitSignal)
 {
     if (d->paletteList != paletteList) {
         QList<KoColorSet *> oldPaletteList = d->paletteList;
         d->paletteList = paletteList;
         if (emitSignal) {
             emit sigPaletteListChanged(oldPaletteList, paletteList);
         }
     }
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     d->syncDecorationsWrapperLayerState();
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 const KisMirrorAxisConfig& KisDocument::mirrorAxisConfig() const
 {
     return d->mirrorAxisConfig;
 }
 
 void KisDocument::setMirrorAxisConfig(const KisMirrorAxisConfig &config)
 {
     if (d->mirrorAxisConfig == config) {
         return;
     }
 
     d->mirrorAxisConfig = config;
     setModified(true);
 
     emit sigMirrorAxisConfigChanged();
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() ) {
         return false;
     }
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() ) {
         return false;
     }
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
 
         setUrl(d->m_url);
         ret = openFile();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, KisConfig::BackgroundStyle bgStyle,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisImageSP image;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
     image->waitForDone();
 
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     KisLayerSP layer;
     if (bgStyle == KisConfig::RASTER_LAYER || bgStyle == KisConfig::FILL_LAYER) {
         KoColor strippedAlpha = bgColor;
         strippedAlpha.setOpacity(OPACITY_OPAQUE_U8);
 
         if (bgStyle == KisConfig::RASTER_LAYER) {
             layer = new KisPaintLayer(image.data(), "Background", OPACITY_OPAQUE_U8, cs);;
             layer->paintDevice()->setDefaultPixel(strippedAlpha);
         } else if (bgStyle == KisConfig::FILL_LAYER) {
             KisFilterConfigurationSP filter_config = KisGeneratorRegistry::instance()->get("color")->defaultConfiguration();
             filter_config->setProperty("color", strippedAlpha.toQColor());
             layer = new KisGeneratorLayer(image.data(), "Background Fill", filter_config, image->globalSelection());
         }
 
         layer->setOpacity(bgColor.opacityU8());
 
         if (numberOfLayers > 1) {
             //Lock bg layer if others are present.
             layer->setUserLocked(true);
         }
     }
     else { // KisConfig::CANVAS_COLOR (needs an unlocked starting layer).
         image->setDefaultProjectionColor(bgColor);
         layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     }
 
     Q_CHECK_PTR(layer);
     image->addNode(layer.data(), image->rootLayer().data());
     layer->setDirty(QRect(0, 0, width, height));
 
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
     KisConfig cfg(false);
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
     cfg.defColorModel(image->colorSpace()->colorModelId().id());
     cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     KisUsageLogger::log(QString("Created image \"%1\", %2 * %3 pixels, %4 dpi. Color model: %6 %5 (%7). Layers: %8")
                              .arg(name)
                              .arg(width).arg(height)
                              .arg(imageResolution * 72.0)
                              .arg(image->colorSpace()->colorModelId().name())
                              .arg(image->colorSpace()->colorDepthId().name())
                              .arg(image->colorSpace()->profile()->name())
                              .arg(numberOfLayers));
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 bool KisDocument::isSaving() const
 {
     const bool result = d->savingMutex.tryLock();
     if (result) {
         d->savingMutex.unlock();
     }
     return !result;
 }
 
 void KisDocument::waitForSavingToComplete()
 {
     if (isSaving()) {
         KisAsyncActionFeedback f(i18nc("progress dialog message when the user closes the document that is being saved", "Waiting for saving to complete..."), 0);
         f.waitForMutex(&d->savingMutex);
     }
 }
 
 KoShapeControllerBase *KisDocument::shapeController() const
 {
     return d->shapeController;
 }
 
 KoShapeLayer* KisDocument::shapeForNode(KisNodeSP layer) const
 {
     return d->shapeController->shapeForNode(layer);
 }
 
 QList<KisPaintingAssistantSP> KisDocument::assistants() const
 {
     return d->assistants;
 }
 
 void KisDocument::setAssistants(const QList<KisPaintingAssistantSP> &value)
 {
     if (d->assistants != value) {
         d->assistants = value;
         d->syncDecorationsWrapperLayerState();
         emit sigAssistantsChanged();
     }
 }
 
 KisReferenceImagesLayerSP KisDocument::referenceImagesLayer() const
 {
     if (!d->image) return KisReferenceImagesLayerSP();
 
     KisReferenceImagesLayerSP referencesLayer =
         KisLayerUtils::findNodeByType<KisReferenceImagesLayer>(d->image->root());
 
     return referencesLayer;
 }
 
 void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage)
 {
     KisReferenceImagesLayerSP currentReferenceLayer = referenceImagesLayer();
 
     if (currentReferenceLayer == layer) {
         return;
     }
 
     if (currentReferenceLayer) {
         currentReferenceLayer->disconnect(this);
     }
 
     if (updateImage) {
         if (currentReferenceLayer) {
             d->image->removeNode(currentReferenceLayer);
         }
 
         if (layer) {
             d->image->addNode(layer);
         }
     }
 
     currentReferenceLayer = layer;
 
     if (currentReferenceLayer) {
         connect(currentReferenceLayer, SIGNAL(sigUpdateCanvas(QRectF)),
                 this, SIGNAL(sigReferenceImagesChanged()));
     }
 
     emit sigReferenceImagesLayerChanged(layer);
 }
 
 void KisDocument::setPreActivatedNode(KisNodeSP activatedNode)
 {
     d->preActivatedNode = activatedNode;
 }
 
 KisNodeSP KisDocument::preActivatedNode() const
 {
     return d->preActivatedNode;
 }
 
 KisImageWSP KisDocument::image() const
 {
     return d->image;
 }
 
 KisImageSP KisDocument::savingImage() const
 {
     return d->savingImage;
 }
 
 
 void KisDocument::setCurrentImage(KisImageSP image, bool forceInitialUpdate)
 {
     if (d->image) {
         // Disconnect existing sig/slot connections
         d->image->setUndoStore(new KisDumbUndoStore());
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->image->setUndoStore(new KisDocumentUndoStore(this));
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     connect(d->image, SIGNAL(sigLayersChangedAsync()), this, SLOT(slotImageRootChanged()));
 
     if (forceInitialUpdate) {
         d->image->initialRefreshGraph();
     }
 }
 
 void KisDocument::hackPreliminarySetImage(KisImageSP image)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
 }
 
 void KisDocument::setImageModified()
 {
     // we only set as modified if undo stack is not at clean state
     setModified(!d->undoStack->isClean());
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportErrorCode status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? status.errorMessage() : errorMessage;
 }
 
 void KisDocument::setAssistantsGlobalColor(QColor color)
 {
     d->globalAssistantsColor = color;
 }
 
 QColor KisDocument::assistantsGlobalColor()
 {
     return d->globalAssistantsColor;
 }
 
 QRectF KisDocument::documentBounds() const
 {
     QRectF bounds = d->image->bounds();
 
     KisReferenceImagesLayerSP referenceImagesLayer = this->referenceImagesLayer();
 
     if (referenceImagesLayer) {
         bounds |= referenceImagesLayer->boundingImageRect();
     }
 
     return bounds;
 }
diff --git a/libs/ui/KisImportExportManager.cpp b/libs/ui/KisImportExportManager.cpp
index 4dccd9f57b..69c0fcdd8c 100644
--- a/libs/ui/KisImportExportManager.cpp
+++ b/libs/ui/KisImportExportManager.cpp
@@ -1,726 +1,726 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) 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 "KisImportExportManager.h"
 
 #include <QDir>
 #include <QFile>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QList>
 #include <QApplication>
 #include <QByteArray>
 #include <QPluginLoader>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QJsonObject>
 #include <QTextBrowser>
 #include <QCheckBox>
 #include <QSaveFile>
 #include <QGroupBox>
 #include <QFuture>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 #include <ksqueezedtextlabel.h>
 #include <kpluginfactory.h>
 
 #include <KisUsageLogger.h>
 #include <KoFileDialog.h>
 #include <kis_icon_utils.h>
 #include <KoDialog.h>
 #include <KoProgressUpdater.h>
 #include <KoJsonTrader.h>
 #include <KisMimeDatabase.h>
 #include <kis_config_widget.h>
 #include <kis_debug.h>
 #include <KisPreExportChecker.h>
 #include <KisPart.h>
 #include "kis_config.h"
 #include "KisImportExportFilter.h"
 #include "KisDocument.h"
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include "kis_painter.h"
 #include "kis_guides_config.h"
 #include "kis_grid_config.h"
 #include "kis_popup_button.h"
 #include <kis_iterator_ng.h>
 #include "kis_async_action_feedback.h"
 #include "KisReferenceImagesLayer.h"
 
 // static cache for import and export mimetypes
 QStringList KisImportExportManager::m_importMimeTypes;
 QStringList KisImportExportManager::m_exportMimeTypes;
 
 class Q_DECL_HIDDEN KisImportExportManager::Private
 {
 public:
     KoUpdaterPtr updater;
 
     QString cachedExportFilterMimeType;
     QSharedPointer<KisImportExportFilter> cachedExportFilter;
 };
 
 struct KisImportExportManager::ConversionResult {
     ConversionResult()
     {
     }
 
     ConversionResult(const QFuture<KisImportExportErrorCode> &futureStatus)
         : m_isAsync(true),
           m_futureStatus(futureStatus)
     {
     }
 
     ConversionResult(KisImportExportErrorCode status)
         : m_isAsync(false),
           m_status(status)
     {
     }
 
     bool isAsync() const {
         return m_isAsync;
     }
 
     QFuture<KisImportExportErrorCode> futureStatus() const {
         // if the result is not async, then it means some failure happened,
         // just return a cancelled future
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_isAsync || !m_status.isOk());
 
         return m_futureStatus;
     }
 
     KisImportExportErrorCode status() const {
         return m_status;
     }
 
     void setStatus(KisImportExportErrorCode value) {
         m_status = value;
     }
 private:
     bool m_isAsync = false;
     QFuture<KisImportExportErrorCode> m_futureStatus;
     KisImportExportErrorCode m_status = ImportExportCodes::InternalError;
 };
 
 
 KisImportExportManager::KisImportExportManager(KisDocument* document)
     : m_document(document)
     , d(new Private)
 {
 }
 
 KisImportExportManager::~KisImportExportManager()
 {
     delete d;
 }
 
 KisImportExportErrorCode KisImportExportManager::importDocument(const QString& location, const QString& mimeType)
 {
     ConversionResult result = convert(Import, location, location, mimeType, false, 0, false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), ImportExportCodes::InternalError);
 
     return result.status();
 }
 
 KisImportExportErrorCode KisImportExportManager::exportDocument(const QString& location, const QString& realLocation, const QByteArray& mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), ImportExportCodes::InternalError);
 
     return result.status();
 }
 
 QFuture<KisImportExportErrorCode> KisImportExportManager::exportDocumentAsyc(const QString &location, const QString &realLocation, const QByteArray &mimeType,
                                                                             KisImportExportErrorCode &status, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, true);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(result.isAsync() ||
                                          !result.status().isOk(), QFuture<KisImportExportErrorCode>());
 
     status = result.status();
     return result.futureStatus();
 }
 
 // The static method to figure out to which parts of the
 // graph this mimetype has a connection to.
 QStringList KisImportExportManager::supportedMimeTypes(Direction direction)
 {
     // Find the right mimetype by the extension
     QSet<QString> mimeTypes;
     //    mimeTypes << KisDocument::nativeFormatMimeType() << "application/x-krita-paintoppreset" << "image/openraster";
 
     if (direction == KisImportExportManager::Import) {
         if (m_importMimeTypes.isEmpty()) {
             QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Import").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  import mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_importMimeTypes = mimeTypes.toList();
         }
         return m_importMimeTypes;
     }
     else if (direction == KisImportExportManager::Export) {
         if (m_exportMimeTypes.isEmpty()) {
             QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Export").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  export mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_exportMimeTypes = mimeTypes.toList();
         }
         return m_exportMimeTypes;
     }
     return QStringList();
 }
 
 KisImportExportFilter *KisImportExportManager::filterForMimeType(const QString &mimetype, KisImportExportManager::Direction direction)
 {
     int weight = -1;
     KisImportExportFilter *filter = 0;
     QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
     Q_FOREACH(QPluginLoader *loader, list) {
         QJsonObject json = loader->metaData().value("MetaData").toObject();
         QString directionKey = direction == Export ? "X-KDE-Export" : "X-KDE-Import";
         if (json.value(directionKey).toString().split(",", QString::SkipEmptyParts).contains(mimetype)) {
             KLibFactory *factory = qobject_cast<KLibFactory *>(loader->instance());
 
             if (!factory) {
                 warnUI << loader->errorString();
                 continue;
             }
 
             QObject* obj = factory->create<KisImportExportFilter>(0);
             if (!obj || !obj->inherits("KisImportExportFilter")) {
                 delete obj;
                 continue;
             }
 
             KisImportExportFilter *f = qobject_cast<KisImportExportFilter*>(obj);
             if (!f) {
                 delete obj;
                 continue;
             }
 
             int w = json.value("X-KDE-Weight").toInt();
             if (w > weight) {
                 delete filter;
                 filter = f;
                 f->setObjectName(loader->fileName());
                 weight = w;
             }
         }
     }
     qDeleteAll(list);
     if (filter) {
         filter->setMimeType(mimetype);
     }
     return filter;
 }
 
 bool KisImportExportManager::batchMode(void) const
 {
     return m_document->fileBatchMode();
 }
 
 void KisImportExportManager::setUpdater(KoUpdaterPtr updater)
 {
     d->updater = updater;
 }
 
 QString KisImportExportManager::askForAudioFileName(const QString &defaultDir, QWidget *parent)
 {
     KoFileDialog dialog(parent, KoFileDialog::ImportFiles, "ImportAudio");
 
     if (!defaultDir.isEmpty()) {
         dialog.setDefaultDir(defaultDir);
     }
 
     QStringList mimeTypes;
     mimeTypes << "audio/mpeg";
     mimeTypes << "audio/ogg";
     mimeTypes << "audio/vorbis";
     mimeTypes << "audio/vnd.wave";
     mimeTypes << "audio/flac";
 
     dialog.setMimeTypeFilters(mimeTypes);
     dialog.setCaption(i18nc("@title:window", "Open Audio"));
 
     return dialog.filename();
 }
 
 KisImportExportManager::ConversionResult KisImportExportManager::convert(KisImportExportManager::Direction direction, const QString &location, const QString& realLocation, const QString &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAsync)
 {
     // export configuration is supported for export only
     KIS_SAFE_ASSERT_RECOVER_NOOP(direction == Export || !bool(exportConfiguration));
 
     QString typeName = mimeType;
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(location, direction == KisImportExportManager::Export ? false : true);
     }
 
     QSharedPointer<KisImportExportFilter> filter;
 
     /**
      * Fetching a filter from the registry is a really expensive operation,
      * because it blocks all the threads. Cache the filter if possible.
      */
     if (direction == KisImportExportManager::Export &&
             d->cachedExportFilter &&
             d->cachedExportFilterMimeType == typeName) {
 
         filter = d->cachedExportFilter;
     } else {
 
         filter = toQShared(filterForMimeType(typeName, direction));
 
         if (direction == Export) {
             d->cachedExportFilter = filter;
             d->cachedExportFilterMimeType = typeName;
         }
     }
 
     if (!filter) {
         return KisImportExportErrorCode(ImportExportCodes::FileFormatIncorrect);
     }
 
     filter->setFilename(location);
     filter->setRealFilename(realLocation);
     filter->setBatchMode(batchMode());
     filter->setMimeType(typeName);
 
     if (!d->updater.isNull()) {
         // WARNING: The updater is not guaranteed to be persistent! If you ever want
         // to add progress reporting to "Save also as .kra", make sure you create
         // a separate KoProgressUpdater for that!
 
         // WARNING2: the failsafe completion of the updater happens in the destructor
         // the filter.
 
         filter->setUpdater(d->updater);
     }
 
     QByteArray from, to;
     if (direction == Export) {
         from = m_document->nativeFormatMimeType();
         to = typeName.toLatin1();
     }
     else {
         from = typeName.toLatin1();
         to = m_document->nativeFormatMimeType();
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(
                 direction == Import || direction == Export,
                 KisImportExportErrorCode(ImportExportCodes::InternalError)); // "bad conversion graph"
 
     ConversionResult result = KisImportExportErrorCode(ImportExportCodes::OK);
     if (direction == Import) {
 
         KisUsageLogger::log(QString("Importing %1 to %2. Location: %3. Real location: %4. Batchmode: %5")
                             .arg(QString::fromLatin1(from))
                             .arg(QString::fromLatin1(to))
                             .arg(location)
                             .arg(realLocation)
                             .arg(batchMode()));
 
 
 
         // async importing is not yet supported!
         KIS_SAFE_ASSERT_RECOVER_NOOP(!isAsync);
 
         // FIXME: Dmitry says "this progress reporting code never worked. Initial idea was to implement it his way, but I stopped and didn't finish it"
         if (0 && !batchMode()) {
             KisAsyncActionFeedback f(i18n("Opening document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doImport, this, location, filter));
         } else {
             result = doImport(location, filter);
         }
         if (result.status().isOk()) {
             KisImageSP image = m_document->image();
             KisUsageLogger::log(QString("Loaded image from %1. Size: %2 * %3 pixels, %4 dpi. Color model: %6 %5 (%7). Layers: %8")
                                 .arg(QString::fromLatin1(from))
                                 .arg(image->width())
                                 .arg(image->height())
                                 .arg(image->xRes())
                                 .arg(image->colorSpace()->colorModelId().name())
                                 .arg(image->colorSpace()->colorDepthId().name())
                                 .arg(image->colorSpace()->profile()->name())
                                 .arg(image->nlayers()));
 
 
         }
         else {
             KisUsageLogger::log(QString("Failed to load image from %1").arg(QString::fromLatin1(from)));
         }
 
     }
     else /* if (direction == Export) */ {
         if (!exportConfiguration) {
             exportConfiguration = filter->lastSavedConfiguration(from, to);
         }
 
         if (exportConfiguration) {
             fillStaticExportConfigurationProperties(exportConfiguration);
         }
 
         bool alsoAsKra = false;
         bool askUser = askUserAboutExportConfiguration(filter, exportConfiguration,
                                                        from, to,
                                                        batchMode(), showWarnings,
                                                        &alsoAsKra);
 
 
         if (!batchMode() && !askUser) {
             return KisImportExportErrorCode(ImportExportCodes::Cancelled);
         }
 
         KisUsageLogger::log(QString("Converting from %1 to %2. Location: %3. Real location: %4. Batchmode: %5. Configuration: %6")
                             .arg(QString::fromLatin1(from))
                             .arg(QString::fromLatin1(to))
                             .arg(location)
                             .arg(realLocation)
                             .arg(batchMode())
                             .arg(exportConfiguration ? exportConfiguration->toXML() : "none"));
 
 
 
         if (isAsync) {
             result = QtConcurrent::run(std::bind(&KisImportExportManager::doExport, this, location, filter, exportConfiguration, alsoAsKra));
 
             // we should explicitly report that the exporting has been initiated
             result.setStatus(ImportExportCodes::OK);
 
         } else if (!batchMode()) {
             KisAsyncActionFeedback f(i18n("Saving document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doExport, this, location, filter, exportConfiguration, alsoAsKra));
         } else {
             result = doExport(location, filter, exportConfiguration, alsoAsKra);
         }
 
-        if (exportConfiguration && !batchMode() && showWarnings) {
+        if (exportConfiguration && !batchMode()) {
             KisConfig(false).setExportConfiguration(typeName, exportConfiguration);
         }
     }
     return result;
 }
 
 void KisImportExportManager::fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration, KisImageSP image)
 {
     KisPaintDeviceSP dev = image->projection();
     const KoColorSpace* cs = dev->colorSpace();
     const bool isThereAlpha =
             KisPainter::checkDeviceHasTransparency(image->projection());
 
     exportConfiguration->setProperty(KisImportExportFilter::ImageContainsTransparencyTag, isThereAlpha);
     exportConfiguration->setProperty(KisImportExportFilter::ColorModelIDTag, cs->colorModelId().id());
     exportConfiguration->setProperty(KisImportExportFilter::ColorDepthIDTag, cs->colorDepthId().id());
 
     const bool sRGB =
             (cs->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive) &&
              !cs->profile()->name().contains(QLatin1String("g10")));
     exportConfiguration->setProperty(KisImportExportFilter::sRGBTag, sRGB);
 }
 
 
 void KisImportExportManager::fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration)
 {
     return fillStaticExportConfigurationProperties(exportConfiguration, m_document->image());
 }
 
 bool KisImportExportManager::askUserAboutExportConfiguration(
         QSharedPointer<KisImportExportFilter> filter,
         KisPropertiesConfigurationSP exportConfiguration,
         const QByteArray &from,
         const QByteArray &to,
         const bool batchMode,
         const bool showWarnings,
         bool *alsoAsKra)
 {
 
     // prevents the animation renderer from running this code
 
 
     const QString mimeUserDescription = KisMimeDatabase::descriptionForMimeType(to);
 
     QStringList warnings;
     QStringList errors;
 
     {
         KisPreExportChecker checker;
         checker.check(m_document->image(), filter->exportChecks());
 
         warnings = checker.warnings();
         errors = checker.errors();
     }
 
     KisConfigWidget *wdg = 0;
 
     if (QThread::currentThread() == qApp->thread()) {
         wdg = filter->createConfigurationWidget(0, from, to);
 
         KisMainWindow *kisMain = KisPart::instance()->currentMainwindow();
         if (wdg && kisMain) {
             KisViewManager *manager = kisMain->viewManager();
             wdg->setView(manager);
         }
     }
 
     // Extra checks that cannot be done by the checker, because the checker only has access to the image.
     if (!m_document->assistants().isEmpty() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>assistants</b>. The assistants will not be saved."));
     }
     if (m_document->referenceImagesLayer() && m_document->referenceImagesLayer()->shapeCount() > 0 && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>reference images</b>. The reference images will not be saved."));
     }
     if (m_document->guidesConfig().hasGuides() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>guides</b>. The guides will not be saved."));
     }
     if (!m_document->gridConfig().isDefault() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains a <b>custom grid configuration</b>. The configuration will not be saved."));
     }
 
     if (!batchMode && !errors.isEmpty()) {
         QString error =  "<html><body><p><b>"
                 + i18n("Error: cannot save this image as a %1.", mimeUserDescription)
                 + "</b> " + i18n("Reasons:") + "</p>"
                 + "<p/><ul>";
         Q_FOREACH(const QString &w, errors) {
             error += "\n<li>" + w + "</li>";
         }
 
         error += "</ul>";
 
         QMessageBox::critical(KisPart::instance()->currentMainwindow(), i18nc("@title:window", "Krita: Export Error"), error);
         return false;
     }
 
     if (!batchMode && (wdg || !warnings.isEmpty())) {
 
         KoDialog dlg;
 
         dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
         dlg.setWindowTitle(mimeUserDescription);
 
         QWidget *page = new QWidget(&dlg);
         QVBoxLayout *layout = new QVBoxLayout(page);
 
         if (showWarnings && !warnings.isEmpty()) {
             QHBoxLayout *hLayout = new QHBoxLayout();
 
             QLabel *labelWarning = new QLabel();
             labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
             hLayout->addWidget(labelWarning);
 
             KisPopupButton *bn = new KisPopupButton(0);
 
             bn->setText(i18nc("Keep the extra space at the end of the sentence, please", "Warning: saving as %1 will lose information from your image.    ", mimeUserDescription));
 
             hLayout->addWidget(bn);
 
             layout->addLayout(hLayout);
 
             QTextBrowser *browser = new QTextBrowser();
             browser->setMinimumWidth(bn->width());
             bn->setPopupWidget(browser);
 
             QString warning = "<html><body><p><b>"
                     + i18n("You will lose information when saving this image as a %1.", mimeUserDescription);
 
             if (warnings.size() == 1) {
                 warning += "</b> " + i18n("Reason:") + "</p>";
             }
             else {
                 warning += "</b> " + i18n("Reasons:") + "</p>";
             }
             warning += "<p/><ul>";
 
             Q_FOREACH(const QString &w, warnings) {
                 warning += "\n<li>" + w + "</li>";
             }
 
             warning += "</ul>";
             browser->setHtml(warning);
         }
 
         if (wdg) {
             QGroupBox *box = new QGroupBox(i18n("Options"));
             QVBoxLayout *boxLayout = new QVBoxLayout(box);
             wdg->setConfiguration(exportConfiguration);
             boxLayout->addWidget(wdg);
             layout->addWidget(box);
         }
 
         QCheckBox *chkAlsoAsKra = 0;
         if (showWarnings && !warnings.isEmpty()) {
             chkAlsoAsKra = new QCheckBox(i18n("Also save your image as a Krita file."));
             chkAlsoAsKra->setChecked(KisConfig(true).readEntry<bool>("AlsoSaveAsKra", false));
             layout->addWidget(chkAlsoAsKra);
         }
 
         dlg.setMainWidget(page);
         dlg.resize(dlg.minimumSize());
 
         if (showWarnings || wdg) {
             if (!dlg.exec()) {
                 return false;
             }
         }
 
         *alsoAsKra = false;
         if (chkAlsoAsKra) {
             KisConfig(false).writeEntry<bool>("AlsoSaveAsKra", chkAlsoAsKra->isChecked());
             *alsoAsKra = chkAlsoAsKra->isChecked();
         }
 
         if (wdg) {
             *exportConfiguration = *wdg->configuration();
         }
     }
 
     return true;
 }
 
 KisImportExportErrorCode KisImportExportManager::doImport(const QString &location, QSharedPointer<KisImportExportFilter> filter)
 {
     QFile file(location);
     if (!file.exists()) {
         return ImportExportCodes::FileNotExist;
     }
 
     if (filter->supportsIO() && !file.open(QFile::ReadOnly)) {
         return KisImportExportErrorCode(KisImportExportErrorCannotRead(file.error()));
     }
 
     KisImportExportErrorCode status = filter->convert(m_document, &file, KisPropertiesConfigurationSP());
 
     if (file.isOpen()) {
         file.close();
     }
 
     return status;
 }
 
 KisImportExportErrorCode KisImportExportManager::doExport(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration, bool alsoAsKra)
 {
     KisImportExportErrorCode status =
             doExportImpl(location, filter, exportConfiguration);
 
     if (alsoAsKra && status.isOk()) {
         QString kraLocation = location + ".kra";
         QByteArray mime = m_document->nativeFormatMimeType();
         QSharedPointer<KisImportExportFilter> filter(
                     filterForMimeType(QString::fromLatin1(mime), Export));
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(filter);
 
         if (filter) {
             filter->setFilename(kraLocation);
 
             KisPropertiesConfigurationSP kraExportConfiguration =
                     filter->lastSavedConfiguration(mime, mime);
 
             status = doExportImpl(kraLocation, filter, kraExportConfiguration);
         } else {
             status = ImportExportCodes::FileFormatIncorrect;
         }
     }
 
     return status;
 }
 
 // Temporary workaround until QTBUG-57299 is fixed.
 // 02-10-2019 update: the bug is closed, but we've still seen this issue.
 //                    and without using QSaveFile the issue can still occur
 //                    when QFile::copy fails because Dropbox/Google/OneDrive
 //                    locks the target file.
 #ifndef Q_OS_WIN
 #define USE_QSAVEFILE
 #endif
 
 KisImportExportErrorCode KisImportExportManager::doExportImpl(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration)
 {
 #ifdef USE_QSAVEFILE
     QSaveFile file(location);
     file.setDirectWriteFallback(true);
     if (filter->supportsIO() && !file.open(QFile::WriteOnly)) {
 #else
     QFileInfo fi(location);
     QTemporaryFile file(QDir::tempPath() + "/.XXXXXX.kra");
     if (filter->supportsIO() && !file.open()) {
 #endif
         KisImportExportErrorCannotWrite result(file.error());
 #ifdef USE_QSAVEFILE
         file.cancelWriting();
 #endif
         return result;
     }
 
     KisImportExportErrorCode status = filter->convert(m_document, &file, exportConfiguration);
 
     if (filter->supportsIO()) {
         if (!status.isOk()) {
 #ifdef USE_QSAVEFILE
             file.cancelWriting();
 #endif
         } else {
 #ifdef USE_QSAVEFILE
             if (!file.commit()) {
                 qWarning() << "Could not commit QSaveFile";
                 status = KisImportExportErrorCannotWrite(file.error());
             }
 #else
             file.flush();
             file.close();
             QFile target(location);
             if (target.exists()) {
                 // There should already be a .kra~ backup
                 target.remove();
             }
             if (!file.copy(location)) {
                 file.setAutoRemove(false);
                 return KisImportExportErrorCannotWrite(file.error());
             }
 #endif
         }
     }
 
     // Do some minimal verification
     QString verificationResult = filter->verify(location);
     if (!verificationResult.isEmpty()) {
         status = KisImportExportErrorCode(ImportExportCodes::ErrorWhileWriting);
         m_document->setErrorMessage(verificationResult);
     }
 
 
     return status;
 
 }
 
 #include <KisMimeDatabase.h>
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index 90eb33725c..d4f1425b8a 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2764 +1,2766 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QStandardPaths>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDialog>
 #include <QDockWidget>
 #include <QIcon>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QToolButton>
 #include <KisSignalMapper.h>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 #include <QStackedWidget>
 #include <QProxyStyle>
 #include <QScreen>
 #include <QAction>
 #include <QWindow>
 #include <QScrollArea>
 
 #include <kactioncollection.h>
 #include <kactionmenu.h>
 #include <kis_debug.h>
 #include <kedittoolbar.h>
 #include <khelpmenu.h>
 #include <klocalizedstring.h>
 #include <kaboutdata.h>
 #include <kis_workspace_resource.h>
 #include <input/kis_input_manager.h>
 #include "kis_selection_manager.h"
 #include "kis_icon_utils.h"
 #include <krecentfilesaction.h>
 #include <ktoggleaction.h>
 #include <ktoolbar.h>
 #include <kmainwindow.h>
 #include <kxmlguiwindow.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <kguiitem.h>
 #include <kwindowconfig.h>
 #include <kformat.h>
 
 #include <KoResourcePaths.h>
 #include <KoToolFactoryBase.h>
 #include <KoToolRegistry.h>
 #include "KoDockFactoryBase.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoPageLayoutDialog.h>
 #include <KoPageLayoutWidget.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include "KoToolBoxDocker_p.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 #include <KoUpdater.h>
 #include <KoResourceModel.h>
 
 #ifdef Q_OS_ANDROID
 #include <KisAndroidFileManager.h>
 #endif
 
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "kis_group_layer.h"
 #include "kis_image_from_clipboard_widget.h"
 #include "kis_image.h"
 #include <KisImportExportFilter.h>
 #include "KisImportExportManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_memory_statistics_server.h"
 #include "kis_node.h"
 #include "KisOpenPane.h"
 #include "kis_paintop_box.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "KisResourceServerProvider.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_statusbar.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "thememanager.h"
 #include "kis_animation_importer.h"
 #include "dialogs/kis_dlg_import_image_sequence.h"
 #include <KisImageConfigNotifier.h>
 #include "KisWindowLayoutManager.h"
 #include <KisUndoActionsUpdateManager.h>
 #include "KisWelcomePageWidget.h"
 #include <KritaVersionWrapper.h>
 #include <kritaversion.h>
 #include "KisCanvasWindow.h"
 #include "kis_action.h"
 
 #include <mutex>
 
 class ToolDockerFactory : public KoDockFactoryBase
 {
 public:
     ToolDockerFactory() : KoDockFactoryBase() { }
 
     QString id() const override {
         return "sharedtooldocker";
     }
 
     QDockWidget* createDockWidget() override {
         KoToolDocker* dockWidget = new KoToolDocker();
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 class Q_DECL_HIDDEN KisMainWindow::Private
 {
 public:
     Private(KisMainWindow *parent, QUuid id)
         : q(parent)
         , id(id)
         , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
         , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
         , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
         , workspaceMenu(new KActionMenu(i18nc("@action:inmenu", "Wor&kspace"), parent))
         , welcomePage(new KisWelcomePageWidget(parent))
         , widgetStack(new QStackedWidget(parent))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new KisSignalMapper(parent))
         , documentMapper(new KisSignalMapper(parent))
     #ifdef Q_OS_ANDROID
         , fileManager(new KisAndroidFileManager(parent))
     #endif
 
     {
         if (id.isNull()) this->id = QUuid::createUuid();
 
         welcomeScroller = new QScrollArea();
         welcomeScroller->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         welcomeScroller->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         welcomeScroller->setWidget(welcomePage);
         welcomeScroller->setWidgetResizable(true);
 
         widgetStack->addWidget(welcomeScroller);
         widgetStack->addWidget(mdiArea);
         mdiArea->setTabsMovable(true);
         mdiArea->setActivationOrder(QMdiArea::ActivationHistoryOrder);
     }
 
     ~Private() {
         qDeleteAll(toolbarList);
     }
 
     KisMainWindow *q {0};
     QUuid id;
 
     KisViewManager *viewManager {0};
 
     QPointer<KisView> activeView;
 
     QList<QAction *> toolbarList;
 
     bool firstTime {true};
     bool windowSizeDirty {false};
     bool readOnly {false};
 
     KisAction *showDocumentInfo {0};
     KisAction *saveAction {0};
     KisAction *saveActionAs {0};
     //    KisAction *printAction;
     //    KisAction *printActionPreview;
     //    KisAction *exportPdf {0};
     KisAction *importAnimation {0};
     KisAction *closeAll {0};
     //    KisAction *reloadFile;
     KisAction *importFile {0};
     KisAction *exportFile {0};
     KisAction *undo {0};
     KisAction *redo {0};
     KisAction *newWindow {0};
     KisAction *close {0};
     KisAction *mdiCascade {0};
     KisAction *mdiTile {0};
     KisAction *mdiNextWindow {0};
     KisAction *mdiPreviousWindow {0};
     KisAction *toggleDockers {0};
     KisAction *toggleDockerTitleBars {0};
     KisAction *toggleDetachCanvas {0};
     KisAction *fullScreenMode {0};
     KisAction *showSessionManager {0};
 
     KisAction *expandingSpacers[2];
 
     KActionMenu *dockWidgetMenu;
     KActionMenu *windowMenu;
     KActionMenu *documentMenu;
     KActionMenu *workspaceMenu;
 
     KHelpMenu *helpMenu  {0};
 
     KRecentFilesAction *recentFiles {0};
     KoResourceModel *workspacemodel {0};
 
     QScopedPointer<KisUndoActionsUpdateManager> undoActionsUpdateManager;
 
     QString lastExportLocation;
 
     QMap<QString, QDockWidget *> dockWidgetsMap;
     QByteArray dockerStateBeforeHiding;
     KoToolDocker *toolOptionsDocker {0};
 
     QCloseEvent *deferredClosingEvent {0};
 
     Digikam::ThemeManager *themeManager {0};
 
     QScrollArea *welcomeScroller {0};
     KisWelcomePageWidget *welcomePage {0};
 
 
     QStackedWidget *widgetStack {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     KisSignalMapper *windowMapper;
     KisSignalMapper *documentMapper;
     KisCanvasWindow *canvasWindow {0};
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
     KisSignalAutoConnectionsStore screenConnectionsStore;
 
 #ifdef Q_OS_ANDROID
     KisAndroidFileManager *fileManager;
 #endif
 
     KisActionManager * actionManager() {
         return viewManager->actionManager();
     }
 
     QTabBar* findTabBarHACK() {
         QObjectList objects = mdiArea->children();
         Q_FOREACH (QObject *object, objects) {
             QTabBar *bar = qobject_cast<QTabBar*>(object);
             if (bar) {
                 return bar;
             }
         }
         return 0;
     }
 };
 
 KisMainWindow::KisMainWindow(QUuid uuid)
     : KXmlGuiWindow()
     , d(new Private(this, uuid))
 {
     auto rserver = KisResourceServerProvider::instance()->workspaceServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter(new KoResourceServerAdapter<KisWorkspaceResource>(rserver));
     d->workspacemodel = new KoResourceModel(adapter, this);
     connect(d->workspacemodel, &KoResourceModel::afterResourcesLayoutReset, this, [&]() { updateWindowMenu(); });
 
 
     d->viewManager = new KisViewManager(this, actionCollection());
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
 
     d->windowStateConfig = KSharedConfig::openConfig()->group("MainWindow");
 
     setStandardToolBarMenuEnabled(true);
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
     setDockNestingEnabled(true);
 
     qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
 #ifdef Q_OS_MACOS
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
     connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
     connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
     connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
     connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
     actionCollection()->addAssociatedWidget(this);
     KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager, false);
 
     // Load the per-application plugins (Right now, only Python) We do this only once, when the first mainwindow is being created.
     KoPluginLoader::instance()->load("Krita/ApplicationPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), qApp, true);
 
     KoToolBoxFactory toolBoxFactory;
     QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
     toolbox->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 
     KisConfig cfg(true);
     if (cfg.toolOptionsInDocker()) {
         ToolDockerFactory toolDockerFactory;
         d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
         d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
     }
 
     QMap<QString, QAction*> dockwidgetActions;
     dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
     Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
         KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
         QDockWidget *dw = createDockWidget(factory);
         dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
     }
 
     if (d->toolOptionsDocker) {
         dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
     }
     connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*,QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*,QList<QPointer<QWidget> >)));
 
     Q_FOREACH (QString title, dockwidgetActions.keys()) {
         d->dockWidgetMenu->addAction(dockwidgetActions[title]);
     }
 
     Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
         if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
             wdg->setVisible(true);
         }
     }
 
     Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
         observer->setObservedCanvas(0);
         KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
         if (mainwindowObserver) {
             mainwindowObserver->setViewManager(d->viewManager);
         }
     }
 
     // Load all the actions from the tool plugins
     Q_FOREACH(KoToolFactoryBase *toolFactory, KoToolRegistry::instance()->values()) {
         toolFactory->createActions(actionCollection());
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     // Tab close button override
     // Windows just has a black X, and Ubuntu has a dark x that is hard to read
     // just switch this icon out for all OSs so it is easier to see
     d->mdiArea->setStyleSheet("QTabBar::close-button { image: url(:/pics/broken-preset.png) }");
 
     setCentralWidget(d->widgetStack);
     d->widgetStack->setCurrentIndex(0);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
     connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     d->canvasWindow = new KisCanvasWindow(this);
     actionCollection()->addAssociatedWidget(d->canvasWindow);
 
     createActions();
 
     // the welcome screen needs to grab actions...so make sure this line goes after the createAction() so they exist
     d->welcomePage->setMainWindow(this);
 
     setAutoSaveSettings(d->windowStateConfig, false);
 
     subWindowActivated();
     updateWindowMenu();
 
     if (isHelpMenuEnabled() && !d->helpMenu) {
         // workaround for KHelpMenu (or rather KAboutData::applicationData()) internally
         // not using the Q*Application metadata ATM, which results e.g. in the bugreport wizard
         // not having the app version preset
         // fixed hopefully in KF5 5.22.0, patch pending
         QGuiApplication *app = qApp;
         KAboutData aboutData(app->applicationName(), app->applicationDisplayName(), app->applicationVersion());
         aboutData.setOrganizationDomain(app->organizationDomain().toUtf8());
         d->helpMenu = new KHelpMenu(this, aboutData, false);
         // workaround-less version:
         // d->helpMenu = new KHelpMenu(this, QString()/*unused*/, false);
 
         // The difference between using KActionCollection->addAction() is that
         // these actions do not get tied to the MainWindow.  What does this all do?
         KActionCollection *actions = d->viewManager->actionCollection();
         QAction *helpContentsAction = d->helpMenu->action(KHelpMenu::menuHelpContents);
         QAction *whatsThisAction = d->helpMenu->action(KHelpMenu::menuWhatsThis);
         QAction *reportBugAction = d->helpMenu->action(KHelpMenu::menuReportBug);
         QAction *switchLanguageAction = d->helpMenu->action(KHelpMenu::menuSwitchLanguage);
         QAction *aboutAppAction = d->helpMenu->action(KHelpMenu::menuAboutApp);
         QAction *aboutKdeAction = d->helpMenu->action(KHelpMenu::menuAboutKDE);
 
         if (helpContentsAction) {
             actions->addAction(helpContentsAction->objectName(), helpContentsAction);
         }
         if (whatsThisAction) {
             actions->addAction(whatsThisAction->objectName(), whatsThisAction);
         }
         if (reportBugAction) {
             actions->addAction(reportBugAction->objectName(), reportBugAction);
         }
         if (switchLanguageAction) {
             actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
         }
         if (aboutAppAction) {
             actions->addAction(aboutAppAction->objectName(), aboutAppAction);
         }
         if (aboutKdeAction) {
             actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
         }
 
         connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
     }
 
     // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
     QAction *helpAction = actionCollection()->action("help_contents");
     helpAction->disconnect();
     connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
 #if 0
     //check for colliding shortcuts
     QSet<QKeySequence> existingShortcuts;
     Q_FOREACH (QAction* action, actionCollection()->actions()) {
         if(action->shortcut() == QKeySequence(0)) {
             continue;
         }
         dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
         Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
         existingShortcuts.insert(action->shortcut());
     }
 #endif
 
     configChanged();
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita4.xmlgui"));
     setXMLFile(":/kxmlgui5/krita4.xmlgui");
 
     guiFactory()->addClient(this);
     connect(guiFactory(), SIGNAL(makingChanges(bool)), SLOT(slotXmlGuiMakingChanges(bool)));
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
         toolBar->setMovable(KisConfig(true).readEntry<bool>("LockAllDockerPanels", false));
 
         if (toolBar) {
             if (toolBar->objectName() == "BrushesAndStuff") {
                 toolBar->setEnabled(false);
             }
 
             KToggleAction* act = new KToggleAction(i18n("Show %1 Toolbar", toolBar->windowTitle()), this);
             actionCollection()->addAction(toolBar->objectName().toUtf8(), act);
             act->setCheckedState(KGuiItem(i18n("Hide %1 Toolbar", toolBar->windowTitle())));
             connect(act, SIGNAL(toggled(bool)), this, SLOT(slotToolbarToggled(bool)));
             act->setChecked(!toolBar->isHidden());
             toolbarList.append(act);
         } else {
             warnUI << "Toolbar list contains a " << it->metaObject()->className() << " which is not a toolbar!";
         }
     }
 
     KToolBar::setToolBarsLocked(KisConfig(true).readEntry<bool>("LockAllDockerPanels", false));
     plugActionList("toolbarlist", toolbarList);
     d->toolbarList = toolbarList;
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
     QTimer::singleShot(1000, this, SLOT(checkSanity()));
 
     {
         using namespace std::placeholders; // For _1 placeholder
         std::function<void (int)> callback(
                     std::bind(&KisMainWindow::switchTab, this, _1));
 
         d->tabSwitchCompressor.reset(
                     new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
     }
 
 
     if (cfg.readEntry("CanvasOnlyActive", false)) {
         QString currentWorkspace = cfg.readEntry<QString>("CurrentWorkspace", "Default");
         KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
         KisWorkspaceResource* workspace = rserver->resourceByName(currentWorkspace);
         if (workspace) {
             restoreWorkspace(workspace);
         }
         cfg.writeEntry("CanvasOnlyActive", false);
         menuBar()->setVisible(true);
     }
 
     this->winId(); // Ensures the native window has been created.
     QWindow *window = this->windowHandle();
     connect(window, SIGNAL(screenChanged(QScreen *)), this, SLOT(windowScreenChanged(QScreen *)));
 
 }
 
 KisMainWindow::~KisMainWindow()
 {
     //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
     //        QAction *action = qobject_cast<QAction*>(ac);
     //        if (action) {
     //        qDebug() << "<Action"
     //                 << "\n\tname=" << action->objectName()
     //                 << "\n\ticon=" << action->icon().name()
     //                 << "\n\ttext="  << action->text().replace("&", "&amp;")
     //                 << "\n\twhatsThis="  << action->whatsThis()
     //                 << "\n\ttoolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
     //                 << "\n\ticonText="  << action->iconText().replace("&", "&amp;")
     //                 << "\n\tshortcut="  << action->shortcut().toString()
     //                 << "\n\tisCheckable="  << QString((action->isChecked() ? "true" : "false"))
     //                 << "\n\tstatusTip=" << action->statusTip()
     //                 << "\n/>\n"   ;
     //        }
     //        else {
     //            dbgKrita << "Got a non-qaction:" << ac->objectName();
     //        }
     //    }
 
     // The doc and view might still exist (this is the case when closing the window)
     KisPart::instance()->removeMainWindow(this);
 
     delete d->viewManager;
     delete d;
 
 }
 
 QUuid KisMainWindow::id() const {
     return d->id;
 }
 
 void KisMainWindow::addView(KisView *view, QMdiSubWindow *subWindow)
 {
     if (d->activeView == view && !subWindow) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view, subWindow);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified()));
         connect(d->viewManager->statusBar(), SIGNAL(memoryStatusUpdated()), this, SLOT(updateCaption()));
     }
 }
 
 void KisMainWindow::notifyChildViewDestroyed(KisView *view)
 {
     /**
      * If we are the last view of the window, Qt will not activate another tab
      * before destroying tab/window. In this case we should clear all the dangling
      * pointers manually by setting the current view to null
      */
     viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
     if (view->canvasBase() == viewManager()->canvasBase()) {
         viewManager()->setCurrentView(0);
     }
 }
 
 
 void KisMainWindow::showView(KisView *imageView, QMdiSubWindow *subwin)
 {
     if (imageView && activeView() != imageView) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         if (!subwin) {
             subwin = d->mdiArea->addSubWindow(imageView);
         } else {
             subwin->setWidget(imageView);
         }
         imageView->setSubWindow(subwin);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg(true);
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
         /**
          * Hack alert!
          *
          * Here we explicitly request KoToolManager to emit all the tool
          * activation signals, to reinitialize the tool options docker.
          *
          * That is needed due to a design flaw we have in the
          * initialization procedure.  The tool in the KoToolManager is
          * initialized in KisView::setViewManager() calls, which
          * happens early enough. During this call the tool manager
          * requests KoCanvasControllerWidget to emit the signal to
          * update the widgets in the tool docker. *But* at that moment
          * of time the view is not yet connected to the main window,
          * because it happens in KisViewManager::setCurrentView a bit
          * later. This fact makes the widgets updating signals be lost
          * and never reach the tool docker.
          *
          * So here we just explicitly call the tool activation stub.
          */
 
         KoToolManager::instance()->initializeCurrentToolForCanvas();
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         // No, no, no: do not try to call this _before_ the show() has
         // been called on the view; only when that has happened is the
         // opengl context active, and very bad things happen if we tell
         // the dockers to update themselves with a view if the opengl
         // context is not active.
         setActiveView(imageView);
 
         updateWindowMenu();
         updateCaption();
     }
 }
 
 void KisMainWindow::slotPreferences()
 {
-    if (KisDlgPreferences::editPreferences()) {
+    QScopedPointer<KisDlgPreferences> dlgPreferences(new KisDlgPreferences(this));
+
+    if (!dlgPreferences->editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
         KisConfigNotifier::instance()->notifyPixelGridModeChanged();
         KisImageConfigNotifier::instance()->notifyConfigChanged();
 
         // XXX: should this be changed for the views in other windows as well?
         Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
             KisViewManager *view = qobject_cast<KisViewManager*>(koview);
             if (view) {
                 // Update the settings for all nodes -- they don't query
                 // KisConfig directly because they need the settings during
                 // compositing, and they don't connect to the config notifier
                 // because nodes are not QObjects (because only one base class
                 // can be a QObject).
                 KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                 node->updateSettings();
             }
 
         }
         updateWindowMenu();
 
         d->viewManager->showHideScrollbars();
     }
 }
 
 void KisMainWindow::slotThemeChanged()
 {
     // save theme changes instantly
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     group.writeEntry("Theme", d->themeManager->currentThemeName());
 
     // reload action icons!
     Q_FOREACH (QAction *action, actionCollection()->actions()) {
         KisIconUtils::updateIcon(action);
     }
     if (d->mdiArea) {
         d->mdiArea->setPalette(qApp->palette());
         for (int i=0; i<d->mdiArea->subWindowList().size(); i++) {
             QMdiSubWindow *window = d->mdiArea->subWindowList().at(i);
             if (window) {
                 window->setPalette(qApp->palette());
                 KisView *view = qobject_cast<KisView*>(window->widget());
                 if (view) {
                     view->slotThemeChanged(qApp->palette());
                 }
             }
         }
     }
 
     emit themeChanged();
 }
 
 bool KisMainWindow::canvasDetached() const
 {
     return centralWidget() != d->widgetStack;
 }
 
 void KisMainWindow::setCanvasDetached(bool detach)
 {
     if (detach == canvasDetached()) return;
 
     QWidget *outgoingWidget = centralWidget() ? takeCentralWidget() : nullptr;
     QWidget *incomingWidget = d->canvasWindow->swapMainWidget(outgoingWidget);
 
     if (incomingWidget) {
         setCentralWidget(incomingWidget);
     }
 
     if (detach) {
         d->canvasWindow->show();
     } else {
         d->canvasWindow->hide();
     }
 }
 
 void KisMainWindow::slotFileSelected(QString path)
 {
     QString url = path;
     if (!url.isEmpty()) {
         bool res = openDocument(QUrl::fromLocalFile(url), Import);
         if (!res) {
             warnKrita << "Loading" << url << "failed";
         }
     }
 }
 
 void KisMainWindow::slotEmptyFilePath()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The chosen file's location could not be found. Does it exist?"));
 }
 
 QWidget * KisMainWindow::canvasWindow() const
 {
     return d->canvasWindow;
 }
 
 void KisMainWindow::updateReloadFileAction(KisDocument *doc)
 {
     Q_UNUSED(doc);
     //    d->reloadFile->setEnabled(doc && !doc->url().isEmpty());
 }
 
 void KisMainWindow::setReadWrite(bool readwrite)
 {
     d->saveAction->setEnabled(readwrite);
     d->importFile->setEnabled(readwrite);
     d->readOnly = !readwrite;
     updateCaption();
 }
 
 void KisMainWindow::addRecentURL(const QUrl &url)
 {
     // Add entry to recent documents list
     // (call coming from KisDocument because it must work with cmd line, template dlg, file/open, etc.)
     if (!url.isEmpty()) {
         bool ok = true;
         if (url.isLocalFile()) {
             QString path = url.adjusted(QUrl::StripTrailingSlash).toLocalFile();
             const QStringList tmpDirs = KoResourcePaths::resourceDirs("tmp");
             for (QStringList::ConstIterator it = tmpDirs.begin() ; ok && it != tmpDirs.end() ; ++it) {
                 if (path.contains(*it)) {
                     ok = false; // it's in the tmp resource
                 }
             }
 
             const QStringList templateDirs = KoResourcePaths::findDirs("templates");
             for (QStringList::ConstIterator it = templateDirs.begin() ; ok && it != templateDirs.end() ; ++it) {
                 if (path.contains(*it)) {
                     ok = false; // it's in the templates directory.
                     break;
                 }
             }
         }
         if (ok) {
             d->recentFiles->addUrl(url);
         }
         saveRecentFiles();
 
     }
 }
 
 void KisMainWindow::saveRecentFiles()
 {
     // Save list of recent files
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 
     // Tell all windows to reload their list, after saving
     // Doesn't work multi-process, but it's a start
     Q_FOREACH (KisMainWindow *mw, KisPart::instance()->mainWindows()) {
         if (mw != this) {
             mw->reloadRecentFileList();
         }
     }
 }
 
 QList<QUrl> KisMainWindow::recentFilesUrls()
 {
     return d->recentFiles->urls();
 }
 
 void KisMainWindow::clearRecentFiles()
 {
     d->recentFiles->clear();
     d->welcomePage->populateRecentDocuments();
 }
 
 void KisMainWindow::removeRecentUrl(const QUrl &url)
 {
     d->recentFiles->removeUrl(url);
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 }
 
 void KisMainWindow::reloadRecentFileList()
 {
     d->recentFiles->loadEntries(KSharedConfig::openConfig()->group("RecentFiles"));
 }
 
 void KisMainWindow::updateCaption()
 {
     if (!d->mdiArea->activeSubWindow()) {
         updateCaption(QString(), false);
     }
     else if (d->activeView && d->activeView->document() && d->activeView->image()){
         KisDocument *doc = d->activeView->document();
 
         QString caption(doc->caption());
         if (d->readOnly) {
             caption += " [" + i18n("Write Protected") + "] ";
         }
 
         if (doc->isRecovered()) {
             caption += " [" + i18n("Recovered") + "] ";
         }
 
         // show the file size for the document
         KisMemoryStatisticsServer::Statistics m_fileSizeStats = KisMemoryStatisticsServer::instance()->fetchMemoryStatistics(d->activeView ? d->activeView->image() : 0);
 
         if (m_fileSizeStats.imageSize) {
             caption += QString(" (").append( KFormat().formatByteSize(m_fileSizeStats.imageSize)).append( ")");
         }
 
         updateCaption(caption, doc->isModified());
 
         if (!doc->url().fileName().isEmpty()) {
             d->saveAction->setToolTip(i18n("Save as %1", doc->url().fileName()));
         }
         else {
             d->saveAction->setToolTip(i18n("Save"));
         }
 
 
     }
 
 }
 
 void KisMainWindow::updateCaption(const QString &caption, bool modified)
 {
     QString versionString = KritaVersionWrapper::versionString(true);
 
     QString title = caption;
     if (!title.contains(QStringLiteral("[*]"))) { // append the placeholder so that the modified mechanism works
         title.append(QStringLiteral(" [*]"));
     }
 
     if (d->mdiArea->activeSubWindow()) {
 #if defined(KRITA_ALPHA) || defined (KRITA_BETA) || defined (KRITA_RC)
         d->mdiArea->activeSubWindow()->setWindowTitle(QString("%1: %2").arg(versionString).arg(title));
 #else
         d->mdiArea->activeSubWindow()->setWindowTitle(title);
 #endif
         d->mdiArea->activeSubWindow()->setWindowModified(modified);
     }
     else {
 #if defined(KRITA_ALPHA) || defined (KRITA_BETA) || defined (KRITA_RC)
     setWindowTitle(QString("%1: %2").arg(versionString).arg(title));
 #else
     setWindowTitle(title);
 #endif
     }
     setWindowModified(modified);
 
 
 }
 
 
 KisView *KisMainWindow::activeView() const
 {
     if (d->activeView) {
         return d->activeView;
     }
     return 0;
 }
 
 bool KisMainWindow::openDocument(const QUrl &url, OpenFlags flags)
 {
     if (!QFile(url.toLocalFile()).exists()) {
         if (!(flags & BatchMode)) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", url.url()));
         }
         d->recentFiles->removeUrl(url); //remove the file from the recent-opened-file-list
         saveRecentFiles();
         return false;
     }
     return openDocumentInternal(url, flags);
 }
 
 bool KisMainWindow::openDocumentInternal(const QUrl &url, OpenFlags flags)
 {
     if (!url.isLocalFile()) {
         qWarning() << "KisMainWindow::openDocumentInternal. Not a local file:" << url;
         return false;
     }
 
     KisDocument *newdoc = KisPart::instance()->createDocument();
 
     if (flags & BatchMode) {
         newdoc->setFileBatchMode(true);
     }
 
     d->firstTime = true;
     connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     connect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
     KisDocument::OpenFlags openFlags = KisDocument::None;
     if (flags & RecoveryFile) {
         openFlags |= KisDocument::RecoveryFile;
     }
 
     bool openRet = !(flags & Import) ? newdoc->openUrl(url, openFlags) : newdoc->importDocument(url);
 
 
     if (!openRet) {
         delete newdoc;
         return false;
     }
 
     KisPart::instance()->addDocument(newdoc);
     updateReloadFileAction(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
     return true;
 }
 
 void KisMainWindow::showDocument(KisDocument *document) {
     Q_FOREACH(QMdiSubWindow *subwindow, d->mdiArea->subWindowList()) {
         KisView *view = qobject_cast<KisView*>(subwindow->widget());
         KIS_SAFE_ASSERT_RECOVER_NOOP(view);
 
         if (view) {
             if (view->document() == document) {
                 setActiveSubWindow(subwindow);
                 return;
             }
         }
     }
 
     addViewAndNotifyLoadingCompleted(document);
 }
 
 KisView* KisMainWindow::addViewAndNotifyLoadingCompleted(KisDocument *document,
                                                          QMdiSubWindow *subWindow)
 {
     showWelcomeScreen(false); // see workaround in function header
 
     KisView *view = KisPart::instance()->createView(document, d->viewManager, this);
     addView(view, subWindow);
 
     emit guiLoadingFinished();
 
     return view;
 }
 
 QStringList KisMainWindow::showOpenFileDialog(bool isImporting)
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     dialog.setCaption(isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::installBundle(const QString &fileName) const
 {
     QFileInfo from(fileName);
     QFileInfo to(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
     if (to.exists()) {
         QFile::remove(to.canonicalFilePath());
     }
     return QFile::copy(fileName, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas, bool isExporting)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     }
     else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     if (document->isRecovered()) {
         saveas = true;
     }
 
     if (document->url().isEmpty()) {
         saveas = true;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     QByteArray nativeFormat = document->nativeFormatMimeType();
     QByteArray oldMimeFormat = document->mimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     if (!mimeFilter.contains(oldMimeFormat)) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
 
         if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
             suggestedFilename = suggestedFilename + "." + KisMimeDatabase::suffixesForMimeType(KIS_MIME_TYPE).first();
             suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
             suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
         }
 
         // force the user to choose outputMimeType
         saveas = true;
     }
 
     bool ret = false;
 
     if (document->url().isEmpty() || isExporting || saveas) {
         // if you're just File/Save As'ing to change filter options you
         // don't want to be reminded about overwriting files etc.
         bool justChangingFilterOptions = false;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
         dialog.setCaption(isExporting ? i18n("Exporting") : i18n("Saving As"));
 
         //qDebug() << ">>>>>" << isExporting << d->lastExportLocation << d->lastExportedFormat << QString::fromLatin1(document->mimeType());
 
         if (isExporting && !d->lastExportLocation.isEmpty() && !d->lastExportLocation.contains(QDir::tempPath())) {
 
             // Use the location where we last exported to, if it's set, as the opening location for the file dialog
             QString proposedPath = QFileInfo(d->lastExportLocation).absolutePath();
             // If the document doesn't have a filename yet, use the title
             QString proposedFileName = suggestedURL.isEmpty() ? document->documentInfo()->aboutInfo("title") :  QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
             // Use the last mimetype we exported to by default
             QString proposedMimeType =  d->lastExportedFormat.isEmpty() ? "" : d->lastExportedFormat;
             QString proposedExtension = KisMimeDatabase::suffixesForMimeType(proposedMimeType).first().remove("*,");
 
             // Set the default dir: this overrides the one loaded from the config file, since we're exporting and the lastExportLocation is not empty
             dialog.setDefaultDir(proposedPath + "/" + proposedFileName + "." + proposedExtension, true);
             dialog.setMimeTypeFilters(mimeFilter, proposedMimeType);
         }
         else {
             // Get the last used location for saving
             KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
             QString proposedPath = group.readEntry("SaveAs", "");
             // if that is empty, get the last used location for loading
             if (proposedPath.isEmpty()) {
                 proposedPath = group.readEntry("OpenDocument", "");
             }
             // If that is empty, too, use the Pictures location.
             if (proposedPath.isEmpty()) {
                 proposedPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
             }
             // But only use that if the suggestedUrl, that is, the document's own url is empty, otherwise
             // open the location where the document currently is.
             dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath : suggestedURL.toLocalFile(), true);
 
             // If exporting, default to all supported file types if user is exporting
             QByteArray default_mime_type = "";
             if (!isExporting) {
                 // otherwise use the document's mimetype, or if that is empty, kra, which is the savest.
                 default_mime_type = document->mimeType().isEmpty() ? nativeFormat : document->mimeType();
             }
             dialog.setMimeTypeFilters(mimeFilter, QString::fromLatin1(default_mime_type));
         }
 
         QUrl newURL = QUrl::fromUserInput(dialog.filename());
 
         if (newURL.isLocalFile()) {
             QString fn = newURL.toLocalFile();
             if (QFileInfo(fn).completeSuffix().isEmpty()) {
                 fn.append(KisMimeDatabase::suffixesForMimeType(nativeFormat).first());
                 newURL = QUrl::fromLocalFile(fn);
             }
         }
 
         if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
             QString fn = newURL.toLocalFile();
             QFileInfo info(fn);
             document->documentInfo()->setAboutInfo("title", info.completeBaseName());
         }
 
         QByteArray outputFormat = nativeFormat;
 
         QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newURL.toLocalFile(), false);
         outputFormat = outputFormatString.toLatin1();
 
 
         if (!isExporting) {
             justChangingFilterOptions = (newURL == document->url()) && (outputFormat == document->mimeType());
         }
         else {
             QString path = QFileInfo(d->lastExportLocation).absolutePath();
             QString filename = QFileInfo(document->url().toLocalFile()).completeBaseName();
             justChangingFilterOptions = (QFileInfo(newURL.toLocalFile()).absolutePath() == path)
                     && (QFileInfo(newURL.toLocalFile()).completeBaseName() == filename)
                     && (outputFormat == d->lastExportedFormat);
         }
 
         bool bOk = true;
         if (newURL.isEmpty()) {
             bOk = false;
         }
 
         if (bOk) {
             bool wantToSave = true;
 
             // don't change this line unless you know what you're doing :)
             if (!justChangingFilterOptions) {
                 if (!document->isNativeFormat(outputFormat))
                     wantToSave = true;
             }
 
             if (wantToSave) {
                 if (!isExporting) {  // Save As
                     ret = document->saveAs(newURL, outputFormat, true);
                     if (ret) {
                         dbgUI << "Successful Save As!";
                         KisPart::instance()->addRecentURLToAllMainWindows(newURL);
                         setReadWrite(true);
                     } else {
                         dbgUI << "Failed Save As!";
 
                     }
                 }
                 else { // Export
                     ret = document->exportDocument(newURL, outputFormat);
 
                     if (ret) {
                         d->lastExportLocation = newURL.toLocalFile();
                         d->lastExportedFormat = outputFormat;
                     }
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
         // We cannot "export" into the currently
         // opened document. We are not Gimp.
         KIS_ASSERT_RECOVER_NOOP(!isExporting);
 
         // be sure document has the correct outputMimeType!
         if (document->isModified()) {
             ret = document->save(true, 0);
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
         }
     }
 
     updateReloadFileAction(document);
     updateCaption();
 
     return ret;
 }
 
 void KisMainWindow::undo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->undo();
     }
 }
 
 void KisMainWindow::redo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->redo();
     }
 }
 
 void KisMainWindow::closeEvent(QCloseEvent *e)
 {
     if (hackIsSaving()) {
         e->setAccepted(false);
         return;
     }
 
     if (!KisPart::instance()->closingSession()) {
         QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
         if ((action) && (action->isChecked())) {
             action->setChecked(false);
         }
 
         // Save session when last window is closed
         if (KisPart::instance()->mainwindowCount() == 1) {
             bool closeAllowed = KisPart::instance()->closeSession();
 
             if (!closeAllowed) {
                 e->setAccepted(false);
                 return;
             }
         }
     }
 
     d->mdiArea->closeAllSubWindows();
 
     QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
     if (childrenList.isEmpty()) {
         d->deferredClosingEvent = e;
         saveWindowState(true);
         d->canvasWindow->close();
     } else {
         e->setAccepted(false);
     }
 }
 
 void KisMainWindow::saveWindowSettings()
 {
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     if (d->windowSizeDirty ) {
         dbgUI << "KisMainWindow::saveWindowSettings";
         KConfigGroup group = d->windowStateConfig;
         KWindowConfig::saveWindowSize(windowHandle(), group);
         config->sync();
         d->windowSizeDirty = false;
     }
 
     if (!d->activeView || d->activeView->document()) {
 
         // Save toolbar position into the config file of the app, under the doc's component name
         KConfigGroup group = d->windowStateConfig;
         saveMainWindowSettings(group);
 
         // Save collapsible state of dock widgets
         for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
              i != d->dockWidgetsMap.constEnd(); ++i) {
             if (i.value()->widget()) {
                 KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                 dockGroup.writeEntry("Collapsed", i.value()->widget()->isHidden());
                 dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                 dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                 dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                 dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                 dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                 dockGroup.writeEntry("height", (int) i.value()->widget()->height());
             }
         }
 
     }
 
     KSharedConfig::openConfig()->sync();
     resetAutoSaveSettings(); // Don't let KMainWindow override the good stuff we wrote down
 
 }
 
 void KisMainWindow::resizeEvent(QResizeEvent * e)
 {
     d->windowSizeDirty = true;
     KXmlGuiWindow::resizeEvent(e);
 }
 
 void KisMainWindow::setActiveView(KisView* view)
 {
     d->activeView = view;
     updateCaption();
 
     if (d->undoActionsUpdateManager) {
         d->undoActionsUpdateManager->setCurrentDocument(view ? view->document() : 0);
     }
 
     d->viewManager->setCurrentView(view);
 
     KisWindowLayoutManager::instance()->activeDocumentChanged(view->document());
 }
 
 void KisMainWindow::dragMove(QDragMoveEvent * event)
 {
     QTabBar *tabBar = d->findTabBarHACK();
 
     if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
         qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
     }
 
     if (tabBar && tabBar->isVisible()) {
         QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
         if (tabBar->rect().contains(pos)) {
             const int tabIndex = tabBar->tabAt(pos);
 
             if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                 d->tabSwitchCompressor->start(tabIndex);
             }
         } else if (d->tabSwitchCompressor->isActive()) {
             d->tabSwitchCompressor->stop();
         }
     }
 }
 
 void KisMainWindow::dragLeave()
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 void KisMainWindow::showWelcomeScreen(bool show)
 {
     d->widgetStack->setCurrentIndex(!show);
 }
 
 void KisMainWindow::slotFileNew()
 {
     const QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
 
     KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
     startupWidget->setWindowModality(Qt::WindowModal);
     startupWidget->setWindowTitle(i18n("Create new document"));
 
 
     KisConfig cfg(true);
 
     int w = cfg.defImageWidth();
     int h = cfg.defImageHeight();
     const double resolution = cfg.defImageResolution();
     const QString colorModel = cfg.defColorModel();
     const QString colorDepth = cfg.defaultColorDepth();
     const QString colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
     item.title = i18n("Custom Document");
     startupWidget->addCustomDocumentWidget(item.widget, item.title, "Custom Document", item.icon);
 
     QSize sz = KisClipboard::instance()->clipSize();
     if (sz.isValid() && sz.width() != 0 && sz.height() != 0) {
         w = sz.width();
         h = sz.height();
     }
 
     item.widget = new KisImageFromClipboard(startupWidget,
                                             w,
                                             h,
                                             resolution,
                                             colorModel,
                                             colorDepth,
                                             colorProfile,
                                             i18n("Unnamed"));
 
     item.title = i18n("Create from Clipboard");
     item.icon = "tab-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, "Create from ClipBoard", item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(QUrl)), KisPart::instance(), SLOT(openTemplate(QUrl)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
 #ifndef Q_OS_ANDROID
     QStringList urls = showOpenFileDialog(isImporting);
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             OpenFlags flags = isImporting ? Import : None;
             bool res = openDocument(QUrl::fromLocalFile(url), flags);
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 #else
     Q_UNUSED(isImporting)
 
     d->fileManager->openImportFile();
     connect(d->fileManager, SIGNAL(sigFileSelected(QString)), this, SLOT(slotFileSelected(QString)));
     connect(d->fileManager, SIGNAL(sigEmptyFilePath()), this, SLOT(slotEmptyFilePath()));
 #endif
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()), None);
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document(), false, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotExportFile()
 {
     if (saveDocument(d->activeView->document(), true, true)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotShowSessionManager() {
     KisPart::instance()->showSessionManager();
 }
 
 KoCanvasResourceProvider *KisMainWindow::resourceManager() const
 {
     return d->viewManager->canvasResourceProvider()->resourceManager();
 }
 
 int KisMainWindow::viewCount() const
 {
     return d->mdiArea->subWindowList().size();
 }
 
 const KConfigGroup &KisMainWindow::windowStateConfig() const
 {
     return d->windowStateConfig;
 }
 
 void KisMainWindow::saveWindowState(bool restoreNormalState)
 {
     if (restoreNormalState) {
         QAction *showCanvasOnly = d->viewManager->actionCollection()->action("view_show_canvas_only");
 
         if (showCanvasOnly && showCanvasOnly->isChecked()) {
             showCanvasOnly->setChecked(false);
         }
 
         d->windowStateConfig.writeEntry("ko_geometry", saveGeometry().toBase64());
         d->windowStateConfig.writeEntry("State", saveState().toBase64());
 
         if (!d->dockerStateBeforeHiding.isEmpty()) {
             restoreState(d->dockerStateBeforeHiding);
         }
 
         statusBar()->setVisible(true);
         menuBar()->setVisible(true);
 
         saveWindowSettings();
 
     } else {
         saveMainWindowSettings(d->windowStateConfig);
     }
 
 }
 
 bool KisMainWindow::restoreWorkspaceState(const QByteArray &state)
 {
     QByteArray oldState = saveState();
 
     // needed because otherwise the layout isn't correctly restored in some situations
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         dock->toggleViewAction()->setEnabled(true);
         dock->hide();
     }
 
     bool success = KXmlGuiWindow::restoreState(state);
 
     if (!success) {
         KXmlGuiWindow::restoreState(oldState);
         return false;
     }
 
     return success;
 }
 
 bool KisMainWindow::restoreWorkspace(KisWorkspaceResource *workspace)
 {
     bool success = restoreWorkspaceState(workspace->dockerState());
 
     if (activeKisView()) {
         activeKisView()->resourceProvider()->notifyLoadingWorkspace(workspace);
     }
 
     return success;
 }
 
 QByteArray KisMainWindow::borrowWorkspace(KisMainWindow *other)
 {
     QByteArray currentWorkspace = saveState();
 
     if (!d->workspaceBorrowedBy.isNull()) {
         if (other->id() == d->workspaceBorrowedBy) {
             // We're swapping our original workspace back
             d->workspaceBorrowedBy = QUuid();
             return currentWorkspace;
         } else {
             // Get our original workspace back before swapping with a third window
             KisMainWindow *borrower = KisPart::instance()->windowById(d->workspaceBorrowedBy);
             if (borrower) {
                 QByteArray originalLayout = borrower->borrowWorkspace(this);
                 borrower->restoreWorkspaceState(currentWorkspace);
 
                 d->workspaceBorrowedBy = other->id();
                 return originalLayout;
             }
         }
     }
 
     d->workspaceBorrowedBy = other->id();
     return currentWorkspace;
 }
 
 void KisMainWindow::swapWorkspaces(KisMainWindow *a, KisMainWindow *b)
 {
     QByteArray workspaceA = a->borrowWorkspace(b);
     QByteArray workspaceB = b->borrowWorkspace(a);
 
     a->restoreWorkspaceState(workspaceB);
     b->restoreWorkspaceState(workspaceA);
 }
 
 KisViewManager *KisMainWindow::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisMainWindow::slotDocumentInfo()
 {
     if (!d->activeView->document())
         return;
 
     KoDocumentInfo *docInfo = d->activeView->document()->documentInfo();
 
     if (!docInfo)
         return;
 
     KoDocumentInfoDlg *dlg = d->activeView->document()->createDocumentInfoDialog(this, docInfo);
 
     if (dlg->exec()) {
         if (dlg->isDocumentSaved()) {
             d->activeView->document()->setModified(false);
         } else {
             d->activeView->document()->setModified(true);
         }
         d->activeView->document()->setTitleModified();
     }
 
     delete dlg;
 }
 
 bool KisMainWindow::slotFileCloseAll()
 {
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         if (subwin) {
             if(!subwin->close())
                 return false;
         }
     }
 
     updateCaption();
     return true;
 }
 
 void KisMainWindow::slotFileQuit()
 {
     // Do not close while KisMainWindow has the savingEntryMutex locked, bug409395.
     // After the background saving job is initiated, KisDocument blocks closing
     // while it saves itself.
     if (hackIsSaving()) {
         return;
     }
     KisPart::instance()->closeSession();
 }
 
 void KisMainWindow::slotFilePrint()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
     applyDefaultSettings(printJob->printer());
     QPrintDialog *printDialog = activeView()->createPrintDialog( printJob, this );
     if (printDialog && printDialog->exec() == QDialog::Accepted) {
         printJob->printer().setPageMargins(0.0, 0.0, 0.0, 0.0, QPrinter::Point);
         printJob->printer().setPaperSize(QSizeF(activeView()->image()->width() / (72.0 * activeView()->image()->xRes()),
                                                 activeView()->image()->height()/ (72.0 * activeView()->image()->yRes())),
                                          QPrinter::Inch);
         printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     }
     else {
         delete printJob;
     }
     delete printDialog;
 }
 
 void KisMainWindow::slotFilePrintPreview()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
 
     /* Sets the startPrinting() slot to be blocking.
      The Qt print-preview dialog requires the printing to be completely blocking
      and only return when the full document has been printed.
      By default the KisPrintingDialog is non-blocking and
      multithreading, setting blocking to true will allow it to be used in the preview dialog */
     printJob->setProperty("blocking", true);
     QPrintPreviewDialog *preview = new QPrintPreviewDialog(&printJob->printer(), this);
     printJob->setParent(preview); // will take care of deleting the job
     connect(preview, SIGNAL(paintRequested(QPrinter*)), printJob, SLOT(startPrinting()));
     preview->exec();
     delete preview;
 }
 
 KisPrintJob* KisMainWindow::exportToPdf(QString pdfFileName)
 {
     if (!activeView())
         return 0;
 
     if (!activeView()->document())
         return 0;
 
     KoPageLayout pageLayout;
     pageLayout.width = 0;
     pageLayout.height = 0;
     pageLayout.topMargin = 0;
     pageLayout.bottomMargin = 0;
     pageLayout.leftMargin = 0;
     pageLayout.rightMargin = 0;
 
     if (pdfFileName.isEmpty()) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
         QString defaultDir = group.readEntry("SavePdfDialog");
         if (defaultDir.isEmpty())
             defaultDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
         QUrl startUrl = QUrl::fromLocalFile(defaultDir);
         KisDocument* pDoc = d->activeView->document();
         /** if document has a file name, take file name and replace extension with .pdf */
         if (pDoc && pDoc->url().isValid()) {
             startUrl = pDoc->url();
             QString fileName = startUrl.toLocalFile();
             fileName = fileName.replace( QRegExp( "\\.\\w{2,5}$", Qt::CaseInsensitive ), ".pdf" );
             startUrl = startUrl.adjusted(QUrl::RemoveFilename);
             startUrl.setPath(startUrl.path() +  fileName );
         }
 
         QPointer<KoPageLayoutDialog> layoutDlg(new KoPageLayoutDialog(this, pageLayout));
         layoutDlg->setWindowModality(Qt::WindowModal);
         if (layoutDlg->exec() != QDialog::Accepted || !layoutDlg) {
             delete layoutDlg;
             return 0;
         }
         pageLayout = layoutDlg->pageLayout();
         delete layoutDlg;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "OpenDocument");
         dialog.setCaption(i18n("Export as PDF"));
         dialog.setDefaultDir(startUrl.toLocalFile());
         dialog.setMimeTypeFilters(QStringList() << "application/pdf");
         QUrl url = QUrl::fromUserInput(dialog.filename());
 
         pdfFileName = url.toLocalFile();
         if (pdfFileName.isEmpty())
             return 0;
     }
 
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return 0;
     if (isHidden()) {
         printJob->setProperty("noprogressdialog", true);
     }
 
     applyDefaultSettings(printJob->printer());
     // TODO for remote files we have to first save locally and then upload.
     printJob->printer().setOutputFileName(pdfFileName);
     printJob->printer().setDocName(pdfFileName);
     printJob->printer().setColorMode(QPrinter::Color);
 
     if (pageLayout.format == KoPageFormat::CustomSize) {
         printJob->printer().setPaperSize(QSizeF(pageLayout.width, pageLayout.height), QPrinter::Millimeter);
     } else {
         printJob->printer().setPaperSize(KoPageFormat::printerPageSize(pageLayout.format));
     }
 
     printJob->printer().setPageMargins(pageLayout.leftMargin, pageLayout.topMargin, pageLayout.rightMargin, pageLayout.bottomMargin, QPrinter::Millimeter);
 
     switch (pageLayout.orientation) {
     case KoPageFormat::Portrait:
         printJob->printer().setOrientation(QPrinter::Portrait);
         break;
     case KoPageFormat::Landscape:
         printJob->printer().setOrientation(QPrinter::Landscape);
         break;
     }
 
     //before printing check if the printer can handle printing
     if (!printJob->canPrint()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Cannot export to the specified file"));
     }
 
     printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     return printJob;
 }
 
 void KisMainWindow::importAnimation()
 {
     if (!activeView()) return;
 
     KisDocument *document = activeView()->document();
     if (!document) return;
 
     KisDlgImportImageSequence dlg(this, document);
 
     if (dlg.exec() == QDialog::Accepted) {
         QStringList files = dlg.files();
         int firstFrame = dlg.firstFrame();
         int step = dlg.step();
 
         KoUpdaterPtr updater =
                 !document->fileBatchMode() ? viewManager()->createUnthreadedUpdater(i18n("Import frames")) : 0;
         KisAnimationImporter importer(document->image(), updater);
         KisImportExportErrorCode status = importer.import(files, firstFrame, step);
 
         if (!status.isOk() && !status.isInternalError()) {
             QString msg = status.errorMessage();
             if (!msg.isEmpty())
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not finish import animation:\n%1", msg));
         }
         activeView()->canvasBase()->refetchDataFromImage();
     }
 }
 
 void KisMainWindow::slotConfigureToolbars()
 {
     saveWindowState();
     KEditToolBar edit(factory(), this);
     connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
     (void) edit.exec();
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotNewToolbarConfig()
 {
     applyMainWindowSettings(d->windowStateConfig);
 
     KXMLGUIFactory *factory = guiFactory();
     Q_UNUSED(factory);
 
     // Check if there's an active view
     if (!d->activeView)
         return;
 
     plugActionList("toolbarlist", d->toolbarList);
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotToolbarToggled(bool toggle)
 {
     //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
     // The action (sender) and the toolbar have the same name
     KToolBar * bar = toolBar(sender()->objectName());
     if (bar) {
         if (toggle) {
             bar->show();
         }
         else {
             bar->hide();
         }
 
         if (d->activeView && d->activeView->document()) {
             saveWindowState();
         }
     } else
         warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
 }
 
 void KisMainWindow::viewFullscreen(bool fullScreen)
 {
     KisConfig cfg(false);
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 void KisMainWindow::slotReloadFile()
 {
     KisDocument* document = d->activeView->document();
     if (!document || document->url().isEmpty())
         return;
 
     if (document->isModified()) {
         bool ok = QMessageBox::question(this,
                                         i18nc("@title:window", "Krita"),
                                         i18n("You will lose all changes made since your last save\n"
                                              "Do you want to continue?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
         if (!ok)
             return;
     }
 
     QUrl url = document->url();
 
     saveWindowSettings();
     if (!document->reload()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Error: Could not reload this document"));
     }
 
     return;
 
 }
 
 QDockWidget* KisMainWindow::createDockWidget(KoDockFactoryBase* factory)
 {
     QDockWidget* dockWidget = 0;
     bool lockAllDockers = KisConfig(true).readEntry<bool>("LockAllDockerPanels", false);
 
     if (!d->dockWidgetsMap.contains(factory->id())) {
         dockWidget = factory->createDockWidget();
 
         // It is quite possible that a dock factory cannot create the dock; don't
         // do anything in that case.
         if (!dockWidget) {
             warnKrita << "Could not create docker for" << factory->id();
             return 0;
         }
 
         dockWidget->setFont(KoDockRegistry::dockFont());
         dockWidget->setObjectName(factory->id());
         dockWidget->setParent(this);
         if (lockAllDockers) {
             if (dockWidget->titleBarWidget()) {
                 dockWidget->titleBarWidget()->setVisible(false);
             }
             dockWidget->setFeatures(QDockWidget::NoDockWidgetFeatures);
         }
         if (dockWidget->widget() && dockWidget->widget()->layout())
             dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
         Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
         bool visible = true;
 
         switch (factory->defaultDockPosition()) {
         case KoDockFactoryBase::DockTornOff:
             dockWidget->setFloating(true); // position nicely?
             break;
         case KoDockFactoryBase::DockTop:
             side = Qt::TopDockWidgetArea; break;
         case KoDockFactoryBase::DockLeft:
             side = Qt::LeftDockWidgetArea; break;
         case KoDockFactoryBase::DockBottom:
             side = Qt::BottomDockWidgetArea; break;
         case KoDockFactoryBase::DockRight:
             side = Qt::RightDockWidgetArea; break;
         case KoDockFactoryBase::DockMinimized:
         default:
             side = Qt::RightDockWidgetArea;
             visible = false;
         }
 
         KConfigGroup group = d->windowStateConfig.group("DockWidget " + factory->id());
         side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
         if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
         addDockWidget(side, dockWidget);
         if (!visible) {
             dockWidget->hide();
         }
 
         d->dockWidgetsMap.insert(factory->id(), dockWidget);
     }
     else {
         dockWidget = d->dockWidgetsMap[factory->id()];
     }
 
 #ifdef Q_OS_MACOS
     dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
     dockWidget->setFont(KoDockRegistry::dockFont());
 
     connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
     return dockWidget;
 }
 
 void KisMainWindow::forceDockTabFonts()
 {
     Q_FOREACH (QObject *child, children()) {
         if (child->inherits("QTabBar")) {
             ((QTabBar *)child)->setFont(KoDockRegistry::dockFont());
         }
     }
 }
 
 QList<QDockWidget*> KisMainWindow::dockWidgets() const
 {
     return d->dockWidgetsMap.values();
 }
 
 QDockWidget* KisMainWindow::dockWidget(const QString &id)
 {
     if (!d->dockWidgetsMap.contains(id)) return 0;
     return d->dockWidgetsMap[id];
 }
 
 QList<KoCanvasObserverBase*> KisMainWindow::canvasObservers() const
 {
     QList<KoCanvasObserverBase*> observers;
 
     Q_FOREACH (QDockWidget *docker, dockWidgets()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observers << observer;
         }
         else {
             warnKrita << docker << "is not a canvas observer";
         }
     }
     return observers;
 }
 
 
 void KisMainWindow::toggleDockersVisibility(bool visible)
 {
     if (!visible) {
         d->dockerStateBeforeHiding = saveState();
 
         Q_FOREACH (QObject* widget, children()) {
             if (widget->inherits("QDockWidget")) {
                 QDockWidget* dw = static_cast<QDockWidget*>(widget);
                 if (dw->isVisible()) {
                     dw->hide();
                 }
             }
         }
     }
     else {
         restoreState(d->dockerStateBeforeHiding);
     }
 }
 
 void KisMainWindow::slotDocumentTitleModified()
 {
     updateCaption();
     updateReloadFileAction(d->activeView ? d->activeView->document() : 0);
 }
 
 
 void KisMainWindow::subWindowActivated()
 {
     bool enabled = (activeKisView() != 0);
 
     d->mdiCascade->setEnabled(enabled);
     d->mdiNextWindow->setEnabled(enabled);
     d->mdiPreviousWindow->setEnabled(enabled);
     d->mdiTile->setEnabled(enabled);
     d->close->setEnabled(enabled);
     d->closeAll->setEnabled(enabled);
 
     setActiveSubWindow(d->mdiArea->activeSubWindow());
     Q_FOREACH (QToolBar *tb, toolBars()) {
         if (tb->objectName() == "BrushesAndStuff") {
             tb->setEnabled(enabled);
         }
     }
 
     /**
      * Qt has a weirdness, it has hardcoded shortcuts added to an action
      * in the window menu. We need to reset the shortcuts for that menu
      * to nothing, otherwise the shortcuts cannot be made configurable.
      *
      * See: https://bugs.kde.org/show_bug.cgi?id=352205
      *      https://bugs.kde.org/show_bug.cgi?id=375524
      *      https://bugs.kde.org/show_bug.cgi?id=398729
      */
     QMdiSubWindow *subWindow = d->mdiArea->currentSubWindow();
     if (subWindow) {
         QMenu *menu = subWindow->systemMenu();
         if (menu && menu->actions().size() == 8) {
             Q_FOREACH (QAction *action, menu->actions()) {
                 action->setShortcut(QKeySequence());
 
             }
             menu->actions().last()->deleteLater();
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::windowFocused()
 {
     /**
      * Notify selection manager so that it could update selection mask overlay
      */
     if (viewManager() && viewManager()->selectionManager()) {
         viewManager()->selectionManager()->selectionChanged();
     }
 
     KisPart *kisPart = KisPart::instance();
     KisWindowLayoutManager *layoutManager = KisWindowLayoutManager::instance();
     if (!layoutManager->primaryWorkspaceFollowsFocus()) return;
 
     QUuid primary = layoutManager->primaryWindowId();
     if (primary.isNull()) return;
 
     if (d->id == primary) {
         if (!d->workspaceBorrowedBy.isNull()) {
             KisMainWindow *borrower = kisPart->windowById(d->workspaceBorrowedBy);
             if (!borrower) return;
             swapWorkspaces(this, borrower);
         }
     } else {
         if (d->workspaceBorrowedBy == primary) return;
 
         KisMainWindow *primaryWindow = kisPart->windowById(primary);
         if (!primaryWindow) return;
         swapWorkspaces(this, primaryWindow);
     }
 }
 
 
 void KisMainWindow::updateWindowMenu()
 {
     QMenu *menu = d->windowMenu->menu();
     menu->clear();
 
     menu->addAction(d->newWindow);
     menu->addAction(d->documentMenu);
 
     QMenu *docMenu = d->documentMenu->menu();
     docMenu->clear();
 
     QFontMetrics fontMetrics = docMenu->fontMetrics();
     int fileStringWidth = int(QApplication::desktop()->screenGeometry(this).width() * .40f);
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = fontMetrics.elidedText(doc->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth);
             if (title.isEmpty() && doc->image()) {
                 title = doc->image()->objectName();
             }
             QAction *action = docMenu->addAction(title);
             action->setIcon(qApp->windowIcon());
             connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
             d->documentMapper->setMapping(action, doc);
         }
     }
 
     menu->addAction(d->workspaceMenu);
     QMenu *workspaceMenu = d->workspaceMenu->menu();
     workspaceMenu->clear();
 
     auto workspaces = KisResourceServerProvider::instance()->workspaceServer()->resources();
     auto m_this = this;
     for (auto &w : workspaces) {
         auto action = workspaceMenu->addAction(w->name());
         connect(action, &QAction::triggered, this, [=]() {
             m_this->restoreWorkspace(w);
         });
     }
     workspaceMenu->addSeparator();
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&Import Workspace...")),
             &QAction::triggered,
             this,
             [&]() {
         QString extensions = d->workspacemodel->extensions();
         QStringList mimeTypes;
         for(const QString &suffix : extensions.split(":")) {
             mimeTypes << KisMimeDatabase::mimeTypeForSuffix(suffix);
         }
 
         KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
         dialog.setMimeTypeFilters(mimeTypes);
         dialog.setCaption(i18nc("@title:window", "Choose File to Add"));
         QString filename = dialog.filename();
 
         d->workspacemodel->importResourceFile(filename);
     });
 
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&New Workspace...")),
             &QAction::triggered,
             [=]() {
         QString name = QInputDialog::getText(this, i18nc("@title:window", "New Workspace..."),
                                              i18nc("@label:textbox", "Name:"));
         if (name.isEmpty()) return;
         auto rserver = KisResourceServerProvider::instance()->workspaceServer();
 
         KisWorkspaceResource* workspace = new KisWorkspaceResource("");
         workspace->setDockerState(m_this->saveState());
         d->viewManager->canvasResourceProvider()->notifySavingWorkspace(workspace);
         workspace->setValid(true);
         QString saveLocation = rserver->saveLocation();
 
         bool newName = false;
         if(name.isEmpty()) {
             newName = true;
             name = i18n("Workspace");
         }
         QFileInfo fileInfo(saveLocation + name + workspace->defaultFileExtension());
 
         int i = 1;
         while (fileInfo.exists()) {
             fileInfo.setFile(saveLocation + name + QString("%1").arg(i) + workspace->defaultFileExtension());
             i++;
         }
         workspace->setFilename(fileInfo.filePath());
         if(newName) {
             name = i18n("Workspace %1", i);
         }
         workspace->setName(name);
         rserver->addResource(workspace);
     });
 
     // TODO: What to do about delete?
     //    workspaceMenu->addAction(i18nc("@action:inmenu", "&Delete Workspace..."));
 
     menu->addSeparator();
     menu->addAction(d->close);
     menu->addAction(d->closeAll);
     if (d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
         menu->addSeparator();
         menu->addAction(d->mdiTile);
         menu->addAction(d->mdiCascade);
     }
     menu->addSeparator();
     menu->addAction(d->mdiNextWindow);
     menu->addAction(d->mdiPreviousWindow);
     menu->addSeparator();
 
     QList<QMdiSubWindow *> windows = d->mdiArea->subWindowList();
     for (int i = 0; i < windows.size(); ++i) {
         QPointer<KisView>child = qobject_cast<KisView*>(windows.at(i)->widget());
         if (child && child->document()) {
             QString text;
             if (i < 9) {
                 text = i18n("&%1 %2", i + 1, fontMetrics.elidedText(child->document()->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth));
             }
             else {
                 text = i18n("%1 %2", i + 1, fontMetrics.elidedText(child->document()->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth));
             }
 
             QAction *action  = menu->addAction(text);
             action->setIcon(qApp->windowIcon());
             action->setCheckable(true);
             action->setChecked(child == activeKisView());
             connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
             d->windowMapper->setMapping(action, windows.at(i));
         }
     }
 
     bool showMdiArea = windows.count( ) > 0;
     if (!showMdiArea) {
         showWelcomeScreen(true); // see workaround in function in header
         // keep the recent file list updated when going back to welcome screen
         reloadRecentFileList();
         d->welcomePage->populateRecentDocuments();
     }
 
     // enable/disable the toolbox docker if there are no documents open
     Q_FOREACH (QObject* widget, children()) {
         if (widget->inherits("QDockWidget")) {
             QDockWidget* dw = static_cast<QDockWidget*>(widget);
 
             if ( dw->objectName() == "ToolBox") {
                 dw->setEnabled(showMdiArea);
             }
         }
     }
 
     updateCaption();
 }
 
 void KisMainWindow::setActiveSubWindow(QWidget *window)
 {
     if (!window) return;
     QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
     //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
     if (subwin && subwin != d->activeSubWindow) {
         KisView *view = qobject_cast<KisView *>(subwin->widget());
         //dbgKrita << "\t" << view << activeView();
         if (view && view != activeView()) {
             d->mdiArea->setActiveSubWindow(subwin);
             setActiveView(view);
         }
         d->activeSubWindow = subwin;
     }
     updateWindowMenu();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::configChanged()
 {
     KisConfig cfg(true);
     QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
     d->mdiArea->setViewMode(viewMode);
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
         /**
          * Dirty workaround for a bug in Qt (checked on Qt 5.6.1):
          *
          * If you make a window "Show on top" and then switch to the tabbed mode
          * the window will continue to be painted in its initial "mid-screen"
          * position. It will persist here until you explicitly switch to its tab.
          */
         if (viewMode == QMdiArea::TabbedView) {
             Qt::WindowFlags oldFlags = subwin->windowFlags();
             Qt::WindowFlags flags = oldFlags;
 
             flags &= ~Qt::WindowStaysOnTopHint;
             flags &= ~Qt::WindowStaysOnBottomHint;
 
             if (flags != oldFlags) {
                 subwin->setWindowFlags(flags);
                 subwin->showMaximized();
             }
         }
 
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QString s = cfg.getMDIBackgroundColor();
     KoColor c = KoColor::fromXML(s);
     QBrush brush(c.toQColor());
     d->mdiArea->setBackground(brush);
 
     QString backgroundImage = cfg.getMDIBackgroundImage();
     if (backgroundImage != "") {
         QImage image(backgroundImage);
         QBrush brush(image);
         d->mdiArea->setBackground(brush);
     }
 
     d->mdiArea->update();
 }
 
 KisView* KisMainWindow::newView(QObject *document, QMdiSubWindow *subWindow)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc, subWindow);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     if (d->mdiArea->currentSubWindow()) {
         d->mdiArea->currentSubWindow()->close();
         d->actionManager()->updateGUI();
     }
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
         m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->resources().isEmpty()) {
         m_errorMessage = i18n("Krita cannot find any brush presets! Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 }
 
 void KisMainWindow::showErrorAndDie()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Installation error"), m_errorMessage);
     if (m_dieOnError) {
         exit(10);
     }
 }
 
 void KisMainWindow::showAboutApplication()
 {
     KisAboutApplication dlg(this);
     dlg.exec();
 }
 
 QPointer<KisView> KisMainWindow::activeKisView()
 {
     if (!d->mdiArea) return 0;
     QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
     //dbgKrita << "activeKisView" << activeSubWindow;
     if (!activeSubWindow) return 0;
     return qobject_cast<KisView*>(activeSubWindow->widget());
 }
 
 void KisMainWindow::newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > &optionWidgetList)
 {
     KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
     bool isOurOwnView = false;
 
     Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->canvasController() == controller) {
             isOurOwnView = view->mainWindow() == this;
         }
     }
 
     if (!isOurOwnView) return;
 
     Q_FOREACH (QWidget *w, optionWidgetList) {
 #ifdef Q_OS_MACOS
         w->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
         w->setFont(KoDockRegistry::dockFont());
     }
 
     if (d->toolOptionsDocker) {
         d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
     }
     else {
         d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisMainWindow::applyDefaultSettings(QPrinter &printer) {
 
     if (!d->activeView) return;
 
     QString title = d->activeView->document()->documentInfo()->aboutInfo("title");
     if (title.isEmpty()) {
         QFileInfo info(d->activeView->document()->url().fileName());
         title = info.completeBaseName();
     }
 
     if (title.isEmpty()) {
         // #139905
         title = i18n("%1 unsaved document (%2)", qApp->applicationDisplayName(),
                      QLocale().toString(QDate::currentDate(), QLocale::ShortFormat));
     }
     printer.setDocName(title);
 }
 
 void KisMainWindow::createActions()
 {
     KisActionManager *actionManager = d->actionManager();
 
 
 
     actionManager->createStandardAction(KStandardAction::New, this, SLOT(slotFileNew()));
     actionManager->createStandardAction(KStandardAction::Open, this, SLOT(slotFileOpen()));
     actionManager->createStandardAction(KStandardAction::Quit, this, SLOT(slotFileQuit()));
     actionManager->createStandardAction(KStandardAction::ConfigureToolbars, this, SLOT(slotConfigureToolbars()));
     d->fullScreenMode = actionManager->createStandardAction(KStandardAction::FullScreen, this, SLOT(viewFullscreen(bool)));
 
     d->recentFiles = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(QUrl)), actionCollection());
     connect(d->recentFiles, SIGNAL(recentListCleared()), this, SLOT(saveRecentFiles()));
     KSharedConfigPtr configPtr =  KSharedConfig::openConfig();
     d->recentFiles->loadEntries(configPtr->group("RecentFiles"));
 
     d->saveAction = actionManager->createStandardAction(KStandardAction::Save, this, SLOT(slotFileSave()));
     d->saveAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->saveActionAs = actionManager->createStandardAction(KStandardAction::SaveAs, this, SLOT(slotFileSaveAs()));
     d->saveActionAs->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     //    d->printAction = actionManager->createStandardAction(KStandardAction::Print, this, SLOT(slotFilePrint()));
     //    d->printAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     //    d->printActionPreview = actionManager->createStandardAction(KStandardAction::PrintPreview, this, SLOT(slotFilePrintPreview()));
     //    d->printActionPreview->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undo = actionManager->createStandardAction(KStandardAction::Undo, this, SLOT(undo()));
     d->undo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->redo = actionManager->createStandardAction(KStandardAction::Redo, this, SLOT(redo()));
     d->redo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undoActionsUpdateManager.reset(new KisUndoActionsUpdateManager(d->undo, d->redo));
     d->undoActionsUpdateManager->setCurrentDocument(d->activeView ? d->activeView->document() : 0);
 
     //    d->exportPdf  = actionManager->createAction("file_export_pdf");
     //    connect(d->exportPdf, SIGNAL(triggered()), this, SLOT(exportToPdf()));
 
     d->importAnimation  = actionManager->createAction("file_import_animation");
     connect(d->importAnimation, SIGNAL(triggered()), this, SLOT(importAnimation()));
 
     d->closeAll = actionManager->createAction("file_close_all");
     connect(d->closeAll, SIGNAL(triggered()), this, SLOT(slotFileCloseAll()));
 
     //    d->reloadFile  = actionManager->createAction("file_reload_file");
     //    d->reloadFile->setActivationFlags(KisAction::CURRENT_IMAGE_MODIFIED);
     //    connect(d->reloadFile, SIGNAL(triggered(bool)), this, SLOT(slotReloadFile()));
 
     d->importFile  = actionManager->createAction("file_import_file");
     connect(d->importFile, SIGNAL(triggered(bool)), this, SLOT(slotImportFile()));
 
     d->exportFile  = actionManager->createAction("file_export_file");
     connect(d->exportFile, SIGNAL(triggered(bool)), this, SLOT(slotExportFile()));
 
     /* The following entry opens the document information dialog.  Since the action is named so it
         intends to show data this entry should not have a trailing ellipses (...).  */
     d->showDocumentInfo  = actionManager->createAction("file_documentinfo");
     connect(d->showDocumentInfo, SIGNAL(triggered(bool)), this, SLOT(slotDocumentInfo()));
 
 
     d->themeManager->setThemeMenuAction(new KActionMenu(i18nc("@action:inmenu", "&Themes"), this));
     d->themeManager->registerThemeActions(actionCollection());
     connect(d->themeManager, SIGNAL(signalThemeChanged()), this, SLOT(slotThemeChanged()));
 
 
     connect(d->themeManager, SIGNAL(signalThemeChanged()), d->welcomePage, SLOT(slotUpdateThemeColors()));
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
     KisConfig(true).showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     d->toggleDetachCanvas = actionManager->createAction("view_detached_canvas");
     d->toggleDetachCanvas->setChecked(false);
     connect(d->toggleDetachCanvas, SIGNAL(toggled(bool)), SLOT(setCanvasDetached(bool)));
     setCanvasDetached(false);
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     d->mdiCascade = actionManager->createAction("windows_cascade");
     connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
     d->mdiTile = actionManager->createAction("windows_tile");
     connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
     d->mdiNextWindow = actionManager->createAction("windows_next");
     connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
     d->mdiPreviousWindow = actionManager->createAction("windows_previous");
     connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
     d->newWindow = actionManager->createAction("view_newwindow");
     connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
 
     d->close = actionManager->createStandardAction(KStandardAction::Close, this, SLOT(closeCurrentWindow()));
 
     d->showSessionManager = actionManager->createAction("file_sessions");
     connect(d->showSessionManager, SIGNAL(triggered(bool)), this, SLOT(slotShowSessionManager()));
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg = d->windowStateConfig;
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QGuiApplication::screens().at(scnum)->availableVirtualGeometry();
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to compensate for the window decs
             w = (deskWidth / 3) * 2;
             h = (desk.height() / 3) * 2;
         }
         else {
             w = desk.width();
             h = desk.height();
         }
 
         x += (desk.width() - w) / 2;
         y += (desk.height() - h) / 2;
 
         move(x,y);
         setGeometry(geometry().x(), geometry().y(), w, h);
     }
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::showManual()
 {
     QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
 }
 
 void KisMainWindow::windowScreenChanged(QScreen *screen)
 {
     emit screenChanged();
     d->screenConnectionsStore.clear();
     d->screenConnectionsStore.addConnection(screen, SIGNAL(physicalDotsPerInchChanged(qreal)),
                                             this, SIGNAL(screenChanged()));
 }
 
 void KisMainWindow::slotXmlGuiMakingChanges(bool finished)
 {
     if (finished) {
         subWindowActivated();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 0a49e9f742..064718a5c6 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1755 +1,1763 @@
 /*
  *  preferencesdlg.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 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_dlg_preferences.h"
 
 #include <config-hdr.h>
 #include <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QCursor>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSlider>
 #include <QToolButton>
 #include <QThread>
 #include <QStandardPaths>
 #include <QGroupBox>
 #include <QGridLayout>
 #include <QRadioButton>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QFormLayout>
 #include <QSettings>
 
 #include <KisDocument.h>
 #include <KoColorProfile.h>
 #include <KisApplication.h>
 #include <KoFileDialog.h>
 #include <KisPart.h>
 #include <KoColorSpaceEngine.h>
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include "KoID.h"
 #include <KoConfigAuthorPage.h>
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kformat.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 #include <kis_image.h>
 #include <KisSqueezedComboBox.h>
 #include "kis_clipboard.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorConversionTransformation.h"
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_preference_set_registry.h"
 #include "kis_color_manager.h"
 #include "KisProofingConfiguration.h"
 #include "kis_image_config.h"
 
 #include "slider_and_spin_box_sync.h"
 
 // for the performance update
 #include <kis_cubic_curve.h>
 #include <kis_signals_blocker.h>
 
 #include "input/config/kis_input_configuration_page.h"
 #include "input/wintab/drawpile_tablettester/tablettester.h"
 
 #ifdef Q_OS_WIN
 #include "config_use_qt_tablet_windows.h"
 #   ifndef USE_QT_TABLET_WINDOWS
 #       include <kis_tablet_support_win8.h>
 #   endif
 #include "config-high-dpi-scale-factor-rounding-policy.h"
 #endif
 
 struct BackupSuffixValidator : public QValidator {
     BackupSuffixValidator(QObject *parent)
         : QValidator(parent)
         , invalidCharacters(QStringList()
                             << "0" << "1" << "2" << "3" << "4" << "5" << "6" << "7" << "8" << "9"
                             << "/" << "\\" << ":" << ";" << " ")
     {}
 
     ~BackupSuffixValidator() override {}
 
     const QStringList invalidCharacters;
 
     State validate(QString &line, int &/*pos*/) const override
     {
         Q_FOREACH(const QString invalidChar, invalidCharacters) {
             if (line.contains(invalidChar)) {
                 return Invalid;
             }
         }
         return Acceptable;
     }
 };
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg(true);
 
     //
     // Cursor Tab
     //
     m_cmbCursorShape->addItem(i18n("No Cursor"));
     m_cmbCursorShape->addItem(i18n("Tool Icon"));
     m_cmbCursorShape->addItem(i18n("Arrow"));
     m_cmbCursorShape->addItem(i18n("Small Circle"));
     m_cmbCursorShape->addItem(i18n("Crosshair"));
     m_cmbCursorShape->addItem(i18n("Triangle Righthanded"));
     m_cmbCursorShape->addItem(i18n("Triangle Lefthanded"));
     m_cmbCursorShape->addItem(i18n("Black Pixel"));
     m_cmbCursorShape->addItem(i18n("White Pixel"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
 
     m_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline());
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor());
     cursorColorBtutton->setColor(cursorColor);
 
     //
     // Window Tab
     //
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
 
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 
     QString xml = cfg.getMDIBackgroundColor();
     KoColor mdiColor = KoColor::fromXML(xml);
     m_mdiColor->setColor(mdiColor);
 
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     m_chkHiDPI->setChecked(kritarc.value("EnableHiDPI", true).toBool());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(kritarc.value("EnableHiDPIFractionalScaling", true).toBool());
 #else
     m_chkHiDPIFractionalScaling->setVisible(false);
 #endif
     chkUsageLogging->setChecked(kritarc.value("LogUsage", true).toBool());
     m_chkSingleApplication->setChecked(kritarc.value("EnableSingleApplication", true).toBool());
 
     //
     // Tools tab
     //
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     cmbFlowMode->setCurrentIndex((int)!cfg.readEntry<bool>("useCreamyAlphaDarken", true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas());
     chkEnableTouchRotation->setChecked(!cfg.disableTouchRotation());
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste());
 
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled());
 
     m_cmbKineticScrollingGesture->addItem(i18n("On Touch Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Click Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Middle-Click Drag"));
     //m_cmbKineticScrollingGesture->addItem(i18n("On Right Click Drag"));
 
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture());
     m_kineticScrollingSensitivitySlider->setRange(0, 100);
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity());
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars());
 
     //
     // File handling
     //
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
     chkHideAutosaveFiles->setChecked(cfg.readEntry<bool>("autosavefileshidden", true));
 
     m_chkCompressKra->setChecked(cfg.compressKra());
     chkZip64->setChecked(cfg.useZip64());
 
     m_backupFileCheckBox->setChecked(cfg.backupFile());
     cmbBackupFileLocation->setCurrentIndex(cfg.readEntry<int>("backupfilelocation", 0));
     txtBackupFileSuffix->setText(cfg.readEntry<QString>("backupfilesuffix", "~"));
     QValidator *validator = new BackupSuffixValidator(txtBackupFileSuffix);
     txtBackupFileSuffix->setValidator(validator);
     intNumBackupFiles->setValue(cfg.readEntry<int>("numberofbackupfiles", 1));
 
     //
     // Miscellaneous
     //
     cmbStartupSession->addItem(i18n("Open default window"));
     cmbStartupSession->addItem(i18n("Load previous session"));
     cmbStartupSession->addItem(i18n("Show session manager"));
     cmbStartupSession->setCurrentIndex(cfg.sessionOnStartup());
 
     chkSaveSessionOnQuit->setChecked(cfg.saveSessionOnQuit(false));
 
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     m_undoStackSize->setValue(cfg.undoStackLimit());
 
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
     bool dontUseNative = true;
 #ifdef Q_OS_UNIX
     if (qgetenv("XDG_CURRENT_DESKTOP") == "KDE") {
         dontUseNative = false;
     }
 #endif
 #ifdef Q_OS_WIN
     dontUseNative = false;
 #endif
     m_chkNativeFileDialog->setChecked(!group.readEntry("DontUseNativeFileDialog", dontUseNative));
 
     intMaxBrushSize->setValue(cfg.readEntry("maximumBrushSize", 1000));
 }
 
 void GeneralTab::setDefault()
 {
     KisConfig cfg(true);
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle(true));
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle(true));
     chkShowRootLayer->setChecked(cfg.showRootLayer(true));
     m_autosaveCheckBox->setChecked(cfg.autoSaveInterval(true) > 0);
     //convert to minutes
     m_autosaveSpinBox->setValue(cfg.autoSaveInterval(true) / 60);
     chkHideAutosaveFiles->setChecked(true);
 
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
 
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     cmbBackupFileLocation->setCurrentIndex(0);
     txtBackupFileSuffix->setText("~");
     intNumBackupFiles->setValue(1);
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline(true));
 
     m_chkNativeFileDialog->setChecked(false);
     intMaxBrushSize->setValue(1000);
 
     m_cmbMDIType->setCurrentIndex((int)QMdiArea::TabbedView);
     m_chkRubberBand->setChecked(cfg.useOpenGL(true));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets(true));
     KoColor mdiColor;
     mdiColor.fromXML(cfg.getMDIBackgroundColor(true));
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage(true));
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages(true));
     m_chkCompressKra->setChecked(cfg.compressKra(true));
     chkZip64->setChecked(cfg.useZip64(true));
     m_chkHiDPI->setChecked(false);
     m_chkSingleApplication->setChecked(true);
 
     m_chkHiDPI->setChecked(true);
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(true);
 #endif
     chkUsageLogging->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     cmbFlowMode->setCurrentIndex(0);
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled(true));
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture(true));
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity(true));
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas(true));
     chkEnableTouchRotation->setChecked(!cfg.disableTouchRotation(true));
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor(true));
     cursorColorBtutton->setColor(cursorColor);
 
 
 
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 KisConfig::SessionOnStartup GeneralTab::sessionOnStartup() const
 {
     return (KisConfig::SessionOnStartup)cmbStartupSession->currentIndex();
 }
 
 bool GeneralTab::saveSessionOnQuit() const
 {
     return chkSaveSessionOnQuit->isChecked();
 }
 
 bool GeneralTab::showRootLayer()
 {
     return chkShowRootLayer->isChecked();
 }
 
 int GeneralTab::autoSaveInterval()
 {
     //convert to seconds
     return m_autosaveCheckBox->isChecked() ? m_autosaveSpinBox->value() * 60 : 0;
 }
 
 int GeneralTab::undoStackSize()
 {
     return m_undoStackSize->value();
 }
 
 bool GeneralTab::showOutlineWhilePainting()
 {
     return m_showOutlinePainting->isChecked();
 }
 
 int GeneralTab::mdiMode()
 {
     return m_cmbMDIType->currentIndex();
 }
 
 int GeneralTab::favoritePresets()
 {
     return m_favoritePresetsSpinBox->value();
 }
 
 bool GeneralTab::showCanvasMessages()
 {
     return m_chkCanvasMessages->isChecked();
 }
 
 bool GeneralTab::compressKra()
 {
     return m_chkCompressKra->isChecked();
 }
 
 bool GeneralTab::useZip64()
 {
     return chkZip64->isChecked();
 }
 
 bool GeneralTab::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 bool GeneralTab::kineticScrollingEnabled()
 {
     return m_groupBoxKineticScrollingSettings->isChecked();
 }
 
 int GeneralTab::kineticScrollingGesture()
 {
     return m_cmbKineticScrollingGesture->currentIndex();
 }
 
 int GeneralTab::kineticScrollingSensitivity()
 {
     return m_kineticScrollingSensitivitySlider->value();
 }
 
 bool GeneralTab::kineticScrollingHiddenScrollbars()
 {
     return m_chkKineticScrollingHideScrollbars->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setImageFilters();
 
     QString fn = dialog.filename();
     // dialog box was canceled or somehow no file was selected
     if (fn.isEmpty()) {
         return;
     }
 
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     else {
         m_backgroundimage->setText(fn);
     }
 }
 
 void GeneralTab::clearBackgroundImage()
 {
     // clearing the background image text will implicitly make the background color be used
     m_backgroundimage->setText("");
 }
 
 #include "kactioncollection.h"
 #include "KisActionsSnapshot.h"
 
 ShortcutSettingsTab::ShortcutSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgShortcutSettings(this);
     l->addWidget(m_page, 0, 0);
 
 
     m_snapshot.reset(new KisActionsSnapshot);
 
     KActionCollection *collection =
         KisPart::instance()->currentMainwindow()->actionCollection();
 
     Q_FOREACH (QAction *action, collection->actions()) {
         m_snapshot->addAction(action->objectName(), action);
     }
 
     QMap<QString, KActionCollection*> sortedCollections =
         m_snapshot->actionCollections();
 
     for (auto it = sortedCollections.constBegin(); it != sortedCollections.constEnd(); ++it) {
         m_page->addCollection(it.value(), it.key());
     }
 }
 
 ShortcutSettingsTab::~ShortcutSettingsTab()
 {
 }
 
 void ShortcutSettingsTab::setDefault()
 {
     m_page->allDefault();
 }
 
 void ShortcutSettingsTab::saveChanges()
 {
     m_page->save();
     KisActionRegistry::instance()->settingsPageSaved();
 }
 
 void ShortcutSettingsTab::cancelChanges()
 {
     m_page->undo();
 }
 
 ColorSettingsTab::ColorSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     // XXX: Make sure only profiles that fit the specified color model
     // are shown in the profile combos
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgColorSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
 
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
     connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
 
     m_page->cmbWorkingColorSpace->setIDList(KoColorSpaceRegistry::instance()->listKeys());
     m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
 
     m_page->bnAddColorProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     m_page->bnAddColorProfile->setToolTip( i18n("Open Color Profile") );
     connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
 
     QFormLayout *monitorProfileGrid = new QFormLayout(m_page->monitorprofileholder);
     for(int i = 0; i < QGuiApplication::screens().count(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileLabels << lbl;
         KisSqueezedComboBox *cmb = new KisSqueezedComboBox();
         cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
         monitorProfileGrid->addRow(lbl, cmb);
         m_monitorProfileWidgets << cmb;
     }
 
 // disable if not Linux as KisColorManager is not yet implemented outside Linux
 #ifndef Q_OS_LINUX
     m_page->chkUseSystemMonitorProfile->setChecked(false);
     m_page->chkUseSystemMonitorProfile->setDisabled(true);
     m_page->chkUseSystemMonitorProfile->setHidden(true);
 #endif
 
     refillMonitorProfiles(KoID("RGBA"));
 
     for(int i = 0; i < QApplication::screens().count(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
     m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors());
     KisImageConfig cfgImage(true);
 
     KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)proofingConfig->adaptationState*20);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,
                                                                                       proofingConfig->proofingDepth,
                                                                                       proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
 
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, PASTE_ASSUME_WEB);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, PASTE_ASSUME_MONITOR);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, PASTE_ASK);
 
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
     Q_ASSERT(button);
 
     if (button) {
         button->setChecked(true);
     }
 
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
 
     toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
 
 }
 
 void ColorSettingsTab::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         if (!QFile::copy(profileName, saveLocation + QFileInfo(profileName).fileName())) {
             qWarning() << "Could not install profile!" << saveLocation + QFileInfo(profileName).fileName();
             continue;
         }
         iccEngine->addProfile(saveLocation + QFileInfo(profileName).fileName());
     }
 
     KisConfig cfg(true);
     refillMonitorProfiles(KoID("RGBA"));
 
     for(int i = 0; i < QApplication::screens().count(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     KisConfig cfg(true);
 
     if (useSystemProfile) {
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::screens().count()) {
             for(int i = 0; i < QApplication::screens().count(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                     if (devices[i] == monitorForScreen) {
                         m_monitorProfileWidgets[i]->setCurrentIndex(i);
                     }
                 }
             }
         }
     }
     else {
         refillMonitorProfiles(KoID("RGBA"));
 
         for(int i = 0; i < QApplication::screens().count(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA"));
 
     KisConfig cfg(true);
     KisImageConfig cfgImage(true);
     KisProofingConfigurationSP proofingConfig =  cfgImage.defaultProofingconfiguration();
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
     m_page->sldAdaptationState->setValue(0);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation(true));
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization(true));
     m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors(true));
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent(true));
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
     Q_ASSERT(button);
     if (button) {
         button->setChecked(true);
     }
 }
 
 
 void ColorSettingsTab::refillMonitorProfiles(const KoID & colorSpaceId)
 {
     for (int i = 0; i < QApplication::screens().count(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
     QMap<QString, const KoColorProfile *>  profileList;
     Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId.id())) {
         profileList[profile->name()] = profile;
     }
 
     Q_FOREACH (const KoColorProfile *profile, profileList.values()) {
         //qDebug() << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
         if (profile->isSuitableForDisplay()) {
             for (int i = 0; i < QApplication::screens().count(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::screens().count(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
         KisConfig(true).useRightMiddleTabletButtonWorkaround(true));
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         KisConfig cfg(true);
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput(true));
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput(true));
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
     }
 #else
         m_page->grpTabletApi->setVisible(false);
 #endif
 }
 
 TabletSettingsTab::TabletSettingsTab(QWidget* parent, const char* name): QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgTabletSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
          cfg.useRightMiddleTabletButtonWorkaround());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput());
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput());
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
         m_page->grpTabletApi->setVisible(false);
     }
 
 #ifdef USE_QT_TABLET_WINDOWS
     connect(m_page->btnResolutionSettings, SIGNAL(clicked()), SLOT(slotResolutionSettings()));
     connect(m_page->radioWintab, SIGNAL(toggled(bool)), m_page->btnResolutionSettings, SLOT(setEnabled(bool)));
     m_page->btnResolutionSettings->setEnabled(m_page->radioWintab->isChecked());
 #else
     m_page->btnResolutionSettings->setVisible(false);
 #endif
 
 #else
     m_page->grpTabletApi->setVisible(false);
 #endif
     connect(m_page->btnTabletTest, SIGNAL(clicked()), SLOT(slotTabletTest()));
 }
 
 void TabletSettingsTab::slotTabletTest()
 {
     TabletTestDialog tabletTestDialog(this);
     tabletTestDialog.exec();
 }
 
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
 #include "KisDlgCustomTabletResolution.h"
 #endif
 
 void TabletSettingsTab::slotResolutionSettings()
 {
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
     KisDlgCustomTabletResolution dlg(this);
     dlg.exec();
 #endif
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM()
 {
     return KisImageConfig(true).totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg(true);
     const double totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(KFormat().formatByteSize(totalRAM * 1024 * 1024, 0, KFormat::IECBinaryDialect, KFormat::UnitMegaByte));
 
     sliderMemoryLimit->setSuffix(i18n(" %"));
     sliderMemoryLimit->setRange(1, 100, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderPoolLimit->setSuffix(i18n(" %"));
     sliderPoolLimit->setRange(0, 20, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderUndoLimit->setSuffix(i18n(" %"));
     sliderUndoLimit->setRange(0, 50, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     intMemoryLimit->setMinimumWidth(80);
     intPoolLimit->setMinimumWidth(80);
     intUndoLimit->setMinimumWidth(80);
 
 
     SliderAndSpinBoxSync *sync1 =
         new SliderAndSpinBoxSync(sliderMemoryLimit,
                                  intMemoryLimit,
                                  getTotalRAM);
 
     sync1->slotParentValueChanged();
     m_syncs << sync1;
 
     SliderAndSpinBoxSync *sync2 =
         new SliderAndSpinBoxSync(sliderPoolLimit,
                                  intPoolLimit,
                                  std::bind(&KisIntParseSpinBox::value,
                                              intMemoryLimit));
 
 
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
     sync2->slotParentValueChanged();
     m_syncs << sync2;
 
     SliderAndSpinBoxSync *sync3 =
         new SliderAndSpinBoxSync(sliderUndoLimit,
                                  intUndoLimit,
                                  std::bind(&PerformanceTab::realTilesRAM,
                                              this));
 
 
     connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     sliderThreadsLimit->setRange(1, QThread::idealThreadCount());
     sliderFrameClonesLimit->setRange(1, QThread::idealThreadCount());
     sliderFpsLimit->setRange(20, 300);
     sliderFpsLimit->setSuffix(i18n(" fps"));
 
     connect(sliderThreadsLimit, SIGNAL(valueChanged(int)), SLOT(slotThreadsLimitChanged(int)));
     connect(sliderFrameClonesLimit, SIGNAL(valueChanged(int)), SLOT(slotFrameClonesLimitChanged(int)));
 
     intCachedFramesSizeLimit->setRange(1, 10000);
     intCachedFramesSizeLimit->setSuffix(i18n(" px"));
     intCachedFramesSizeLimit->setSingleStep(1);
     intCachedFramesSizeLimit->setPageStep(1000);
 
     intRegionOfInterestMargin->setRange(1, 100);
     intRegionOfInterestMargin->setSuffix(i18n(" %"));
     intRegionOfInterestMargin->setSingleStep(1);
     intRegionOfInterestMargin->setPageStep(10);
 
     connect(chkCachedFramesSizeLimit, SIGNAL(toggled(bool)), intCachedFramesSizeLimit, SLOT(setEnabled(bool)));
     connect(chkUseRegionOfInterest, SIGNAL(toggled(bool)), intRegionOfInterestMargin, SLOT(setEnabled(bool)));
 
 #ifndef Q_OS_WIN
     // AVX workaround is needed on Windows+GCC only
     chkDisableAVXOptimizations->setVisible(false);
 #endif
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg(true);
 
     sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
     sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
     sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
     chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
     chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
     sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
     lblSwapFileLocation->setText(cfg.swapDir(requestDefault));
 
     m_lastUsedThreadsLimit = cfg.maxNumberOfThreads(requestDefault);
     m_lastUsedClonesLimit = cfg.frameRenderingClones(requestDefault);
 
     sliderThreadsLimit->setValue(m_lastUsedThreadsLimit);
     sliderFrameClonesLimit->setValue(m_lastUsedClonesLimit);
 
     sliderFpsLimit->setValue(cfg.fpsLimit(requestDefault));
 
     {
         KisConfig cfg2(true);
         chkOpenGLFramerateLogging->setChecked(cfg2.enableOpenGLFramerateLogging(requestDefault));
         chkBrushSpeedLogging->setChecked(cfg2.enableBrushSpeedLogging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
 #ifdef Q_OS_WIN
         chkDisableAVXOptimizations->setChecked(cfg2.disableAVXOptimizations(requestDefault));
 #endif
         chkBackgroundCacheGeneration->setChecked(cfg2.calculateAnimationCacheInBackground(requestDefault));
     }
 
     if (cfg.useOnDiskAnimationCacheSwapping(requestDefault)) {
         optOnDisk->setChecked(true);
     } else {
         optInMemory->setChecked(true);
     }
 
     chkCachedFramesSizeLimit->setChecked(cfg.useAnimationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setValue(cfg.animationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setEnabled(chkCachedFramesSizeLimit->isChecked());
 
     chkUseRegionOfInterest->setChecked(cfg.useAnimationCacheRegionOfInterest(requestDefault));
     intRegionOfInterestMargin->setValue(cfg.animationCacheRegionOfInterestMargin(requestDefault) * 100.0);
     intRegionOfInterestMargin->setEnabled(chkUseRegionOfInterest->isChecked());
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg(false);
 
     cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
     cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
     cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
     cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
     cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
     cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
     cfg.setSwapDir(lblSwapFileLocation->text());
 
     cfg.setMaxNumberOfThreads(sliderThreadsLimit->value());
     cfg.setFrameRenderingClones(sliderFrameClonesLimit->value());
     cfg.setFpsLimit(sliderFpsLimit->value());
 
     {
         KisConfig cfg2(true);
         cfg2.setEnableOpenGLFramerateLogging(chkOpenGLFramerateLogging->isChecked());
         cfg2.setEnableBrushSpeedLogging(chkBrushSpeedLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
 #ifdef Q_OS_WIN
         cfg2.setDisableAVXOptimizations(chkDisableAVXOptimizations->isChecked());
 #endif
         cfg2.setCalculateAnimationCacheInBackground(chkBackgroundCacheGeneration->isChecked());
     }
 
     cfg.setUseOnDiskAnimationCacheSwapping(optOnDisk->isChecked());
 
     cfg.setUseAnimationCacheFrameSizeLimit(chkCachedFramesSizeLimit->isChecked());
     cfg.setAnimationCacheFrameSizeLimit(intCachedFramesSizeLimit->value());
 
     cfg.setUseAnimationCacheRegionOfInterest(chkUseRegionOfInterest->isChecked());
     cfg.setAnimationCacheRegionOfInterestMargin(intRegionOfInterestMargin->value() / 100.0);
 
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg(true);
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     if (swapDir.isEmpty()) {
         return;
     }
     lblSwapFileLocation->setText(swapDir);
 }
 
 void PerformanceTab::slotThreadsLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderFrameClonesLimit);
     sliderFrameClonesLimit->setValue(qMin(m_lastUsedClonesLimit, value));
     m_lastUsedThreadsLimit = value;
 }
 
 void PerformanceTab::slotFrameClonesLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderThreadsLimit);
     sliderThreadsLimit->setValue(qMax(m_lastUsedThreadsLimit, value));
     m_lastUsedClonesLimit = value;
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 #include "opengl/KisOpenGLModeProber.h"
 #include "opengl/KisScreenInformationAdapter.h"
 #include <QOpenGLContext>
 #include <QScreen>
 
 QString colorSpaceString(KisSurfaceColorSpace cs, int depth)
 {
     const QString csString =
 #ifdef HAVE_HDR
         cs == KisSurfaceColorSpace::bt2020PQColorSpace ? "Rec. 2020 PQ" :
         cs == KisSurfaceColorSpace::scRGBColorSpace ? "Rec. 709 Linear" :
 #endif
         cs == KisSurfaceColorSpace::sRGBColorSpace ? "sRGB" :
         cs == KisSurfaceColorSpace::DefaultColorSpace ? "sRGB" :
         "Unknown Color Space";
 
     return QString("%1 (%2 bit)").arg(csString).arg(depth);
 }
 
 int formatToIndex(KisConfig::RootSurfaceFormat fmt)
 {
     return fmt == KisConfig::BT2020_PQ ? 1 :
            fmt == KisConfig::BT709_G10 ? 2 :
            0;
 }
 
 KisConfig::RootSurfaceFormat indexToFormat(int value)
 {
     return value == 1 ? KisConfig::BT2020_PQ :
            value == 2 ? KisConfig::BT709_G10 :
            KisConfig::BT709_G22;
 }
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
     KisConfig cfg(true);
 
     const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL");
     const QString rendererSoftwareText = i18nc("canvas renderer", "Software Renderer (very slow)");
 #ifdef Q_OS_WIN
     const QString rendererOpenGLESText = i18nc("canvas renderer", "Direct3D 11 via ANGLE");
 #else
     const QString rendererOpenGLESText = i18nc("canvas renderer", "OpenGL ES");
 #endif
 
     const KisOpenGL::OpenGLRenderer renderer = KisOpenGL::getCurrentOpenGLRenderer();
     lblCurrentRenderer->setText(renderer == KisOpenGL::RendererOpenGLES ? rendererOpenGLESText :
                                 renderer == KisOpenGL::RendererDesktopGL ? rendererOpenGLText :
                                 renderer == KisOpenGL::RendererSoftware ? rendererSoftwareText :
                                 i18nc("canvas renderer", "Unknown"));
 
     cmbPreferredRenderer->clear();
 
     const KisOpenGL::OpenGLRenderers supportedRenderers = KisOpenGL::getSupportedOpenGLRenderers();
     const bool onlyOneRendererSupported =
         supportedRenderers == KisOpenGL::RendererDesktopGL ||
         supportedRenderers == KisOpenGL::RendererOpenGLES ||
         supportedRenderers == KisOpenGL::RendererSoftware;
 
 
     if (!onlyOneRendererSupported) {
         QString qtPreferredRendererText;
         if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererOpenGLES) {
             qtPreferredRendererText = rendererOpenGLESText;
         } else if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererSoftware) {
             qtPreferredRendererText = rendererSoftwareText;
         } else {
             qtPreferredRendererText = rendererOpenGLText;
         }
         cmbPreferredRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto);
         cmbPreferredRenderer->setCurrentIndex(0);
     } else {
         cmbPreferredRenderer->setEnabled(false);
     }
 
     if (supportedRenderers & KisOpenGL::RendererDesktopGL) {
         cmbPreferredRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
 
 #ifdef Q_OS_WIN
     if (supportedRenderers & KisOpenGL::RendererOpenGLES) {
         cmbPreferredRenderer->addItem(rendererOpenGLESText, KisOpenGL::RendererOpenGLES);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererOpenGLES) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
     if (supportedRenderers & KisOpenGL::RendererSoftware) {
         cmbPreferredRenderer->addItem(rendererSoftwareText, KisOpenGL::RendererSoftware);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererSoftware) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
 #endif
 
     if (!(supportedRenderers &
           (KisOpenGL::RendererDesktopGL |
            KisOpenGL::RendererOpenGLES |
            KisOpenGL::RendererSoftware))) {
 
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     } else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL());
         chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
         chkDisableVsync->setVisible(cfg.showAdvancedOpenGLSettings());
         chkDisableVsync->setEnabled(cfg.useOpenGL());
         chkDisableVsync->setChecked(cfg.disableVSync());
         cmbFilterMode->setEnabled(cfg.useOpenGL());
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode());
         // Don't show the high quality filtering mode if it's not available
         if (!KisOpenGL::supportsLoD()) {
             cmbFilterMode->removeItem(3);
         }
     }
 
     lblCurrentDisplayFormat->setText("");
     lblCurrentRootSurfaceFormat->setText("");
     lblHDRWarning->setText("");
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::sRGBColorSpace, 8));
 #ifdef HAVE_HDR
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::bt2020PQColorSpace, 10));
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::scRGBColorSpace, 16));
 #endif
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
 
     if (!context) {
         context = QOpenGLContext::globalShareContext();
     }
 
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         KisScreenInformationAdapter adapter(context);
         if (screen && adapter.isValid()) {
             KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
             if (info.isValid()) {
                 QStringList toolTip;
 
                 toolTip << i18n("Display Id: %1", info.screen->name());
                 toolTip << i18n("Display Name: %1 %2", info.screen->manufacturer(), info.screen->model());
                 toolTip << i18n("Min Luminance: %1", info.minLuminance);
                 toolTip << i18n("Max Luminance: %1", info.maxLuminance);
                 toolTip << i18n("Max Full Frame Luminance: %1", info.maxFullFrameLuminance);
                 toolTip << i18n("Red Primary: %1, %2", info.redPrimary[0], info.redPrimary[1]);
                 toolTip << i18n("Green Primary: %1, %2", info.greenPrimary[0], info.greenPrimary[1]);
                 toolTip << i18n("Blue Primary: %1, %2", info.bluePrimary[0], info.bluePrimary[1]);
                 toolTip << i18n("White Point: %1, %2", info.whitePoint[0], info.whitePoint[1]);
 
                 lblCurrentDisplayFormat->setToolTip(toolTip.join('\n'));
                 lblCurrentDisplayFormat->setText(colorSpaceString(info.colorSpace, info.bitsPerColor));
             } else {
                 lblCurrentDisplayFormat->setToolTip("");
                 lblCurrentDisplayFormat->setText(i18n("Unknown"));
             }
         } else {
             lblCurrentDisplayFormat->setToolTip("");
             lblCurrentDisplayFormat->setText(i18n("Unknown"));
             qWarning() << "Failed to fetch display info:" << adapter.errorString();
         }
 
         const QSurfaceFormat currentFormat = KisOpenGLModeProber::instance()->surfaceformatInUse();
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         KisSurfaceColorSpace colorSpace = currentFormat.colorSpace();
 #else
         KisSurfaceColorSpace colorSpace = KisSurfaceColorSpace::DefaultColorSpace;
 #endif
         lblCurrentRootSurfaceFormat->setText(colorSpaceString(colorSpace, currentFormat.redBufferSize()));
         cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(cfg.rootSurfaceFormat()));
         connect(cmbPreferedRootSurfaceFormat, SIGNAL(currentIndexChanged(int)), SLOT(slotPreferredSurfaceFormatChanged(int)));
         slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
     }
 
 #ifndef HAVE_HDR
     grpHDRSettings->setVisible(false);
     tabWidget->removeTab(tabWidget->indexOf(tabHDR));
 #endif
 
     const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings();
     if (openglWarnings.isEmpty()) {
         lblOpenGLWarnings->setVisible(false);
     } else {
         QString text("<span style=\"color: yellow;\">&#x26A0;</span> ");
         text.append(i18n("Warning(s):"));
         text.append("<ul>");
         Q_FOREACH (const QString &warning, openglWarnings) {
             text.append("<li>");
             text.append(warning.toHtmlEscaped());
             text.append("</li>");
         }
         text.append("</ul>");
         lblOpenGLWarnings->setText(text);
         lblOpenGLWarnings->setVisible(true);
     }
 
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     KisImageConfig imageCfg(false);
 
     KoColor c;
     c.fromQColor(imageCfg.selectionOverlayMaskColor());
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
     sldSelectionOverlayOpacity->setSingleStep(0.05);
     sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor().alphaF());
 
     intCheckSize->setValue(cfg.checkSize());
     chkMoving->setChecked(cfg.scrollCheckers());
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1());
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2());
     colorChecks2->setColor(ck2);
     KoColor cb(KoColorSpaceRegistry::instance()->rgb8());
     cb.fromQColor(cfg.canvasBorderColor());
     canvasBorder->setColor(cb);
     hideScrollbars->setChecked(cfg.hideScrollbars());
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves());
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline());
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor());
     chkHidePopups->setChecked(cfg.hidePopups());
 
     connect(grpOpenGL, SIGNAL(toggled(bool)), SLOT(slotUseOpenGLToggled(bool)));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor());
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold() * 100);
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg(true);
     cmbPreferredRenderer->setCurrentIndex(0);
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererOpenGLES))) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     }
     else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL(true));
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
         chkUseTextureBuffer->setEnabled(true);
         chkDisableVsync->setEnabled(true);
         chkDisableVsync->setChecked(cfg.disableVSync(true));
         cmbFilterMode->setEnabled(true);
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
     }
 
     chkMoving->setChecked(cfg.scrollCheckers(true));
 
     KisImageConfig imageCfg(false);
     KoColor c;
     c.fromQColor(imageCfg.selectionOverlayMaskColor(true));
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor(true).alphaF());
 
     intCheckSize->setValue(cfg.checkSize(true));
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1(true));
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2(true));
     colorChecks2->setColor(ck2);
     KoColor cvb(KoColorSpaceRegistry::instance()->rgb8());
     cvb.fromQColor(cfg.canvasBorderColor(true));
     canvasBorder->setColor(cvb);
     hideScrollbars->setChecked(cfg.hideScrollbars(true));
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves(true));
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline(true));
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor(true));
     chkHidePopups->setChecked(cfg.hidePopups(true));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor(true));
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold(true) * 100);
 
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 void DisplaySettingsTab::slotPreferredSurfaceFormatChanged(int index)
 {
     Q_UNUSED(index);
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         KisScreenInformationAdapter adapter(context);
         if (adapter.isValid()) {
             KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
             if (info.isValid()) {
                 if (cmbPreferedRootSurfaceFormat->currentIndex() != formatToIndex(KisConfig::BT709_G22) &&
                     info.colorSpace == KisSurfaceColorSpace::sRGBColorSpace) {
                     lblHDRWarning->setText(i18n("WARNING: current display doesn't support HDR rendering"));
                 } else {
                     lblHDRWarning->setText("");
                 }
             }
         }
     }
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg(true);
 
     chkDockers->setChecked(cfg.hideDockersFullscreen());
     chkMenu->setChecked(cfg.hideMenuFullscreen());
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen());
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen());
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen());
     chkToolbar->setChecked(cfg.hideToolbarFullscreen());
 
 }
 
 void FullscreenSettingsTab::setDefault()
 {
     KisConfig cfg(true);
     chkDockers->setChecked(cfg.hideDockersFullscreen(true));
     chkMenu->setChecked(cfg.hideMenuFullscreen(true));
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen(true));
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen(true));
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen(true));
     chkToolbar->setChecked(cfg.hideToolbarFullscreen(true));
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 KisDlgPreferences::KisDlgPreferences(QWidget* parent, const char* name)
     : KPageDialog(parent)
 {
     Q_UNUSED(name);
     setWindowTitle(i18n("Configure Krita"));
     setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults);
 
     setFaceType(KPageDialog::List);
 
     // General
     KoVBox *vbox = new KoVBox();
     KPageWidgetItem *page = new KPageWidgetItem(vbox, i18n("General"));
     page->setObjectName("general");
     page->setHeader(i18n("General"));
     page->setIcon(KisIconUtils::loadIcon("go-home"));
     m_pages << page;
     addPage(page);
     m_general = new GeneralTab(vbox);
 
     // Shortcuts
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Keyboard Shortcuts"));
     page->setObjectName("shortcuts");
     page->setHeader(i18n("Shortcuts"));
     page->setIcon(KisIconUtils::loadIcon("document-export"));
     m_pages << page;
     addPage(page);
     m_shortcutSettings = new ShortcutSettingsTab(vbox);
     connect(this, SIGNAL(accepted()), m_shortcutSettings, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_shortcutSettings, SLOT(cancelChanges()));
 
     // Canvas input settings
     m_inputConfiguration = new KisInputConfigurationPage();
     page = addPage(m_inputConfiguration, i18n("Canvas Input Settings"));
     page->setHeader(i18n("Canvas Input"));
     page->setObjectName("canvasinput");
     page->setIcon(KisIconUtils::loadIcon("configure"));
     m_pages << page;
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     m_pages << page;
     addPage(page);
     m_displaySettings = new DisplaySettingsTab(vbox);
 
     // Color
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Color Management"));
     page->setObjectName("colormanagement");
     page->setHeader(i18n("Color"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-color"));
     m_pages << page;
     addPage(page);
     m_colorSettings = new ColorSettingsTab(vbox);
 
     // Performance
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Performance"));
     page->setObjectName("performance");
     page->setHeader(i18n("Performance"));
     page->setIcon(KisIconUtils::loadIcon("applications-system"));
     m_pages << page;
     addPage(page);
     m_performanceSettings = new PerformanceTab(vbox);
 
     // Tablet
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Tablet settings"));
     page->setObjectName("tablet");
     page->setHeader(i18n("Tablet"));
     page->setIcon(KisIconUtils::loadIcon("document-edit"));
     m_pages << page;
     addPage(page);
     m_tabletSettings = new TabletSettingsTab(vbox);
 
     // full-screen mode
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Canvas-only settings"));
     page->setObjectName("canvasonly");
     page->setHeader(i18n("Canvas-only"));
     page->setIcon(KisIconUtils::loadIcon("folder-pictures"));
     m_pages << page;
     addPage(page);
     m_fullscreenSettings = new FullscreenSettingsTab(vbox);
 
     // Author profiles
     m_authorPage = new KoConfigAuthorPage();
     page = addPage(m_authorPage, i18nc("@title:tab Author page", "Author" ));
     page->setObjectName("author");
     page->setHeader(i18n("Author"));
     page->setIcon(KisIconUtils::loadIcon("im-user"));
     m_pages << page;
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
     restoreDefaultsButton->setText(i18nc("@action:button", "Restore Defaults"));
 
     connect(this, SIGNAL(accepted()), m_inputConfiguration, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_inputConfiguration, SLOT(revertChanges()));
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     QStringList keys = preferenceSetRegistry->keys();
     keys.sort();
     Q_FOREACH(const QString &key, keys) {
         KisAbstractPreferenceSetFactory *preferenceSetFactory = preferenceSetRegistry->value(key);
         KisPreferenceSet* preferenceSet = preferenceSetFactory->createPreferenceSet();
         vbox = new KoVBox();
         page = new KPageWidgetItem(vbox, preferenceSet->name());
         page->setHeader(preferenceSet->header());
         page->setIcon(preferenceSet->icon());
         addPage(page);
         preferenceSet->setParent(vbox);
         preferenceSet->loadPreferences();
 
         connect(restoreDefaultsButton, SIGNAL(clicked(bool)), preferenceSet, SLOT(loadDefaultPreferences()), Qt::UniqueConnection);
         connect(this, SIGNAL(accepted()), preferenceSet, SLOT(savePreferences()), Qt::UniqueConnection);
     }
 
     connect(restoreDefaultsButton, SIGNAL(clicked(bool)), this, SLOT(slotDefault()));
 
     KisConfig cfg(true);
     QString currentPageName = cfg.readEntry<QString>("KisDlgPreferences/CurrentPage");
     Q_FOREACH(KPageWidgetItem *page, m_pages) {
         if (page->objectName() == currentPageName) {
             setCurrentPage(page);
             break;
         }
     }
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
     KisConfig cfg(true);
     cfg.writeEntry<QString>("KisDlgPreferences/CurrentPage", currentPage()->objectName());
 }
 
 void KisDlgPreferences::showEvent(QShowEvent *event){
     KPageDialog::showEvent(event);
     button(QDialogButtonBox::Cancel)->setAutoDefault(false);
     button(QDialogButtonBox::Ok)->setAutoDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setAutoDefault(false);
     button(QDialogButtonBox::Cancel)->setDefault(false);
     button(QDialogButtonBox::Ok)->setDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setDefault(false);
 }
 
+void KisDlgPreferences::slotButtonClicked(QAbstractButton *button)
+{
+    if (buttonBox()->buttonRole(button) == QDialogButtonBox::RejectRole) {
+        m_cancelClicked = true;
+    }
+}
+
 void KisDlgPreferences::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
-    KisDlgPreferences* dialog;
+    connect(this->buttonBox(), SIGNAL(clicked(QAbstractButton*)), this, SLOT(slotButtonClicked(QAbstractButton*)));
+
+    int retval = exec();
+    Q_UNUSED(retval)
 
-    dialog = new KisDlgPreferences();
-    bool baccept = (dialog->exec() == Accepted);
-    if (baccept) {
+    if (!m_cancelClicked) {
         // General settings
         KisConfig cfg(false);
-        cfg.setNewCursorStyle(dialog->m_general->cursorStyle());
-        cfg.setNewOutlineStyle(dialog->m_general->outlineStyle());
-        cfg.setShowRootLayer(dialog->m_general->showRootLayer());
-        cfg.setShowOutlineWhilePainting(dialog->m_general->showOutlineWhilePainting());
-        cfg.setForceAlwaysFullSizedOutline(!dialog->m_general->m_changeBrushOutline->isChecked());
-        cfg.setSessionOnStartup(dialog->m_general->sessionOnStartup());
-        cfg.setSaveSessionOnQuit(dialog->m_general->saveSessionOnQuit());
+        cfg.setNewCursorStyle(m_general->cursorStyle());
+        cfg.setNewOutlineStyle(m_general->outlineStyle());
+        cfg.setShowRootLayer(m_general->showRootLayer());
+        cfg.setShowOutlineWhilePainting(m_general->showOutlineWhilePainting());
+        cfg.setForceAlwaysFullSizedOutline(!m_general->m_changeBrushOutline->isChecked());
+        cfg.setSessionOnStartup(m_general->sessionOnStartup());
+        cfg.setSaveSessionOnQuit(m_general->saveSessionOnQuit());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
-        group.writeEntry("DontUseNativeFileDialog", !dialog->m_general->m_chkNativeFileDialog->isChecked());
+        group.writeEntry("DontUseNativeFileDialog", !m_general->m_chkNativeFileDialog->isChecked());
 
-        cfg.writeEntry<int>("maximumBrushSize", dialog->m_general->intMaxBrushSize->value());
+        cfg.writeEntry<int>("maximumBrushSize", m_general->intMaxBrushSize->value());
 
-        cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
-        cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toXML());
-        cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
-        cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
-        cfg.writeEntry("autosavefileshidden", dialog->m_general->chkHideAutosaveFiles->isChecked());
+        cfg.writeEntry<int>("mdi_viewmode", m_general->mdiMode());
+        cfg.setMDIBackgroundColor(m_general->m_mdiColor->color().toXML());
+        cfg.setMDIBackgroundImage(m_general->m_backgroundimage->text());
+        cfg.setAutoSaveInterval(m_general->autoSaveInterval());
+        cfg.writeEntry("autosavefileshidden", m_general->chkHideAutosaveFiles->isChecked());
 
-        cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
-        cfg.writeEntry("backupfilelocation", dialog->m_general->cmbBackupFileLocation->currentIndex());
-        cfg.writeEntry("backupfilesuffix", dialog->m_general->txtBackupFileSuffix->text());
-        cfg.writeEntry("numberofbackupfiles", dialog->m_general->intNumBackupFiles->value());
+        cfg.setBackupFile(m_general->m_backupFileCheckBox->isChecked());
+        cfg.writeEntry("backupfilelocation", m_general->cmbBackupFileLocation->currentIndex());
+        cfg.writeEntry("backupfilesuffix", m_general->txtBackupFileSuffix->text());
+        cfg.writeEntry("numberofbackupfiles", m_general->intNumBackupFiles->value());
 
-        cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
-        cfg.setCompressKra(dialog->m_general->compressKra());
-        cfg.setUseZip64(dialog->m_general->useZip64());
+        cfg.setShowCanvasMessages(m_general->showCanvasMessages());
+        cfg.setCompressKra(m_general->compressKra());
+        cfg.setUseZip64(m_general->useZip64());
 
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
-        kritarc.setValue("EnableHiDPI", dialog->m_general->m_chkHiDPI->isChecked());
+        kritarc.setValue("EnableHiDPI", m_general->m_chkHiDPI->isChecked());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
-        kritarc.setValue("EnableHiDPIFractionalScaling", dialog->m_general->m_chkHiDPIFractionalScaling->isChecked());
+        kritarc.setValue("EnableHiDPIFractionalScaling", m_general->m_chkHiDPIFractionalScaling->isChecked());
 #endif
-        kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
-        kritarc.setValue("LogUsage", dialog->m_general->chkUsageLogging->isChecked());
+        kritarc.setValue("EnableSingleApplication", m_general->m_chkSingleApplication->isChecked());
+        kritarc.setValue("LogUsage", m_general->chkUsageLogging->isChecked());
 
-        cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
+        cfg.setToolOptionsInDocker(m_general->toolOptionsInDocker());
 
-        cfg.writeEntry<bool>("useCreamyAlphaDarken", (bool)!dialog->m_general->cmbFlowMode->currentIndex());
+        cfg.writeEntry<bool>("useCreamyAlphaDarken", (bool)!m_general->cmbFlowMode->currentIndex());
 
-        cfg.setKineticScrollingEnabled(dialog->m_general->kineticScrollingEnabled());
-        cfg.setKineticScrollingGesture(dialog->m_general->kineticScrollingGesture());
-        cfg.setKineticScrollingSensitivity(dialog->m_general->kineticScrollingSensitivity());
-        cfg.setKineticScrollingHideScrollbars(dialog->m_general->kineticScrollingHiddenScrollbars());
+        cfg.setKineticScrollingEnabled(m_general->kineticScrollingEnabled());
+        cfg.setKineticScrollingGesture(m_general->kineticScrollingGesture());
+        cfg.setKineticScrollingSensitivity(m_general->kineticScrollingSensitivity());
+        cfg.setKineticScrollingHideScrollbars(m_general->kineticScrollingHiddenScrollbars());
 
-        cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
-        cfg.setDisableTouchOnCanvas(!dialog->m_general->chkEnableTouch->isChecked());
-        cfg.setDisableTouchRotation(!dialog->m_general->chkEnableTouchRotation->isChecked());
-        cfg.setActivateTransformToolAfterPaste(dialog->m_general->chkEnableTranformToolAfterPaste->isChecked());
-        cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
-        cfg.setUndoStackLimit(dialog->m_general->undoStackSize());
-        cfg.setFavoritePresets(dialog->m_general->favoritePresets());
+        cfg.setSwitchSelectionCtrlAlt(m_general->switchSelectionCtrlAlt());
+        cfg.setDisableTouchOnCanvas(!m_general->chkEnableTouch->isChecked());
+        cfg.setDisableTouchRotation(!m_general->chkEnableTouchRotation->isChecked());
+        cfg.setActivateTransformToolAfterPaste(m_general->chkEnableTranformToolAfterPaste->isChecked());
+        cfg.setConvertToImageColorspaceOnImport(m_general->convertToImageColorspaceOnImport());
+        cfg.setUndoStackLimit(m_general->undoStackSize());
+        cfg.setFavoritePresets(m_general->favoritePresets());
 
         // Color settings
-        cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
+        cfg.setUseSystemMonitorProfile(m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::screens().count(); ++i) {
-            if (dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
-                int currentIndex = dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
-                QString monitorid = dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
+            if (m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
+                int currentIndex = m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
+                QString monitorid = m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
-                                      dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentUnsqueezedText(),
-                                      dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
+                                      m_colorSettings->m_monitorProfileWidgets[i]->currentUnsqueezedText(),
+                                      m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
-        cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
+        cfg.setWorkingColorSpace(m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
         KisImageConfig cfgImage(false);
-        cfgImage.setDefaultProofingConfig(dialog->m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
-                                          dialog->m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
-                                          dialog->m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
-                                          dialog->m_colorSettings->m_page->gamutAlarm->color(),
-                                          (double)dialog->m_colorSettings->m_page->sldAdaptationState->value()/20);
-        cfg.setUseBlackPointCompensation(dialog->m_colorSettings->m_page->chkBlackpoint->isChecked());
-        cfg.setAllowLCMSOptimization(dialog->m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
-        cfg.setForcePaletteColors(dialog->m_colorSettings->m_page->chkForcePaletteColor->isChecked());
-        cfg.setPasteBehaviour(dialog->m_colorSettings->m_pasteBehaviourGroup.checkedId());
-        cfg.setRenderIntent(dialog->m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
+        cfgImage.setDefaultProofingConfig(m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
+                                          m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
+                                          m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
+                                          m_colorSettings->m_page->gamutAlarm->color(),
+                                          (double)m_colorSettings->m_page->sldAdaptationState->value()/20);
+        cfg.setUseBlackPointCompensation(m_colorSettings->m_page->chkBlackpoint->isChecked());
+        cfg.setAllowLCMSOptimization(m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
+        cfg.setForcePaletteColors(m_colorSettings->m_page->chkForcePaletteColor->isChecked());
+        cfg.setPasteBehaviour(m_colorSettings->m_pasteBehaviourGroup.checkedId());
+        cfg.setRenderIntent(m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
-        cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
+        cfg.setPressureTabletCurve( m_tabletSettings->m_page->pressureCurve->curve().toString() );
         cfg.setUseRightMiddleTabletButtonWorkaround(
-            dialog->m_tabletSettings->m_page->chkUseRightMiddleClickWorkaround->isChecked());
+            m_tabletSettings->m_page->chkUseRightMiddleClickWorkaround->isChecked());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
         // ask Qt if WinInk is actually available
         const bool isWinInkAvailable = true;
 #else
         const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
         if (isWinInkAvailable) {
-            cfg.setUseWin8PointerInput(dialog->m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
+            cfg.setUseWin8PointerInput(m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
         }
 #endif
 
-        dialog->m_performanceSettings->save();
+        m_performanceSettings->save();
 
-        if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
+        if (!cfg.useOpenGL() && m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
 
-        if (dialog->m_displaySettings->grpOpenGL->isChecked()) {
+        if (m_displaySettings->grpOpenGL->isChecked()) {
             KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
-                    dialog->m_displaySettings->cmbPreferredRenderer->itemData(
-                            dialog->m_displaySettings->cmbPreferredRenderer->currentIndex()).toInt());
+                    m_displaySettings->cmbPreferredRenderer->itemData(
+                            m_displaySettings->cmbPreferredRenderer->currentIndex()).toInt());
             KisOpenGL::setUserPreferredOpenGLRendererConfig(renderer);
         } else {
             KisOpenGL::setUserPreferredOpenGLRendererConfig(KisOpenGL::RendererNone);
         }
 
-        cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
-        cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
-        cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
-        cfg.setRootSurfaceFormat(&kritarc, indexToFormat(dialog->m_displaySettings->cmbPreferedRootSurfaceFormat->currentIndex()));
-
-        cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value());
-        cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked());
-        cfg.setCheckersColor1(dialog->m_displaySettings->colorChecks1->color().toQColor());
-        cfg.setCheckersColor2(dialog->m_displaySettings->colorChecks2->color().toQColor());
-        cfg.setCanvasBorderColor(dialog->m_displaySettings->canvasBorder->color().toQColor());
-        cfg.setHideScrollbars(dialog->m_displaySettings->hideScrollbars->isChecked());
-        KoColor c = dialog->m_displaySettings->btnSelectionOverlayColor->color();
-        c.setOpacity(dialog->m_displaySettings->sldSelectionOverlayOpacity->value());
+        cfg.setUseOpenGLTextureBuffer(m_displaySettings->chkUseTextureBuffer->isChecked());
+        cfg.setOpenGLFilteringMode(m_displaySettings->cmbFilterMode->currentIndex());
+        cfg.setDisableVSync(m_displaySettings->chkDisableVsync->isChecked());
+        cfg.setRootSurfaceFormat(&kritarc, indexToFormat(m_displaySettings->cmbPreferedRootSurfaceFormat->currentIndex()));
+
+        cfg.setCheckSize(m_displaySettings->intCheckSize->value());
+        cfg.setScrollingCheckers(m_displaySettings->chkMoving->isChecked());
+        cfg.setCheckersColor1(m_displaySettings->colorChecks1->color().toQColor());
+        cfg.setCheckersColor2(m_displaySettings->colorChecks2->color().toQColor());
+        cfg.setCanvasBorderColor(m_displaySettings->canvasBorder->color().toQColor());
+        cfg.setHideScrollbars(m_displaySettings->hideScrollbars->isChecked());
+        KoColor c = m_displaySettings->btnSelectionOverlayColor->color();
+        c.setOpacity(m_displaySettings->sldSelectionOverlayOpacity->value());
         cfgImage.setSelectionOverlayMaskColor(c.toQColor());
-        cfg.setAntialiasCurves(dialog->m_displaySettings->chkCurveAntialiasing->isChecked());
-        cfg.setAntialiasSelectionOutline(dialog->m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
-        cfg.setShowSingleChannelAsColor(dialog->m_displaySettings->chkChannelsAsColor->isChecked());
-        cfg.setHidePopups(dialog->m_displaySettings->chkHidePopups->isChecked());
+        cfg.setAntialiasCurves(m_displaySettings->chkCurveAntialiasing->isChecked());
+        cfg.setAntialiasSelectionOutline(m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
+        cfg.setShowSingleChannelAsColor(m_displaySettings->chkChannelsAsColor->isChecked());
+        cfg.setHidePopups(m_displaySettings->chkHidePopups->isChecked());
 
-        cfg.setHideDockersFullscreen(dialog->m_fullscreenSettings->chkDockers->checkState());
-        cfg.setHideMenuFullscreen(dialog->m_fullscreenSettings->chkMenu->checkState());
-        cfg.setHideScrollbarsFullscreen(dialog->m_fullscreenSettings->chkScrollbars->checkState());
-        cfg.setHideStatusbarFullscreen(dialog->m_fullscreenSettings->chkStatusbar->checkState());
-        cfg.setHideTitlebarFullscreen(dialog->m_fullscreenSettings->chkTitlebar->checkState());
-        cfg.setHideToolbarFullscreen(dialog->m_fullscreenSettings->chkToolbar->checkState());
+        cfg.setHideDockersFullscreen(m_fullscreenSettings->chkDockers->checkState());
+        cfg.setHideMenuFullscreen(m_fullscreenSettings->chkMenu->checkState());
+        cfg.setHideScrollbarsFullscreen(m_fullscreenSettings->chkScrollbars->checkState());
+        cfg.setHideStatusbarFullscreen(m_fullscreenSettings->chkStatusbar->checkState());
+        cfg.setHideTitlebarFullscreen(m_fullscreenSettings->chkTitlebar->checkState());
+        cfg.setHideToolbarFullscreen(m_fullscreenSettings->chkToolbar->checkState());
 
-        cfg.setCursorMainColor(dialog->m_general->cursorColorBtutton->color().toQColor());
-        cfg.setPixelGridColor(dialog->m_displaySettings->pixelGridColorButton->color().toQColor());
-        cfg.setPixelGridDrawingThreshold(dialog->m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
+        cfg.setCursorMainColor(m_general->cursorColorBtutton->color().toQColor());
+        cfg.setPixelGridColor(m_displaySettings->pixelGridColorButton->color().toQColor());
+        cfg.setPixelGridDrawingThreshold(m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
 
-        dialog->m_authorPage->apply();
+        m_authorPage->apply();
 
         cfg.logImportantSettings();
 
     }
-    delete dialog;
-    return baccept;
+
+    return !m_cancelClicked;
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_preferences.h b/libs/ui/dialogs/kis_dlg_preferences.h
index bfc2cc6e0f..7845313c25 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.h
+++ b/libs/ui/dialogs/kis_dlg_preferences.h
@@ -1,356 +1,357 @@
 /*
  *  preferencesdlg.h - part of KImageShop^WKrita
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 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_DLG_PREFERENCES_H_
 #define _KIS_DLG_PREFERENCES_H_
 
 #include <QWidget>
 #include <QButtonGroup>
 #include <QMap>
 #include <QString>
 
 #include <kpagedialog.h>
 #include <kis_config.h>
 
 #include "kis_global.h"
 #include <KisSqueezedComboBox.h>
 
 #include "ui_wdggeneralsettings.h"
 #include "ui_wdgdisplaysettings.h"
 #include "ui_wdgcolorsettings.h"
 #include "ui_wdgtabletsettings.h"
 #include "ui_wdgperformancesettings.h"
 #include "ui_wdgfullscreensettings.h"
 #include "KisShortcutsDialog.h"
 
 class KoID;
 class KisInputConfigurationPage;
 class KoConfigAuthorPage;
 
 /**
  *  "General"-tab for preferences dialog
  */
 
 class WdgGeneralSettings : public QWidget, public Ui::WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
     WdgGeneralSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name);
         setupUi(this);
         chkShowRootLayer->setVisible(false);
     }
 };
 
 class GeneralTab : public WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
 
     GeneralTab(QWidget *parent = 0, const char *name = 0);
 
     CursorStyle cursorStyle();
     OutlineStyle outlineStyle();
 
     KisConfig::SessionOnStartup sessionOnStartup() const;
     bool saveSessionOnQuit() const;
 
     bool showRootLayer();
     int autoSaveInterval();
     void setDefault();
     int undoStackSize();
     bool showOutlineWhilePainting();
 
     int mdiMode();
     int favoritePresets();
     bool showCanvasMessages();
     bool compressKra();
     bool useZip64();
     bool toolOptionsInDocker();
     bool kineticScrollingEnabled();
     int kineticScrollingGesture();
     int kineticScrollingSensitivity();
     bool kineticScrollingHiddenScrollbars();
     bool switchSelectionCtrlAlt();
     bool convertToImageColorspaceOnImport();
 
 private Q_SLOTS:
     void getBackgroundImage();
     void clearBackgroundImage();
 
 };
 
 
 
 /**
  *  "Shortcuts" tab for preferences dialog
  */
 
 class WdgShortcutSettings : public KisShortcutsDialog
 {
     Q_OBJECT
 
 public:
     WdgShortcutSettings(QWidget *parent)
         : KisShortcutsDialog(KisShortcutsEditor::AllActions,
                              KisShortcutsEditor::LetterShortcutsAllowed,
                              parent)
     { }
 };
 
 class KisActionsSnapshot;
 
 class ShortcutSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ShortcutSettingsTab(QWidget *parent = 0, const char *name = 0);
     ~ShortcutSettingsTab() override;
 
 public:
     void setDefault();
     WdgShortcutSettings  *m_page;
     QScopedPointer<KisActionsSnapshot> m_snapshot;
 
 public Q_SLOTS:
     void saveChanges();
     void cancelChanges();
 };
 
 
 
 /**
  *  "Color" tab for preferences dialog
  */
 
 class WdgColorSettings : public QWidget, public Ui::WdgColorSettings
 {
     Q_OBJECT
 
 public:
     WdgColorSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class ColorSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ColorSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 private Q_SLOTS:
 
     void refillMonitorProfiles(const KoID & s);
     void installProfile();
     void toggleAllowMonitorProfileSelection(bool useSystemProfile);
 
 public:
     void setDefault();
     WdgColorSettings  *m_page;
     QButtonGroup m_pasteBehaviourGroup;
     QList<QLabel*> m_monitorProfileLabels;
     QList<KisSqueezedComboBox*> m_monitorProfileWidgets;
 };
 
 //=======================
 
 class WdgTabletSettings : public QWidget, public Ui::WdgTabletSettings {
 
     Q_OBJECT
 
 public:
     WdgTabletSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 
 };
 
 class TabletSettingsTab : public QWidget {
     Q_OBJECT
 public:
     TabletSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 private Q_SLOTS:
     void slotTabletTest();
     void slotResolutionSettings();
 
 public:
     void setDefault();
     WdgTabletSettings  *m_page;
 
 
 };
 
 //=======================
 
 /**
   * "Performance"-tab for preferences dialog
  */
 
 class SliderAndSpinBoxSync;
 
 class WdgPerformanceSettings : public QWidget, public Ui::WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     WdgPerformanceSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 class PerformanceTab : public WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     PerformanceTab(QWidget *parent = 0, const char *name = 0);
 
     ~PerformanceTab() override;
 
     void load(bool requestDefault);
     void save();
 
 private Q_SLOTS:
 
     void selectSwapDir();
 
     void slotThreadsLimitChanged(int value);
     void slotFrameClonesLimitChanged(int value);
 
 private:
     int realTilesRAM();
 
 private:
     QVector<SliderAndSpinBoxSync*> m_syncs;
     int m_lastUsedThreadsLimit;
     int m_lastUsedClonesLimit;
 };
 
 //=======================
 
 class WdgDisplaySettings : public QWidget, public Ui::WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     WdgDisplaySettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 /**
  *  Display settings tab for preferences dialog
  */
 
 
 class DisplaySettingsTab : public WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     DisplaySettingsTab(QWidget *parent = 0, const char *name = 0);
 
 public:
     void setDefault();
 protected Q_SLOTS:
     void slotUseOpenGLToggled(bool isChecked);
     void slotPreferredSurfaceFormatChanged(int index);
 
 public:
 };
 
 //=======================
 
 /**
  *  Full screen settings tab for preferences dialog
  */
 
 class WdgFullscreenSettingsBase : public QWidget, public Ui::WdgFullscreenSettings
 {
     Q_OBJECT
 
 public:
     WdgFullscreenSettingsBase(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class FullscreenSettingsTab : public WdgFullscreenSettingsBase
 {
     Q_OBJECT
 public:
     FullscreenSettingsTab(QWidget *parent);
 public:
     void setDefault();
 };
 
 
 //=======================
 
 
 /**
  *  Preferences dialog of KImageShop^WKrayon^WKrita
  */
 class KisDlgPreferences : public KPageDialog
 {
     Q_OBJECT
 
 public:
 
-    static bool editPreferences();
-
-
-protected:
-
     KisDlgPreferences(QWidget *parent = 0, const char *name = 0);
     ~KisDlgPreferences() override;
 
+    bool editPreferences();
+
     void showEvent(QShowEvent *event) override;
 
-protected:
+private:
 
     GeneralTab *m_general;
     ShortcutSettingsTab  *m_shortcutSettings;
     ColorSettingsTab *m_colorSettings;
     PerformanceTab *m_performanceSettings;
     DisplaySettingsTab  *m_displaySettings;
     TabletSettingsTab *m_tabletSettings;
     FullscreenSettingsTab *m_fullscreenSettings;
     KisInputConfigurationPage *m_inputConfiguration;
     KoConfigAuthorPage *m_authorPage;
 
     QList<KPageWidgetItem*> m_pages;
 
-protected Q_SLOTS:
+private Q_SLOTS:
 
+    void slotButtonClicked(QAbstractButton *button);
     void slotDefault();
 
+private:
+
+    bool m_cancelClicked {false};
 };
 
 #endif
diff --git a/libs/ui/flake/KisReferenceImagesLayer.cpp b/libs/ui/flake/KisReferenceImagesLayer.cpp
index edf9fe039d..e029ce6149 100644
--- a/libs/ui/flake/KisReferenceImagesLayer.cpp
+++ b/libs/ui/flake/KisReferenceImagesLayer.cpp
@@ -1,234 +1,234 @@
 /*
  * Copyright (C) 2017 Jouni Pentikäinen <joupent@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 <KoShapeCreateCommand.h>
 #include <KoShapeDeleteCommand.h>
 #include <kis_node_visitor.h>
 #include <kis_processing_visitor.h>
 #include <kis_shape_layer_canvas.h>
 
 #include "KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 #include "KisDocument.h"
 
 struct AddReferenceImagesCommand : KoShapeCreateCommand
 {
     AddReferenceImagesCommand(KisDocument *document, KisSharedPtr<KisReferenceImagesLayer> layer, const QList<KoShape*> referenceImages)
         : KoShapeCreateCommand(layer->shapeController(), referenceImages, layer.data(), nullptr, kundo2_i18n("Add reference image"))
         , m_document(document)
         , m_layer(layer)
     {}
 
     void redo() override {
         auto layer = m_document->referenceImagesLayer();
-        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer)
+        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer);
 
         if (!layer) {
             m_document->setReferenceImagesLayer(m_layer, true);
         }
 
         KoShapeCreateCommand::redo();
     }
 
     void undo() override {
         KoShapeCreateCommand::undo();
 
         if (m_layer->shapeCount() == 0) {
             m_document->setReferenceImagesLayer(nullptr, true);
         }
     }
 
 private:
     KisDocument *m_document;
     KisSharedPtr<KisReferenceImagesLayer> m_layer;
 };
 
 struct RemoveReferenceImagesCommand : KoShapeDeleteCommand
 {
     RemoveReferenceImagesCommand(KisDocument *document, KisSharedPtr<KisReferenceImagesLayer> layer, QList<KoShape *> referenceImages)
         : KoShapeDeleteCommand(layer->shapeController(), referenceImages)
         , m_document(document)
         , m_layer(layer)
     {}
 
 
     void redo() override {
         KoShapeDeleteCommand::redo();
 
         if (m_layer->shapeCount() == 0) {
             m_document->setReferenceImagesLayer(nullptr, true);
         }
     }
 
     void undo() override {
         auto layer = m_document->referenceImagesLayer();
-        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer)
+        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer);
 
         if (!layer) {
             m_document->setReferenceImagesLayer(m_layer, true);
         }
 
         KoShapeDeleteCommand::undo();
     }
 
 private:
     KisDocument *m_document;
     KisSharedPtr<KisReferenceImagesLayer> m_layer;
 };
 
 class ReferenceImagesCanvas : public KisShapeLayerCanvasBase
 {
 public:
     ReferenceImagesCanvas(KisReferenceImagesLayer *parent, KisImageWSP image)
         : KisShapeLayerCanvasBase(parent, image)
         , m_layer(parent)
     {}
 
     void updateCanvas(const QRectF &rect) override
     {
         if (!m_layer->image() || m_isDestroying) {
             return;
         }
 
         QRectF r = m_viewConverter->documentToView(rect);
         m_layer->signalUpdate(r);
     }
 
     void forceRepaint() override
     {
         m_layer->signalUpdate(m_layer->boundingImageRect());
     }
 
     bool hasPendingUpdates() const override
     {
         return false;
     }
 
     void rerenderAfterBeingInvisible() override {}
     void resetCache() override {}
     void setImage(KisImageWSP image) override
     {
         m_viewConverter->setImage(image);
     }
 
 private:
     KisReferenceImagesLayer *m_layer;
 };
 
 KisReferenceImagesLayer::KisReferenceImagesLayer(KoShapeControllerBase* shapeController, KisImageWSP image)
     : KisShapeLayer(shapeController, image, i18n("Reference images"), OPACITY_OPAQUE_U8, new ReferenceImagesCanvas(this, image))
 {}
 
 KisReferenceImagesLayer::KisReferenceImagesLayer(const KisReferenceImagesLayer &rhs)
     : KisShapeLayer(rhs, rhs.shapeController(), new ReferenceImagesCanvas(this, rhs.image()))
 {}
 
 KUndo2Command * KisReferenceImagesLayer::addReferenceImages(KisDocument *document, const QList<KoShape*> referenceImages)
 {
     KisSharedPtr<KisReferenceImagesLayer> layer = document->referenceImagesLayer();
     if (!layer) {
         layer = new KisReferenceImagesLayer(document->shapeController(), document->image());
     }
 
     return new AddReferenceImagesCommand(document, layer, referenceImages);
 }
 
 KUndo2Command * KisReferenceImagesLayer::removeReferenceImages(KisDocument *document, QList<KoShape*> referenceImages)
 {
     return new RemoveReferenceImagesCommand(document, this, referenceImages);
 }
 
 QVector<KisReferenceImage*> KisReferenceImagesLayer::referenceImages() const
 {
     QVector<KisReferenceImage*> references;
 
     Q_FOREACH(auto shape, shapes()) {
         KisReferenceImage *referenceImage = dynamic_cast<KisReferenceImage*>(shape);
         if (referenceImage) {
             references.append(referenceImage);
         }
     }
     return references;
 }
 
 void KisReferenceImagesLayer::paintReferences(QPainter &painter) {
     shapeManager()->paint(painter, *converter(), false);
 }
 
 bool KisReferenceImagesLayer::allowAsChild(KisNodeSP) const
 {
     return false;
 }
 
 bool KisReferenceImagesLayer::accept(KisNodeVisitor &visitor)
 {
     return visitor.visit(this);
 }
 
 void KisReferenceImagesLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     visitor.visit(this, undoAdapter);
 }
 
 bool KisReferenceImagesLayer::isFakeNode() const
 {
     return true;
 }
 
 KUndo2Command *KisReferenceImagesLayer::setProfile(const KoColorProfile *profile)
 {
     // references should not be converted with the image
     Q_UNUSED(profile);
     return 0;
 }
 
 KUndo2Command *KisReferenceImagesLayer::convertTo(const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     // references should not be converted with the image
     Q_UNUSED(dstColorSpace);
     Q_UNUSED(renderingIntent);
     Q_UNUSED(conversionFlags);
     return 0;
 }
 
 void KisReferenceImagesLayer::signalUpdate(const QRectF &rect)
 {
     emit sigUpdateCanvas(rect);
 }
 
 QRectF KisReferenceImagesLayer::boundingImageRect() const
 {
     return converter()->documentToView(boundingRect());
 }
 
 QColor KisReferenceImagesLayer::getPixel(QPointF position) const
 {
     const QPointF docPoint = converter()->viewToDocument(position);
 
     KoShape *shape = shapeManager()->shapeAt(docPoint);
 
     if (shape) {
         auto *reference = dynamic_cast<KisReferenceImage*>(shape);
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, QColor());
 
         return reference->getPixel(docPoint);
     }
 
     return QColor();
 }
diff --git a/libs/ui/flake/KisReferenceImagesLayer.h b/libs/ui/flake/KisReferenceImagesLayer.h
index 8b9206001f..30764b6965 100644
--- a/libs/ui/flake/KisReferenceImagesLayer.h
+++ b/libs/ui/flake/KisReferenceImagesLayer.h
@@ -1,80 +1,80 @@
 /*
  * Copyright (C) 2017 Jouni Pentikäinen <joupent@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KRITA_KISREFERENCEIMAGESLAYER_H
 #define KRITA_KISREFERENCEIMAGESLAYER_H
 
 #include "kis_shape_layer.h"
 
 #include <kis_types.h>
 
 class KisDocument;
 
 class KRITAUI_EXPORT KisReferenceImagesLayer : public KisShapeLayer
 {
     Q_OBJECT
 
 public:
     KisReferenceImagesLayer(KoShapeControllerBase* shapeController, KisImageWSP image);
     KisReferenceImagesLayer(const KisReferenceImagesLayer &rhs);
 
     static KUndo2Command * addReferenceImages(KisDocument *document, QList<KoShape*> referenceImages);
     KUndo2Command * removeReferenceImages(KisDocument *document, QList<KoShape*> referenceImages);
     QVector<KisReferenceImage*> referenceImages() const;
 
     QRectF boundingImageRect() const;
     QColor getPixel(QPointF position) const;
 
     void paintReferences(QPainter &painter);
 
     bool allowAsChild(KisNodeSP) const override;
 
     bool accept(KisNodeVisitor&) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KisNodeSP clone() const override {
         return new KisReferenceImagesLayer(*this);
     }
 
     bool isFakeNode() const override;
 
     KUndo2Command* setProfile(const KoColorProfile *profile) override;
     KUndo2Command* convertTo(const KoColorSpace * dstColorSpace,
                                  KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
-                                 KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
+                                 KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) override;
 
 
 Q_SIGNALS:
     /**
      * The content of the layer has changed, and the canvas decoration
      * needs to update.
      */
     void sigUpdateCanvas(const QRectF &rect);
 
 private:
     void signalUpdate(const QRectF &rect);
     friend struct AddReferenceImagesCommand;
     friend struct RemoveReferenceImagesCommand;
     friend class ReferenceImagesCanvas;
 };
 
 typedef KisSharedPtr<KisReferenceImagesLayer> KisReferenceImagesLayerSP;
 
 
 #endif //KRITA_KISREFERENCEIMAGESLAYER_H
diff --git a/libs/ui/flake/kis_node_dummies_graph.cpp b/libs/ui/flake/kis_node_dummies_graph.cpp
index d4ec0dc8a4..7b49384783 100644
--- a/libs/ui/flake/kis_node_dummies_graph.cpp
+++ b/libs/ui/flake/kis_node_dummies_graph.cpp
@@ -1,192 +1,205 @@
 /*
  *  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_node_dummies_graph.h"
 #include "kis_node_shape.h"
+#include "kis_selection_mask.h"
 
 
 /********************************************************************/
 /*                 KisNodeDummy                                     */
 /********************************************************************/
 
 KisNodeDummy::KisNodeDummy(KisNodeShape *nodeShape, KisNodeSP node)
     : m_nodeShape(nodeShape),
       m_node(node)
 {
 }
 
 KisNodeDummy::~KisNodeDummy()
 {
     qDeleteAll(m_children);
 }
 
 KisNodeDummy* KisNodeDummy::firstChild() const
 {
     return !m_children.isEmpty() ? m_children.first() : 0;
 }
 
 KisNodeDummy* KisNodeDummy::lastChild() const
 {
     return !m_children.isEmpty() ? m_children.last() : 0;
 }
 
 KisNodeDummy* KisNodeDummy::nextSibling() const
 {
     if(!parent()) return 0;
 
     int index = parent()->m_children.indexOf(const_cast<KisNodeDummy*>(this));
     Q_ASSERT(index >= 0);
 
     index++;
     return index < parent()->m_children.size() ?
         parent()->m_children[index] : 0;
 }
 
 KisNodeDummy* KisNodeDummy::prevSibling() const
 {
     if(!parent()) return 0;
 
     int index = parent()->m_children.indexOf(const_cast<KisNodeDummy*>(this));
     Q_ASSERT(index >= 0);
 
     index--;
     return index >= 0 ? parent()->m_children[index] : 0;
 }
 
 KisNodeDummy* KisNodeDummy::parent() const
 {
     return qobject_cast<KisNodeDummy*>(QObject::parent());
 }
 
 KisNodeShape* KisNodeDummy::nodeShape() const
 {
     return m_nodeShape;
 }
 
 KisNodeSP KisNodeDummy::node() const
 {
     return m_node;
 }
 
+bool KisNodeDummy::isGUIVisible(bool showGlobalSelection) const
+{
+    if (!showGlobalSelection &&
+        parent() && !parent()->parent() &&
+        dynamic_cast<const KisSelectionMask*>(m_node.data())) {
+
+        return false;
+    }
+
+    return parent() && !m_node->isFakeNode();
+}
+
 KisNodeDummy* KisNodeDummy::at(int index) const
 {
     return m_children.at(index);
 }
 
 int KisNodeDummy::childCount() const
 {
     return m_children.size();
 }
 
 int KisNodeDummy::indexOf(KisNodeDummy *child) const
 {
     return m_children.indexOf(child);
 }
 
 /********************************************************************/
 /*                 KisNodeDummiesGraph                              */
 /********************************************************************/
 
 KisNodeDummiesGraph::KisNodeDummiesGraph()
     : m_rootDummy(0)
 {
 }
 
 KisNodeDummy* KisNodeDummiesGraph::rootDummy() const
 {
     return m_rootDummy;
 }
 
 void KisNodeDummiesGraph::addNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis)
 {
     Q_ASSERT(!containsNode(node->node()));
 
     node->setParent(parent);
 
     Q_ASSERT_X(parent || !m_rootDummy, "KisNodeDummiesGraph::addNode", "Trying to add second root dummy");
     Q_ASSERT_X(!parent || m_rootDummy, "KisNodeDummiesGraph::addNode", "Trying to add non-orphan child with no root dummy set");
 
     if(!parent) {
         m_rootDummy = node;
     }
     else {
         int insertionIndex = parent->m_children.size();
 
         insertionIndex = aboveThis ?
             parent->m_children.indexOf(aboveThis) + 1: 0;
 
         Q_ASSERT(!aboveThis || parent->m_children.indexOf(aboveThis) >= 0);
 
         parent->m_children.insert(insertionIndex, node);
     }
 
     m_dummiesMap[node->node()] = node;
 }
 
 void KisNodeDummiesGraph::removeNode(KisNodeDummy *node)
 {
     Q_ASSERT(containsNode(node->node()));
     unmapDummyRecursively(node);
 
     KisNodeDummy *parent = node->parent();
     Q_ASSERT_X(m_rootDummy, "KisNodeDummiesGraph::removeNode", "Trying to remove a dummy with no root dummy");
 
     if(!parent) {
         m_rootDummy = 0;
     }
     else {
         parent->m_children.removeOne(node);
     }
 }
 
 void KisNodeDummiesGraph::unmapDummyRecursively(KisNodeDummy *dummy)
 {
     m_dummiesMap.remove(dummy->node());
 
     KisNodeDummy *child = dummy->firstChild();
     while(child) {
         unmapDummyRecursively(child);
         child = child->nextSibling();
     }
 }
 
 
 void KisNodeDummiesGraph::moveNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis)
 {
     removeNode(node);
     addNode(node, parent, aboveThis);
 }
 
 bool KisNodeDummiesGraph::containsNode(KisNodeSP node) const
 {
     return m_dummiesMap.contains(node);
 }
 
 int KisNodeDummiesGraph::dummiesCount() const
 {
     return m_dummiesMap.size();
 }
 
 KisNodeDummy* KisNodeDummiesGraph::nodeToDummy(KisNodeSP node)
 {
     if (!m_dummiesMap.contains(node)) {
         return 0;
     }
 
     return m_dummiesMap[node];
 }
diff --git a/libs/ui/flake/kis_node_dummies_graph.h b/libs/ui/flake/kis_node_dummies_graph.h
index 65e2a4f09e..215653b7d1 100644
--- a/libs/ui/flake/kis_node_dummies_graph.h
+++ b/libs/ui/flake/kis_node_dummies_graph.h
@@ -1,146 +1,148 @@
 /*
  *  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_NODE_DUMMIES_GRAPH_H
 #define __KIS_NODE_DUMMIES_GRAPH_H
 
 #include <QList>
 #include <QMap>
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 #include "kis_node.h"
 
 class KisNodeShape;
 
 /**
  * KisNodeDummy is a simplified representation of a node
  * in the node stack. It stores all the hierarchy information
  * about the node, so you needn't access from the node
  * directly (actually, you cannot do it usually, because UI
  * works in a different thread and race conditions are possible).
  *
  * The dummy stores a KisNodeShape which can store a pointer to
  * to node. You can access to the node data through it, but take
  * care -- not all the information is accessible in
  * multithreading environment.
  *
  * The ownership on the KisNodeShape is taken by the dummy.
  * The ownership on the children of the dummy is taken as well.
  */
 
 class KRITAUI_EXPORT KisNodeDummy : public QObject
 {
     Q_OBJECT
 
 public:
     /**
      * Take care that KisNodeDummy does not take ownership over
      * the \p nodeShape since the handling of the removal of the
      * children of the shape is done by flake. So please handle it
      * manually.
      *
      * The children dummies of the dummy are still owned by the
      * dummy and are deleted automatically.
      */
     KisNodeDummy(KisNodeShape *nodeShape, KisNodeSP node);
     ~KisNodeDummy() override;
 
     KisNodeDummy* firstChild() const;
     KisNodeDummy* lastChild() const;
     KisNodeDummy* nextSibling() const;
     KisNodeDummy* prevSibling() const;
     KisNodeDummy* parent() const;
 
     KisNodeDummy* at(int index) const;
     int childCount() const;
     int indexOf(KisNodeDummy *child) const;
 
     KisNodeSP node() const;
 
+    bool isGUIVisible(bool showGlobalSelection) const;
+
 private:
     friend class KisNodeShapesGraph; // for ::nodeShape() method
     friend class KisNodeShapesGraphTest;
     KisNodeShape* nodeShape() const;
 
     friend class KisNodeDummiesGraph;
     QList<KisNodeDummy*> m_children;
 
     KisNodeShape *m_nodeShape;
     KisNodeSP m_node;
 };
 
 /**
  * KisNodeDummiesGraph manages the hierarchy of dummy objects
  * representing nodes in the UI environment.
  */
 
 class KRITAUI_EXPORT KisNodeDummiesGraph
 {
 public:
     KisNodeDummiesGraph();
 
     KisNodeDummy* rootDummy() const;
 
     KisNodeDummy* nodeToDummy(KisNodeSP node);
     bool containsNode(KisNodeSP node) const;
     int dummiesCount() const;
 
     /**
      * Adds a dummy \p node to the position specified
      * by \p parent and \p aboveThis.
      *
      * It is not expected that you would add a dummy twice.
      */
     void addNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis);
 
     /**
      * Moves a dummy \p node from its current position to
      * the position specified by \p parent and \p aboveThis.
      *
      * It is expected that the dummy \p node has been added
      * to the graph with addNode() before calling this function.
      */
     void moveNode(KisNodeDummy *node, KisNodeDummy *parent, KisNodeDummy *aboveThis);
 
     /**
      * Removes the dummy \p node from the graph.
      *
      * WARNING: The dummy is only "unlinked" from the graph. Neither
      * deletion of the node nor deletion of its children happens.
      * The dummy keeps maintaining its children so after unlinking
      * it from the graph you can just type to free memory recursively:
      * \code
      * graph.removeNode(node);
      * delete node;
      * \endcode
      */
     void removeNode(KisNodeDummy *node);
 
 private:
     void unmapDummyRecursively(KisNodeDummy *dummy);
 
 private:
     typedef QMap<KisNodeSP, KisNodeDummy*> NodeMap;
 
 private:
     KisNodeDummy *m_rootDummy;
     NodeMap m_dummiesMap;
 };
 
 #endif /* __KIS_NODE_DUMMIES_GRAPH_H */
diff --git a/libs/ui/flake/kis_shape_layer.cc b/libs/ui/flake/kis_shape_layer.cc
index f5191fe744..4757138e8d 100644
--- a/libs/ui/flake/kis_shape_layer.cc
+++ b/libs/ui/flake/kis_shape_layer.cc
@@ -1,754 +1,754 @@
 /*
  *  Copyright (c) 2006-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 Jan Hambrecht <jaham@gmx.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_shape_layer.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QRect>
 #include <QDomElement>
 #include <QDomDocument>
 #include <QString>
 #include <QList>
 #include <QMap>
 #include <kis_debug.h>
 #include <kundo2command.h>
 #include <commands_new/kis_node_move_command2.h>
 #include <QMimeData>
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KisDocument.h>
 #include <KoUnit.h>
 #include <KoOdf.h>
 #include <KoOdfReadStore.h>
 #include <KoOdfStylesReader.h>
 #include <KoOdfLoadingContext.h>
 #include <KoPageLayout.h>
 #include <KoShapeContainer.h>
 #include <KoShapeLayer.h>
 #include <KoShapeGroup.h>
 #include <KoShapeLoadingContext.h>
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeSavingContext.h>
 #include <KoStore.h>
 #include <KoShapeControllerBase.h>
 #include <KoStoreDevice.h>
 #include <KoViewConverter.h>
 #include <KoXmlNS.h>
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoSelection.h>
 #include <KoShapeMoveCommand.h>
 #include <KoShapeTransformCommand.h>
 #include <KoShapeShadow.h>
 #include <KoShapeShadowCommand.h>
 
 #include "SvgWriter.h"
 #include "SvgParser.h"
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include "kis_default_bounds.h"
 #include <kis_paint_device.h>
 #include "kis_shape_layer_canvas.h"
 #include "kis_image_view_converter.h"
 #include <kis_painter.h>
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_effect_mask.h"
 #include "commands/KoShapeReorderCommand.h"
 #include "kis_do_something_command.h"
 
 
 #include <SimpleShapeContainerModel.h>
 class ShapeLayerContainerModel : public SimpleShapeContainerModel
 {
 public:
     ShapeLayerContainerModel(KisShapeLayer *parent)
         : q(parent)
 {}
 
     void add(KoShape *child) override {
         SimpleShapeContainerModel::add(child);
 
         /**
          * The shape is always added with the absolute transformation set appropriately.
          * Here we should just squeeze it into the layer's transformation.
          */
         KIS_SAFE_ASSERT_RECOVER_NOOP(inheritsTransform(child));
         if (inheritsTransform(child)) {
             QTransform parentTransform = q->absoluteTransformation(0);
             child->applyAbsoluteTransformation(parentTransform.inverted());
         }
     }
 
     void remove(KoShape *child) override {
         KIS_SAFE_ASSERT_RECOVER_NOOP(inheritsTransform(child));
         if (inheritsTransform(child)) {
             QTransform parentTransform = q->absoluteTransformation(0);
             child->applyAbsoluteTransformation(parentTransform);
         }
 
         SimpleShapeContainerModel::remove(child);
     }
 
     void shapeHasBeenAddedToHierarchy(KoShape *shape, KoShapeContainer *addedToSubtree) override {
         q->shapeManager()->addShape(shape);
         SimpleShapeContainerModel::shapeHasBeenAddedToHierarchy(shape, addedToSubtree);
     }
 
     void shapeToBeRemovedFromHierarchy(KoShape *shape, KoShapeContainer *removedFromSubtree) override {
         q->shapeManager()->remove(shape);
         SimpleShapeContainerModel::shapeToBeRemovedFromHierarchy(shape, removedFromSubtree);
     }
 
 private:
     KisShapeLayer *q;
 };
 
 
 struct KisShapeLayer::Private
 {
 public:
     Private()
         : canvas(0)
         , controller(0)
         , x(0)
         , y(0)
          {}
 
     KisPaintDeviceSP paintDevice;
     KisShapeLayerCanvasBase * canvas;
     KoShapeControllerBase* controller;
     int x;
     int y;
 };
 
 
 KisShapeLayer::KisShapeLayer(KoShapeControllerBase* controller,
                              KisImageWSP image,
                              const QString &name,
                              quint8 opacity)
     : KisExternalLayer(image, name, opacity),
       KoShapeLayer(new ShapeLayerContainerModel(this)),
       m_d(new Private())
 {
     initShapeLayer(controller);
 }
 
 KisShapeLayer::KisShapeLayer(const KisShapeLayer& rhs)
     : KisShapeLayer(rhs, rhs.m_d->controller)
 {
 }
 
 KisShapeLayer::KisShapeLayer(const KisShapeLayer& _rhs, KoShapeControllerBase* controller, KisShapeLayerCanvasBase *canvas)
         : KisExternalLayer(_rhs)
         , KoShapeLayer(new ShapeLayerContainerModel(this)) //no _rhs here otherwise both layer have the same KoShapeContainerModel
         , m_d(new Private())
 {
     // copy the projection to avoid extra round of updates!
     initShapeLayer(controller, _rhs.m_d->paintDevice, canvas);
 
     /**
      * The transformaitons of the added shapes are automatically merged into the transformation
      * of the layer, so we should apply this extra transform separately
      */
     const QTransform thisInvertedTransform = this->absoluteTransformation(0).inverted();
 
     m_d->canvas->shapeManager()->setUpdatesBlocked(true);
 
     Q_FOREACH (KoShape *shape, _rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         clonedShape->setTransformation(shape->absoluteTransformation(0) * thisInvertedTransform);
         addShape(clonedShape);
     }
 
     m_d->canvas->shapeManager()->setUpdatesBlocked(false);
 }
 
 KisShapeLayer::KisShapeLayer(const KisShapeLayer& _rhs, const KisShapeLayer &_addShapes)
         : KisExternalLayer(_rhs)
         , KoShapeLayer(new ShapeLayerContainerModel(this)) //no _merge here otherwise both layer have the same KoShapeContainerModel
         , m_d(new Private())
 {
     // Make sure our new layer is visible otherwise the shapes cannot be painted.
     setVisible(true);
 
     initShapeLayer(_rhs.m_d->controller);
 
     /**
      * With current implementation this matrix will always be an identity, because
      * we do not copy the transformation from any of the source layers. But we should
      * handle this anyway, to not be caught by this in the future.
      */
     const QTransform thisInvertedTransform = this->absoluteTransformation(0).inverted();
 
     QList<KoShape *> shapesAbove;
     QList<KoShape *> shapesBelow;
 
     // copy in _rhs's shapes
     Q_FOREACH (KoShape *shape, _rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         clonedShape->setTransformation(shape->absoluteTransformation(0) * thisInvertedTransform);
         shapesBelow.append(clonedShape);
     }
 
     // copy in _addShapes's shapes
     Q_FOREACH (KoShape *shape, _addShapes.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         clonedShape->setTransformation(shape->absoluteTransformation(0) * thisInvertedTransform);
         shapesAbove.append(clonedShape);
     }
 
     QList<KoShapeReorderCommand::IndexedShape> shapes =
         KoShapeReorderCommand::mergeDownShapes(shapesBelow, shapesAbove);
     KoShapeReorderCommand cmd(shapes);
     cmd.redo();
 
     Q_FOREACH (KoShape *shape, shapesBelow + shapesAbove) {
         addShape(shape);
     }
 }
 
 KisShapeLayer::KisShapeLayer(KoShapeControllerBase* controller,
                              KisImageWSP image,
                              const QString &name,
                              quint8 opacity,
                              KisShapeLayerCanvasBase *canvas)
         : KisExternalLayer(image, name, opacity)
         , KoShapeLayer(new ShapeLayerContainerModel(this))
         , m_d(new Private())
 {
     initShapeLayer(controller, nullptr, canvas);
 }
 
 KisShapeLayer::~KisShapeLayer()
 {
     /**
      * Small hack alert: we should avoid updates on shape deletion
      */
     m_d->canvas->prepareForDestroying();
 
     Q_FOREACH (KoShape *shape, shapes()) {
         shape->setParent(0);
         delete shape;
     }
 
     delete m_d->canvas;
     delete m_d;
 }
 
 void KisShapeLayer::initShapeLayer(KoShapeControllerBase* controller, KisPaintDeviceSP copyFromProjection, KisShapeLayerCanvasBase *canvas)
 {
     setSupportsLodMoves(false);
     setShapeId(KIS_SHAPE_LAYER_ID);
 
     KIS_ASSERT_RECOVER_NOOP(this->image());
 
     if (!copyFromProjection) {
         m_d->paintDevice = new KisPaintDevice(image()->colorSpace());
         m_d->paintDevice->setDefaultBounds(new KisDefaultBounds(this->image()));
         m_d->paintDevice->setParentNode(this);
     } else {
         m_d->paintDevice = new KisPaintDevice(*copyFromProjection);
     }
 
     if (!canvas) {
         auto *slCanvas = new KisShapeLayerCanvas(this, image());
         slCanvas->setProjection(m_d->paintDevice);
         canvas = slCanvas;
     }
 
     m_d->canvas = canvas;
     m_d->canvas->moveToThread(this->thread());
     m_d->controller = controller;
 
     m_d->canvas->shapeManager()->selection()->disconnect(this);
 
     connect(m_d->canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
     connect(m_d->canvas->selectedShapesProxy(), SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             this, SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(this, SIGNAL(sigMoveShapes(QPointF)), SLOT(slotMoveShapes(QPointF)));
 }
 
 bool KisShapeLayer::allowAsChild(KisNodeSP node) const
 {
     return node->inherits("KisMask");
 }
 
 void KisShapeLayer::setImage(KisImageWSP _image)
 {
     KisLayer::setImage(_image);
     m_d->canvas->setImage(_image);
     m_d->paintDevice->convertTo(_image->colorSpace());
     m_d->paintDevice->setDefaultBounds(new KisDefaultBounds(_image));
 }
 
 KisLayerSP KisShapeLayer::createMergedLayerTemplate(KisLayerSP prevLayer)
 {
     KisShapeLayer *prevShape = dynamic_cast<KisShapeLayer*>(prevLayer.data());
 
     if (prevShape)
         return new KisShapeLayer(*prevShape, *this);
     else
         return KisExternalLayer::createMergedLayerTemplate(prevLayer);
 }
 
 void KisShapeLayer::fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer)
 {
     if (!dynamic_cast<KisShapeLayer*>(dstLayer.data())) {
         KisLayer::fillMergedLayerTemplate(dstLayer, prevLayer);
     }
 }
 
 void KisShapeLayer::setParent(KoShapeContainer *parent)
 {
     Q_UNUSED(parent)
-    KIS_ASSERT_RECOVER_RETURN(0)
+    KIS_ASSERT_RECOVER_RETURN(0);
 }
 
 QIcon KisShapeLayer::icon() const
 {
     return KisIconUtils::loadIcon("vectorLayer");
 }
 
 KisPaintDeviceSP KisShapeLayer::original() const
 {
     return m_d->paintDevice;
 }
 
 KisPaintDeviceSP KisShapeLayer::paintDevice() const
 {
     return 0;
 }
 
 qint32 KisShapeLayer::x() const
 {
     return m_d->x;
 }
 
 qint32 KisShapeLayer::y() const
 {
     return m_d->y;
 }
 
 void KisShapeLayer::setX(qint32 x)
 {
     qint32 delta = x - this->x();
     QPointF diff = QPointF(m_d->canvas->viewConverter()->viewToDocumentX(delta), 0);
     emit sigMoveShapes(diff);
 
     // Save new value to satisfy LSP
     m_d->x = x;
 }
 
 void KisShapeLayer::setY(qint32 y)
 {
     qint32 delta = y - this->y();
     QPointF diff = QPointF(0, m_d->canvas->viewConverter()->viewToDocumentY(delta));
     emit sigMoveShapes(diff);
 
     // Save new value to satisfy LSP
     m_d->y = y;
 }
 namespace {
 void filterTransformableShapes(QList<KoShape*> &shapes)
 {
     auto it = shapes.begin();
     while (it != shapes.end()) {
         if (shapes.size() == 1) break;
 
         if ((*it)->inheritsTransformFromAny(shapes)) {
             it = shapes.erase(it);
         } else {
             ++it;
         }
     }
 }
 }
 
 QList<KoShape *> KisShapeLayer::shapesToBeTransformed()
 {
     QList<KoShape*> shapes = shapeManager()->shapes();
 
     // We expect that **all** the shapes inherit the transform from its parent
 
     // SANITY_CHECK: we expect all the shapes inside the
     //               shape layer to inherit transform!
     Q_FOREACH (KoShape *shape, shapes) {
         if (shape->parent()) {
             KIS_SAFE_ASSERT_RECOVER(shape->parent()->inheritsTransform(shape)) {
                 break;
             }
         }
     }
 
     shapes << this;
     filterTransformableShapes(shapes);
     return shapes;
 }
 
 void KisShapeLayer::slotMoveShapes(const QPointF &diff)
 {
     QList<KoShape*> shapes = shapesToBeTransformed();
     if (shapes.isEmpty()) return;
 
     KoShapeMoveCommand cmd(shapes, diff);
     cmd.redo();
 }
 
 bool KisShapeLayer::accept(KisNodeVisitor& visitor)
 {
     return visitor.visit(this);
 }
 
 void KisShapeLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 KoShapeManager* KisShapeLayer::shapeManager() const
 {
     return m_d->canvas->shapeManager();
 }
 
 KoViewConverter* KisShapeLayer::converter() const
 {
     return m_d->canvas->viewConverter();
 }
 
 bool KisShapeLayer::visible(bool recursive) const
 {
     return KisExternalLayer::visible(recursive);
 }
 
 void KisShapeLayer::setVisible(bool visible, bool isLoading)
 {
     const bool oldVisible = this->visible(false);
 
     KoShapeLayer::setVisible(visible);
     KisExternalLayer::setVisible(visible, isLoading);
 
     if (visible && !oldVisible &&
         m_d->canvas->hasChangedWhileBeingInvisible()) {
 
         m_d->canvas->rerenderAfterBeingInvisible();
     }
 }
 
 void KisShapeLayer::setUserLocked(bool value)
 {
     KoShapeLayer::setGeometryProtected(value);
     KisExternalLayer::setUserLocked(value);
 }
 
 bool KisShapeLayer::isShapeEditable(bool recursive) const
 {
     return KoShapeLayer::isShapeEditable(recursive) && isEditable(true);
 }
 
 // we do not override KoShape::setGeometryProtected() as we consider
 // the user not being able to access the layer shape from Krita UI!
 
 void KisShapeLayer::forceUpdateTimedNode()
 {
     m_d->canvas->forceRepaint();
 }
 
 bool KisShapeLayer::hasPendingTimedUpdates() const
 {
     return m_d->canvas->hasPendingUpdates();
 }
 
 void KisShapeLayer::forceUpdateHiddenAreaOnOriginal()
 {
     m_d->canvas->forceRepaintWithHiddenAreas();
 }
 
 bool KisShapeLayer::saveShapesToStore(KoStore *store, QList<KoShape *> shapes, const QSizeF &sizeInPt)
 {
     if (!store->open("content.svg")) {
         return false;
     }
 
     KoStoreDevice storeDev(store);
     storeDev.open(QIODevice::WriteOnly);
 
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     SvgWriter writer(shapes);
     writer.save(storeDev, sizeInPt);
 
     if (!store->close()) {
         return false;
     }
 
     return true;
 }
 
 QList<KoShape *> KisShapeLayer::createShapesFromSvg(QIODevice *device, const QString &baseXmlDir, const QRectF &rectInPixels, qreal resolutionPPI, KoDocumentResourceManager *resourceManager, QSizeF *fragmentSize)
 {
 
     QString errorMsg;
     int errorLine = 0;
     int errorColumn;
 
     KoXmlDocument doc = SvgParser::createDocumentFromSvg(device, &errorMsg, &errorLine, &errorColumn);
     if (doc.isNull()) {
         errKrita << "Parsing error in " << "contents.svg" << "! Aborting!" << endl
         << " In line: " << errorLine << ", column: " << errorColumn << endl
         << " Error message: " << errorMsg << endl;
         errKrita << i18n("Parsing error in the main document at line %1, column %2\nError message: %3"
                          , errorLine , errorColumn , errorMsg);
     }
 
     SvgParser parser(resourceManager);
     parser.setXmlBaseDir(baseXmlDir);
     parser.setResolution(rectInPixels /* px */, resolutionPPI /* ppi */);
     return parser.parseSvg(doc.documentElement(), fragmentSize);
 }
 
 
 bool KisShapeLayer::saveLayer(KoStore * store) const
 {
     // FIXME: we handle xRes() only!
 
     const QSizeF sizeInPx = image()->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / image()->xRes(), sizeInPx.height() / image()->yRes());
 
     return saveShapesToStore(store, this->shapes(), sizeInPt);
 }
 
 bool KisShapeLayer::loadSvg(QIODevice *device, const QString &baseXmlDir)
 {
     QSizeF fragmentSize; // unused!
     KisImageSP image = this->image();
 
     // FIXME: we handle xRes() only!
     KIS_SAFE_ASSERT_RECOVER_NOOP(qFuzzyCompare(image->xRes(), image->yRes()));
     const qreal resolutionPPI = 72.0 * image->xRes();
 
     QList<KoShape*> shapes =
         createShapesFromSvg(device, baseXmlDir,
                             image->bounds(), resolutionPPI,
                             m_d->controller->resourceManager(),
                             &fragmentSize);
 
     Q_FOREACH (KoShape *shape, shapes) {
         addShape(shape);
     }
 
     return true;
 }
 
 bool KisShapeLayer::loadLayer(KoStore* store)
 {
     if (!store) {
         warnKrita << i18n("No store backend");
         return false;
     }
 
     if (store->open("content.svg")) {
         KoStoreDevice storeDev(store);
         storeDev.open(QIODevice::ReadOnly);
 
         loadSvg(&storeDev, "");
 
         store->close();
 
         return true;
     }
 
     KoOdfReadStore odfStore(store);
     QString errorMessage;
 
     odfStore.loadAndParse(errorMessage);
 
     if (!errorMessage.isEmpty()) {
         warnKrita << errorMessage;
         return false;
     }
 
     KoXmlElement contents = odfStore.contentDoc().documentElement();
 
     //    dbgKrita <<"Start loading OASIS document..." << contents.text();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().localName();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().namespaceURI();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().isElement();
 
     KoXmlElement body(KoXml::namedItemNS(contents, KoXmlNS::office, "body"));
 
     if (body.isNull()) {
         //setErrorMessage( i18n( "Invalid OASIS document. No office:body tag found." ) );
         return false;
     }
 
     body = KoXml::namedItemNS(body, KoXmlNS::office, "drawing");
     if (body.isNull()) {
         //setErrorMessage( i18n( "Invalid OASIS document. No office:drawing tag found." ) );
         return false;
     }
 
     KoXmlElement page(KoXml::namedItemNS(body, KoXmlNS::draw, "page"));
     if (page.isNull()) {
         //setErrorMessage( i18n( "Invalid OASIS document. No draw:page tag found." ) );
         return false;
     }
 
     KoXmlElement * master = 0;
     if (odfStore.styles().masterPages().contains("Standard"))
         master = odfStore.styles().masterPages().value("Standard");
     else if (odfStore.styles().masterPages().contains("Default"))
         master = odfStore.styles().masterPages().value("Default");
     else if (! odfStore.styles().masterPages().empty())
         master = odfStore.styles().masterPages().begin().value();
 
     if (master) {
         const KoXmlElement *style = odfStore.styles().findStyle(
                                         master->attributeNS(KoXmlNS::style, "page-layout-name", QString()));
         KoPageLayout pageLayout;
         pageLayout.loadOdf(*style);
         setSize(QSizeF(pageLayout.width, pageLayout.height));
     }
     // We work fine without a master page
 
     KoOdfLoadingContext context(odfStore.styles(), odfStore.store());
     context.setManifestFile(QString("tar:/") + odfStore.store()->currentPath() + "META-INF/manifest.xml");
     KoShapeLoadingContext shapeContext(context, m_d->controller->resourceManager());
 
 
     KoXmlElement layerElement;
     forEachElement(layerElement, context.stylesReader().layerSet()) {
         // FIXME: investigate what is this
         //        KoShapeLayer * l = new KoShapeLayer();
         if (!loadOdf(layerElement, shapeContext)) {
             dbgKrita << "Could not load vector layer!";
             return false;
         }
     }
 
     KoXmlElement child;
     forEachElement(child, page) {
         KoShape * shape = KoShapeRegistry::instance()->createShapeFromOdf(child, shapeContext);
         if (shape) {
             addShape(shape);
         }
     }
 
     return true;
 
 }
 
 void KisShapeLayer::resetCache()
 {
     m_d->canvas->resetCache();
 }
 
 KUndo2Command* KisShapeLayer::crop(const QRect & rect)
 {
     QPoint oldPos(x(), y());
     QPoint newPos = oldPos - rect.topLeft();
 
     return new KisNodeMoveCommand2(this, oldPos, newPos);
 }
 
 KUndo2Command* KisShapeLayer::transform(const QTransform &transform) {
     QList<KoShape*> shapes = shapesToBeTransformed();
     if (shapes.isEmpty()) return 0;
 
     KisImageViewConverter *converter = dynamic_cast<KisImageViewConverter*>(this->converter());
     QTransform realTransform = converter->documentToView() *
         transform * converter->viewToDocument();
 
     QList<QTransform> oldTransformations;
     QList<QTransform> newTransformations;
 
     QList<KoShapeShadow*> newShadows;
     const qreal transformBaseScale = KoUnit::approxTransformScale(transform);
 
     Q_FOREACH (const KoShape* shape, shapes) {
         QTransform oldTransform = shape->transformation();
         oldTransformations.append(oldTransform);
 
         QTransform globalTransform = shape->absoluteTransformation(0);
         QTransform localTransform = globalTransform * realTransform * globalTransform.inverted();
         newTransformations.append(localTransform * oldTransform);
 
         KoShapeShadow *shadow = 0;
 
         if (shape->shadow()) {
             shadow = new KoShapeShadow(*shape->shadow());
             shadow->setOffset(transformBaseScale * shadow->offset());
             shadow->setBlur(transformBaseScale * shadow->blur());
         }
 
         newShadows.append(shadow);
 
     }
 
     KUndo2Command *parentCommand = new KUndo2Command();
     new KoShapeTransformCommand(shapes,
                                 oldTransformations,
                                 newTransformations,
                                 parentCommand);
 
     new KoShapeShadowCommand(shapes,
                              newShadows,
                              parentCommand);
 
     return parentCommand;
 }
 
 KUndo2Command *KisShapeLayer::setProfile(const KoColorProfile *profile)
 {
     using namespace KisDoSomethingCommandOps;
 
     KUndo2Command *cmd = new KUndo2Command();
     new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, false, cmd);
     m_d->paintDevice->setProfile(profile, cmd);
     new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, true, cmd);
 
     return cmd;
 }
 
 KUndo2Command *KisShapeLayer::convertTo(const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     using namespace KisDoSomethingCommandOps;
 
     KUndo2Command *cmd = new KUndo2Command();
     new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, false, cmd);
     m_d->paintDevice->convertTo(dstColorSpace, renderingIntent, conversionFlags, cmd);
     new KisDoSomethingCommand<ResetOp, KisShapeLayer*>(this, true, cmd);
     return cmd;
 }
 
 KoShapeControllerBase *KisShapeLayer::shapeController() const
 {
     return m_d->controller;
 }
diff --git a/libs/ui/flake/kis_shape_layer.h b/libs/ui/flake/kis_shape_layer.h
index aa6f2083a4..fa55e2d73d 100644
--- a/libs/ui/flake/kis_shape_layer.h
+++ b/libs/ui/flake/kis_shape_layer.h
@@ -1,207 +1,207 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Thomas Zander <zander@kde.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_SHAPE_LAYER_H_
 #define KIS_SHAPE_LAYER_H_
 
 #include <KoShapeLayer.h>
 
 #include <kis_types.h>
 #include <kis_external_layer_iface.h>
 #include <kritaui_export.h>
 #include <KisDelayedUpdateNodeInterface.h>
 #include <KisCroppedOriginalLayerInterface.h>
 
 class QRect;
 class QIcon;
 class QRect;
 class QString;
 class KoShapeManager;
 class KoStore;
 class KoViewConverter;
 class KoShapeControllerBase;
 class KoDocumentResourceManager;
 class KisShapeLayerCanvasBase;
 
 const QString KIS_SHAPE_LAYER_ID = "KisShapeLayer";
 /**
    A KisShapeLayer contains any number of non-krita flakes, such as
    path shapes, text shapes and anything else people come up with.
 
    The KisShapeLayer has a shapemanager and a canvas of its own. The
    canvas paints onto the projection, and the projection is what we
    render in Krita. This means that no matter how many views you have,
    you cannot have a different view on your shapes per view.
 
    XXX: what about removing shapes?
 */
 class KRITAUI_EXPORT KisShapeLayer
         : public KisExternalLayer,
         public KoShapeLayer,
         public KisDelayedUpdateNodeInterface,
         public KisCroppedOriginalLayerInterface
 {
     Q_OBJECT
 
 public:
 
     KisShapeLayer(KoShapeControllerBase* shapeController, KisImageWSP image, const QString &name, quint8 opacity);
     KisShapeLayer(const KisShapeLayer& _rhs);
     KisShapeLayer(const KisShapeLayer& _rhs, KoShapeControllerBase* controller, KisShapeLayerCanvasBase *canvas = 0);
     /**
      * Merge constructor.
      *
      * Creates a new layer as a merge of two existing layers.
      *
      * This is used by createMergedLayer()
      */
     KisShapeLayer(const KisShapeLayer& _merge, const KisShapeLayer &_addShapes);
     ~KisShapeLayer() override;
 protected:
     KisShapeLayer(KoShapeControllerBase* shapeController, KisImageWSP image, const QString &name, quint8 opacity, KisShapeLayerCanvasBase *canvas);
 private:
     void initShapeLayer(KoShapeControllerBase* controller, KisPaintDeviceSP copyFromProjection = 0, KisShapeLayerCanvasBase *canvas = 0);
 public:
     KisNodeSP clone() const override {
         return new KisShapeLayer(*this);
     }
     bool allowAsChild(KisNodeSP) const override;
 
 
     void setImage(KisImageWSP image) override;
 
     KisLayerSP createMergedLayerTemplate(KisLayerSP prevLayer) override;
     void fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer) override;
 public:
 
     // KoShape overrides
     bool isSelectable() const {
         return false;
     }
 
     void setParent(KoShapeContainer *parent);
 
     // KisExternalLayer implementation
     QIcon icon() const override;
     void resetCache() override;
 
     KisPaintDeviceSP original() const override;
     KisPaintDeviceSP paintDevice() const override;
 
     qint32 x() const override;
     qint32 y() const override;
     void setX(qint32) override;
     void setY(qint32) override;
 
     bool accept(KisNodeVisitor&) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KoShapeManager *shapeManager() const;
 
     static bool saveShapesToStore(KoStore *store, QList<KoShape*> shapes, const QSizeF &sizeInPt);
 
     static QList<KoShape *> createShapesFromSvg(QIODevice *device,
                                                 const QString &baseXmlDir,
                                                 const QRectF &rectInPixels,
                                                 qreal resolutionPPI,
                                                 KoDocumentResourceManager *resourceManager,
                                                 QSizeF *fragmentSize);
 
 
 
     bool saveLayer(KoStore * store) const;
     bool loadLayer(KoStore* store);
 
     KUndo2Command* crop(const QRect & rect) override;
     KUndo2Command* transform(const QTransform &transform) override;
     KUndo2Command* setProfile(const KoColorProfile *profile) override;
     KUndo2Command* convertTo(const KoColorSpace * dstColorSpace,
                                  KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
-                                 KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
+                                 KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) override;
 
 
     bool visible(bool recursive = false) const override;
     void setVisible(bool visible, bool isLoading = false) override;
 
     void setUserLocked(bool value) override;
 
     bool isShapeEditable(bool recursive) const override;
 
     /**
      * Forces a repaint of a shape layer without waiting for an event loop
      * calling a delayed timer update. If you want to see the result of the shape
      * layer right here and right now, you should do:
      *
      * shapeLayer->setDirty();
      * shapeLayer->image()->waitForDone();
      * shapeLayer->forceUpdateTimedNode();
      * shapeLayer->image()->waitForDone();
      *
      */
     void forceUpdateTimedNode() override;
 
     /**
      * \return true if there are any pending updates in the delayed queue
      */
     bool hasPendingTimedUpdates() const override;
 
     void forceUpdateHiddenAreaOnOriginal() override;
 
 protected:
     using KoShape::isVisible;
 
     bool loadSvg(QIODevice *device, const QString &baseXmlDir);
 
     friend class ShapeLayerContainerModel;
     KoViewConverter* converter() const;
 
     KoShapeControllerBase *shapeController() const;
 
 Q_SIGNALS:
     /**
      * These signals are forwarded from the local shape manager
      * This is done because we switch KoShapeManager and therefore
      * KoSelection in KisCanvas2, so we need to connect local managers
      * to the UI as well.
      *
      * \see comment in the constructor of KisCanvas2
      */
     void selectionChanged();
     void currentLayerChanged(const KoShapeLayer *layer);
 
 Q_SIGNALS:
     /**
      * A signal + slot to synchronize UI and image
      * threads. Image thread emits the signal, UI
      * thread performs the action
      */
     void sigMoveShapes(const QPointF &diff);
 
 private Q_SLOTS:
     void slotMoveShapes(const QPointF &diff);
 
 private:
     QList<KoShape*> shapesToBeTransformed();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/flake/kis_shape_layer_canvas.cpp b/libs/ui/flake/kis_shape_layer_canvas.cpp
index d7879c26d5..3676366f82 100644
--- a/libs/ui/flake/kis_shape_layer_canvas.cpp
+++ b/libs/ui/flake/kis_shape_layer_canvas.cpp
@@ -1,419 +1,426 @@
 /*
  *  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.
  */
 
 #include "kis_shape_layer_canvas.h"
 
 #include <QPainter>
 #include <QMutexLocker>
 
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxySimple.h>
 #include <KoViewConverter.h>
 #include <KoColorSpace.h>
 
 #include <kis_paint_device.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_painter.h>
 #include <flake/kis_shape_layer.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include "kis_image_view_converter.h"
 
 #include <kis_debug.h>
 
 #include <QThread>
 #include <QApplication>
 
 #include <kis_spontaneous_job.h>
 #include "kis_global.h"
 
 //#define DEBUG_REPAINT
 
 KisShapeLayerCanvasBase::KisShapeLayerCanvasBase(KisShapeLayer *parent, KisImageWSP image)
     : KoCanvasBase(0)
     , m_viewConverter(new KisImageViewConverter(image))
     , m_shapeManager(new KoShapeManager(this))
     , m_selectedShapesProxy(new KoSelectedShapesProxySimple(m_shapeManager.data()))
 {
     m_shapeManager->selection()->setActiveLayer(parent);
 }
 
 KoShapeManager *KisShapeLayerCanvasBase::shapeManager() const
 {
     return m_shapeManager.data();
 }
 
 KoSelectedShapesProxy *KisShapeLayerCanvasBase::selectedShapesProxy() const
 {
     return m_selectedShapesProxy.data();
 }
 
 KoViewConverter* KisShapeLayerCanvasBase::viewConverter() const
 {
     return m_viewConverter.data();
 }
 
 void KisShapeLayerCanvasBase::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     Q_UNUSED(offset);
     Q_UNUSED(spacing);
 }
 
 bool KisShapeLayerCanvasBase::snapToGrid() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return false;
 }
 
 void KisShapeLayerCanvasBase::addCommand(KUndo2Command *)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
 }
 
 
 KoToolProxy * KisShapeLayerCanvasBase::toolProxy() const
 {
 //     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return 0;
 }
 
 QWidget* KisShapeLayerCanvasBase::canvasWidget()
 {
     return 0;
 }
 
 const QWidget* KisShapeLayerCanvasBase::canvasWidget() const
 {
     return 0;
 }
 
 KoUnit KisShapeLayerCanvasBase::unit() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return KoUnit(KoUnit::Point);
 }
 
 void KisShapeLayerCanvasBase::prepareForDestroying()
 {
     m_isDestroying = true;
 }
 
 bool KisShapeLayerCanvasBase::hasChangedWhileBeingInvisible()
 {
     return m_hasChangedWhileBeingInvisible;
 }
 
 
 KisShapeLayerCanvas::KisShapeLayerCanvas(KisShapeLayer *parent, KisImageWSP image)
         : KisShapeLayerCanvasBase(parent, image)
         , m_projection(0)
         , m_parentLayer(parent)
         , m_canvasUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
         , m_asyncUpdateSignalCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     /**
      * The layour should also add itself to its own shape manager, so that the canvas
      * would track its changes/transformations
      */
     m_shapeManager->addShape(parent, KoShapeManager::AddWithoutRepaint);
     m_shapeManager->selection()->setActiveLayer(parent);
 
     connect(&m_asyncUpdateSignalCompressor, SIGNAL(timeout()), SLOT(slotStartAsyncRepaint()));
     connect(this, SIGNAL(forwardRepaint()), &m_canvasUpdateCompressor, SLOT(start()));
     connect(&m_canvasUpdateCompressor, SIGNAL(timeout()), this, SLOT(slotStartDirectSyncRepaint()));
 
     setImage(image);
 }
 
 KisShapeLayerCanvas::~KisShapeLayerCanvas()
 {
     m_shapeManager->remove(m_parentLayer);
 }
 
 void KisShapeLayerCanvas::setImage(KisImageWSP image)
 {
     if (m_image) {
         disconnect(m_image, 0, this, 0);
     }
 
     m_viewConverter->setImage(image);
     m_image = image;
 
     if (image) {
         connect(m_image, SIGNAL(sigSizeChanged(QPointF,QPointF)), SLOT(slotImageSizeChanged()));
         m_cachedImageRect = m_image->bounds();
     }
 
     updateUpdateCompressorDelay();
 }
 
 
 #ifdef DEBUG_REPAINT
 # include <stdlib.h>
 #endif
 
 
 class KisRepaintShapeLayerLayerJob : public KisSpontaneousJob
 {
 public:
     KisRepaintShapeLayerLayerJob(KisShapeLayerSP layer, KisShapeLayerCanvas *canvas)
         : m_layer(layer),
           m_canvas(canvas)
     {
     }
 
     bool overrides(const KisSpontaneousJob *_otherJob) override {
         const KisRepaintShapeLayerLayerJob *otherJob =
             dynamic_cast<const KisRepaintShapeLayerLayerJob*>(_otherJob);
 
         return otherJob && otherJob->m_canvas == m_canvas;
     }
 
     void run() override {
         m_canvas->repaint();
     }
 
     int levelOfDetail() const override {
         return 0;
     }
 
+    QString debugName() const override {
+        QString result;
+        QDebug dbg(&result);
+        dbg << "KisRepaintShapeLayerLayerJob" << m_layer;
+        return result;
+    }
+
 private:
 
     // we store a pointer to the layer just
     // to keep the lifetime of the canvas!
     KisShapeLayerSP m_layer;
 
     KisShapeLayerCanvas *m_canvas;
 };
 
 
 void KisShapeLayerCanvas::updateCanvas(const QVector<QRectF> &region)
 {
     if (!m_parentLayer->image() || m_isDestroying) {
         return;
     }
 
     {
         QMutexLocker locker(&m_dirtyRegionMutex);
         Q_FOREACH (const QRectF &rc, region) {
             // grow for antialiasing
             const QRect imageRect = kisGrowRect(m_viewConverter->documentToView(rc).toAlignedRect(), 2);
             m_dirtyRegion += imageRect;
         }
     }
 
     /**
      * HACK ALERT!
      *
      * The shapes may be accessed from both, GUI and worker threads! And we have no real
      * guard against this until the vector tools will be ported to the strokes framework.
      *
      * Here we just avoid the most obvious conflict of threads:
      *
      * 1) If the layer is modified by a non-gui (worker) thread, use a spontaneous jobs
      *    to rerender the canvas. The job will be executed (almost) exclusively and it is
      *    the responsibility of the worker thread to add a barrier to wait until this job is
      *    completed, and not try to access the shapes concurrently.
      *
      * 2) If the layer is modified by a gui thread, it means that we are being accessed by
      *    a legacy vector tool. It this case just emit a queued signal to make sure the updates
      *    are compressed a little bit (TODO: add a compressor?)
      */
 
     if (qApp->thread() == QThread::currentThread()) {
         emit forwardRepaint();
         m_hasDirectSyncRepaintInitiated = true;
     } else {
         m_asyncUpdateSignalCompressor.start();
         m_hasUpdateInCompressor = true;
     }
 }
 
 
 void KisShapeLayerCanvas::updateCanvas(const QRectF& rc)
 {
     updateCanvas(QVector<QRectF>({rc}));
 }
 
 void KisShapeLayerCanvas::slotStartAsyncRepaint()
 {
     m_hasUpdateInCompressor = false;
     m_image->addSpontaneousJob(new KisRepaintShapeLayerLayerJob(m_parentLayer, this));
 }
 
 void KisShapeLayerCanvas::slotStartDirectSyncRepaint()
 {
     m_hasDirectSyncRepaintInitiated = false;
     repaint();
 }
 
 void KisShapeLayerCanvas::slotImageSizeChanged()
 {
     QRegion dirtyCacheRegion;
     dirtyCacheRegion += m_image->bounds();
     dirtyCacheRegion += m_cachedImageRect;
     dirtyCacheRegion -= m_image->bounds() & m_cachedImageRect;
 
     QVector<QRectF> dirtyRects;
     Q_FOREACH (const QRect &rc, dirtyCacheRegion.rects()) {
         dirtyRects.append(m_viewConverter->viewToDocument(rc));
     }
     updateCanvas(dirtyRects);
 
     m_cachedImageRect = m_image->bounds();
     updateUpdateCompressorDelay();
 }
 
 void KisShapeLayerCanvas::repaint()
 {
     QRect repaintRect;
     bool forceUpdateHiddenAreasOnly = false;
 
     {
         QMutexLocker locker(&m_dirtyRegionMutex);
         repaintRect = m_dirtyRegion.boundingRect();
         forceUpdateHiddenAreasOnly = m_forceUpdateHiddenAreasOnly;
 
         m_dirtyRegion = QRegion();
         m_forceUpdateHiddenAreasOnly = false;
     }
 
     if (!forceUpdateHiddenAreasOnly) {
         if (repaintRect.isEmpty()) {
             return;
         }
 
         // Crop the update rect by the image bounds. We keep the cache consistent
         // by tracking the size of the image in slotImageSizeChanged()
         repaintRect = repaintRect.intersected(m_parentLayer->image()->bounds());
     } else {
         const QRectF shapesBounds = KoShape::boundingRect(m_shapeManager->shapes());
         repaintRect = kisGrowRect(m_viewConverter->documentToView(shapesBounds).toAlignedRect(), 2);
     }
 
     const QRect r = repaintRect;
     const qint32 MASK_IMAGE_WIDTH = 256;
     const qint32 MASK_IMAGE_HEIGHT = 256;
 
     QImage image(MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT, QImage::Format_ARGB32);
     QPainter tempPainter(&image);
 
     tempPainter.setRenderHint(QPainter::Antialiasing);
     tempPainter.setRenderHint(QPainter::TextAntialiasing);
 
     quint8 * dstData = new quint8[MASK_IMAGE_WIDTH * MASK_IMAGE_HEIGHT * m_projection->pixelSize()];
 
     for (qint32 x = r.x(); x < r.x() + r.width(); x += MASK_IMAGE_WIDTH) {
         for (qint32 y = r.y(); y < r.y() + r.height(); y += MASK_IMAGE_HEIGHT) {
 
             image.fill(0);
             tempPainter.translate(-x, -y);
             tempPainter.setClipRect(QRect(x,y,MASK_IMAGE_WIDTH,MASK_IMAGE_HEIGHT));
 
             #ifdef DEBUG_REPAINT
                 QColor color = QColor(random() % 255, random() % 255, random() % 255);
                 maskPainter.fillRect(srcRect, color);
             #endif
 
             m_shapeManager->paint(tempPainter, *m_viewConverter, false);
 
             tempPainter.translate(x, y);
 
             KoColorSpaceRegistry::instance()->rgb8()
             ->convertPixelsTo(image.constBits(), dstData, m_projection->colorSpace(),
                               MASK_IMAGE_WIDTH * MASK_IMAGE_HEIGHT,
                               KoColorConversionTransformation::internalRenderingIntent(),
                               KoColorConversionTransformation::internalConversionFlags());
 
             m_projection->writeBytes(dstData, x, y, MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT);
         }
     }
     delete[] dstData;
     m_projection->purgeDefaultPixels();
     m_parentLayer->setDirty(repaintRect);
 
     m_hasChangedWhileBeingInvisible |= !m_parentLayer->visible(true);
 }
 
 void KisShapeLayerCanvas::forceRepaint()
 {
     /**
      * WARNING! Although forceRepaint() may be called from different threads, it is
      * not entirely safe. If the user plays with shapes at the same time (vector tools are
      * not ported to strokes yet), the shapes my be accessed from two different places at
      * the same time, which will cause a crash.
      *
      * The only real solution to this is to port vector tools to strokes framework.
      */
 
     if (hasPendingUpdates()) {
         m_asyncUpdateSignalCompressor.stop();
         slotStartAsyncRepaint();
     }
 }
 
 bool KisShapeLayerCanvas::hasPendingUpdates() const
 {
     return m_hasUpdateInCompressor || m_hasDirectSyncRepaintInitiated;
 }
 
 void KisShapeLayerCanvas::forceRepaintWithHiddenAreas()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->image());
     KIS_SAFE_ASSERT_RECOVER_RETURN(!m_isDestroying);
 
     {
         QMutexLocker locker(&m_dirtyRegionMutex);
         m_forceUpdateHiddenAreasOnly = true;
     }
 
     m_asyncUpdateSignalCompressor.stop();
     slotStartAsyncRepaint();
 }
 
 void KisShapeLayerCanvas::resetCache()
 {
     m_projection->clear();
 
     QList<KoShape*> shapes = m_shapeManager->shapes();
     Q_FOREACH (const KoShape* shape, shapes) {
         shape->update();
     }
 }
 
 void KisShapeLayerCanvas::rerenderAfterBeingInvisible()
 {
-    KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->visible(true))
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->visible(true));
 
     m_hasChangedWhileBeingInvisible = false;
     resetCache();
 }
 
 void KisShapeLayerCanvas::updateUpdateCompressorDelay()
 {
     if (m_cachedImageRect.width() * m_cachedImageRect.height() < 2480 * 3508) { // A4 300 DPI
         m_canvasUpdateCompressor.setDelay(25);
     } else if (m_cachedImageRect.width() * m_cachedImageRect.height() < 4961 * 7061) { // A4 600 DPI
         m_canvasUpdateCompressor.setDelay(100);
     } else { // Really big
         m_canvasUpdateCompressor.setDelay(500);
     }
 }
diff --git a/libs/ui/flake/kis_shape_selection.cpp b/libs/ui/flake/kis_shape_selection.cpp
index e5f12e3ff6..4af0df5092 100644
--- a/libs/ui/flake/kis_shape_selection.cpp
+++ b/libs/ui/flake/kis_shape_selection.cpp
@@ -1,408 +1,416 @@
 /*
  *  Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2011 Jan Hambrecht <jaham@gmx.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_shape_selection.h"
 
 
 #include <QPainter>
 #include <QTimer>
 #include <kundo2command.h>
 #include <QMimeData>
 #include <QApplication>
 #include <QThread>
 
 #include <KoShapeStroke.h>
 #include <KoPathShape.h>
 #include <KoShapeGroup.h>
 #include <KoCompositeOp.h>
 #include <KoShapeManager.h>
 #include <KisDocument.h>
 
 #include <KoEmbeddedDocumentSaver.h>
 #include <KoGenStyles.h>
 #include <KoOdfLoadingContext.h>
 #include <KoOdfReadStore.h>
 #include <KoOdfStylesReader.h>
 #include <KoOdfWriteStore.h>
 #include <KoXmlNS.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeLoadingContext.h>
 #include <KoXmlWriter.h>
 #include <KoStore.h>
 #include <KoShapeController.h>
 #include <KoShapeSavingContext.h>
 #include <KoStoreDevice.h>
 #include <KoShapeTransformCommand.h>
 #include <KoElementReference.h>
 
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_selection.h>
 
 #include "kis_shape_selection_model.h"
 #include "kis_shape_selection_canvas.h"
 #include "kis_take_all_shapes_command.h"
 #include "kis_image_view_converter.h"
 #include "kis_shape_layer.h"
 
 
 #include <kis_debug.h>
 
 KisShapeSelection::KisShapeSelection(KoShapeControllerBase *shapeControllerBase, KisImageWSP image, KisSelectionWSP selection)
     : KoShapeLayer(m_model = new KisShapeSelectionModel(image, selection, this))
     , m_image(image)
     , m_shapeControllerBase(shapeControllerBase)
 {
     Q_ASSERT(m_image);
     setShapeId("KisShapeSelection");
     setSelectable(false);
     m_converter = new KisImageViewConverter(image);
     m_canvas = new KisShapeSelectionCanvas(shapeControllerBase);
     m_canvas->shapeManager()->addShape(this);
 
     m_model->setObjectName("KisShapeSelectionModel");
     m_model->moveToThread(image->thread());
     m_canvas->setObjectName("KisShapeSelectionCanvas");
     m_canvas->moveToThread(image->thread());
 
     connect(this, SIGNAL(sigMoveShapes(QPointF)), SLOT(slotMoveShapes(QPointF)));
 }
 
 KisShapeSelection::~KisShapeSelection()
 {
     m_model->setShapeSelection(0);
     delete m_canvas;
     delete m_converter;
 }
 
 KisShapeSelection::KisShapeSelection(const KisShapeSelection& rhs, KisSelection* selection)
     : KoShapeLayer(m_model = new KisShapeSelectionModel(rhs.m_image, selection, this))
 {
     m_image = rhs.m_image;
     m_shapeControllerBase = rhs.m_shapeControllerBase;
     m_converter = new KisImageViewConverter(m_image);
     m_canvas = new KisShapeSelectionCanvas(m_shapeControllerBase);
-    m_canvas->shapeManager()->addShape(this);
 
+    // TODO: refactor shape selection to pass signals
+    //       via KoShapeManager, not via the model
+    m_canvas->shapeManager()->setUpdatesBlocked(true);
+    m_model->setUpdatesEnabled(false);
+
+    m_canvas->shapeManager()->addShape(this);
     Q_FOREACH (KoShape *shape, rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         this->addShape(clonedShape);
     }
+
+    m_canvas->shapeManager()->setUpdatesBlocked(false);
+    m_model->setUpdatesEnabled(true);
 }
 
 KisSelectionComponent* KisShapeSelection::clone(KisSelection* selection)
 {
     /**
      * TODO: make cloning of vector selections safe! Right now it crashes
      * on Windows because of manipulations with timers from non-gui thread.
      */
     KIS_SAFE_ASSERT_RECOVER_NOOP(QThread::currentThread() == qApp->thread());
 
     return new KisShapeSelection(*this, selection);
 }
 
 bool KisShapeSelection::saveSelection(KoStore * store) const
 {
     const QSizeF sizeInPx = m_image->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_image->xRes(), sizeInPx.height() / m_image->yRes());
 
     return KisShapeLayer::saveShapesToStore(store, this->shapes(), sizeInPt);
 }
 
 bool KisShapeSelection::loadSelection(KoStore* store)
 {
     QSizeF fragmentSize; // unused!
 
     // FIXME: we handle xRes() only!
     KIS_SAFE_ASSERT_RECOVER_NOOP(qFuzzyCompare(m_image->xRes(), m_image->yRes()));
     const qreal resolutionPPI = 72.0 * m_image->xRes();
 
     QList<KoShape*> shapes;
 
     if (store->open("content.svg")) {
         KoStoreDevice storeDev(store);
         storeDev.open(QIODevice::ReadOnly);
 
         shapes = KisShapeLayer::createShapesFromSvg(&storeDev,
                                                     "", m_image->bounds(),
                                                     resolutionPPI, m_canvas->shapeController()->resourceManager(),
                                                     &fragmentSize);
 
         store->close();
 
         Q_FOREACH (KoShape *shape, shapes) {
             addShape(shape);
         }
 
         return true;
     }
 
 
     KoOdfReadStore odfStore(store);
     QString errorMessage;
 
     odfStore.loadAndParse(errorMessage);
 
     if (!errorMessage.isEmpty()) {
         dbgKrita << errorMessage;
         return false;
     }
 
     KoXmlElement contents = odfStore.contentDoc().documentElement();
 
     //    dbgKrita <<"Start loading OASIS document..." << contents.text();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().localName();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().namespaceURI();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().isElement();
 
     KoXmlElement body(KoXml::namedItemNS(contents, KoXmlNS::office, "body"));
 
     if (body.isNull()) {
         dbgKrita << "No office:body found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No office:body tag found." ) );
         return false;
     }
 
     body = KoXml::namedItemNS(body, KoXmlNS::office, "drawing");
     if (body.isNull()) {
         dbgKrita << "No office:drawing found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No office:drawing tag found." ) );
         return false;
     }
 
     KoXmlElement page(KoXml::namedItemNS(body, KoXmlNS::draw, "page"));
     if (page.isNull()) {
         dbgKrita << "No office:drawing found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No draw:page tag found." ) );
         return false;
     }
 
     KoXmlElement * master = 0;
     if (odfStore.styles().masterPages().contains("Standard"))
         master = odfStore.styles().masterPages().value("Standard");
     else if (odfStore.styles().masterPages().contains("Default"))
         master = odfStore.styles().masterPages().value("Default");
     else if (! odfStore.styles().masterPages().empty())
         master = odfStore.styles().masterPages().begin().value();
 
     if (master) {
         const KoXmlElement *style = odfStore.styles().findStyle(
                     master->attributeNS(KoXmlNS::style, "page-layout-name", QString()));
         KoPageLayout pageLayout;
         pageLayout.loadOdf(*style);
         setSize(QSizeF(pageLayout.width, pageLayout.height));
     } else {
         dbgKrita << "No master page found!";
         return false;
     }
 
     KoOdfLoadingContext context(odfStore.styles(), odfStore.store());
     KoShapeLoadingContext shapeContext(context, 0);
 
     KoXmlElement layerElement;
     forEachElement(layerElement, context.stylesReader().layerSet()) {
         if (!loadOdf(layerElement, shapeContext)) {
             dbgKrita << "Could not load vector layer!";
             return false;
         }
     }
 
     KoXmlElement child;
     forEachElement(child, page) {
         KoShape * shape = KoShapeRegistry::instance()->createShapeFromOdf(child, shapeContext);
         if (shape) {
             addShape(shape);
         }
     }
 
     return true;
 }
 
 void KisShapeSelection::setUpdatesEnabled(bool enabled)
 {
     m_model->setUpdatesEnabled(enabled);
 }
 
 bool KisShapeSelection::updatesEnabled() const
 {
     return m_model->updatesEnabled();
 }
 
 KUndo2Command* KisShapeSelection::resetToEmpty()
 {
     return new KisTakeAllShapesCommand(this, true);
 }
 
 bool KisShapeSelection::isEmpty() const
 {
     return !m_model->count();
 }
 
 QPainterPath KisShapeSelection::outlineCache() const
 {
     return m_outline;
 }
 
 bool KisShapeSelection::outlineCacheValid() const
 {
     return true;
 }
 
 void KisShapeSelection::recalculateOutlineCache()
 {
     QList<KoShape*> shapesList = shapes();
 
     QPainterPath outline;
     Q_FOREACH (KoShape * shape, shapesList) {
         QTransform shapeMatrix = shape->absoluteTransformation(0);
         outline = outline.united(shapeMatrix.map(shape->outline()));
     }
 
     QTransform resolutionMatrix;
     resolutionMatrix.scale(m_image->xRes(), m_image->yRes());
 
     m_outline = resolutionMatrix.map(outline);
 }
 
 void KisShapeSelection::paintComponent(QPainter& painter, const KoViewConverter& converter, KoShapePaintingContext &)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
 }
 
 void KisShapeSelection::renderToProjection(KisPaintDeviceSP projection)
 {
     Q_ASSERT(projection);
     Q_ASSERT(m_image);
 
     QRectF boundingRect = outlineCache().boundingRect();
     renderSelection(projection, boundingRect.toAlignedRect());
 }
 
 void KisShapeSelection::renderToProjection(KisPaintDeviceSP projection, const QRect& r)
 {
     Q_ASSERT(projection);
     renderSelection(projection, r);
 }
 
 void KisShapeSelection::renderSelection(KisPaintDeviceSP projection, const QRect& requestedRect)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(projection);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_image);
 
     const qint32 MASK_IMAGE_WIDTH = 256;
     const qint32 MASK_IMAGE_HEIGHT = 256;
 
     const QPainterPath selectionOutline = outlineCache();
 
     if (*projection->defaultPixel().data() == OPACITY_TRANSPARENT_U8) {
         projection->clear(requestedRect);
     } else {
         KoColor transparentColor(Qt::transparent, projection->colorSpace());
         projection->fill(requestedRect, transparentColor);
     }
     const QRect r = requestedRect & selectionOutline.boundingRect().toAlignedRect();
 
     QImage polygonMaskImage(MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT, QImage::Format_ARGB32);
     QPainter maskPainter(&polygonMaskImage);
     maskPainter.setRenderHint(QPainter::Antialiasing, true);
 
     // Break the mask up into chunks so we don't have to allocate a potentially very large QImage.
     for (qint32 x = r.x(); x < r.x() + r.width(); x += MASK_IMAGE_WIDTH) {
         for (qint32 y = r.y(); y < r.y() + r.height(); y += MASK_IMAGE_HEIGHT) {
 
             maskPainter.fillRect(polygonMaskImage.rect(), Qt::black);
             maskPainter.translate(-x, -y);
             maskPainter.fillPath(selectionOutline, Qt::white);
             maskPainter.translate(x, y);
 
             qint32 rectWidth = qMin(r.x() + r.width() - x, MASK_IMAGE_WIDTH);
             qint32 rectHeight = qMin(r.y() + r.height() - y, MASK_IMAGE_HEIGHT);
 
             KisSequentialIterator it(projection, QRect(x, y, rectWidth, rectHeight));
             while (it.nextPixel()) {
                 (*it.rawData()) = qRed(polygonMaskImage.pixel(it.x() - x, it.y() - y));
             }
         }
     }
 }
 
 KoShapeManager* KisShapeSelection::shapeManager() const
 {
     return m_canvas->shapeManager();
 }
 
 KisShapeSelectionFactory::KisShapeSelectionFactory()
     : KoShapeFactoryBase("KisShapeSelection", "selection shape container")
 {
     setHidden(true);
 }
 
 void KisShapeSelection::moveX(qint32 x)
 {
     const QPointF diff(x / m_image->xRes(), 0);
     emit sigMoveShapes(diff);
 }
 
 void KisShapeSelection::moveY(qint32 y)
 {
     const QPointF diff(0, y / m_image->yRes());
     emit sigMoveShapes(diff);
 }
 
 void KisShapeSelection::slotMoveShapes(const QPointF &diff)
 {
     Q_FOREACH (KoShape* shape, shapeManager()->shapes()) {
         if (shape != this) {
             QPointF pos = shape->position();
             shape->setPosition(pos + diff);
         }
     }
 }
 
 // TODO same code as in vector layer, refactor!
 KUndo2Command* KisShapeSelection::transform(const QTransform &transform) {
     QList<KoShape*> shapes = m_canvas->shapeManager()->shapes();
     if(shapes.isEmpty()) return 0;
 
     QTransform realTransform = m_converter->documentToView() *
             transform * m_converter->viewToDocument();
 
     QList<QTransform> oldTransformations;
     QList<QTransform> newTransformations;
 
     // this code won't work if there are shapes, that inherit the transformation from the parent container.
     // the chart and tree shapes are examples for that, but they aren't used in krita and there are no other shapes like that.
     Q_FOREACH (const KoShape* shape, shapes) {
         QTransform oldTransform = shape->transformation();
         oldTransformations.append(oldTransform);
         if (dynamic_cast<const KoShapeGroup*>(shape)) {
             newTransformations.append(oldTransform);
         } else {
             QTransform globalTransform = shape->absoluteTransformation(0);
             QTransform localTransform = globalTransform * realTransform * globalTransform.inverted();
             newTransformations.append(localTransform*oldTransform);
         }
     }
 
     return new KoShapeTransformCommand(shapes, oldTransformations, newTransformations);
 }
diff --git a/libs/ui/kis_model_index_converter.cpp b/libs/ui/kis_model_index_converter.cpp
index f41cde44f1..075a4b4e9d 100644
--- a/libs/ui/kis_model_index_converter.cpp
+++ b/libs/ui/kis_model_index_converter.cpp
@@ -1,197 +1,197 @@
 /*
  *  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_model_index_converter.h"
 
 #include "kis_selection_mask.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_node_model.h"
 #include "kis_node_manager.h"
 #include "KisReferenceImagesLayer.h"
 #include "KisDecorationsWrapperLayer.h"
 
 
 KisModelIndexConverter::KisModelIndexConverter(KisDummiesFacadeBase *dummiesFacade,
                                                KisNodeModel *model,
                                                bool showGlobalSelection)
     : m_dummiesFacade(dummiesFacade),
       m_model(model),
       m_showGlobalSelection(showGlobalSelection)
 {
 }
 
 inline bool KisModelIndexConverter::checkDummyType(KisNodeDummy *dummy)
 {
-    return !KisNodeManager::isNodeHidden(dummy->node(), !m_showGlobalSelection);
+    return dummy->isGUIVisible(m_showGlobalSelection);
 }
 
 inline bool KisModelIndexConverter::checkDummyMetaObjectType(const QString &type)
 {
     const QString selectionMaskType = KisSelectionMask::staticMetaObject.className();
     const QString referencesLayerType = KisReferenceImagesLayer::staticMetaObject.className();
     const QString decorationsLayerType = KisDecorationsWrapperLayer::staticMetaObject.className();
 
     return (type != selectionMaskType || m_showGlobalSelection) &&
             type != referencesLayerType &&
             type != decorationsLayerType;
 }
 
 KisNodeDummy* KisModelIndexConverter::dummyFromRow(int row, QModelIndex parent)
 {
 
     KisNodeDummy *parentDummy = parent.isValid() ?
         dummyFromIndex(parent) : m_dummiesFacade->rootDummy();
 
     if(!parentDummy) return 0;
 
     KisNodeDummy *resultDummy = 0;
 
     // a child of the root node
     if(!parentDummy->parent()) {
         KisNodeDummy *currentDummy = parentDummy->lastChild();
         while(currentDummy) {
             if(checkDummyType(currentDummy)) {
                 if(!row) {
                     resultDummy = currentDummy;
                     break;
                 }
                 row--;
             }
             currentDummy = currentDummy->prevSibling();
         }
     }
     // a child of other layer
     else {
         int rowCount = parentDummy->childCount();
         int index = rowCount - row - 1;
         resultDummy = parentDummy->at(index);
     }
 
 
     return resultDummy;
 }
 
 KisNodeDummy* KisModelIndexConverter::dummyFromIndex(QModelIndex index)
 {
     Q_ASSERT(index.isValid());
     Q_ASSERT(index.internalPointer());
     return static_cast<KisNodeDummy*>(index.internalPointer());
 }
 
 QModelIndex KisModelIndexConverter::indexFromDummy(KisNodeDummy *dummy)
 {
     Q_ASSERT(dummy);
     KisNodeDummy *parentDummy = dummy->parent();
 
     // a root node
     if(!parentDummy) return QModelIndex();
 
     int row = 0;
 
     // a child of the root node
     if(!parentDummy->parent()) {
         if(!checkDummyType(dummy)) return QModelIndex();
 
         KisNodeDummy *currentDummy = parentDummy->lastChild();
         while(currentDummy && currentDummy != dummy) {
             if(checkDummyType(currentDummy)) {
                 row++;
             }
             currentDummy = currentDummy->prevSibling();
         }
     }
     // a child of other layer
     else {
         int rowCount = parentDummy->childCount();
         int index = parentDummy->indexOf(dummy);
         row = rowCount - index - 1;
     }
 
     return m_model->createIndex(row, 0, (void*)dummy);
 }
 
 bool KisModelIndexConverter::indexFromAddedDummy(KisNodeDummy *parentDummy,
                                                  int index,
                                                  const QString &newNodeMetaObjectType,
                                                  QModelIndex &parentIndex,
                                                  int &row)
 {
     // adding a root node
     if(!parentDummy) {
         Q_ASSERT(!index);
         return false;
     }
 
     // adding a child of the root node
     if(!parentDummy->parent()) {
         if(!checkDummyMetaObjectType(newNodeMetaObjectType)) {
             return false;
         }
 
         row = 0;
 
         parentIndex = QModelIndex();
         KisNodeDummy *dummy = parentDummy->lastChild();
         int toScan = parentDummy->childCount() - index;
         while(dummy && toScan > 0) {
             if(checkDummyType(dummy)) {
                 row++;
             }
             dummy = dummy->prevSibling();
             toScan--;
         }
     }
     // everything else
     else {
         parentIndex = indexFromDummy(parentDummy);
         int rowCount = parentDummy->childCount();
         row = rowCount - index;
     }
 
     return true;
 }
 
 int KisModelIndexConverter::rowCount(QModelIndex parent)
 {
     KisNodeDummy *dummy = parent.isValid() ?
         dummyFromIndex(parent) : m_dummiesFacade->rootDummy();
 
     // a root node (hidden)
     if(!dummy) return 0;
 
     int numChildren = 0;
 
     // children of the root node
     if(!dummy->parent()) {
         KisNodeDummy *currentDummy = dummy->lastChild();
         while(currentDummy) {
             if(checkDummyType(currentDummy)) {
                 numChildren++;
             }
 
             currentDummy = currentDummy->prevSibling();
         }
     }
     // children of other nodes
     else {
         numChildren = dummy->childCount();
     }
 
     return numChildren;
 }
diff --git a/libs/ui/kis_node_manager.cpp b/libs/ui/kis_node_manager.cpp
index 138114d2bc..f9918f17a3 100644
--- a/libs/ui/kis_node_manager.cpp
+++ b/libs/ui/kis_node_manager.cpp
@@ -1,1580 +1,1580 @@
 /*
  *  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.
  */
 
 #include "kis_node_manager.h"
 
 #include <QStandardPaths>
 #include <QMessageBox>
 #include <KisSignalMapper.h>
 #include <QApplication>
 
 #include <kactioncollection.h>
 
 #include <QKeySequence>
 
 #include <kis_icon.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoShape.h>
 #include <KoShapeLayer.h>
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KoToolManager.h>
 #include <KoProperties.h>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_image.h>
 #include <kis_painter.h>
 #include <kis_paint_layer.h>
 #include <KisMimeDatabase.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "KisPart.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_shape_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_mask_manager.h"
 #include "kis_group_layer.h"
 #include "kis_layer_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_processing_applicator.h"
 #include "kis_sequential_iterator.h"
 #include "kis_transaction.h"
 #include "kis_node_selection_adapter.h"
 #include "kis_node_insertion_adapter.h"
 #include "kis_node_juggler_compressed.h"
 #include "KisNodeDisplayModeAdapter.h"
 #include "kis_clipboard.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_mimedata.h"
 #include "kis_layer_utils.h"
 #include "krita_utils.h"
 #include "kis_shape_layer.h"
 
 #include "processing/kis_mirror_processing_visitor.h"
 #include "KisView.h"
 
 #include <kis_signals_blocker.h>
 #include <libs/image/kis_layer_properties_icons.h>
 #include <libs/image/commands/kis_node_property_list_command.h>
 
 struct KisNodeManager::Private {
 
     Private(KisNodeManager *_q, KisViewManager *v)
         : q(_q)
         , view(v)
         , imageView(0)
         , layerManager(v)
         , maskManager(v)
         , commandsAdapter(v)
         , nodeSelectionAdapter(new KisNodeSelectionAdapter(q))
         , nodeInsertionAdapter(new KisNodeInsertionAdapter(q))
         , nodeDisplayModeAdapter(new KisNodeDisplayModeAdapter())
         , lastRequestedIsolatedModeStatus(false)
     {
     }
 
     KisNodeManager * q;
     KisViewManager * view;
     QPointer<KisView>imageView;
     KisLayerManager layerManager;
     KisMaskManager maskManager;
     KisNodeCommandsAdapter commandsAdapter;
     QScopedPointer<KisNodeSelectionAdapter> nodeSelectionAdapter;
     QScopedPointer<KisNodeInsertionAdapter> nodeInsertionAdapter;
     QScopedPointer<KisNodeDisplayModeAdapter> nodeDisplayModeAdapter;
 
     KisAction *showInTimeline;
 
     KisNodeList selectedNodes;
     QPointer<KisNodeJugglerCompressed> nodeJuggler;
 
     KisNodeWSP previouslyActiveNode;
 
     bool activateNodeImpl(KisNodeSP node);
 
     KisSignalMapper nodeCreationSignalMapper;
     KisSignalMapper nodeConversionSignalMapper;
 
     bool lastRequestedIsolatedModeStatus;
 
     void saveDeviceAsImage(KisPaintDeviceSP device,
                            const QString &defaultName,
                            const QRect &bounds,
                            qreal xRes,
                            qreal yRes,
                            quint8 opacity);
 
     void mergeTransparencyMaskAsAlpha(bool writeToLayers);
     KisNodeJugglerCompressed* lazyGetJuggler(const KUndo2MagicString &actionName);
 };
 
 bool KisNodeManager::Private::activateNodeImpl(KisNodeSP node)
 {
     Q_ASSERT(view);
     Q_ASSERT(view->canvasBase());
     Q_ASSERT(view->canvasBase()->globalShapeManager());
     Q_ASSERT(imageView);
     if (node && node == q->activeNode()) {
         return false;
     }
 
     // Set the selection on the shape manager to the active layer
     // and set call KoSelection::setActiveLayer( KoShapeLayer* layer )
     // with the parent of the active layer.
     KoSelection *selection = view->canvasBase()->globalShapeManager()->selection();
     Q_ASSERT(selection);
     selection->deselectAll();
 
     if (!node) {
         selection->setActiveLayer(0);
         imageView->setCurrentNode(0);
         maskManager.activateMask(0);
         layerManager.activateLayer(0);
         previouslyActiveNode = q->activeNode();
     } else {
 
         previouslyActiveNode = q->activeNode();
 
         KoShape * shape = view->document()->shapeForNode(node);
 
         //if (!shape) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape, false);
 
         selection->select(shape);
         KoShapeLayer * shapeLayer = dynamic_cast<KoShapeLayer*>(shape);
 
         //if (!shapeLayer) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shapeLayer, false);
 
         //         shapeLayer->setGeometryProtected(node->userLocked());
         //         shapeLayer->setVisible(node->visible());
         selection->setActiveLayer(shapeLayer);
 
         imageView->setCurrentNode(node);
         if (KisLayerSP layer = qobject_cast<KisLayer*>(node.data())) {
             maskManager.activateMask(0);
             layerManager.activateLayer(layer);
         } else if (KisMaskSP mask = dynamic_cast<KisMask*>(node.data())) {
             maskManager.activateMask(mask);
             // XXX_NODE: for now, masks cannot be nested.
             layerManager.activateLayer(static_cast<KisLayer*>(node->parent().data()));
         }
     }
     return true;
 }
 
 KisNodeManager::KisNodeManager(KisViewManager *view)
     : m_d(new Private(this, view))
 {
 }
 
 KisNodeManager::~KisNodeManager()
 {
     delete m_d;
 }
 
 void KisNodeManager::setView(QPointer<KisView>imageView)
 {
     m_d->maskManager.setView(imageView);
     m_d->layerManager.setView(imageView);
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         shapeController->disconnect(SIGNAL(sigActivateNode(KisNodeSP)), this);
         m_d->imageView->image()->disconnect(this);
     }
 
     m_d->imageView = imageView;
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         connect(shapeController, SIGNAL(sigActivateNode(KisNodeSP)), SLOT(slotNonUiActivatedNode(KisNodeSP)));
         connect(m_d->imageView->image(), SIGNAL(sigIsolatedModeChanged()),this, SLOT(slotUpdateIsolateModeActionImageStatusChange()));
         connect(m_d->imageView->image(), SIGNAL(sigRequestNodeReselection(KisNodeSP,KisNodeList)),this, SLOT(slotImageRequestNodeReselection(KisNodeSP,KisNodeList)));
         m_d->imageView->resourceProvider()->slotNodeActivated(m_d->imageView->currentNode());
     }
 
 }
 
 #define NEW_LAYER_ACTION(id, layerType)                                 \
 {                                                                   \
     action = actionManager->createAction(id);                       \
     m_d->nodeCreationSignalMapper.setMapping(action, layerType);    \
     connect(action, SIGNAL(triggered()),                            \
     &m_d->nodeCreationSignalMapper, SLOT(map()));           \
     }
 
 #define CONVERT_NODE_ACTION_2(id, layerType, exclude)                   \
 {                                                                   \
     action = actionManager->createAction(id);                       \
     action->setExcludedNodeTypes(QStringList(exclude));             \
     actionManager->addAction(id, action);                           \
     m_d->nodeConversionSignalMapper.setMapping(action, layerType);  \
     connect(action, SIGNAL(triggered()),                            \
     &m_d->nodeConversionSignalMapper, SLOT(map()));         \
     }
 
 #define CONVERT_NODE_ACTION(id, layerType)              \
     CONVERT_NODE_ACTION_2(id, layerType, layerType)
 
 void KisNodeManager::setup(KActionCollection * actionCollection, KisActionManager* actionManager)
 {
     m_d->layerManager.setup(actionManager);
     m_d->maskManager.setup(actionCollection, actionManager);
 
     KisAction * action = 0;
 
     action = actionManager->createAction("mirrorNodeX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeX()));
 
     action  = actionManager->createAction("mirrorNodeY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeY()));
 
     action = actionManager->createAction("mirrorAllNodesX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorAllNodesX()));
 
     action  = actionManager->createAction("mirrorAllNodesY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorAllNodesY()));
 
     action = actionManager->createAction("activateNextLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activateNextNode()));
 
     action = actionManager->createAction("activatePreviousLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activatePreviousNode()));
 
     action = actionManager->createAction("switchToPreviouslyActiveNode");
     connect(action, SIGNAL(triggered()), this, SLOT(switchToPreviouslyActiveNode()));
 
     action  = actionManager->createAction("save_node_as_image");
     connect(action, SIGNAL(triggered()), this, SLOT(saveNodeAsImage()));
 
     action  = actionManager->createAction("save_vector_node_to_svg");
     connect(action, SIGNAL(triggered()), this, SLOT(saveVectorLayerAsImage()));
     action->setActivationFlags(KisAction::ACTIVE_SHAPE_LAYER);
 
     action = actionManager->createAction("duplicatelayer");
     connect(action, SIGNAL(triggered()), this, SLOT(duplicateActiveNode()));
 
     action = actionManager->createAction("copy_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(copyLayersToClipboard()));
 
     action = actionManager->createAction("cut_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(cutLayersToClipboard()));
 
     action = actionManager->createAction("paste_layer_from_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(pasteLayersFromClipboard()));
 
     action = actionManager->createAction("create_quick_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickGroup()));
 
     action = actionManager->createAction("create_quick_clipping_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickClippingGroup()));
 
     action = actionManager->createAction("quick_ungroup");
     connect(action, SIGNAL(triggered()), this, SLOT(quickUngroup()));
 
     action = actionManager->createAction("select_all_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectAllNodes()));
 
     action = actionManager->createAction("select_visible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectVisibleNodes()));
 
     action = actionManager->createAction("select_locked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectLockedNodes()));
 
     action = actionManager->createAction("select_invisible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectInvisibleNodes()));
 
     action = actionManager->createAction("select_unlocked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectUnlockedNodes()));
 
     action = actionManager->createAction("new_from_visible");
     connect(action, SIGNAL(triggered()), this, SLOT(createFromVisible()));
 
     action = actionManager->createAction("show_in_timeline");
     action->setCheckable(true);
     connect(action, SIGNAL(toggled(bool)), this, SLOT(slotShowHideTimeline(bool)));
     m_d->showInTimeline = action;
 
     NEW_LAYER_ACTION("add_new_paint_layer", "KisPaintLayer");
 
     NEW_LAYER_ACTION("add_new_group_layer", "KisGroupLayer");
 
     NEW_LAYER_ACTION("add_new_clone_layer", "KisCloneLayer");
 
     NEW_LAYER_ACTION("add_new_shape_layer", "KisShapeLayer");
 
     NEW_LAYER_ACTION("add_new_adjustment_layer", "KisAdjustmentLayer");
 
     NEW_LAYER_ACTION("add_new_fill_layer", "KisGeneratorLayer");
 
     NEW_LAYER_ACTION("add_new_file_layer", "KisFileLayer");
 
     NEW_LAYER_ACTION("add_new_transparency_mask", "KisTransparencyMask");
 
     NEW_LAYER_ACTION("add_new_filter_mask", "KisFilterMask");
 
     NEW_LAYER_ACTION("add_new_colorize_mask", "KisColorizeMask");
 
     NEW_LAYER_ACTION("add_new_transform_mask", "KisTransformMask");
 
     NEW_LAYER_ACTION("add_new_selection_mask", "KisSelectionMask");
 
     connect(&m_d->nodeCreationSignalMapper, SIGNAL(mapped(QString)),
             this, SLOT(createNode(QString)));
 
     CONVERT_NODE_ACTION("convert_to_paint_layer", "KisPaintLayer");
 
     CONVERT_NODE_ACTION_2("convert_to_selection_mask", "KisSelectionMask", QStringList() << "KisSelectionMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_filter_mask", "KisFilterMask", QStringList() << "KisFilterMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_transparency_mask", "KisTransparencyMask", QStringList() << "KisTransparencyMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION("convert_to_animated", "animated");
 
     CONVERT_NODE_ACTION_2("convert_to_file_layer", "KisFileLayer", QStringList() << "KisFileLayer" << "KisCloneLayer");
 
     connect(&m_d->nodeConversionSignalMapper, SIGNAL(mapped(QString)),
             this, SLOT(convertNode(QString)));
 
     action = actionManager->createAction("isolate_layer");
     connect(action, SIGNAL(triggered(bool)), this, SLOT(toggleIsolateMode(bool)));
 
     action = actionManager->createAction("toggle_layer_visibility");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleVisibility()));
 
     action = actionManager->createAction("toggle_layer_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleLock()));
 
     action = actionManager->createAction("toggle_layer_inherit_alpha");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleInheritAlpha()));
 
     action = actionManager->createAction("toggle_layer_alpha_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleAlphaLock()));
 
     action  = actionManager->createAction("split_alpha_into_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaIntoMask()));
 
     action  = actionManager->createAction("split_alpha_write");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaWrite()));
 
     // HINT: we can save even when the nodes are not editable
     action  = actionManager->createAction("split_alpha_save_merged");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaSaveMerged()));
 
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotUpdateIsolateModeAction()));
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotTryRestartIsolatedMode()));
 }
 
 void KisNodeManager::updateGUI()
 {
     // enable/disable all relevant actions
     m_d->layerManager.updateGUI();
     m_d->maskManager.updateGUI();
 }
 
 KisNodeSP KisNodeManager::activeNode()
 {
     if (m_d->imageView) {
         return m_d->imageView->currentNode();
     }
     return 0;
 }
 
 KisLayerSP KisNodeManager::activeLayer()
 {
     return m_d->layerManager.activeLayer();
 }
 
 const KoColorSpace* KisNodeManager::activeColorSpace()
 {
     if (m_d->maskManager.activeDevice()) {
         return m_d->maskManager.activeDevice()->colorSpace();
     } else {
         Q_ASSERT(m_d->layerManager.activeLayer());
         if (m_d->layerManager.activeLayer()->parentLayer())
             return m_d->layerManager.activeLayer()->parentLayer()->colorSpace();
         else
             return m_d->view->image()->colorSpace();
     }
 }
 
 void KisNodeManager::moveNodeAt(KisNodeSP node, KisNodeSP parent, int index)
 {
     if (parent->allowAsChild(node)) {
         if (node->inherits("KisSelectionMask") && parent->inherits("KisLayer")) {
             KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data());
             KisLayer *l = qobject_cast<KisLayer*>(parent.data());
             if (m && m->active() && l && l->selectionMask()) {
                 l->selectionMask()->setActive(false);
             }
         }
         m_d->commandsAdapter.moveNode(node, parent, index);
     }
 }
 
 void KisNodeManager::moveNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Move Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->moveNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::copyNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Copy Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->copyNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::addNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Add Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->addNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::toggleIsolateActiveNode()
 {
     KisImageWSP image = m_d->view->image();
     KisNodeSP activeNode = this->activeNode();
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     if (activeNode == image->isolatedModeRoot()) {
         toggleIsolateMode(false);
     } else {
         toggleIsolateMode(true);
     }
 }
 
 void KisNodeManager::toggleIsolateMode(bool checked)
 {
     KisImageWSP image = m_d->view->image();
 
     KisNodeSP activeNode = this->activeNode();
     if (checked && activeNode) {
 
         // Transform and colorize masks don't have pixel data...
         if (activeNode->inherits("KisTransformMask") ||
                 activeNode->inherits("KisColorizeMask")) return;
 
         if (!image->startIsolatedMode(activeNode)) {
             KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
             action->setChecked(false);
         }
     } else {
         image->stopIsolatedMode();
     }
 
     m_d->lastRequestedIsolatedModeStatus = checked;
 }
 
 void KisNodeManager::slotUpdateIsolateModeActionImageStatusChange()
 {
     slotUpdateIsolateModeAction();
 
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (this->activeNode() &&
             bool(isolatedRootNode) != m_d->lastRequestedIsolatedModeStatus) {
 
         slotTryRestartIsolatedMode();
     }
 }
 
 void KisNodeManager::slotUpdateIsolateModeAction()
 {
     KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
     Q_ASSERT(action);
 
     KisNodeSP activeNode = this->activeNode();
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
 
     action->setChecked(isolatedRootNode && isolatedRootNode == activeNode);
 }
 
 void KisNodeManager::slotTryRestartIsolatedMode()
 {
     /**
      * It might be that we have multiple Krita windows open. In such a case
      * only the currently active one should restart isolated mode
      */
     if (!m_d->view->mainWindow()->isActiveWindow()) return;
 
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (!isolatedRootNode && !m_d->lastRequestedIsolatedModeStatus) return;
 
     this->toggleIsolateMode(true);
 }
 
 KisNodeSP  KisNodeManager::createNode(const QString & nodeType, bool quiet, KisPaintDeviceSP copyFrom)
 {
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) {
         return 0;
     }
 
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(activeNode, 0);
 
     // XXX: make factories for this kind of stuff,
     //      with a registry
 
     if (nodeType == "KisPaintLayer") {
         return m_d->layerManager.addPaintLayer(activeNode);
     } else if (nodeType == "KisGroupLayer") {
         return m_d->layerManager.addGroupLayer(activeNode);
     } else if (nodeType == "KisAdjustmentLayer") {
         return m_d->layerManager.addAdjustmentLayer(activeNode);
     } else if (nodeType == "KisGeneratorLayer") {
         return m_d->layerManager.addGeneratorLayer(activeNode);
     } else if (nodeType == "KisShapeLayer") {
         return m_d->layerManager.addShapeLayer(activeNode);
     } else if (nodeType == "KisCloneLayer") {
         KisNodeList nodes = selectedNodes();
         if (nodes.isEmpty()) {
             nodes.append(activeNode);
         }
 
         return m_d->layerManager.addCloneLayer(nodes);
     } else if (nodeType == "KisTransparencyMask") {
         return m_d->maskManager.createTransparencyMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFilterMask") {
         return m_d->maskManager.createFilterMask(activeNode, copyFrom, quiet, false);
     } else if (nodeType == "KisColorizeMask") {
         return m_d->maskManager.createColorizeMask(activeNode);
     } else if (nodeType == "KisTransformMask") {
         return m_d->maskManager.createTransformMask(activeNode);
     } else if (nodeType == "KisSelectionMask") {
         return m_d->maskManager.createSelectionMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFileLayer") {
         return m_d->layerManager.addFileLayer(activeNode);
     }
     return 0;
 }
 
 void KisNodeManager::createFromVisible()
 {
     KisLayerUtils::newLayerFromVisible(m_d->view->image(), m_d->view->image()->root()->lastChild());
 }
 
 void KisNodeManager::slotShowHideTimeline(bool value)
 {
     Q_FOREACH (KisNodeSP node, selectedNodes()) {
         node->setUseInTimeline(value);
     }
 }
 
 KisLayerSP KisNodeManager::createPaintLayer()
 {
     KisNodeSP node = createNode("KisPaintLayer");
     return dynamic_cast<KisLayer*>(node.data());
 }
 
 void KisNodeManager::convertNode(const QString &nodeType)
 {
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) {
         return;
     }
 
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.convertNodeToPaintLayer(activeNode);
     } else if (nodeType == "KisSelectionMask" ||
                nodeType == "KisFilterMask" ||
                nodeType == "KisTransparencyMask") {
 
         KisPaintDeviceSP copyFrom = activeNode->paintDevice() ?
                     activeNode->paintDevice() : activeNode->projection();
 
         m_d->commandsAdapter.beginMacro(kundo2_i18n("Convert to a Selection Mask"));
 
         bool result = false;
 
         if (nodeType == "KisSelectionMask") {
             result = !m_d->maskManager.createSelectionMask(activeNode, copyFrom, true).isNull();
         } else if (nodeType == "KisFilterMask") {
             result = !m_d->maskManager.createFilterMask(activeNode, copyFrom, false, true).isNull();
         } else if (nodeType == "KisTransparencyMask") {
             result = !m_d->maskManager.createTransparencyMask(activeNode, copyFrom, true).isNull();
         }
 
         m_d->commandsAdapter.endMacro();
 
         if (!result) {
             m_d->view->blockUntilOperationsFinishedForced(m_d->imageView->image());
             m_d->commandsAdapter.undoLastCommand();
         }
 
     } else if (nodeType == "KisFileLayer") {
         m_d->layerManager.convertLayerToFileLayer(activeNode);
     } else {
         warnKrita << "Unsupported node conversion type:" << nodeType;
     }
 }
 
 void KisNodeManager::slotSomethingActivatedNodeImpl(KisNodeSP node)
 {
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     KIS_SAFE_ASSERT_RECOVER_RETURN(dummiesFacade);
 
     const bool nodeVisible = !isNodeHidden(node, !m_d->nodeDisplayModeAdapter->showGlobalSelectionMask());
     if (!nodeVisible) {
         return;
     }
 
     KIS_ASSERT_RECOVER_RETURN(node != activeNode());
     if (m_d->activateNodeImpl(node)) {
         emit sigUiNeedChangeActiveNode(node);
         emit sigNodeActivated(node);
         nodesUpdated();
         if (node) {
             bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
             if (toggled) {
                 m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
             }
         }
     }
 }
 
 void KisNodeManager::slotNonUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 
     if (node) {
         bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
         if (toggled) {
             m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
         }
     }
 }
 
 void KisNodeManager::slotUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node) {
         QStringList vectorTools = QStringList()
                 << "InteractionTool"
                 << "KarbonPatternTool"
                 << "KarbonGradientTool"
                 << "KarbonCalligraphyTool"
                 << "CreateShapesTool"
                 << "PathTool";
 
         QStringList pixelTools = QStringList()
                 << "KritaShape/KisToolBrush"
                 << "KritaShape/KisToolDyna"
                 << "KritaShape/KisToolMultiBrush"
                 << "KritaFill/KisToolFill"
                 << "KritaFill/KisToolGradient";
 
 
         KisSelectionMask *selectionMask = dynamic_cast<KisSelectionMask*>(node.data());
         const bool nodeHasVectorAbilities = node->inherits("KisShapeLayer") ||
                 (selectionMask && selectionMask->selection()->hasShapeSelection());
 
         if (nodeHasVectorAbilities) {
             if (pixelTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("InteractionTool");
             }
         }
         else {
             if (vectorTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
             }
         }
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 }
 
 void KisNodeManager::nodesUpdated()
 {
     KisNodeSP node = activeNode();
     if (!node) return;
 
     m_d->layerManager.layersUpdated();
     m_d->maskManager.masksUpdated();
 
     m_d->view->updateGUI();
     m_d->view->selectionManager()->selectionChanged();
 
     {
         KisSignalsBlocker b(m_d->showInTimeline);
         m_d->showInTimeline->setChecked(node->useInTimeline());
     }
 }
 
 KisPaintDeviceSP KisNodeManager::activePaintDevice()
 {
     return m_d->maskManager.activeMask() ?
                 m_d->maskManager.activeDevice() :
                 m_d->layerManager.activeDevice();
 }
 
 void KisNodeManager::nodeProperties(KisNodeSP node)
 {
     if ((selectedNodes().size() > 1 && node->inherits("KisLayer")) || node->inherits("KisLayer")) {
         m_d->layerManager.layerProperties();
     }
     else if (node->inherits("KisMask")) {
         m_d->maskManager.maskProperties();
     }
 }
 
 void KisNodeManager::changeCloneSource()
 {
     m_d->layerManager.changeCloneSource();
 }
 
 qint32 KisNodeManager::convertOpacityToInt(qreal opacity)
 {
     /**
      * Scales opacity from the range 0...100
      * to the integer range 0...255
      */
 
     return qMin(255, int(opacity * 2.55 + 0.5));
 }
 
 void KisNodeManager::setNodeName(KisNodeSP node, const QString &name)
 {
     if (!node) return;
     if (node->name() == name) return;
 
     m_d->commandsAdapter.setNodeName(node, name);
 
 }
 
 void KisNodeManager::setNodeOpacity(KisNodeSP node, qint32 opacity)
 {
     if (!node) return;
     if (node->opacity() == opacity) return;
 
     m_d->commandsAdapter.setOpacity(node, opacity);
 }
 
 void KisNodeManager::setNodeCompositeOp(KisNodeSP node,
                                         const KoCompositeOp* compositeOp)
 {
     if (!node) return;
     if (node->compositeOp() == compositeOp) return;
 
     m_d->commandsAdapter.setCompositeOp(node, compositeOp);
 }
 
 void KisNodeManager::slotImageRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes)
 {
     if (activeNode) {
         slotNonUiActivatedNode(activeNode);
     }
     if (!selectedNodes.isEmpty()) {
         slotSetSelectedNodes(selectedNodes);
     }
 }
 
 void KisNodeManager::slotSetSelectedNodes(const KisNodeList &nodes)
 {
     m_d->selectedNodes = nodes;
     emit sigUiNeedChangeSelectedNodes(nodes);
 }
 
 KisNodeList KisNodeManager::selectedNodes()
 {
     return m_d->selectedNodes;
 }
 
 KisNodeSelectionAdapter* KisNodeManager::nodeSelectionAdapter() const
 {
     return m_d->nodeSelectionAdapter.data();
 }
 
 KisNodeInsertionAdapter* KisNodeManager::nodeInsertionAdapter() const
 {
     return m_d->nodeInsertionAdapter.data();
 }
 
 KisNodeDisplayModeAdapter *KisNodeManager::nodeDisplayModeAdapter() const
 {
     return m_d->nodeDisplayModeAdapter.data();
 }
 
 bool KisNodeManager::isNodeHidden(KisNodeSP node, bool isGlobalSelectionHidden)
 {
     if (node && node->isFakeNode()) {
         return true;
     }
 
     if (isGlobalSelectionHidden && dynamic_cast<KisSelectionMask *>(node.data()) &&
             (!node->parent() || !node->parent()->parent())) {
         return true;
     }
 
     return false;
 }
 
 bool KisNodeManager::trySetNodeProperties(KisNodeSP node, KisImageSP image, KisBaseNode::PropertyList properties) const
 {
     const KisPaintLayer *paintLayer = dynamic_cast<KisPaintLayer*>(node.data());
     if (paintLayer) {
         const auto onionSkinOn = KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::onionSkins, true);
 
         if (properties.contains(onionSkinOn)) {
             const KisPaintDeviceSP &paintDevice = paintLayer->paintDevice();
             if (paintDevice && paintDevice->defaultPixel().opacityU8() == 255) {
                 m_d->view->showFloatingMessage(i18n("Onion skins require a layer with transparent background."), QIcon());
                 return false;
             }
         }
     }
 
     KisNodePropertyListCommand::setNodePropertiesNoUndo(node, image, properties);
 
     return true;
 }
 
 void KisNodeManager::nodeOpacityChanged(qreal opacity)
 {
     KisNodeSP node = activeNode();
 
     setNodeOpacity(node, convertOpacityToInt(opacity));
 }
 
 void KisNodeManager::nodeCompositeOpChanged(const KoCompositeOp* op)
 {
     KisNodeSP node = activeNode();
 
     setNodeCompositeOp(node, op);
 }
 
 void KisNodeManager::duplicateActiveNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Duplicate Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->duplicateNode(selectedNodes());
 }
 
 KisNodeJugglerCompressed* KisNodeManager::Private::lazyGetJuggler(const KUndo2MagicString &actionName)
 {
     KisImageWSP image = view->image();
 
     if (!nodeJuggler ||
             (nodeJuggler &&
              (nodeJuggler->isEnded() ||
               !nodeJuggler->canMergeAction(actionName)))) {
 
         nodeJuggler = new KisNodeJugglerCompressed(actionName, image, q, 750);
         nodeJuggler->setAutoDelete(true);
     }
 
     return nodeJuggler;
 }
 
 void KisNodeManager::raiseNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Raise Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->raiseNode(selectedNodes());
 }
 
 void KisNodeManager::lowerNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Lower Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->lowerNode(selectedNodes());
 }
 
 void KisNodeManager::removeSingleNode(KisNodeSP node)
 {
     if (!node || !node->parent()) {
         return;
     }
 
     KisNodeList nodes;
     nodes << node;
     removeSelectedNodes(nodes);
 }
 
 void KisNodeManager::removeSelectedNodes(KisNodeList nodes)
 {
     KUndo2MagicString actionName = kundo2_i18n("Remove Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::removeNode()
 {
     removeSelectedNodes(selectedNodes());
 }
 
 void KisNodeManager::mirrorNodeX()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer X");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask X");
     }
     mirrorNode(node, commandName, Qt::Horizontal, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorNodeY()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer Y");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask Y");
     }
     mirrorNode(node, commandName, Qt::Vertical, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorAllNodesX()
 {
     KisNodeSP node = m_d->view->image()->root();
     mirrorNode(node, kundo2_i18n("Mirror All Layers X"),
                Qt::Horizontal, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorAllNodesY()
 {
     KisNodeSP node = m_d->view->image()->root();
     mirrorNode(node, kundo2_i18n("Mirror All Layers Y"),
                Qt::Vertical, m_d->view->selection());
 }
 
 void KisNodeManager::activateNextNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node = activeNode->nextSibling();
 
     while (node && node->childCount() > 0) {
         node = node->firstChild();
     }
 
     if (!node && activeNode->parent() && activeNode->parent()->parent()) {
         node = activeNode->parent();
     }
 
-    while(node && isNodeHidden(node, true)) {
+    while(node && isNodeHidden(node, m_d->nodeDisplayModeAdapter->showGlobalSelectionMask())) {
         node = node->nextSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::activatePreviousNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node;
 
     if (activeNode->childCount() > 0) {
         node = activeNode->lastChild();
     }
     else {
         node = activeNode->prevSibling();
     }
 
     while (!node && activeNode->parent()) {
         node = activeNode->parent()->prevSibling();
         activeNode = activeNode->parent();
     }
 
-    while(node && isNodeHidden(node, true)) {
+    while(node && isNodeHidden(node, m_d->nodeDisplayModeAdapter->showGlobalSelectionMask())) {
         node = node->prevSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::switchToPreviouslyActiveNode()
 {
     if (m_d->previouslyActiveNode && m_d->previouslyActiveNode->parent()) {
         slotNonUiActivatedNode(m_d->previouslyActiveNode);
     }
 }
 
 void KisNodeManager::mirrorNode(KisNodeSP node,
                                 const KUndo2MagicString& actionName,
                                 Qt::Orientation orientation,
                                 KisSelectionSP selection)
 {
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(m_d->view->image(), node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor;
 
     if (selection) {
         visitor = new KisMirrorProcessingVisitor(selection, orientation);
     } else {
         visitor = new KisMirrorProcessingVisitor(m_d->view->image()->bounds(), orientation);
     }
 
     if (!selection) {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     applicator.end();
 
     nodesUpdated();
 }
 
 void KisNodeManager::Private::saveDeviceAsImage(KisPaintDeviceSP device,
                                                 const QString &defaultName,
                                                 const QRect &bounds,
                                                 qreal xRes,
                                                 qreal yRes,
                                                 quint8 opacity)
 {
     KoFileDialog dialog(view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18n("Export \"%1\"", defaultName));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export));
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(filename, false);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   device->compositionSourceColorSpace(),
                                   defaultName);
     dst->setResolution(xRes, yRes);
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", opacity);
     paintLayer->paintDevice()->makeCloneFrom(device, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
     dst->initialRefreshGraph();
 
     if (!doc->exportDocumentSync(url, mimefilter.toLatin1())) {
         QMessageBox::warning(0,
                              i18nc("@title:window", "Krita"),
                              i18n("Could not save the layer. %1", doc->errorMessage().toUtf8().data()),
                              QMessageBox::Ok);
 
     }
 }
 
 void KisNodeManager::saveNodeAsImage()
 {
     KisNodeSP node = activeNode();
 
     if (!node) {
         warnKrita << "BUG: Save Node As Image was called without any node selected";
         return;
     }
 
     KisImageWSP image = m_d->view->image();
     QRect saveRect = image->bounds() | node->exactBounds();
 
     m_d->saveDeviceAsImage(node->projection(),
                            node->name(),
                            saveRect,
                            image->xRes(), image->yRes(),
                            node->opacity());
 }
 
 #include "SvgWriter.h"
 
 void KisNodeManager::saveVectorLayerAsImage()
 {
     KisShapeLayerSP shapeLayer = qobject_cast<KisShapeLayer*>(activeNode().data());
     if (!shapeLayer) {
         return;
     }
 
     KoFileDialog dialog(m_d->view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18nc("@title:window", "Export to SVG"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "image/svg+xml", "image/svg+xml");
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     const QSizeF sizeInPx = m_d->view->image()->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_d->view->image()->xRes(),
                           sizeInPx.height() / m_d->view->image()->yRes());
 
     QList<KoShape*> shapes = shapeLayer->shapes();
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     SvgWriter writer(shapes);
     if (!writer.save(filename, sizeInPt, true)) {
         QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("Could not save to svg: %1", filename));
     }
 }
 
 void KisNodeManager::slotSplitAlphaIntoMask()
 {
     KisNodeSP node = activeNode();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->hasEditablePaintDevice());
 
     KisPaintDeviceSP srcDevice = node->paintDevice();
     const KoColorSpace *srcCS = srcDevice->colorSpace();
     const QRect processRect =
             srcDevice->exactBounds() |
             srcDevice->defaultBounds()->bounds();
 
     KisPaintDeviceSP selectionDevice =
             new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
     m_d->commandsAdapter.beginMacro(kundo2_i18n("Split Alpha into a Mask"));
     KisTransaction transaction(kundo2_noi18n("__split_alpha_channel__"), srcDevice);
 
     KisSequentialIterator srcIt(srcDevice, processRect);
     KisSequentialIterator dstIt(selectionDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *srcPtr = srcIt.rawData();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->opacityU8(srcPtr);
         srcCS->setOpacity(srcPtr, OPACITY_OPAQUE_U8, 1);
     }
 
     m_d->commandsAdapter.addExtraCommand(transaction.endAndTake());
 
     createNode("KisTransparencyMask", false, selectionDevice);
     m_d->commandsAdapter.endMacro();
 }
 
 void KisNodeManager::Private::mergeTransparencyMaskAsAlpha(bool writeToLayers)
 {
     KisNodeSP node = q->activeNode();
     KisNodeSP parentNode = node->parent();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->inherits("KisTransparencyMask"));
 
     if (writeToLayers && !parentNode->hasEditablePaintDevice()) {
         QMessageBox::information(view->mainWindow(),
                                  i18nc("@title:window", "Layer %1 is not editable", parentNode->name()),
                                  i18n("Cannot write alpha channel of "
                                       "the parent layer \"%1\".\n"
                                       "The operation will be cancelled.", parentNode->name()));
         return;
     }
 
     KisPaintDeviceSP dstDevice;
     if (writeToLayers) {
         KIS_ASSERT_RECOVER_RETURN(parentNode->paintDevice());
         dstDevice = parentNode->paintDevice();
     } else {
         KisPaintDeviceSP copyDevice = parentNode->paintDevice();
         if (!copyDevice) {
             copyDevice = parentNode->original();
         }
         dstDevice = new KisPaintDevice(*copyDevice);
     }
 
     const KoColorSpace *dstCS = dstDevice->colorSpace();
 
     KisPaintDeviceSP selectionDevice = node->paintDevice();
     KIS_ASSERT_RECOVER_RETURN(selectionDevice->colorSpace()->pixelSize() == 1);
 
     const QRect processRect =
             selectionDevice->exactBounds() |
             dstDevice->exactBounds() |
             selectionDevice->defaultBounds()->bounds();
 
     QScopedPointer<KisTransaction> transaction;
 
     if (writeToLayers) {
         commandsAdapter.beginMacro(kundo2_i18n("Write Alpha into a Layer"));
         transaction.reset(new KisTransaction(kundo2_noi18n("__write_alpha_channel__"), dstDevice));
     }
 
     KisSequentialIterator srcIt(selectionDevice, processRect);
     KisSequentialIterator dstIt(dstDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *alpha8Ptr = srcIt.rawData();
         quint8 *dstPtr = dstIt.rawData();
 
         dstCS->setOpacity(dstPtr, *alpha8Ptr, 1);
     }
 
     if (writeToLayers) {
         commandsAdapter.addExtraCommand(transaction->endAndTake());
         commandsAdapter.removeNode(node);
         commandsAdapter.endMacro();
     } else {
         KisImageWSP image = view->image();
         QRect saveRect = image->bounds();
 
         saveDeviceAsImage(dstDevice, parentNode->name(),
                           saveRect,
                           image->xRes(), image->yRes(),
                           OPACITY_OPAQUE_U8);
     }
 }
 
 
 void KisNodeManager::slotSplitAlphaWrite()
 {
     m_d->mergeTransparencyMaskAsAlpha(true);
 }
 
 void KisNodeManager::slotSplitAlphaSaveMerged()
 {
     m_d->mergeTransparencyMaskAsAlpha(false);
 }
 
 void KisNodeManager::toggleLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isLocked = active->userLocked();
 
     for (auto &node : nodes) {
         node->setUserLocked(!isLocked);
     }
 }
 
 void KisNodeManager::toggleVisibility()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isVisible = active->visible();
 
     for (auto &node : nodes) {
         node->setVisible(!isVisible);
         node->setDirty();
     }
 }
 
 void KisNodeManager::toggleAlphaLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisPaintLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaLocked = layer->alphaLocked();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisPaintLayer*>(node.data());
         if (layer) {
             layer->setAlphaLocked(!isAlphaLocked);
         }
     }
 }
 
 void KisNodeManager::toggleInheritAlpha()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaDisabled = layer->alphaChannelDisabled();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisLayer*>(node.data());
         if (layer) {
             layer->disableAlphaChannel(!isAlphaDisabled);
             node->setDirty();
         }
     }
 }
 
 void KisNodeManager::cutLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     if (nodes.isEmpty()) return;
 
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), false);
 
     KUndo2MagicString actionName = kundo2_i18n("Cut Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::copyLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), true);
 }
 
 void KisNodeManager::pasteLayersFromClipboard()
 {
     const QMimeData *data = KisClipboard::instance()->layersMimeData();
     if (!data) return;
 
     KisNodeSP activeNode = this->activeNode();
 
     KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(shapeController);
 
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(dummiesFacade);
 
     const bool copyNode = false;
     KisImageSP image = m_d->view->image();
     KisNodeDummy *parentDummy = dummiesFacade->dummyForNode(activeNode);
     KisNodeDummy *aboveThisDummy = parentDummy ? parentDummy->lastChild() : 0;
 
     KisMimeData::insertMimeLayers(data,
                                   image,
                                   shapeController,
                                   parentDummy,
                                   aboveThisDummy,
                                   copyNode,
                                   nodeInsertionAdapter());
 }
 
 void KisNodeManager::createQuickGroupImpl(KisNodeJugglerCompressed *juggler,
                                           const QString &overrideGroupName,
                                           KisNodeSP *newGroup,
                                           KisNodeSP *newLastChild)
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisImageSP image = m_d->view->image();
     QString groupName = !overrideGroupName.isEmpty() ? overrideGroupName : image->nextLayerName();
     KisGroupLayerSP group = new KisGroupLayer(image.data(), groupName, OPACITY_OPAQUE_U8);
 
     KisNodeList nodes1;
     nodes1 << group;
 
     KisNodeList nodes2;
     nodes2 = KisLayerUtils::sortMergableNodes(image->root(), selectedNodes());
     KisLayerUtils::filterMergableNodes(nodes2);
 
     if (nodes2.size() == 0) return;
 
     if (KisLayerUtils::checkIsChildOf(active, nodes2)) {
         active = nodes2.first();
     }
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     juggler->addNode(nodes1, parent, aboveThis);
     juggler->moveNode(nodes2, group, 0);
 
     *newGroup = group;
     *newLastChild = nodes2.last();
 }
 
 void KisNodeManager::createQuickGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     createQuickGroupImpl(juggler, "", &parent, &above);
 }
 
 void KisNodeManager::createQuickClippingGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Clipping Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     KisImageSP image = m_d->view->image();
     createQuickGroupImpl(juggler, image->nextLayerName(i18nc("default name for a clipping group layer", "Clipping Group")), &parent, &above);
 
     KisPaintLayerSP maskLayer = new KisPaintLayer(image.data(), i18nc("default name for quick clip group mask layer", "Mask Layer"), OPACITY_OPAQUE_U8, image->colorSpace());
     maskLayer->disableAlphaChannel(true);
 
     juggler->addNode(KisNodeList() << maskLayer, parent, above);
 }
 
 void KisNodeManager::quickUngroup()
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     KUndo2MagicString actionName = kundo2_i18n("Quick Ungroup");
 
     if (parent && dynamic_cast<KisGroupLayer*>(active.data())) {
         KisNodeList nodes = active->childNodes(QStringList(), KoProperties());
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(nodes, parent, active);
         juggler->removeNode(KisNodeList() << active);
     } else if (parent && parent->parent()) {
         KisNodeSP grandParent = parent->parent();
 
         KisNodeList allChildNodes = parent->childNodes(QStringList(), KoProperties());
         KisNodeList allSelectedNodes = selectedNodes();
 
         const bool removeParent = KritaUtils::compareListsUnordered(allChildNodes, allSelectedNodes);
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(allSelectedNodes, grandParent, parent);
         if (removeParent) {
             juggler->removeNode(KisNodeList() << parent);
         }
     }
 }
 
 void KisNodeManager::selectLayersImpl(const KoProperties &props, const KoProperties &invertedProps)
 {
     KisImageSP image = m_d->view->image();
     KisNodeList nodes = KisLayerUtils::findNodesWithProps(image->root(), props, true);
 
     KisNodeList selectedNodes = this->selectedNodes();
 
     if (KritaUtils::compareListsUnordered(nodes, selectedNodes)) {
         nodes = KisLayerUtils::findNodesWithProps(image->root(), invertedProps, true);
     }
 
     if (!nodes.isEmpty()) {
         slotImageRequestNodeReselection(nodes.last(), nodes);
     }
 }
 
 void KisNodeManager::selectAllNodes()
 {
     KoProperties props;
     selectLayersImpl(props, props);
 }
 
 void KisNodeManager::selectVisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectLockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectInvisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", true);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectUnlockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", true);
 
     selectLayersImpl(props, invertedProps);
 }
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index a7711be368..a69cfe2817 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1394 +1,1394 @@
 /*
  *  Copyright (c) 2005-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_png_converter.h"
 // A big thank to Glenn Randers-Pehrson for his wonderful
 // documentation of libpng available at
 // http://www.libpng.org/pub/png/libpng-1.2.5-manual.html
 
 #ifndef PNG_MAX_UINT // Removed in libpng 1.4
 #define PNG_MAX_UINT PNG_UINT_31_MAX
 #endif
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 
 #include <limits.h>
 #include <stdio.h>
 #include <zlib.h>
 
 #include <QBuffer>
 #include <QFile>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <QUrl>
 
 #include <KoColorSpace.h>
 #include <KoDocumentInfo.h>
 #include <KoID.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 
 #include <kis_config.h>
 #include <kis_painter.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_meta_data_io_backend.h>
 #include <kis_meta_data_store.h>
 #include <KoColorModelStandardIds.h>
 #include "dialogs/kis_dlg_png_import.h"
 #include "kis_clipboard.h"
 #include <kis_cursor_override_hijacker.h>
 #include "kis_undo_stores.h"
 
 #include <kis_assert.h>
 
 namespace
 {
 
 int getColorTypeforColorSpace(const KoColorSpace * cs , bool alpha)
 {
 
     QString id = cs->id();
 
     if (id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16") {
         return alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY;
     }
     if (id == "RGBA" || id == "RGBA16") {
         return alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
     }
 
     return -1;
 
 }
 
 bool colorSpaceIdSupported(const QString &id)
 {
     return id == "RGBA" || id == "RGBA16" ||
         id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16";
 }
 
 QPair<QString, QString> getColorSpaceForColorType(int color_type, int color_nb_bits)
 {
     QPair<QString, QString> r;
 
     if (color_type ==  PNG_COLOR_TYPE_PALETTE) {
         r.first = RGBAColorModelID.id();
         r.second = Integer8BitsColorDepthID.id();
     } else {
         if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
             r.first = GrayAColorModelID.id();
         } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_RGB) {
             r.first = RGBAColorModelID.id();
         }
         if (color_nb_bits == 16) {
             r.second = Integer16BitsColorDepthID.id();
         } else if (color_nb_bits <= 8) {
             r.second = Integer8BitsColorDepthID.id();
         }
     }
     return r;
 }
 
 
 void fillText(png_text* p_text, const char* key, QString& text)
 {
     p_text->compression = PNG_TEXT_COMPRESSION_zTXt;
     p_text->key = const_cast<char *>(key);
     char* textc = new char[text.length()+1];
     strcpy(textc, text.toLatin1());
     p_text->text = textc;
     p_text->text_length = text.length() + 1;
 }
 
 long formatStringList(char *string, const size_t length, const char *format, va_list operands)
 {
     int n = vsnprintf(string, length, format, operands);
 
     if (n < 0)
         string[length-1] = '\0';
 
     return((long) n);
 }
 
 long formatString(char *string, const size_t length, const char *format, ...)
 {
     long n;
 
     va_list operands;
 
     va_start(operands, format);
     n = (long) formatStringList(string, length, format, operands);
     va_end(operands);
     return(n);
 }
 
 void writeRawProfile(png_struct *ping, png_info *ping_info, QString profile_type, QByteArray profile_data)
 {
 
     png_textp      text;
 
     png_uint_32    allocated_length, description_length;
 
     const uchar hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     dbgFile << "Writing Raw profile: type=" << profile_type << ", length=" << profile_data.length() << endl;
 
     text               = (png_textp) png_malloc(ping, (png_uint_32) sizeof(png_text));
     description_length = profile_type.length();
     allocated_length   = (png_uint_32)(profile_data.length() * 2 + (profile_data.length() >> 5) + 20 + description_length);
 
     text[0].text   = (png_charp) png_malloc(ping, allocated_length);
 
     QString key = QLatin1Literal("Raw profile type ") + profile_type.toLatin1();
     QByteArray keyData = key.toLatin1();
     text[0].key = keyData.data();
 
     uchar* sp = (uchar*)profile_data.data();
     png_charp dp = text[0].text;
     *dp++ = '\n';
 
     memcpy(dp, profile_type.toLatin1().constData(), profile_type.length());
 
     dp += description_length;
     *dp++ = '\n';
 
     formatString(dp, allocated_length - strlen(text[0].text), "%8lu ", (unsigned long)profile_data.length());
 
     dp += 8;
 
     for (long i = 0; i < (long) profile_data.length(); i++) {
         if (i % 36 == 0)
             *dp++ = '\n';
 
         *(dp++) = (char) hex[((*sp >> 4) & 0x0f)];
         *(dp++) = (char) hex[((*sp++) & 0x0f)];
     }
 
     *dp++ = '\n';
     *dp = '\0';
     text[0].text_length = (png_size_t)(dp - text[0].text);
     text[0].compression = -1;
 
     if (text[0].text_length <= allocated_length)
         png_set_text(ping, ping_info, text, 1);
 
     png_free(ping, text[0].text);
     png_free(ping, text);
 }
 
 QByteArray png_read_raw_profile(png_textp text)
 {
     QByteArray profile;
 
     static const unsigned char unhex[103] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
         13, 14, 15
     };
 
     png_charp sp = text[0].text + 1;
     /* look for newline */
     while (*sp != '\n')
         sp++;
     /* look for length */
     while (*sp == '\0' || *sp == ' ' || *sp == '\n')
         sp++;
     png_uint_32 length = (png_uint_32) atol(sp);
     while (*sp != ' ' && *sp != '\n')
         sp++;
     if (length == 0) {
         return profile;
     }
     profile.resize(length);
     /* copy profile, skipping white space and column 1 "=" signs */
     unsigned char *dp = (unsigned char*)profile.data();
     png_uint_32 nibbles = length * 2;
     for (png_uint_32 i = 0; i < nibbles; i++) {
         while (*sp < '0' || (*sp > '9' && *sp < 'a') || *sp > 'f') {
             if (*sp == '\0') {
                 return QByteArray();
             }
             sp++;
         }
         if (i % 2 == 0)
             *dp = (unsigned char)(16 * unhex[(int) *sp++]);
         else
             (*dp++) += unhex[(int) *sp++];
     }
     return profile;
 }
 
 void decode_meta_data(png_textp text, KisMetaData::Store* store, QString type, int headerSize)
 {
     dbgFile << "Decoding " << type << " " << text[0].key;
     KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value(type);
     Q_ASSERT(exifIO);
 
     QByteArray rawProfile = png_read_raw_profile(text);
     if (headerSize > 0) {
         rawProfile.remove(0, headerSize);
     }
     if (rawProfile.size() > 0) {
         QBuffer buffer;
         buffer.setData(rawProfile);
         exifIO->loadFrom(store, &buffer);
     } else {
         dbgFile << "Decoding failed";
     }
 }
 }
 
 KisPNGConverter::KisPNGConverter(KisDocument *doc, bool batchMode)
 {
     //     Q_ASSERT(doc);
     //     Q_ASSERT(adapter);
 
     m_doc = doc;
     m_stop = false;
     m_max_row = 0;
     m_image = 0;
     m_batchMode = batchMode;
 }
 
 KisPNGConverter::~KisPNGConverter()
 {
 }
 
 class KisPNGReadStream
 {
 public:
     KisPNGReadStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
     }
     int nextValue() {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
         }
         m_posinc -= m_depth;
         return (((*m_buf) >> (m_posinc)) & ((1 << m_depth) - 1));
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGWriteStream
 {
 public:
     KisPNGWriteStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
         *m_buf = 0;
     }
     void setNextValue(int v) {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
             *m_buf = 0;
         }
         m_posinc -= m_depth;
         *m_buf = (v << m_posinc) | *m_buf;
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGReaderAbstract
 {
 public:
     KisPNGReaderAbstract(png_structp _png_ptr, int _width, int _height) : png_ptr(_png_ptr), width(_width), height(_height) {}
     virtual ~KisPNGReaderAbstract() {}
     virtual png_bytep readLine() = 0;
 protected:
     png_structp png_ptr;
     int width, height;
 };
 
 class KisPNGReaderLineByLine : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderLineByLine(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height) {
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         row_pointer = new png_byte[rowbytes];
     }
     ~KisPNGReaderLineByLine() override {
         delete[] row_pointer;
     }
     png_bytep readLine() override {
         png_read_row(png_ptr, row_pointer, 0);
         return row_pointer;
     }
 private:
     png_bytep row_pointer;
 };
 
 class KisPNGReaderFullImage : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderFullImage(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height), y(0) {
         row_pointers = new png_bytep[height];
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         for (int i = 0; i < height; i++) {
             row_pointers[i] = new png_byte[rowbytes];
         }
         png_read_image(png_ptr, row_pointers);
     }
     ~KisPNGReaderFullImage() override {
         for (int i = 0; i < height; i++) {
             delete[] row_pointers[i];
         }
         delete[] row_pointers;
     }
     png_bytep readLine() override {
         return row_pointers[y++];
     }
 private:
     png_bytepp row_pointers;
     int y;
 };
 
 
 static
 void _read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);
 
     while (length) {
         int nr = in->read((char*)data, length);
         if (nr <= 0) {
             png_error(png_ptr, "Read Error");
             return;
         }
         length -= nr;
     }
 }
 
 static
 void _write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice* out = (QIODevice*)png_get_io_ptr(png_ptr);
 
     uint nr = out->write((char*)data, length);
     if (nr != length) {
         png_error(png_ptr, "Write Error");
         return;
     }
 }
 
 static
 void _flush_fn(png_structp png_ptr)
 {
     Q_UNUSED(png_ptr);
 }
 
 KisImportExportErrorCode KisPNGConverter::buildImage(QIODevice* iod)
 {
     dbgFile << "Start decoding PNG File";
 
     png_byte signature[8];
     iod->peek((char*)signature, 8);
 
 #if PNG_LIBPNG_VER < 10400
     if (!png_check_sig(signature, 8)) {
 #else
     if (png_sig_cmp(signature, 0, 8) != 0) {
 #endif
         iod->close();
         return (ImportExportCodes::FileFormatIncorrect);
     }
 
     // Initialize the internal structures
     png_structp png_ptr =  png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         iod->close();
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_read_struct(&png_ptr, (png_infopp)0, (png_infopp)0);
         iod->close();
         return (ImportExportCodes::Failure);
     }
 
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
         png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)0);
         iod->close();
         return (ImportExportCodes::Failure);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (ImportExportCodes::Failure);
     }
 
     // Initialize the special
     png_set_read_fn(png_ptr, iod, _read_fn);
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
     // read all PNG info up to image data
     png_read_info(png_ptr, info_ptr);
 
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_expand(png_ptr);
     }
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_packing(png_ptr);
     }
 
 
     if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE &&
             (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) {
         png_set_expand(png_ptr);
     }
     png_read_update_info(png_ptr, info_ptr);
 
     // Read information about the png
     png_uint_32 width, height;
     int color_nb_bits, color_type, interlace_type;
     png_get_IHDR(png_ptr, info_ptr, &width, &height, &color_nb_bits, &color_type, &interlace_type, 0, 0);
     dbgFile << "width = " << width << " height = " << height << " color_nb_bits = " << color_nb_bits << " color_type = " << color_type << " interlace_type = " << interlace_type << endl;
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Determine the colorspace
     QPair<QString, QString> csName = getColorSpaceForColorType(color_type, color_nb_bits);
     if (csName.first.isEmpty()) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return ImportExportCodes::FormatColorSpaceUnsupported;
     }
     bool hasalpha = (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_GRAY_ALPHA);
 
     // Read image profile
     png_charp profile_name;
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
     png_bytep profile_data;
 #else
     png_charp profile_data;
 #endif
     int compression_type;
     png_uint_32 proflen;
 
     // Get the various optional chunks
 
     // https://www.w3.org/TR/PNG/#11cHRM
 #if defined(PNG_cHRM_SUPPORTED)
     double whitePointX, whitePointY;
     double redX, redY;
     double greenX, greenY;
     double blueX, blueY;
     png_get_cHRM(png_ptr,info_ptr, &whitePointX, &whitePointY, &redX, &redY, &greenX, &greenY, &blueX, &blueY);
     dbgFile << "cHRM:" << whitePointX << whitePointY << redX << redY << greenX << greenY << blueX << blueY;
 #endif
 
     // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
     double gamma;
     png_get_gAMA(png_ptr, info_ptr, &gamma);
     dbgFile << "gAMA" << gamma;
 #endif
 
     // https://www.w3.org/TR/PNG/#11sRGB
 #if defined(PNG_sRGB_SUPPORTED)
     int sRGBIntent;
     png_get_sRGB(png_ptr, info_ptr, &sRGBIntent);
     dbgFile << "sRGB" << sRGBIntent;
 #endif
 
     bool fromBlender = false;
 
     png_text* text_ptr;
     int num_comments;
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
 
     for (int i = 0; i < num_comments; i++) {
         QString key = QString(text_ptr[i].key).toLower();
         if (key == "file") {
             QString relatedFile = text_ptr[i].text;
             if (relatedFile.contains(".blend", Qt::CaseInsensitive)){
                 fromBlender=true;
             }
         }
     }
 
     bool loadedImageIsHDR = false;
     const KoColorProfile* profile = 0;
     if (png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &proflen)) {
         QByteArray profile_rawdata;
         // XXX: Hardcoded for icc type -- is that correct for us?
         profile_rawdata.resize(proflen);
         memcpy(profile_rawdata.data(), profile_data, proflen);
         profile = KoColorSpaceRegistry::instance()->createColorProfile(csName.first, csName.second, profile_rawdata);
         Q_CHECK_PTR(profile);
         if (profile) {
             //                 dbgFile << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo();
             if (!profile->isSuitableForOutput()) {
                 dbgFile << "the profile is not suitable for output and therefore cannot be used in krita, we need to convert the image to a standard profile"; // TODO: in ko2 popup a selection menu to inform the user
             }
         }
 
         loadedImageIsHDR = strcmp(profile_name, "ITUR_2100_PQ_FULL") == 0;
     }
     else {
         dbgFile << "no embedded profile, will use the default profile";
         if (color_nb_bits == 16 && !fromBlender && !qAppName().toLower().contains("test") && !m_batchMode) {
             KisConfig cfg(true);
             quint32 behaviour = cfg.pasteBehaviour();
             if (behaviour == PASTE_ASK) {
                 KisDlgPngImport dlg(m_path, csName.first, csName.second);
                 KisCursorOverrideHijacker hijacker;
                 Q_UNUSED(hijacker);
                 dlg.exec();
                 if (!dlg.profile().isEmpty()) {
                     profile = KoColorSpaceRegistry::instance()->profileByName(dlg.profile());
                 }
 
             }
         }
         dbgFile << "no embedded profile, will use the default profile";
     }
 
     const QString colorSpaceId =
         KoColorSpaceRegistry::instance()->colorSpaceId(csName.first, csName.second);
 
     // Check that the profile is used by the color space
     if (profile && !KoColorSpaceRegistry::instance()->profileIsCompatible(profile, colorSpaceId)) {
         warnFile << "The profile " << profile->name() << " is not compatible with the color space model " << csName.first << " " << csName.second;
         profile = 0;
     }
 
     // Retrieve a pointer to the colorspace
     KoColorConversionTransformation* transform = 0;
     const KoColorSpace* cs = 0;
 
     if (loadedImageIsHDR &&
         csName.first == RGBAColorModelID.id() &&
         csName.second == Integer16BitsColorDepthID.id()) {
 
         const KoColorSpace *p2020PQCS =
             KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Integer16BitsColorDepthID.id(),
                 KoColorSpaceRegistry::instance()->p2020PQProfile());
 
         cs = p2020PQCS;
 
     } else if (profile && profile->isSuitableForOutput()) {
         dbgFile << "image has embedded profile: " << profile->name() << "\n";
         cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile);
     }
     else {
         if (csName.first == RGBAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "sRGB-elle-V2-srgbtrc.icc");
         } else if (csName.first == GrayAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "Gray-D50-elle-V2-srgbtrc.icc");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
 
         //TODO: two fixes : one tell the user about the problem and ask for a solution, and two once the kocolorspace include KoColorTransformation, use that instead of hacking a lcms transformation
         // Create the cmsTransform if needed
         if (profile) {
             transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return ImportExportCodes::FormatColorSpaceUnsupported;
     }
 
     // Creating the KisImageSP
     if (m_image == 0) {
         KisUndoStore *store = m_doc ? m_doc->createUndoStore() : new KisSurrogateUndoStore();
         m_image = new KisImage(store, width, height, cs, "built image");
     }
 
     // Read resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 
     png_get_pHYs(png_ptr, info_ptr, &x_resolution, &y_resolution, &unit_type);
     if (x_resolution > 0 && y_resolution > 0 && unit_type == PNG_RESOLUTION_METER) {
         m_image->setResolution((double) POINT_TO_CM(x_resolution) / 100.0, (double) POINT_TO_CM(y_resolution) / 100.0); // It is the "invert" macro because we convert from pointer-per-inchs to points
     }
 
     double coeff = quint8_MAX / (double)(pow((double)2, color_nb_bits) - 1);
     KisPaintLayerSP layer = new KisPaintLayer(m_image.data(), m_image -> nextLayerName(), UCHAR_MAX);
 
     // Read comments/texts...
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
     if (m_doc) {
         KoDocumentInfo * info = m_doc->documentInfo();
         dbgFile << "There are " << num_comments << " comments in the text";
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             dbgFile << "key: " << text_ptr[i].key
                     << ", containing: " << text_ptr[i].text
                     << ": " << (key == "raw profile type exif " ? "isExif" : "something else");
             if (key == "title") {
                 info->setAboutInfo("title", text_ptr[i].text);
             } else if (key == "description") {
                 info->setAboutInfo("comment", text_ptr[i].text);
             } else if (key == "author") {
                 info->setAuthorInfo("creator", text_ptr[i].text);
             } else if (key.contains("raw profile type exif")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "exif", 6);
             } else if (key.contains("raw profile type iptc")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "iptc", 14);
             } else if (key.contains("raw profile type xmp")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "xmp", 0);
             } else if (key == "version") {
                 m_image->addAnnotation(new KisAnnotation("kpp_version", "version", QByteArray(text_ptr[i].text)));
             } else if (key == "preset") {
                 m_image->addAnnotation(new KisAnnotation("kpp_preset", "preset", QByteArray(text_ptr[i].text)));
             }
         }
     }
     // Read image data
     QScopedPointer<KisPNGReaderAbstract> reader;
     try {
         if (interlace_type == PNG_INTERLACE_ADAM7) {
             reader.reset(new KisPNGReaderFullImage(png_ptr, info_ptr, width, height));
         } else {
             reader.reset(new KisPNGReaderLineByLine(png_ptr, info_ptr, width, height));
         }
     } catch (const std::bad_alloc& e) {
         // new png_byte[] may raise such an exception if the image
         // is invalid / to large.
         dbgFile << "bad alloc: " << e.what();
         // Free only the already allocated png_byte instances.
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return (ImportExportCodes::Failure);
     }
 
     // Read the palette if the file is indexed
     png_colorp palette ;
     int num_palette;
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
     }
 
     // Read the transparency palette
     quint8 palette_alpha[256];
     memset(palette_alpha, 255, 256);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         if (color_type == PNG_COLOR_TYPE_PALETTE) {
             png_bytep alpha_ptr;
             int num_alpha;
             png_get_tRNS(png_ptr, info_ptr, &alpha_ptr, &num_alpha, 0);
             for (int i = 0; i < num_alpha; ++i) {
                 palette_alpha[i] = alpha_ptr[i];
             }
         }
     }
 
     for (png_uint_32 y = 0; y < height; y++) {
         KisHLineIteratorSP it = layer -> paintDevice() -> createHLineIteratorNG(0, y, width);
 
         png_bytep row_pointer = reader->readLine();
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[0] = *(src++);
                     if (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                     if (transform) transform->transformInPlace(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                     if (transform) transform->transformInPlace(d, d, 1);
                 } while (it->nextPixel());
             }
             // FIXME:should be able to read 1 and 4 bits depth and scale them to 8 bits"
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[2] = *(src++);
                     d[1] = *(src++);
                     d[0] = *(src++);
                     if (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                     if (transform) transform->transformInPlace(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                 } while (it->nextPixel());
             } else {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[2] = (quint8)(stream.nextValue() * coeff);
                     d[1] = (quint8)(stream.nextValue() * coeff);
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                     if (transform) transform->transformInPlace(d, d, 1);
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             KisPNGReadStream stream(row_pointer, color_nb_bits);
             do {
                 quint8 *d = it->rawData();
                 quint8 index = stream.nextValue();
                 quint8 alpha = palette_alpha[ index ];
                 if (alpha == 0) {
                     memset(d, 0, 4);
                 } else {
                     png_color c = palette[ index ];
                     d[2] = c.red;
                     d[1] = c.green;
                     d[0] = c.blue;
                     d[3] = alpha;
                 }
             } while (it->nextPixel());
         }
             break;
         default:
             return ImportExportCodes::FormatFeaturesUnsupported;
         }
     }
     m_image->addNode(layer.data(), m_image->rootLayer().data());
 
     png_read_end(png_ptr, end_info);
     iod->close();
 
     // Freeing memory
     png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
     return ImportExportCodes::OK;
 
 }
 
 KisImportExportErrorCode KisPNGConverter::buildImage(const QString &filename)
 {
     m_path = filename;
 
     QFile fp(filename);
     if (fp.exists()) {
         if (!fp.open(QIODevice::ReadOnly)) {
             dbgFile << "Failed to open PNG File";
             return (ImportExportCodes::FileFormatIncorrect);
         }
 
         return buildImage(&fp);
     }
     return (ImportExportCodes::FileNotExist);
 
 }
 
 
 KisImageSP KisPNGConverter::image()
 {
     return m_image;
 }
 
 bool KisPNGConverter::saveDeviceToStore(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP dev, KoStore *store, KisMetaData::Store* metaData)
 {
     if (store->open(filename)) {
         KoStoreDevice io(store);
         if (!io.open(QIODevice::WriteOnly)) {
             dbgFile << "Could not open for writing:" << filename;
             return false;
         }
         KisPNGConverter pngconv(0);
         vKisAnnotationSP_it annotIt = 0;
         KisMetaData::Store* metaDataStore = 0;
         if (metaData) {
             metaDataStore = new KisMetaData::Store(*metaData);
         }
         KisPNGOptions options;
         options.compression = 0;
         options.interlace = false;
         options.tryToSaveAsIndexed = false;
         options.alpha = true;
         options.saveSRGBProfile = false;
 
         if (dev->colorSpace()->id() != "RGBA") {
             dev = new KisPaintDevice(*dev.data());
             dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
         }
 
         KisImportExportErrorCode success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (!success.isOk()) {
             dbgFile << "Saving PNG failed:" << filename;
             delete metaDataStore;
             return false;
         }
         delete metaDataStore;
         io.close();
         if (!store->close()) {
             return false;
         }
     } else {
         dbgFile << "Opening of data file failed :" << filename;
         return false;
     }
     return true;
 
 }
 
 
 KisImportExportErrorCode KisPNGConverter::buildFile(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     dbgFile << "Start writing PNG File " << filename;
     // Open a QIODevice for writing
     QFile fp (filename);
     if (!fp.open(QIODevice::WriteOnly)) {
         dbgFile << "Failed to open PNG File for writing";
         return (KisImportExportErrorCannotWrite(fp.error()));
     }
 
     KisImportExportErrorCode result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImportExportErrorCode KisPNGConverter::buildFile(QIODevice* iodevice, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(device, ImportExportCodes::InternalError);
 
     if (!options.alpha) {
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         KoColor c(options.transparencyFillColor, device->colorSpace());
         tmp->fill(imageRect, c);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (device->colorSpace()->colorDepthId() == Float16BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float32BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float64BitsColorDepthID
             || options.saveAsHDR) {
 
         const KoColorSpace *dstCS =
             KoColorSpaceRegistry::instance()->colorSpace(
                 device->colorSpace()->colorModelId().id(),
                 Integer16BitsColorDepthID.id(),
                 device->colorSpace()->profile());
 
         if (options.saveAsHDR) {
             dstCS =
                 KoColorSpaceRegistry::instance()->colorSpace(
                         RGBAColorModelID.id(),
                         Integer16BitsColorDepthID.id(),
                         KoColorSpaceRegistry::instance()->p2020PQProfile());
         }
 
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         tmp->makeCloneFromRough(device, imageRect);
         tmp->convertTo(dstCS);
 
         device = tmp;
 
     }
 
     KIS_SAFE_ASSERT_RECOVER(!options.saveAsHDR || !options.forceSRGB) {
         options.forceSRGB = false;
     }
 
     KIS_SAFE_ASSERT_RECOVER(!options.saveAsHDR || !options.tryToSaveAsIndexed) {
         options.tryToSaveAsIndexed = false;
     }
 
     QStringList colormodels = QStringList() << RGBAColorModelID.id() << GrayAColorModelID.id();
     if (options.forceSRGB || !colormodels.contains(device->colorSpace()->colorModelId().id())) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         device->convertTo(cs);
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (ImportExportCodes::Failure);
     }
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
     png_set_check_for_invalid_index(png_ptr, 0);
 #endif
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_write_struct(&png_ptr, (png_infopp)0);
         return (ImportExportCodes::Failure);
     }
 
     // If an error occurs during writing, libpng will jump here
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
         return (ImportExportCodes::Failure);
     }
     // Initialize the writing
     //     png_init_io(png_ptr, fp);
     // Setup the progress function
     // XXX: Implement progress updating -- png_set_write_status_fn(png_ptr, progress);"
     //     setProgressTotalSteps(100/*height*/);
 
     /* set the zlib compression level */
     png_set_compression_level(png_ptr, options.compression);
 
     png_set_write_fn(png_ptr, (void*)iodevice, _write_fn, _flush_fn);
 
     /* set other zlib parameters */
     png_set_compression_mem_level(png_ptr, 8);
     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
     png_set_compression_window_bits(png_ptr, 15);
     png_set_compression_method(png_ptr, 8);
     png_set_compression_buffer_size(png_ptr, 8192);
 
     int color_nb_bits = 8 * device->pixelSize() / device->channelCount();
     int color_type = getColorTypeforColorSpace(device->colorSpace(), options.alpha);
 
     Q_ASSERT(color_type > -1);
 
     // Try to compute a table of color if the colorspace is RGB8f
     QScopedArrayPointer<png_color> palette;
     int num_palette = 0;
     if (!options.alpha && options.tryToSaveAsIndexed && KoID(device->colorSpace()->id()) == KoID("RGBA")) { // png doesn't handle indexed images and alpha, and only have indexed for RGB8
         palette.reset(new png_color[255]);
 
         KisSequentialIterator it(device, imageRect);
 
         bool toomuchcolor = false;
         while (it.nextPixel()) {
             const quint8* c = it.oldRawData();
             bool findit = false;
             for (int i = 0; i < num_palette; i++) {
                 if (palette[i].red == c[2] &&
                         palette[i].green == c[1] &&
                         palette[i].blue == c[0]) {
                     findit = true;
                     break;
                 }
             }
             if (!findit) {
                 if (num_palette == 255) {
                     toomuchcolor = true;
                     break;
                 }
                 palette[num_palette].red = c[2];
                 palette[num_palette].green = c[1];
                 palette[num_palette].blue = c[0];
                 num_palette++;
             }
         }
 
         if (!toomuchcolor) {
             dbgFile << "Found a palette of " << num_palette << " colors";
             color_type = PNG_COLOR_TYPE_PALETTE;
             if (num_palette <= 2) {
                 color_nb_bits = 1;
             } else if (num_palette <= 4) {
                 color_nb_bits = 2;
             } else if (num_palette <= 16) {
                 color_nb_bits = 4;
             } else {
                 color_nb_bits = 8;
             }
         } else {
             palette.reset();
         }
     }
 
     int interlacetype = options.interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(color_type >= 0, ImportExportCodes::Failure);
 
     png_set_IHDR(png_ptr, info_ptr,
                  imageRect.width(),
                  imageRect.height(),
                  color_nb_bits,
                  color_type, interlacetype,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
     // set sRGB only if the profile is sRGB  -- http://www.w3.org/TR/PNG/#11sRGB says sRGB and iCCP should not both be present
 
-    bool sRGB = device->colorSpace()->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
+    const bool sRGB = *device->colorSpace()->profile() == *KoColorSpaceRegistry::instance()->p709SRGBProfile();
     /*
      * This automatically writes the correct gamma and chroma chunks along with the sRGB chunk, but firefox's
      * color management is bugged, so once you give it any incentive to start color managing an sRGB image it
      * will turn, for example, a nice desaturated rusty red into bright poppy red. So this is disabled for now.
      */
     /*if (!options.saveSRGBProfile && sRGB) {
         png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
     }*/
 
 
     /** TODO: Firefox still opens the image incorrectly if there is gAMA+cHRM tags
      * present. According to the standard it should use iCCP tag with higher priority,
      * but it doesn't:
      *
      * "When the iCCP chunk is present, PNG decoders that recognize it and are capable
      *  of colour management [ICC] shall ignore the gAMA and cHRM chunks and use
      *  the iCCP chunk instead and interpret it according to [ICC-1] and [ICC-1A]"
      */
 
 #if 0
     if (options.saveAsHDR) {
         // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
         // the values are set in accurdance of HDR-PNG standard:
         // https://www.w3.org/TR/png-hdr-pq/
 
         png_set_gAMA_fixed(png_ptr, info_ptr, 15000);
         dbgFile << "gAMA" << "(Rec 2100)";
 #endif
 
 #if defined PNG_cHRM_SUPPORTED
         png_set_cHRM_fixed(png_ptr, info_ptr,
                            31270, 32900, // white point
                            70800, 29200, // red
                            17000, 79700, // green
                            13100, 4600 // blue
                            );
         dbgFile << "cHRM" << "(Rec 2100)";
 #endif
     }
 #endif
 
 
     // we should ensure we don't access non-existing palette object
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(palette || color_type != PNG_COLOR_TYPE_PALETTE, ImportExportCodes::Failure);
 
     // set the palette
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_set_PLTE(png_ptr, info_ptr, palette.data(), num_palette);
     }
     // Save annotation
     vKisAnnotationSP_it it = annotationsStart;
     while (it != annotationsEnd) {
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         dbgFile << "Trying to store annotation of type " << (*it) -> type() << " of size " << (*it) -> annotation() . size();
 
         if ((*it) -> type().startsWith(QString("krita_attribute:"))) { //
             // Attribute
             // XXX: it should be possible to save krita_attributes in the \"CHUNKs\""
             dbgFile << "cannot save this annotation : " << (*it) -> type();
         } else if ((*it)->type() == "kpp_version" || (*it)->type() == "kpp_preset" ) {
             dbgFile << "Saving preset information " << (*it)->description();
             png_textp      text = (png_textp) png_malloc(png_ptr, (png_uint_32) sizeof(png_text));
 
             QByteArray keyData = (*it)->description().toLatin1();
             text[0].key = keyData.data();
             text[0].text = (char*)(*it)->annotation().data();
             text[0].text_length = (*it)->annotation().size();
             text[0].compression = -1;
 
             png_set_text(png_ptr, info_ptr, text, 1);
             png_free(png_ptr, text);
         }
         it++;
     }
 
     // Save the color profile
     const KoColorProfile* colorProfile = device->colorSpace()->profile();
     QByteArray colorProfileData = colorProfile->rawData();
     if (!sRGB || options.saveSRGBProfile) {
 
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
         const char *typeString = !options.saveAsHDR ? "icc" : "ITUR_2100_PQ_FULL";
         png_set_iCCP(png_ptr, info_ptr, (png_const_charp)typeString, PNG_COMPRESSION_TYPE_BASE, (png_const_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
         // older version of libpng has a problem with constness on the parameters
         char typeStringICC[] = "icc";
         char typeStringHDR[] = "ITUR_2100_PQ_FULL";
         char *typeString = !options.saveAsHDR ? typeStringICC : typeStringHDR;
         png_set_iCCP(png_ptr, info_ptr, typeString, PNG_COMPRESSION_TYPE_BASE, colorProfileData.data(), colorProfileData . size());
 #endif
     }
 
     // save comments from the document information
     // warning: according to the official png spec, the keys need to be capitalized!
     if (m_doc) {
         png_text texts[4];
         int nbtexts = 0;
         KoDocumentInfo * info = m_doc->documentInfo();
         QString title = info->aboutInfo("title");
         if (!title.isEmpty() && options.storeMetaData) {
             fillText(texts + nbtexts, "Title", title);
             nbtexts++;
         }
         QString abstract = info->aboutInfo("subject");
         if (abstract.isEmpty()) {
             abstract = info->aboutInfo("abstract");
         }
         if (!abstract.isEmpty() && options.storeMetaData) {
             QString keywords = info->aboutInfo("keyword");
             if (!keywords.isEmpty()) {
                 abstract = abstract + " keywords: " + keywords;
             }
             fillText(texts + nbtexts, "Description", abstract);
             nbtexts++;
         }
 
         QString license = info->aboutInfo("license");
         if (!license.isEmpty() && options.storeMetaData) {
             fillText(texts + nbtexts, "Copyright", license);
             nbtexts++;
         }
 
         QString author = info->authorInfo("creator");
         if (!author.isEmpty() && options.storeAuthor) {
             if (!info->authorContactInfo().isEmpty()) {
                 QString contact = info->authorContactInfo().at(0);
                 if (!contact.isEmpty()) {
                     author = author+"("+contact+")";
                 }
             }
             fillText(texts + nbtexts, "Author", author);
             nbtexts++;
         }
 
         png_set_text(png_ptr, info_ptr, texts, nbtexts);
     }
 
     // Save metadata following imagemagick way
 
     // Save exif
     if (metaData && !metaData->empty()) {
         if (options.exif) {
             dbgFile << "Trying to save exif information";
 
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
 
             QBuffer buffer;
             exifIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
             writeRawProfile(png_ptr, info_ptr, "exif", buffer.data());
         }
         // Save IPTC
         if (options.iptc) {
             dbgFile << "Trying to save exif information";
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
 
             QBuffer buffer;
             iptcIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "IPTC information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "iptc", buffer.data());
         }
         // Save XMP
         if (options.xmp) {
             dbgFile << "Trying to save XMP information";
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
 
             QBuffer buffer;
             xmpIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::NoHeader);
 
             dbgFile << "XMP information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "xmp", buffer.data());
         }
     }
 #if 0 // Unimplemented?
     // Save resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 #endif
     png_set_pHYs(png_ptr, info_ptr, CM_TO_POINT(xRes) * 100.0, CM_TO_POINT(yRes) * 100.0, PNG_RESOLUTION_METER); // It is the "invert" macro because we convert from pointer-per-inchs to points
 
     // Save the information to the file
     png_write_info(png_ptr, info_ptr);
     png_write_flush(png_ptr);
 
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Write the PNG
     //     png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
 
     struct RowPointersStruct {
         RowPointersStruct(const QSize &size, int pixelSize)
             : numRows(size.height())
         {
             rows = new png_byte*[numRows];
 
             for (int i = 0; i < numRows; i++) {
                 rows[i] = new png_byte[size.width() * pixelSize];
             }
         }
 
         ~RowPointersStruct() {
             for (int i = 0; i < numRows; i++) {
                 delete[] rows[i];
             }
             delete[] rows;
         }
 
         const int numRows = 0;
         png_byte** rows = 0;
     };
 
 
     // Fill the data structure
     RowPointersStruct rowPointers(imageRect.size(), device->pixelSize());
 
     int row = 0;
     for (int y = imageRect.y(); y < imageRect.y() + imageRect.height(); y++, row++) {
         KisHLineConstIteratorSP it = device->createHLineConstIteratorNG(imageRect.x(), y, imageRect.width());
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(rowPointers.rows[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = rowPointers.rows[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(rowPointers.rows[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = rowPointers.rows[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             quint8 *dst = rowPointers.rows[row];
             KisPNGWriteStream writestream(dst, color_nb_bits);
             do {
                 const quint8 *d = it->oldRawData();
                 int i;
                 for (i = 0; i < num_palette; i++) {
                     if (palette[i].red == d[2] &&
                             palette[i].green == d[1] &&
                             palette[i].blue == d[0]) {
                         break;
                     }
                 }
                 writestream.setNextValue(i);
             } while (it->nextPixel());
         }
             break;
         default:
             return ImportExportCodes::FormatColorSpaceUnsupported;
         }
     }
 
     png_write_image(png_ptr, rowPointers.rows);
 
     // Writing is over
     png_write_end(png_ptr, info_ptr);
 
     // Free memory
     png_destroy_write_struct(&png_ptr, &info_ptr);
     return ImportExportCodes::OK;
 }
 
 
 void KisPNGConverter::cancel()
 {
     m_stop = true;
 }
 
 void KisPNGConverter::progress(png_structp png_ptr, png_uint_32 row_number, int pass)
 {
     if (png_ptr == 0 || row_number > PNG_MAX_UINT || pass > 7) return;
     //     setProgress(row_number);
 }
 
 bool KisPNGConverter::isColorSpaceSupported(const KoColorSpace *cs)
 {
     return colorSpaceIdSupported(cs->id());
 }
 
 
diff --git a/libs/ui/tool/strokes/freehand_stroke.cpp b/libs/ui/tool/strokes/freehand_stroke.cpp
index 25fd09c670..278ba0ac45 100644
--- a/libs/ui/tool/strokes/freehand_stroke.cpp
+++ b/libs/ui/tool/strokes/freehand_stroke.cpp
@@ -1,350 +1,350 @@
 /*
  *  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 "freehand_stroke.h"
 
 #include <QElapsedTimer>
 
 #include "kis_canvas_resource_provider.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_painter.h"
 #include "kis_paintop.h"
 
 #include "kis_update_time_monitor.h"
 
 #include <brushengine/kis_stroke_random_source.h>
 #include <KisRunnableStrokeJobsInterface.h>
 #include "FreehandStrokeRunnableJobDataWithUpdate.h"
 #include <mutex>
 
 #include "KisStrokeEfficiencyMeasurer.h"
 #include <KisStrokeSpeedMonitor.h>
 #include <strokes/KisFreehandStrokeInfo.h>
 #include <strokes/KisMaskedFreehandStrokePainter.h>
 
 #include "brushengine/kis_paintop_utils.h"
 #include "KisAsyncronousStrokeUpdateHelper.h"
 
 struct FreehandStrokeStrategy::Private
 {
     Private(KisResourcesSnapshotSP _resources)
         : resources(_resources),
           needsAsynchronousUpdates(_resources->presetNeedsAsynchronousUpdates())
     {
         if (needsAsynchronousUpdates) {
             timeSinceLastUpdate.start();
         }
     }
 
     Private(const Private &rhs)
         : randomSource(rhs.randomSource),
           resources(rhs.resources),
           needsAsynchronousUpdates(rhs.needsAsynchronousUpdates)
     {
         if (needsAsynchronousUpdates) {
             timeSinceLastUpdate.start();
         }
     }
 
     KisStrokeRandomSource randomSource;
     KisResourcesSnapshotSP resources;
 
     KisStrokeEfficiencyMeasurer efficiencyMeasurer;
 
     QElapsedTimer timeSinceLastUpdate;
     int currentUpdatePeriod = 40;
 
     const bool needsAsynchronousUpdates = false;
     std::mutex updateEntryMutex;
 };
 
 FreehandStrokeStrategy::FreehandStrokeStrategy(KisResourcesSnapshotSP resources,
                                                KisFreehandStrokeInfo *strokeInfo,
                                                const KUndo2MagicString &name)
-    : KisPainterBasedStrokeStrategy("FREEHAND_STROKE", name,
+    : KisPainterBasedStrokeStrategy(QLatin1String("FREEHAND_STROKE"), name,
                                     resources, strokeInfo),
       m_d(new Private(resources))
 {
     init();
 }
 
 FreehandStrokeStrategy::FreehandStrokeStrategy(KisResourcesSnapshotSP resources,
                                                QVector<KisFreehandStrokeInfo*> strokeInfos,
                                                const KUndo2MagicString &name)
-    : KisPainterBasedStrokeStrategy("FREEHAND_STROKE", name,
+    : KisPainterBasedStrokeStrategy(QLatin1String("FREEHAND_STROKE"), name,
                                     resources, strokeInfos),
       m_d(new Private(resources))
 {
     init();
 }
 
 FreehandStrokeStrategy::FreehandStrokeStrategy(const FreehandStrokeStrategy &rhs, int levelOfDetail)
     : KisPainterBasedStrokeStrategy(rhs, levelOfDetail),
       m_d(new Private(*rhs.m_d))
 {
     m_d->randomSource.setLevelOfDetail(levelOfDetail);
 }
 
 FreehandStrokeStrategy::~FreehandStrokeStrategy()
 {
     KisStrokeSpeedMonitor::instance()->notifyStrokeFinished(m_d->efficiencyMeasurer.averageCursorSpeed(),
                                                             m_d->efficiencyMeasurer.averageRenderingSpeed(),
                                                             m_d->efficiencyMeasurer.averageFps(),
                                                             m_d->resources->currentPaintOpPreset());
 
     KisUpdateTimeMonitor::instance()->endStrokeMeasure();
 }
 
 void FreehandStrokeStrategy::init()
 {
     setSupportsWrapAroundMode(true);
     setSupportsMaskingBrush(true);
     setSupportsIndirectPainting(true);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 
     if (m_d->needsAsynchronousUpdates) {
         /**
          * In case the paintop uses asynchronous updates, we should set priority to it,
          * because FPS is controlled separately, not by the queue's merging algorithm.
          */
         setBalancingRatioOverride(0.01); // set priority to updates
     }
 
     KisUpdateTimeMonitor::instance()->startStrokeMeasure();
     m_d->efficiencyMeasurer.setEnabled(KisStrokeSpeedMonitor::instance()->haveStrokeSpeedMeasurement());
 }
 
 void FreehandStrokeStrategy::initStrokeCallback()
 {
     KisPainterBasedStrokeStrategy::initStrokeCallback();
     m_d->efficiencyMeasurer.notifyRenderingStarted();
 }
 
 void FreehandStrokeStrategy::finishStrokeCallback()
 {
     m_d->efficiencyMeasurer.notifyRenderingFinished();
     KisPainterBasedStrokeStrategy::finishStrokeCallback();
 }
 
 
 void FreehandStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     if (KisAsyncronousStrokeUpdateHelper::UpdateData *d =
             dynamic_cast<KisAsyncronousStrokeUpdateHelper::UpdateData*>(data)) {
 
         // this job is lod-clonable in contrast to FreehandStrokeRunnableJobDataWithUpdate!
         tryDoUpdate(d->forceUpdate);
 
     } else if (Data *d = dynamic_cast<Data*>(data)) {
         KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(d->strokeInfoId);
 
         KisUpdateTimeMonitor::instance()->reportPaintOpPreset(maskedPainter->preset());
         KisRandomSourceSP rnd = m_d->randomSource.source();
         KisPerStrokeRandomSourceSP strokeRnd = m_d->randomSource.perStrokeSource();
 
         switch(d->type) {
         case Data::POINT:
             d->pi1.setRandomSource(rnd);
             d->pi1.setPerStrokeRandomSource(strokeRnd);
             maskedPainter->paintAt(d->pi1);
             m_d->efficiencyMeasurer.addSample(d->pi1.pos());
             break;
         case Data::LINE:
             d->pi1.setRandomSource(rnd);
             d->pi2.setRandomSource(rnd);
             d->pi1.setPerStrokeRandomSource(strokeRnd);
             d->pi2.setPerStrokeRandomSource(strokeRnd);
             maskedPainter->paintLine(d->pi1, d->pi2);
             m_d->efficiencyMeasurer.addSample(d->pi2.pos());
             break;
         case Data::CURVE:
             d->pi1.setRandomSource(rnd);
             d->pi2.setRandomSource(rnd);
             d->pi1.setPerStrokeRandomSource(strokeRnd);
             d->pi2.setPerStrokeRandomSource(strokeRnd);
             maskedPainter->paintBezierCurve(d->pi1,
                                          d->control1,
                                          d->control2,
                                          d->pi2);
             m_d->efficiencyMeasurer.addSample(d->pi2.pos());
             break;
         case Data::POLYLINE:
             maskedPainter->paintPolyline(d->points, 0, d->points.size());
             m_d->efficiencyMeasurer.addSamples(d->points);
             break;
         case Data::POLYGON:
             maskedPainter->paintPolygon(d->points);
             m_d->efficiencyMeasurer.addSamples(d->points);
             break;
         case Data::RECT:
             maskedPainter->paintRect(d->rect);
             m_d->efficiencyMeasurer.addSample(d->rect.topLeft());
             m_d->efficiencyMeasurer.addSample(d->rect.topRight());
             m_d->efficiencyMeasurer.addSample(d->rect.bottomRight());
             m_d->efficiencyMeasurer.addSample(d->rect.bottomLeft());
             break;
         case Data::ELLIPSE:
             maskedPainter->paintEllipse(d->rect);
             // TODO: add speed measures
             break;
         case Data::PAINTER_PATH:
             maskedPainter->paintPainterPath(d->path);
             // TODO: add speed measures
             break;
         case Data::QPAINTER_PATH:
             maskedPainter->drawPainterPath(d->path, d->pen);
             break;
         case Data::QPAINTER_PATH_FILL:
             maskedPainter->drawAndFillPainterPath(d->path, d->pen, d->customColor);
             break;
         };
 
         tryDoUpdate();
     } else {
         KisPainterBasedStrokeStrategy::doStrokeCallback(data);
 
         FreehandStrokeRunnableJobDataWithUpdate *dataWithUpdate =
             dynamic_cast<FreehandStrokeRunnableJobDataWithUpdate*>(data);
 
         if (dataWithUpdate) {
             tryDoUpdate();
         }
     }
 }
 
 void FreehandStrokeStrategy::tryDoUpdate(bool forceEnd)
 {
     // we should enter this function only once!
     std::unique_lock<std::mutex> entryLock(m_d->updateEntryMutex, std::try_to_lock);
     if (!entryLock.owns_lock()) return;
 
     if (m_d->needsAsynchronousUpdates) {
         if (forceEnd || m_d->timeSinceLastUpdate.elapsed() > m_d->currentUpdatePeriod) {
             m_d->timeSinceLastUpdate.restart();
 
             for (int i = 0; i < numMaskedPainters(); i++) {
                 KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(i);
 
                 // TODO: well, we should count all N simultaneous painters for FPS rate!
                 QVector<KisRunnableStrokeJobData*> jobs;
 
                 bool needsMoreUpdates = false;
 
                 std::tie(m_d->currentUpdatePeriod, needsMoreUpdates) =
                     maskedPainter->doAsyncronousUpdate(jobs);
 
                 if (!jobs.isEmpty() ||
                     maskedPainter->hasDirtyRegion() ||
                     (forceEnd && needsMoreUpdates)) {
 
                     jobs.append(new KisRunnableStrokeJobData(
                                     [this] () {
                                         this->issueSetDirtySignals();
                                     },
                                     KisStrokeJobData::SEQUENTIAL));
 
                     if (forceEnd && needsMoreUpdates) {
                         jobs.append(new KisRunnableStrokeJobData(
                                         [this] () {
                                             this->tryDoUpdate(true);
                                         },
                                         KisStrokeJobData::SEQUENTIAL));
                     }
 
 
                     runnableJobsInterface()->addRunnableJobs(jobs);
                     m_d->efficiencyMeasurer.notifyFrameRenderingStarted();
                 }
 
             }
         }
     } else {
         issueSetDirtySignals();
     }
 
 
 }
 
 void FreehandStrokeStrategy::issueSetDirtySignals()
 {
     QVector<QRect> dirtyRects;
 
     for (int i = 0; i < numMaskedPainters(); i++) {
         KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(i);
         dirtyRects.append(maskedPainter->takeDirtyRegion());
     }
 
     if (needsMaskingUpdates()) {
 
         // optimize the rects so that they would never intersect with each other!
         // that is a mandatory step for the multithreaded execution of merging jobs
 
         // sanity check: updates from the brush should have already been normalized
         //               to the wrapping rect
         const KisDefaultBoundsBaseSP defaultBounds = targetNode()->projection()->defaultBounds();
         if (defaultBounds->wrapAroundMode()) {
             const QRect wrapRect = defaultBounds->bounds();
             for (auto it = dirtyRects.begin(); it != dirtyRects.end(); ++it) {
                 KIS_SAFE_ASSERT_RECOVER(wrapRect.contains(*it)) {
                     ENTER_FUNCTION() << ppVar(*it) << ppVar(wrapRect);
                     *it = *it & wrapRect;
                 }
             }
         }
 
         const int maxPatchSizeForMaskingUpdates = 64;
         const QRect totalRect =
             std::accumulate(dirtyRects.constBegin(), dirtyRects.constEnd(), QRect(), std::bit_or<QRect>());
 
         dirtyRects = KisPaintOpUtils::splitAndFilterDabRect(totalRect, dirtyRects, maxPatchSizeForMaskingUpdates);
 
         QVector<KisRunnableStrokeJobData*> jobs = doMaskingBrushUpdates(dirtyRects);
 
         jobs.append(new KisRunnableStrokeJobData(
             [this, dirtyRects] () {
                 this->targetNode()->setDirty(dirtyRects);
             },
             KisStrokeJobData::SEQUENTIAL));
 
         runnableJobsInterface()->addRunnableJobs(jobs);
 
     } else {
         targetNode()->setDirty(dirtyRects);
     }
 
     //KisUpdateTimeMonitor::instance()->reportJobFinished(data, dirtyRects);
 }
 
 KisStrokeStrategy* FreehandStrokeStrategy::createLodClone(int levelOfDetail)
 {
     if (!m_d->resources->presetAllowsLod()) return 0;
 
     FreehandStrokeStrategy *clone = new FreehandStrokeStrategy(*this, levelOfDetail);
     return clone;
 }
 
 void FreehandStrokeStrategy::notifyUserStartedStroke()
 {
     m_d->efficiencyMeasurer.notifyCursorMoveStarted();
 }
 
 void FreehandStrokeStrategy::notifyUserEndedStroke()
 {
     m_d->efficiencyMeasurer.notifyCursorMoveFinished();
 }
diff --git a/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp b/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp
index 97252ff918..290d40c30d 100644
--- a/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/kis_color_picker_stroke_strategy.cpp
@@ -1,73 +1,74 @@
 /*
  *  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_color_picker_stroke_strategy.h"
 
 #include "kis_tool_utils.h"
 #include "kis_paint_device.h"
 
 struct KisColorPickerStrokeStrategy::Private
 {
     Private() : shouldSkipWork(false) {}
 
     bool shouldSkipWork;
     int radius = 1;
     int blend = 100;
 };
 
 KisColorPickerStrokeStrategy::KisColorPickerStrokeStrategy(int lod)
-    : m_d(new Private)
+    : KisSimpleStrokeStrategy(QLatin1String("KisColorPickerStrokeStrategy")),
+      m_d(new Private)
 {
     setSupportsWrapAroundMode(true);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 
     KisToolUtils::ColorPickerConfig config;
     config.load();
 
     m_d->radius = qMax(1, qRound(config.radius * KisLodTransform::lodToScale(lod)));
     m_d->blend = config.blend;
 }
 
 KisColorPickerStrokeStrategy::~KisColorPickerStrokeStrategy()
 {
 }
 
 void KisColorPickerStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     if (m_d->shouldSkipWork) return;
 
     Data *d = dynamic_cast<Data*>(data);
     KIS_ASSERT_RECOVER_RETURN(d);
 
     KoColor color;
     KoColor previous = d->currentColor;
     if (KisToolUtils::pickColor(color, d->dev, d->pt, &previous, m_d->radius, m_d->blend) == true) {
         emit sigColorUpdated(color);
     }
 }
 
 KisStrokeStrategy* KisColorPickerStrokeStrategy::createLodClone(int levelOfDetail)
 {
     m_d->shouldSkipWork = true;
 
     KisColorPickerStrokeStrategy *lodStrategy = new KisColorPickerStrokeStrategy(levelOfDetail);
     connect(lodStrategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
             this, &KisColorPickerStrokeStrategy::sigColorUpdated,
             Qt::DirectConnection);
     return lodStrategy;
 }
diff --git a/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp b/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp
index 5ba8d96933..c31a634088 100644
--- a/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp
@@ -1,208 +1,208 @@
 /*
  *  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_filter_stroke_strategy.h"
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_transaction.h>
 #include <KoCompositeOpRegistry.h>
 
 
 struct KisFilterStrokeStrategy::Private {
     Private()
         : updatesFacade(0),
           cancelSilently(false),
           secondaryTransaction(0),
           levelOfDetail(0)
     {
     }
 
     Private(const Private &rhs)
         : filter(rhs.filter),
           filterConfig(rhs.filterConfig),
           node(rhs.node),
           updatesFacade(rhs.updatesFacade),
           cancelSilently(rhs.cancelSilently),
           filterDevice(),
           filterDeviceBounds(),
           secondaryTransaction(0),
           progressHelper(),
           levelOfDetail(0)
     {
         KIS_ASSERT_RECOVER_RETURN(!rhs.filterDevice);
         KIS_ASSERT_RECOVER_RETURN(rhs.filterDeviceBounds.isEmpty());
         KIS_ASSERT_RECOVER_RETURN(!rhs.secondaryTransaction);
         KIS_ASSERT_RECOVER_RETURN(!rhs.progressHelper);
         KIS_ASSERT_RECOVER_RETURN(!rhs.levelOfDetail);
     }
 
     KisFilterSP filter;
     KisFilterConfigurationSP filterConfig;
     KisNodeSP node;
     KisUpdatesFacade *updatesFacade;
 
     bool cancelSilently;
     KisPaintDeviceSP filterDevice;
     QRect filterDeviceBounds;
     KisTransaction *secondaryTransaction;
     QScopedPointer<KisProcessingVisitor::ProgressHelper> progressHelper;
 
     int levelOfDetail;
 };
 
 
 KisFilterStrokeStrategy::KisFilterStrokeStrategy(KisFilterSP filter,
                                                  KisFilterConfigurationSP filterConfig,
                                                  KisResourcesSnapshotSP resources)
-    : KisPainterBasedStrokeStrategy("FILTER_STROKE",
+    : KisPainterBasedStrokeStrategy(QLatin1String("FILTER_STROKE"),
                                     kundo2_i18n("Filter \"%1\"", filter->name()),
                                     resources,
                                     QVector<KisFreehandStrokeInfo*>(),false),
       m_d(new Private())
 {
     m_d->filter = filter;
     m_d->filterConfig = filterConfig;
     m_d->node = resources->currentNode();
     m_d->updatesFacade = resources->image().data();
     m_d->cancelSilently = false;
     m_d->secondaryTransaction = 0;
     m_d->levelOfDetail = 0;
 
     setSupportsWrapAroundMode(true);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 }
 
 KisFilterStrokeStrategy::KisFilterStrokeStrategy(const KisFilterStrokeStrategy &rhs, int levelOfDetail)
     : KisPainterBasedStrokeStrategy(rhs, levelOfDetail),
       m_d(new Private(*rhs.m_d))
 {
     // only non-started transaction are allowed
     KIS_ASSERT_RECOVER_NOOP(!m_d->secondaryTransaction);
     m_d->levelOfDetail = levelOfDetail;
 }
 
 KisFilterStrokeStrategy::~KisFilterStrokeStrategy()
 {
     delete m_d;
 }
 
 void KisFilterStrokeStrategy::initStrokeCallback()
 {
     KisPainterBasedStrokeStrategy::initStrokeCallback();
 
     KisPaintDeviceSP dev = targetDevice();
     m_d->filterDeviceBounds = dev->extent();
 
 
     if (activeSelection() ||
         (dev->colorSpace() != dev->compositionSourceColorSpace() &&
          *dev->colorSpace() != *dev->compositionSourceColorSpace())) {
 
         m_d->filterDevice = dev->createCompositionSourceDevice(dev);
         m_d->secondaryTransaction = new KisTransaction(m_d->filterDevice);
 
         if (activeSelection()) {
             m_d->filterDeviceBounds &= activeSelection()->selectedRect();
         }
     } else {
         m_d->filterDevice = dev;
     }
 
     m_d->progressHelper.reset(new KisProcessingVisitor::ProgressHelper(m_d->node));
 }
 
 void KisFilterStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Data *d = dynamic_cast<Data*>(data);
     CancelSilentlyMarker *cancelJob =
         dynamic_cast<CancelSilentlyMarker*>(data);
 
     if (d) {
         const QRect rc = d->processRect;
 
         if (!m_d->filterDeviceBounds.intersects(
                 m_d->filter->neededRect(rc, m_d->filterConfig.data(), m_d->levelOfDetail))) {
 
             return;
         }
 
         m_d->filter->processImpl(m_d->filterDevice, rc,
                                  m_d->filterConfig.data(),
                                  m_d->progressHelper->updater());
 
         if (m_d->secondaryTransaction) {
             KisPainter::copyAreaOptimized(rc.topLeft(), m_d->filterDevice, targetDevice(), rc, activeSelection());
 
             // Free memory
             m_d->filterDevice->clear(rc);
         }
 
         m_d->node->setDirty(rc);
     } else if (cancelJob) {
         m_d->cancelSilently = true;
     } else {
         qFatal("KisFilterStrokeStrategy: job type is not known");
     }
 }
 
 void KisFilterStrokeStrategy::cancelStrokeCallback()
 {
     delete m_d->secondaryTransaction;
     m_d->filterDevice = 0;
 
     KisProjectionUpdatesFilterSP prevUpdatesFilter;
 
     if (m_d->cancelSilently) {
         /**
          * TODO: Projection updates filter is not recursive, please
          *       redesign this part
          */
         prevUpdatesFilter = m_d->updatesFacade->projectionUpdatesFilter();
         if (prevUpdatesFilter) {
             m_d->updatesFacade->setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
         }
         m_d->updatesFacade->disableDirtyRequests();
     }
 
     KisPainterBasedStrokeStrategy::cancelStrokeCallback();
 
     if (m_d->cancelSilently) {
         m_d->updatesFacade->enableDirtyRequests();
         if (prevUpdatesFilter) {
             m_d->updatesFacade->setProjectionUpdatesFilter(prevUpdatesFilter);
             prevUpdatesFilter.clear();
         }
     }
 }
 
 void KisFilterStrokeStrategy::finishStrokeCallback()
 {
     delete m_d->secondaryTransaction;
     m_d->filterDevice = 0;
 
     KisPainterBasedStrokeStrategy::finishStrokeCallback();
 }
 
 KisStrokeStrategy* KisFilterStrokeStrategy::createLodClone(int levelOfDetail)
 {
     if (!m_d->filter->supportsLevelOfDetail(m_d->filterConfig.data(), levelOfDetail)) return 0;
 
     KisFilterStrokeStrategy *clone = new KisFilterStrokeStrategy(*this, levelOfDetail);
     return clone;
 }
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 c496f3bc58..ce0b6ef189 100644
--- a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
@@ -1,401 +1,401 @@
 /*
  *  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"
 #include "KisFreehandStrokeInfo.h"
 #include "KisMaskedFreehandStrokePainter.h"
 #include "KisMaskingBrushRenderer.h"
 #include "KisRunnableStrokeJobData.h"
 
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings.h"
 
-KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QString &id,
+KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                                              const KUndo2MagicString &name,
                                                              KisResourcesSnapshotSP resources,
                                                              QVector<KisFreehandStrokeInfo*> strokeInfos,bool useMergeID)
     : KisRunnableBasedStrokeStrategy(id, name),
       m_resources(resources),
       m_strokeInfos(strokeInfos),
       m_transaction(0),
       m_useMergeID(useMergeID),
       m_supportsMaskingBrush(false),
       m_supportsIndirectPainting(false)
 {
     init();
 }
 
-KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QString &id,
+KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                                              const KUndo2MagicString &name,
                                                              KisResourcesSnapshotSP resources,
                                                              KisFreehandStrokeInfo *strokeInfo,bool useMergeID)
     : KisRunnableBasedStrokeStrategy(id, name),
       m_resources(resources),
       m_strokeInfos(QVector<KisFreehandStrokeInfo*>() <<  strokeInfo),
       m_transaction(0),
       m_useMergeID(useMergeID),
       m_supportsMaskingBrush(false),
       m_supportsIndirectPainting(false)
 {
     init();
 }
 
 KisPainterBasedStrokeStrategy::~KisPainterBasedStrokeStrategy()
 {
 }
 
 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)
     : KisRunnableBasedStrokeStrategy(rhs),
       m_resources(rhs.m_resources),
       m_transaction(rhs.m_transaction),
       m_useMergeID(rhs.m_useMergeID),
       m_supportsMaskingBrush(rhs.m_supportsMaskingBrush),
       m_supportsIndirectPainting(rhs.m_supportsIndirectPainting)
 {
     Q_FOREACH (KisFreehandStrokeInfo *info, rhs.m_strokeInfos) {
         m_strokeInfos.append(new KisFreehandStrokeInfo(info, levelOfDetail));
     }
 
     KIS_ASSERT_RECOVER_NOOP(
         rhs.m_maskStrokeInfos.isEmpty() &&
         !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;
 }
 
 KisMaskedFreehandStrokePainter *KisPainterBasedStrokeStrategy::maskedPainter(int strokeInfoId)
 {
     return m_maskedPainters[strokeInfoId];
 }
 
 int KisPainterBasedStrokeStrategy::numMaskedPainters() const
 {
     return m_maskedPainters.size();
 }
 
 bool KisPainterBasedStrokeStrategy::needsMaskingUpdates() const
 {
     return m_maskingBrushRenderer;
 }
 
 QVector<KisRunnableStrokeJobData *> KisPainterBasedStrokeStrategy::doMaskingBrushUpdates(const QVector<QRect> &rects)
 {
     QVector<KisRunnableStrokeJobData *> jobs;
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_maskingBrushRenderer, jobs);
 
     Q_FOREACH (const QRect &rc, rects) {
         jobs.append(new KisRunnableStrokeJobData(
             [this, rc] () {
                 this->m_maskingBrushRenderer->updateProjection(rc);
             },
             KisStrokeJobData::CONCURRENT));
     }
 
     return jobs;
 }
 
 void KisPainterBasedStrokeStrategy::setSupportsMaskingBrush(bool value)
 {
     m_supportsMaskingBrush = value;
 }
 
 bool KisPainterBasedStrokeStrategy::supportsMaskingBrush() const
 {
     return m_supportsMaskingBrush;
 }
 
 void KisPainterBasedStrokeStrategy::setSupportsIndirectPainting(bool value)
 {
     m_supportsIndirectPainting = value;
 }
 
 bool KisPainterBasedStrokeStrategy::supportsIndirectPainting() const
 {
     return m_supportsIndirectPainting;
 }
 
 void KisPainterBasedStrokeStrategy::initPainters(KisPaintDeviceSP targetDevice,
                                                  KisPaintDeviceSP maskingDevice,
                                                  KisSelectionSP selection,
                                                  bool hasIndirectPainting,
                                                  const QString &indirectPaintingCompositeOp)
 {
     Q_FOREACH (KisFreehandStrokeInfo *info, m_strokeInfos) {
         KisPainter *painter = info->painter;
 
         painter->begin(targetDevice, !hasIndirectPainting ? selection : 0);
         painter->setRunnableStrokeJobsInterface(runnableJobsInterface());
         m_resources->setupPainter(painter);
 
         if(hasIndirectPainting) {
             painter->setCompositeOp(targetDevice->colorSpace()->compositeOp(indirectPaintingCompositeOp));
             painter->setOpacity(OPACITY_OPAQUE_U8);
             painter->setChannelFlags(QBitArray());
         }
     }
 
     if (maskingDevice) {
         for (int i = 0; i < m_strokeInfos.size(); i++) {
             KisFreehandStrokeInfo *maskingInfo =
                 new KisFreehandStrokeInfo(*m_strokeInfos[i]->dragDistance);
 
             KisPainter *painter = maskingInfo->painter;
 
             painter->begin(maskingDevice, 0);
             m_resources->setupMaskingBrushPainter(painter);
 
             KIS_SAFE_ASSERT_RECOVER_NOOP(hasIndirectPainting);
             m_maskStrokeInfos.append(maskingInfo);
         }
     }
 
     for (int i = 0; i < m_strokeInfos.size(); i++) {
         m_maskedPainters.append(
             new KisMaskedFreehandStrokePainter(m_strokeInfos[i],
                                                !m_maskStrokeInfos.isEmpty() ?
                                                    m_maskStrokeInfos[i] : 0));
     }
 }
 
 void KisPainterBasedStrokeStrategy::deletePainters()
 {
     Q_FOREACH (KisFreehandStrokeInfo *info, m_strokeInfos) {
         delete info;
     }
 
     m_strokeInfos.clear();
 
     Q_FOREACH (KisFreehandStrokeInfo *info, m_maskStrokeInfos) {
         delete info;
     }
 
     m_maskStrokeInfos.clear();
 
     Q_FOREACH (KisMaskedFreehandStrokePainter *info, m_maskedPainters) {
         delete info;
     }
 
     m_maskedPainters.clear();
 }
 
 void KisPainterBasedStrokeStrategy::initStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisPaintDeviceSP paintDevice = node->paintDevice();
     KisPaintDeviceSP targetDevice = paintDevice;
     bool hasIndirectPainting = supportsIndirectPainting() && m_resources->needsIndirectPainting();
     const QString indirectCompositeOp = m_resources->indirectPaintingCompositeOp();
 
     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);
     }
 
     // WARNING: masked brush cannot work without indirect painting mode!
     KIS_SAFE_ASSERT_RECOVER_NOOP(!(supportsMaskingBrush() &&
                                    m_resources->needsMaskingBrushRendering()) || hasIndirectPainting);
 
     if (hasIndirectPainting &&
         supportsMaskingBrush() &&
         m_resources->needsMaskingBrushRendering()) {
 
         const QString compositeOpId =
             m_resources->currentPaintOpPreset()->settings()->maskingBrushCompositeOp();
 
         m_maskingBrushRenderer.reset(new KisMaskingBrushRenderer(targetDevice, compositeOpId));
 
         initPainters(m_maskingBrushRenderer->strokeDevice(),
                      m_maskingBrushRenderer->maskDevice(),
                      selection,
                      hasIndirectPainting,
                      indirectCompositeOp);
 
     } else {
         initPainters(targetDevice, 0, selection, hasIndirectPainting, indirectCompositeOp);
     }
 
     m_targetDevice = targetDevice;
     m_activeSelection = selection;
 
     // sanity check: selection should be applied only once
     if (selection && !m_strokeInfos.isEmpty()) {
         KisIndirectPaintingSupport *indirect =
             dynamic_cast<KisIndirectPaintingSupport*>(node.data());
         KIS_ASSERT_RECOVER_RETURN(hasIndirectPainting || m_strokeInfos.first()->painter->selection());
         KIS_ASSERT_RECOVER_RETURN(!hasIndirectPainting || !indirect->temporarySelection() || !m_strokeInfos.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
         // todo:change to an assert
         if (node->paintDevice() != m_targetDevice) {
             indirect->setTemporaryTarget(m_targetDevice);
             indirect->setTemporaryCompositeOp(m_resources->compositeOpId());
             indirect->setTemporaryOpacity(m_resources->opacity());
             indirect->setTemporarySelection(m_activeSelection);
         }
     }
 }
 
 KisNodeSP KisPainterBasedStrokeStrategy::targetNode() const
 {
     return m_resources->currentNode();
 }
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 b838207e22..908c29ade5 100644
--- a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
+++ b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
@@ -1,140 +1,140 @@
 /*
  *  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 <QVector>
 
 #include "KisRunnableBasedStrokeStrategy.h"
 #include "kis_resources_snapshot.h"
 #include "kis_selection.h"
 
 class KisPainter;
 class KisDistanceInformation;
 class KisTransaction;
 class KisFreehandStrokeInfo;
 class KisMaskedFreehandStrokePainter;
 class KisMaskingBrushRenderer;
 class KisRunnableStrokeJobData;
 
 
 class KRITAUI_EXPORT KisPainterBasedStrokeStrategy : public KisRunnableBasedStrokeStrategy
 {
 public:
-    KisPainterBasedStrokeStrategy(const QString &id,
+    KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                   const KUndo2MagicString &name,
                                   KisResourcesSnapshotSP resources,
                                   QVector<KisFreehandStrokeInfo*> strokeInfos, bool useMergeID = false);
 
-    KisPainterBasedStrokeStrategy(const QString &id,
+    KisPainterBasedStrokeStrategy(const QLatin1String &id,
                                   const KUndo2MagicString &name,
                                   KisResourcesSnapshotSP resources,
-                                  KisFreehandStrokeInfo *strokeInfo,bool useMergeID = false);
+                                  KisFreehandStrokeInfo *strokeInfo, bool useMergeID = false);
 
     ~KisPainterBasedStrokeStrategy();
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
 
     void suspendStrokeCallback() override;
     void resumeStrokeCallback() override;
 
 protected:
     KisNodeSP targetNode() const;
     KisPaintDeviceSP targetDevice() const;
     KisSelectionSP activeSelection() const;
 
     KisMaskedFreehandStrokePainter* maskedPainter(int strokeInfoId);
     int numMaskedPainters() const;
 
     void setUndoEnabled(bool value);
 
     /**
      * Return true if the descendant should execute a few more jobs before issuing setDirty()
      * call on the layer.
      *
      * If the returned value is true, then the stroke actually paints **not** on the
      * layer's paint device, but on some intermediate device owned by
      * KisPainterBasedStrokeStrategy and one should merge it first before asking the
      * update.
      *
      * The value can be true only when the stroke is declared to support masked brush!
      * \see supportsMaskingBrush()
      */
     bool needsMaskingUpdates() const;
 
     /**
      * Create a list of update jobs that should be run before issuing the setDirty()
      * call on the node
      *
      * \see needsMaskingUpdates()
      */
     QVector<KisRunnableStrokeJobData*> doMaskingBrushUpdates(const QVector<QRect> &rects);
 
 protected:
 
     /**
      * The descendants may declare if this stroke should support auto-creation
      * of the masked brush. Default value: false
      */
     void setSupportsMaskingBrush(bool value);
 
     /**
      * Return if the stroke should auto-create a masked brush from the provided
      * paintop preset or not
      */
     bool supportsMaskingBrush() const;
 
     void setSupportsIndirectPainting(bool value);
     bool supportsIndirectPainting() const;
 
 protected:
     KisPainterBasedStrokeStrategy(const KisPainterBasedStrokeStrategy &rhs, int levelOfDetail);
 
 private:
     void init();
     void initPainters(KisPaintDeviceSP targetDevice, KisPaintDeviceSP maskingDevice,
                       KisSelectionSP selection,
                       bool hasIndirectPainting,
                       const QString &indirectPaintingCompositeOp);
     void deletePainters();
     inline int timedID(const QString &id){
         return int(qHash(id));
     }
 
 private:
     KisResourcesSnapshotSP m_resources;
     QVector<KisFreehandStrokeInfo*> m_strokeInfos;
     QVector<KisFreehandStrokeInfo*> m_maskStrokeInfos;
     QVector<KisMaskedFreehandStrokePainter*> m_maskedPainters;
 
     KisTransaction *m_transaction;
 
     QScopedPointer<KisMaskingBrushRenderer> m_maskingBrushRenderer;
 
     KisPaintDeviceSP m_targetDevice;
     KisSelectionSP m_activeSelection;
     bool m_useMergeID;
 
     bool m_supportsMaskingBrush;
     bool m_supportsIndirectPainting;
 };
 
 #endif /* __KIS_PAINTER_BASED_STROKE_STRATEGY_H */
diff --git a/libs/ui/widgets/kis_preset_live_preview_view.cpp b/libs/ui/widgets/kis_preset_live_preview_view.cpp
index b719743ebf..5a488e6ca4 100644
--- a/libs/ui/widgets/kis_preset_live_preview_view.cpp
+++ b/libs/ui/widgets/kis_preset_live_preview_view.cpp
@@ -1,383 +1,384 @@
 
 /*
  *  Copyright (c) 2017 Scott Petrovic <scottpetrovic@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_preset_live_preview_view.h>
 #include <QDebug>
 #include <QGraphicsPixmapItem>
 #include "kis_paintop_settings.h"
 #include <strokes/freehand_stroke.h>
 #include <strokes/KisFreehandStrokeInfo.h>
 #include "KisAsyncronousStrokeUpdateHelper.h"
 #include <kis_brush.h>
 
 KisPresetLivePreviewView::KisPresetLivePreviewView(QWidget *parent)
     : QGraphicsView(parent),
       m_updateCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
 {
     connect(&m_updateCompressor, SIGNAL(timeout()), SLOT(updateStroke()));
 }
 
 KisPresetLivePreviewView::~KisPresetLivePreviewView()
 {
     delete m_noPreviewText;
     delete m_brushPreviewScene;
 }
 
 void KisPresetLivePreviewView::setup()
 {
     // initializing to 0 helps check later if they actually have something in them
     m_noPreviewText = 0;
     m_sceneImageItem = 0;
 
     setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
     setVerticalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
 
 
     // layer image needs to be big enough to get an entire stroke of data
     m_canvasSize.setWidth(this->width());
     m_canvasSize.setHeight(this->height());
 
     m_canvasCenterPoint.setX(m_canvasSize.width()*0.5);
     m_canvasCenterPoint.setY(m_canvasSize.height()*0.5);
 
     m_colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     m_image = new KisImage(0, m_canvasSize.width(), m_canvasSize.height(), m_colorSpace, "stroke sample image");
 
 
     m_layer = new KisPaintLayer(m_image, "livePreviewStrokeSample", OPACITY_OPAQUE_U8, m_colorSpace);
 
     // set scene for the view
     m_brushPreviewScene = new QGraphicsScene();
     setScene(m_brushPreviewScene);
 
 }
 
 void KisPresetLivePreviewView::setCurrentPreset(KisPaintOpPresetSP preset)
 {
     m_currentPreset = preset;
 }
 
 void KisPresetLivePreviewView::requestUpdateStroke()
 {
     m_updateCompressor.start();
 }
 
 void KisPresetLivePreviewView::updateStroke()
 {
     // do not paint a stroke if we are any of these engines (they have some issue currently)
     if (m_currentPreset->paintOp().id() == "roundmarker" ||
             m_currentPreset->paintOp().id() == "experimentbrush" ||
             m_currentPreset->paintOp().id() == "duplicate") {
 
         paintBackground();
         slotPreviewGenerationCompleted();
         return;
     }
 
     if (!m_previewGenerationInProgress) {
         paintBackground();
         setupAndPaintStroke();
     } else {
         m_updateCompressor.start();
     }
 }
 
 void KisPresetLivePreviewView::slotPreviewGenerationCompleted()
 {
     m_previewGenerationInProgress = false;
 
     QImage m_temp_image;
     m_temp_image = m_layer->paintDevice()->convertToQImage(0, m_image->bounds());
 
     // only add the object once...then just update the pixmap so we can move the preview around
     if (!m_sceneImageItem) {
         m_sceneImageItem = m_brushPreviewScene->addPixmap(QPixmap::fromImage(m_temp_image));
     } else {
         m_sceneImageItem->setPixmap(QPixmap::fromImage(m_temp_image));
     }
 }
 
 void KisPresetLivePreviewView::paintBackground()
 {
     // clean up "no preview" text object if it exists. we will add it later if we need it
     if (m_noPreviewText) {
         this->scene()->removeItem(m_noPreviewText);
         m_noPreviewText = 0;
     }
 
 
     if (m_currentPreset->paintOp().id() == "colorsmudge" ||
             m_currentPreset->paintOp().id() == "deformbrush" ||
             m_currentPreset->paintOp().id() == "filter") {
 
         // easier to see deformations and smudging with alternating stripes in the background
         // paint the whole background with alternating stripes
         // filter engine may or may not show things depending on the filter...but it is better than nothing
 
         int grayStrips = 20;
         for (int i=0; i < grayStrips; i++ ) {
 
             float sectionPercent = 1.0 / (float)grayStrips;
             bool isAlternating = i % 2;
             KoColor fillColor(m_layer->paintDevice()->colorSpace());
 
             if (isAlternating) {
                 fillColor.fromQColor(QColor(80,80,80));
             } else {
                 fillColor.fromQColor(QColor(140,140,140));
             }
 
 
             const QRect fillRect(m_layer->image()->width()*sectionPercent*i,
                                  0,
                                  m_layer->image()->width()*(sectionPercent*i +sectionPercent),
                                  m_layer->image()->height());
             m_layer->paintDevice()->fill(fillRect, fillColor);
         }
 
         m_paintColor = KoColor(Qt::white, m_colorSpace);
 
     }
     else if (m_currentPreset->paintOp().id() == "roundmarker" ||
              m_currentPreset->paintOp().id() == "experimentbrush" ||
              m_currentPreset->paintOp().id() == "duplicate" ) {
 
         // cases where we will not show a preview for now
         // roundbrush (quick) -- this isn't showing anything, disable showing preview
         // experimentbrush -- this creates artifacts that carry over to other previews and messes up their display
         // duplicate (clone) brush doesn't have a preview as it doesn't show anything)
 
         if(m_sceneImageItem) {
             this->scene()->removeItem(m_sceneImageItem);
             m_sceneImageItem = 0;
         }
         QFont font;
         font.setPixelSize(14);
         font.setBold(false);
 
         m_noPreviewText = this->scene()->addText(i18n("No Preview for this engine"),font);
         m_noPreviewText->setPos(50, this->height()/4);
 
         return;
 
     }
     else {
 
         // fill with gray first to clear out what existed from previous preview
         m_layer->paintDevice()->fill(m_image->bounds(), KoColor(palette().color(QPalette::Background) , m_colorSpace));
         m_paintColor = KoColor(palette().color(QPalette::Text), m_colorSpace);
     }
 }
 
 class NotificationStroke : public QObject, public KisSimpleStrokeStrategy
 {
   Q_OBJECT
 public:
     NotificationStroke()
+        : KisSimpleStrokeStrategy(QLatin1String("NotificationStroke"))
     {
         setClearsRedoOnStart(false);
         this->enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER);
         this->enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
     }
 
     void initStrokeCallback() {
         emit timeout();
     }
 
     void cancelStrokeCallback() {
         emit cancelled();
     }
 
 Q_SIGNALS:
     void timeout();
     void cancelled();
 };
 
 void KisPresetLivePreviewView::setupAndPaintStroke()
 {
     // limit the brush stroke size. larger brush strokes just don't look good and are CPU intensive
     // we are making a proxy preset and setting it to the painter...otherwise setting the brush size of the original preset
     // will fire off signals that make this run in an infinite loop
     qreal originalPresetSize = m_currentPreset->settings()->paintOpSize();
     qreal previewSize = qBound(3.0, m_currentPreset->settings()->paintOpSize(), 25.0 ); // constrain live preview brush size
     //Except for the sketchbrush where it determine sthe history.
     if (m_currentPreset->paintOp().id() == "sketchbrush" ||
             m_currentPreset->paintOp().id() == "spraybrush") {
         previewSize = qMax(3.0, m_currentPreset->settings()->paintOpSize());
     }
 
 
     KisPaintOpPresetSP proxy_preset = m_currentPreset->clone();
     KisPaintOpSettingsSP settings = proxy_preset->settings();
     settings->setPaintOpSize(previewSize);
 
     int maxTextureSize = 200;
     int textureOffsetX = settings->getInt("Texture/Pattern/MaximumOffsetX")*2;
     int textureOffsetY = settings->getInt("Texture/Pattern/MaximumOffsetY")*2;
     double textureScale = settings->getDouble("Texture/Pattern/Scale");
     if ( textureOffsetX*textureScale> maxTextureSize || textureOffsetY*textureScale > maxTextureSize) {
         int maxSize = qMax(textureOffsetX, textureOffsetY);
         double result = qreal(maxTextureSize) / maxSize;
         settings->setProperty("Texture/Pattern/Scale", result);
     }
     if (proxy_preset->paintOp().id() == "spraybrush") {
 
         QDomElement element;
         QDomDocument d;
         QString brushDefinition = settings->getString("brush_definition");
         if (!brushDefinition.isEmpty()) {
             d.setContent(brushDefinition, false);
             element = d.firstChildElement("Brush");
 
             KisBrushSP brush = KisBrush::fromXML(element);
 
             qreal width = brush->image().width();
             qreal scale = brush->scale();
             qreal diameterToBrushRatio = 1.0;
             qreal diameter = settings->getInt("Spray/diameter");
             //hack, 1000 being the maximum possible brushsize.
             if (brush->filename().endsWith(".svg")) {
                 diameterToBrushRatio = diameter/(1000.0*scale);
                 scale = 25.0 / 1000.0;
             } else {
                 if (width * scale > 25.0) {
                     diameterToBrushRatio = diameter / (width * scale);
                     scale = 25.0 / width;
                 }
             }
             settings->setProperty("Spray/diameter", int(25.0 * diameterToBrushRatio));
 
             brush->setScale(scale);
             d.clear();
             element = d.createElement("Brush");
             brush->toXML(d, element);
             d.appendChild(element);
             settings->setProperty("brush_definition", d.toString());
         }
     }
 
     // Preset preview cannot display gradient color source: there is
     // no resource manager for KisResourcesSnapshot, therefore gradient is nullptr.
     // BUG: 385521 (Selecting "Gradient" in brush editor crashes krita)
     if (proxy_preset->paintOp().id() == "paintbrush") {
         QString colorSourceType = settings->getString("ColorSource/Type", "plain");
         if (colorSourceType == "gradient") {
             settings->setProperty("ColorSource/Type", "plain");
         }
     }
 
     proxy_preset->setSettings(settings);
 
 
     KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(m_image,
                                      m_layer);
     resources->setOpacity(settings->paintOpOpacity());
 
     resources->setBrush(proxy_preset);
     resources->setFGColorOverride(m_paintColor);
     KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
     KisStrokeStrategy *stroke =
             new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("temp_stroke"));
 
     KisStrokeId strokeId = m_image->startStroke(stroke);
 
     // paint the stroke. The sketchbrush gets a different shape than the others to show how it works
     if (proxy_preset->paintOp().id() == "sketchbrush"
             || proxy_preset->paintOp().id() == "curvebrush"
             || proxy_preset->paintOp().id() == "particlebrush") {
         qreal startX = m_canvasCenterPoint.x() - (this->width()*0.4);
         qreal endX   = m_canvasCenterPoint.x() + (this->width()*0.4);
         qreal middle = m_canvasCenterPoint.y();
         KisPaintInformation pointOne;
         pointOne.setPressure(0.0);
         pointOne.setPos(QPointF(startX, middle));
         KisPaintInformation pointTwo;
         pointTwo.setPressure(0.0);
         pointTwo.setPos(QPointF(startX, middle));
         int repeats = 8;
 
         for (int i = 0; i < repeats; i++) {
             pointOne.setPos(pointTwo.pos());
             pointOne.setPressure(pointTwo.pressure());
 
             pointTwo.setPressure((1.0/repeats)*(i+1));
             qreal xPos = ((1.0/repeats) * (i+1) * (endX-startX) )+startX;
             pointTwo.setPos(QPointF(xPos, middle));
 
             qreal offset = (this->height()/(repeats*1.5))*(i+1);
             qreal handleY = middle + offset;
             if (i%2 == 0) {
                 handleY = middle - offset;
             }
 
             m_image->addJob(strokeId,
                             new FreehandStrokeStrategy::Data(0,
                                                              pointOne,
                                                              QPointF(pointOne.pos().x(),
                                                                      handleY),
                                                              QPointF(pointTwo.pos().x(),
                                                                      handleY),
                                                              pointTwo));
             m_image->addJob(strokeId, new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
         }
 
     } else {
 
         // paint an S curve
         m_curvePointPI1.setPos(QPointF(m_canvasCenterPoint.x() - (this->width()*0.45),
                                        m_canvasCenterPoint.y() + (this->height()*0.2)));
         m_curvePointPI1.setPressure(0.0);
 
 
         m_curvePointPI2.setPos(QPointF(m_canvasCenterPoint.x() + (this->width()*0.4),
                                        m_canvasCenterPoint.y() - (this->height()*0.2)   ));
 
         m_curvePointPI2.setPressure(1.0);
 
         m_image->addJob(strokeId,
                         new FreehandStrokeStrategy::Data(0,
                                                          m_curvePointPI1,
                                                          QPointF(m_canvasCenterPoint.x(),
                                                                  m_canvasCenterPoint.y()-this->height()),
                                                          QPointF(m_canvasCenterPoint.x(),
                                                                  m_canvasCenterPoint.y()+this->height()),
                                                          m_curvePointPI2));
         m_image->addJob(strokeId, new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
     }
     m_image->endStroke(strokeId);
 
     m_previewGenerationInProgress = true;
 
     NotificationStroke *notificationStroke = new NotificationStroke();
     connect(notificationStroke, SIGNAL(timeout()), SLOT(slotPreviewGenerationCompleted()));
     KisStrokeId notificationId = m_image->startStroke(notificationStroke);
     m_image->endStroke(notificationId);
 
 
     // TODO: if we don't have any regressions because of it until 4.2.8, then
     //       just remove this code.
     // even though the brush is cloned, the proxy_preset still has some connection to the original preset which will mess brush sizing
     // we need to return brush size to normal.The normal brush sends out a lot of extra signals, so keeping the proxy for now
     //proxy_preset->settings()->setPaintOpSize(originalPresetSize);
 
 }
 
 #include "kis_preset_live_preview_view.moc"
diff --git a/libs/widgets/KoResourceTaggingManager.cpp b/libs/widgets/KoResourceTaggingManager.cpp
index 41dca4fe6c..3e9f443018 100644
--- a/libs/widgets/KoResourceTaggingManager.cpp
+++ b/libs/widgets/KoResourceTaggingManager.cpp
@@ -1,392 +1,394 @@
 /*
  *    This file is part of the KDE project
  *    Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *    Copyright (c) 2007 Jan Hambrecht <jaham@gmx.net>
  *    Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *    Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *    Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *    Copyright (c) 2013 Sascha Suelzer <s.suelzer@gmail.com>
  *
  *    This library is free software; you can redistribute it and/or
  *    modify it under the terms of the GNU 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 "KoResourceTaggingManager.h"
 
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QPointer>
 #include <QStringList>
 
 #include <WidgetsDebug.h>
 
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 
 #include "KoTagFilterWidget.h"
 #include "KoTagChooserWidget.h"
 #include "KoResourceModel.h"
 #include <resources/KoResource.h>
 #include "KoResourceItemChooserContextMenu.h"
 
 #include <kconfiggroup.h>
 
 class TaggedResourceSet
 {
 public:
     TaggedResourceSet()
     {}
 
     TaggedResourceSet(const QString& tagName, const QList<KoResource*>& resources)
         : tagName(tagName)
         , resources(resources)
     {}
 
     QString tagName;
     QList<KoResource*> resources;
 };
 
 
 class KoResourceTaggingManager::Private
 {
 public:
     QString currentTag;
     QList<KoResource*> originalResources;
     TaggedResourceSet lastDeletedTag;
 
     KoTagChooserWidget* tagChooser;
     KoTagFilterWidget* tagFilter;
 
     QCompleter* tagCompleter;
 
     QPointer<KoResourceModel> model;
 };
 
 
 KoResourceTaggingManager::KoResourceTaggingManager(KoResourceModel *model, QWidget* parent)
     : QObject(parent)
     , d(new Private())
 {
     d->model = model;
 
     d->tagChooser = new KoTagChooserWidget(parent);
     d->tagChooser->addReadOnlyItem("All"); // not translatable until other tags made translatable!
     d->tagChooser->addItems(d->model->tagNamesList());
 
     d->tagFilter = new KoTagFilterWidget(parent);
 
     connect(d->tagChooser, SIGNAL(tagChosen(QString)),
             this, SLOT(tagChooserIndexChanged(QString)));
     connect(d->tagChooser, SIGNAL(newTagRequested(QString)),
             this, SLOT(contextCreateNewTag(QString)));
     connect(d->tagChooser, SIGNAL(tagDeletionRequested(QString)),
             this, SLOT(removeTagFromComboBox(QString)));
     connect(d->tagChooser, SIGNAL(tagRenamingRequested(QString,QString)),
             this, SLOT(renameTag(QString,QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionRequested(QString)),
             this, SLOT(undeleteTag(QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionListPurgeRequested()),
             this, SLOT(purgeTagUndeleteList()));
 
     connect(d->tagFilter, SIGNAL(saveButtonClicked()),
             this, SLOT(tagSaveButtonPressed()));
     connect(d->tagFilter, SIGNAL(filterTextChanged(QString)),
             this, SLOT(tagSearchLineEditTextChanged(QString)));
 
     connect(d->model, SIGNAL(tagBoxEntryAdded(QString)),
             this, SLOT(syncTagBoxEntryAddition(QString)));
     connect(d->model, SIGNAL(tagBoxEntryRemoved(QString)),
             this, SLOT(syncTagBoxEntryRemoval(QString)));
     connect(d->model, SIGNAL(tagBoxEntryModified()),
             this, SLOT(syncTagBoxEntries()));
 
     // FIXME: fix tag completer
     // d->tagCompleter = new QCompleter(this);
     //  d->tagSearchLineEdit->setCompleter(d->tagCompleter);
 
     syncTagBoxEntries();
 }
 
 KoResourceTaggingManager::~KoResourceTaggingManager()
 {
     delete d;
 }
 
 void KoResourceTaggingManager::showTaggingBar(bool show)
 {
     show ? d->tagFilter->show() : d->tagFilter->hide();
     show ? d->tagChooser->show() : d->tagChooser->hide();
 
     blockSignals(!show);
 
     QString tag("All");
     if (show) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("SelectedTags");
         tag = group.readEntry<QString>(d->model->serverType(), "All");
     }
     int idx = d->tagChooser->findIndexOf(tag);
     if (idx < 0) idx = 0;
     d->tagChooser->setCurrentIndex(idx);
 }
 
 void KoResourceTaggingManager::purgeTagUndeleteList()
 {
     d->lastDeletedTag = TaggedResourceSet();
     d->tagChooser->setUndeletionCandidate(QString());
 }
 
 void KoResourceTaggingManager::undeleteTag(const QString & tagToUndelete)
 {
     QString tagName = tagToUndelete;
     QStringList allTags = availableTags();
 
     if (allTags.contains(tagName)) {
         bool ok;
         tagName = QInputDialog::getText(
                     d->tagChooser, i18n("Unable to undelete tag"),
                     i18n("<qt>The tag you are trying to undelete already exists in tag list.<br>Please enter a new, unique name for it.</qt>"),
                     QLineEdit::Normal,
                     tagName, &ok);
 
         if (!ok || allTags.contains(tagName) || tagName.isEmpty()) {
             QMessageBox msgBox;
             msgBox.setIcon(QMessageBox::Warning);
             msgBox.setText(i18n("Tag was not undeleted."));
             msgBox.exec();
             return;
         }
     }
 
     QList<KoResource*> serverResources = d->model->serverResources();
 
     Q_FOREACH (KoResource * resource, d->lastDeletedTag.resources) {
         if (serverResources.contains(resource)) {
             addResourceTag(resource, tagName);
         }
     }
     d->model->tagCategoryAdded(tagName);
     d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tagName));
     d->tagChooser->setUndeletionCandidate(QString());
     d->lastDeletedTag = TaggedResourceSet();
 }
 
 QStringList KoResourceTaggingManager::availableTags() const
 {
     return d->tagChooser->allTags();
 }
 
 void KoResourceTaggingManager::addResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
     if (tagsList.isEmpty()) {
         d->model->addTag(resource, tagName);
     } else {
         Q_FOREACH (const QString & tag, tagsList) {
             if (tag.compare(tagName)) {
                 d->model->addTag(resource, tagName);
             }
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryAddition(const QString& tag)
 {
     d->tagChooser->insertItem(tag);
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->addTag(0, tag);
         d->model->tagCategoryAdded(tag);
         d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tag));
         updateTaggedResourceView();
     }
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(KoResource* resource , const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->tagCategoryAdded(tag);
         if (resource) {
             addResourceTag(resource, tag);
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryRemoval(const QString& tag)
 {
     d->tagChooser->removeItem(tag);
 }
 
 void KoResourceTaggingManager::syncTagBoxEntries()
 {
     QStringList tags = d->model->tagNamesList();
     tags.sort();
     Q_FOREACH (const QString &tag, tags) {
         d->tagChooser->insertItem(tag);
     }
 }
 
 void KoResourceTaggingManager::contextAddTagToResource(KoResource* resource, const QString& tag)
 {
     addResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextRemoveTagFromResource(KoResource* resource, const QString& tag)
 {
     removeResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::removeTagFromComboBox(const QString &tag)
 {
     QList<KoResource*> resources = d->model->currentlyVisibleResources();
     Q_FOREACH (KoResource * resource, resources) {
         removeResourceTag(resource, tag);
     }
     d->model->tagCategoryRemoved(tag);
     d->lastDeletedTag = TaggedResourceSet(tag, resources);
     d->tagChooser->setUndeletionCandidate(tag);
 }
 
 void KoResourceTaggingManager::removeResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
 
     Q_FOREACH (const QString & oldName, tagsList) {
         if (!oldName.compare(tagName)) {
             d->model->deleteTag(resource, oldName);
         }
     }
 }
 
 void KoResourceTaggingManager::renameTag(const QString &oldName, const QString& newName)
 {
     if (!d->model->tagNamesList().contains(newName)) {
         QList<KoResource*> resources = d->model->currentlyVisibleResources();
 
         Q_FOREACH (KoResource * resource, resources) {
             removeResourceTag(resource, oldName);
             addResourceTag(resource, newName);
         }
         contextCreateNewTag(newName);
         d->model->tagCategoryRemoved(oldName);
         d->model->tagCategoryAdded(newName);
     }
 }
 
 void KoResourceTaggingManager::updateTaggedResourceView()
 {
     d->model->setCurrentTag(d->currentTag);
     d->model->updateServer();
     d->originalResources = d->model->currentlyVisibleResources();
     emit updateView();
 }
 
 void KoResourceTaggingManager::tagChooserIndexChanged(const QString& lineEditText)
 {
-    if (!d->tagChooser->selectedTagIsReadOnly()) {
-        d->currentTag = lineEditText;
+    // HACK This allows tag "All" to be written in kritarc BUG:
+    if (lineEditText == "All" || !d->tagChooser->selectedTagIsReadOnly()) {
         d->tagFilter->allowSave(true);
-        d->model->enableResourceFiltering(true);
+        d->currentTag = lineEditText;
+        d->model->enableResourceFiltering( (lineEditText == "All")? false : true);
+
     } else {
         d->model->enableResourceFiltering(false);
         d->tagFilter->allowSave(false);
         d->currentTag.clear();
     }
 
     d->tagFilter->clear();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::tagSearchLineEditTextChanged(const QString& lineEditText)
 {
     if (d->tagChooser->selectedTagIsReadOnly()) {
         d->model->enableResourceFiltering(!lineEditText.isEmpty());
     } else {
         d->model->enableResourceFiltering(true);
     }
 
     d->model->searchTextChanged(lineEditText);
     d->model->updateServer();
 
     ///FIXME: fix completer
     //     d->tagCompleter = new QCompleter(tagNamesList(lineEditText),this);
     //    d->tagSearchLineEdit->setCompleter(d->tagCompleter);
 
     emit updateView();
 }
 
 void KoResourceTaggingManager::tagSaveButtonPressed()
 {
     if (!d->tagChooser->selectedTagIsReadOnly()) {
         QList<KoResource*> newResources = d->model->currentlyVisibleResources();
         Q_FOREACH (KoResource * oldRes, d->originalResources) {
             if (!newResources.contains(oldRes))
                 removeResourceTag(oldRes, d->currentTag);
         }
         Q_FOREACH (KoResource * newRes, newResources) {
             if (!d->originalResources.contains(newRes))
                 addResourceTag(newRes, d->currentTag);
         }
         d->model->tagCategoryMembersChanged();
     }
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* resource, const QStringList& resourceTags, const QPoint& pos)
 {
     /* no visible tag chooser usually means no intended tag interaction,
      * context menu makes no sense then either */
     if (!resource || !d->tagChooser->isVisible())
         return;
 
     KoResourceItemChooserContextMenu menu(resource,
                                           resourceTags,
                                           d->tagChooser->currentlySelectedTag(),
                                           d->tagChooser->allTags());
 
     connect(&menu, SIGNAL(resourceTagAdditionRequested(KoResource*,QString)),
             this, SLOT(contextAddTagToResource(KoResource*,QString)));
 
     connect(&menu, SIGNAL(resourceTagRemovalRequested(KoResource*,QString)),
             this, SLOT(contextRemoveTagFromResource(KoResource*,QString)));
 
     connect(&menu, SIGNAL(resourceAssignmentToNewTagRequested(KoResource*,QString)),
             this, SLOT(contextCreateNewTag(KoResource*,QString)));
     menu.exec(pos);
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* currentResource, QPoint pos)
 {
     if (currentResource) {
         contextMenuRequested(currentResource, d->model->assignedTagsList(currentResource), pos);
     }
 }
 
 KoTagChooserWidget* KoResourceTaggingManager::tagChooserWidget()
 {
     return d->tagChooser;
 }
 
 KoTagFilterWidget* KoResourceTaggingManager::tagFilterWidget()
 {
     return d->tagFilter;
 }
 
diff --git a/libs/widgets/kis_color_button.cpp b/libs/widgets/kis_color_button.cpp
index 265e80e6b9..2e60eb5e47 100644
--- a/libs/widgets/kis_color_button.cpp
+++ b/libs/widgets/kis_color_button.cpp
@@ -1,382 +1,387 @@
 /*  This file is part of the KDE libraries
     Copyright (C) 1997 Martin Jones (mjones@kde.org)
     Copyright (C) 1999 Cristian Tibirna (ctibirna@kde.org)
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kis_color_button.h"
 
 #include <QPointer>
 #include <QPainter>
 #include <qdrawutil.h>
 #include <QApplication>
 #include <QColorDialog>
 #include <QClipboard>
 #include <QMimeData>
 #include <QDrag>
 #include <QStyle>
 #include <QMouseEvent>
 #include <QStyleOptionButton>
 
 #include <KoColor.h>
 #include <KisDlgInternalColorSelector.h>
 
 class KisColorButton::KisColorButtonPrivate
 {
 public:
     KisColorButtonPrivate(KisColorButton *q);
+    ~KisColorButtonPrivate() {
+        if (dialogPtr) {
+            dialogPtr.data()->close();
+        }
+    }
 
     void _k_chooseColor();
     void _k_colorChosen();
 
     KisColorButton *q;
     KoColor m_defaultColor;
     bool m_bdefaultColor : 1;
     bool m_alphaChannel : 1;
     bool m_palette : 1;
 
     KoColor col;
     QPoint mPos;
 #ifndef Q_OS_MACOS
     QPointer<KisDlgInternalColorSelector> dialogPtr;
 #else
     QPointer<QColorDialog> dialogPtr;
 #endif
 
     void initStyleOption(QStyleOptionButton *opt) const;
 };
 
 /////////////////////////////////////////////////////////////////////
 // Functions duplicated from KColorMimeData
 // Should be kept in sync
 void _k_populateMimeData(QMimeData *mimeData, const KoColor &color)
 {
     mimeData->setColorData(color.toQColor());
     mimeData->setText(color.toQColor().name());
 }
 
 bool _k_canDecode(const QMimeData *mimeData)
 {
     if (mimeData->hasColor()) {
         return true;
     }
     if (mimeData->hasText()) {
         const QString colorName = mimeData->text();
         if ((colorName.length() >= 4) && (colorName[0] == QLatin1Char('#'))) {
             return true;
         }
     }
     return false;
 }
 
 QColor _k_fromMimeData(const QMimeData *mimeData)
 {
     if (mimeData->hasColor()) {
         return mimeData->colorData().value<QColor>();
     }
     if (_k_canDecode(mimeData)) {
         return QColor(mimeData->text());
     }
     return QColor();
 }
 
 QDrag *_k_createDrag(const KoColor &color, QObject *dragsource)
 {
     QDrag *drag = new QDrag(dragsource);
     QMimeData *mime = new QMimeData;
     _k_populateMimeData(mime, color);
     drag->setMimeData(mime);
     QPixmap colorpix(25, 20);
     colorpix.fill(color.toQColor());
     QPainter p(&colorpix);
     p.setPen(Qt::black);
     p.drawRect(0, 0, 24, 19);
     p.end();
     drag->setPixmap(colorpix);
     drag->setHotSpot(QPoint(-5, -7));
     return drag;
 }
 /////////////////////////////////////////////////////////////////////
 
 KisColorButton::KisColorButtonPrivate::KisColorButtonPrivate(KisColorButton *q)
     : q(q)
 {
     m_bdefaultColor = false;
     m_alphaChannel = false;
     m_palette = true;
     q->setAcceptDrops(true);
 
     connect(q, SIGNAL(clicked()), q, SLOT(_k_chooseColor()));
 }
 
 KisColorButton::KisColorButton(QWidget *parent)
     : QPushButton(parent)
     , d(new KisColorButtonPrivate(this))
 {
 }
 
 KisColorButton::KisColorButton(const KoColor &c, QWidget *parent)
     : QPushButton(parent)
     , d(new KisColorButtonPrivate(this))
 {
     d->col = c;
 }
 
 KisColorButton::KisColorButton(const KoColor &c, const KoColor &defaultColor, QWidget *parent)
     : QPushButton(parent)
     , d(new KisColorButtonPrivate(this))
 {
     d->col = c;
     setDefaultColor(defaultColor);
 }
 
 KisColorButton::~KisColorButton()
 {
     delete d;
 }
 
 KoColor KisColorButton::color() const
 {
     return d->col;
 }
 
 void KisColorButton::setColor(const KoColor &c)
 {
     d->col = c;
     update();
     emit changed(d->col);
 }
 
 void KisColorButton::setAlphaChannelEnabled(bool alpha)
 {
     d->m_alphaChannel = alpha;
 }
 
 bool KisColorButton::isAlphaChannelEnabled() const
 {
     return d->m_alphaChannel;
 }
 
 void KisColorButton::setPaletteViewEnabled(bool enable)
 {
     d->m_palette = enable;
 }
 
 bool KisColorButton::paletteViewEnabled() const
 {
     return d->m_palette;
 }
 
 KoColor KisColorButton::defaultColor() const
 {
     return d->m_defaultColor;
 }
 
 void KisColorButton::setDefaultColor(const KoColor &c)
 {
     d->m_bdefaultColor = true;
     d->m_defaultColor = c;
 }
 
 void KisColorButton::KisColorButtonPrivate::initStyleOption(QStyleOptionButton *opt) const
 {
     opt->initFrom(q);
     opt->state |= q->isDown() ? QStyle::State_Sunken : QStyle::State_Raised;
     opt->features = QStyleOptionButton::None;
     if (q->isDefault()) {
         opt->features |= QStyleOptionButton::DefaultButton;
     }
     opt->text.clear();
     opt->icon = QIcon();
 }
 
 void KisColorButton::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
     QStyle *style = QWidget::style();
 
     //First, we need to draw the bevel.
     QStyleOptionButton butOpt;
     d->initStyleOption(&butOpt);
     style->drawControl(QStyle::CE_PushButtonBevel, &butOpt, &painter, this);
 
     //OK, now we can muck around with drawing out pretty little color box
     //First, sort out where it goes
     QRect labelRect = style->subElementRect(QStyle::SE_PushButtonContents,
                                             &butOpt, this);
     int shift = style->pixelMetric(QStyle::PM_ButtonMargin, &butOpt, this) / 2;
     labelRect.adjust(shift, shift, -shift, -shift);
     int x, y, w, h;
     labelRect.getRect(&x, &y, &w, &h);
 
     if (isChecked() || isDown()) {
         x += style->pixelMetric(QStyle::PM_ButtonShiftHorizontal, &butOpt, this);
         y += style->pixelMetric(QStyle::PM_ButtonShiftVertical, &butOpt, this);
     }
 
     QColor fillCol = isEnabled() ? d->col.toQColor() : palette().color(backgroundRole());
     qDrawShadePanel(&painter, x, y, w, h, palette(), true, 1, NULL);
     if (fillCol.isValid()) {
         const QRect rect(x + 1, y + 1, w - 2, h - 2);
         if (fillCol.alpha() < 255) {
             QPixmap chessboardPattern(16, 16);
             QPainter patternPainter(&chessboardPattern);
             patternPainter.fillRect(0, 0, 8, 8, Qt::black);
             patternPainter.fillRect(8, 8, 8, 8, Qt::black);
             patternPainter.fillRect(0, 8, 8, 8, Qt::white);
             patternPainter.fillRect(8, 0, 8, 8, Qt::white);
             patternPainter.end();
             painter.fillRect(rect, QBrush(chessboardPattern));
         }
         painter.fillRect(rect, fillCol);
     }
 
     if (hasFocus()) {
         QRect focusRect = style->subElementRect(QStyle::SE_PushButtonFocusRect, &butOpt, this);
         QStyleOptionFocusRect focusOpt;
         focusOpt.init(this);
         focusOpt.rect            = focusRect;
         focusOpt.backgroundColor = palette().window().color();
         style->drawPrimitive(QStyle::PE_FrameFocusRect, &focusOpt, &painter, this);
     }
 }
 
 QSize KisColorButton::sizeHint() const
 {
     QStyleOptionButton opt;
     d->initStyleOption(&opt);
     return style()->sizeFromContents(QStyle::CT_PushButton, &opt, QSize(40, 15), this).
             expandedTo(QApplication::globalStrut());
 }
 
 QSize KisColorButton::minimumSizeHint() const
 {
     QStyleOptionButton opt;
     d->initStyleOption(&opt);
     return style()->sizeFromContents(QStyle::CT_PushButton, &opt, QSize(3, 3), this).
             expandedTo(QApplication::globalStrut());
 }
 
 void KisColorButton::dragEnterEvent(QDragEnterEvent *event)
 {
     event->setAccepted(_k_canDecode(event->mimeData()) && isEnabled());
 }
 
 void KisColorButton::dropEvent(QDropEvent *event)
 {
     QColor c = _k_fromMimeData(event->mimeData());
     if (c.isValid()) {
         KoColor col;
         col.fromQColor(c);
         setColor(col);
     }
 }
 
 void KisColorButton::keyPressEvent(QKeyEvent *e)
 {
     int key = e->key() | e->modifiers();
 
     if (QKeySequence::keyBindings(QKeySequence::Copy).contains(key)) {
         QMimeData *mime = new QMimeData;
         _k_populateMimeData(mime, color());
         QApplication::clipboard()->setMimeData(mime, QClipboard::Clipboard);
     } else if (QKeySequence::keyBindings(QKeySequence::Paste).contains(key)) {
         QColor color = _k_fromMimeData(QApplication::clipboard()->mimeData(QClipboard::Clipboard));
         KoColor col;
         col.fromQColor(color);
         setColor(col);
     } else {
         QPushButton::keyPressEvent(e);
     }
 }
 
 void KisColorButton::mousePressEvent(QMouseEvent *e)
 {
     d->mPos = e->pos();
     QPushButton::mousePressEvent(e);
 }
 
 void KisColorButton::mouseMoveEvent(QMouseEvent *e)
 {
     if ((e->buttons() & Qt::LeftButton) &&
             (e->pos() - d->mPos).manhattanLength() > QApplication::startDragDistance()) {
         _k_createDrag(color(), this)->exec();
         setDown(false);
     }
 }
 
 void KisColorButton::KisColorButtonPrivate::_k_chooseColor()
 {
 #ifndef Q_OS_MACOS
     KisDlgInternalColorSelector *dialog = dialogPtr.data();
 #else
     QColorDialog *dialog = dialogPtr.data();
 #endif
     if (dialog) {
 #ifndef Q_OS_MACOS
         dialog->setPreviousColor(q->color());
 #else
         dialog->setCurrentColor(q->color().toQColor());
 #endif
         dialog->show();
         dialog->raise();
         dialog->activateWindow();
         return;
     }
 
     KisDlgInternalColorSelector::Config cfg;
     cfg.paletteBox = q->paletteViewEnabled();
 #ifndef Q_OS_MACOS
     dialog = new KisDlgInternalColorSelector(q,
                                              q->color(),
                                              cfg,
                                              i18n("Choose a color"));
 #else
     dialog = new QColorDialog(q);
     dialog->setOption(QColorDialog::ShowAlphaChannel, m_alphaChannel);
 #endif
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     connect(dialog, SIGNAL(accepted()), q, SLOT(_k_colorChosen()));
     dialogPtr = dialog;
 #ifndef Q_OS_MACOS
     dialog->setPreviousColor(q->color());
 #else
     dialog->setCurrentColor(q->color().toQColor());
 #endif
     dialog->show();
 }
 
 void KisColorButton::KisColorButtonPrivate::_k_colorChosen()
 {
 #ifndef Q_OS_MACOS
     KisDlgInternalColorSelector *dialog = dialogPtr.data();
 #else
     QColorDialog *dialog = dialogPtr.data();
 #endif
     if (!dialog) {
         return;
     }
 #ifndef Q_OS_MACOS
     q->setColor(dialog->getCurrentColor());
 #else
     KoColor c;
     c.fromQColor(dialog->currentColor());
     q->setColor(c);
 #endif
 }
 
 #include "moc_kis_color_button.cpp"
diff --git a/libs/widgetutils/KoFileDialog.cpp b/libs/widgetutils/KoFileDialog.cpp
index ecd6e0a963..fe64d8b2d3 100644
--- a/libs/widgetutils/KoFileDialog.cpp
+++ b/libs/widgetutils/KoFileDialog.cpp
@@ -1,432 +1,441 @@
 /* This file is part of the KDE project
    Copyright (C) 2013 - 2014 Yue Liu <yue.liu@mail.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 "KoFileDialog.h"
 #include <QDebug>
 #include <QFileDialog>
 #include <QApplication>
 #include <QImageReader>
 #include <QClipboard>
 
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 #include <klocalizedstring.h>
 
 #include <KisMimeDatabase.h>
 #include <KoJsonTrader.h>
 
 class Q_DECL_HIDDEN KoFileDialog::Private
 {
 public:
     Private(QWidget *parent_,
             KoFileDialog::DialogType dialogType_,
             const QString caption_,
             const QString defaultDir_,
             const QString dialogName_)
         : parent(parent_)
         , type(dialogType_)
         , dialogName(dialogName_)
         , caption(caption_)
         , defaultDirectory(defaultDir_)
         , filterList(QStringList())
         , defaultFilter(QString())
         , swapExtensionOrder(false)
     {
     }
 
     ~Private()
     {
     }
 
     QWidget *parent;
     KoFileDialog::DialogType type;
     QString dialogName;
     QString caption;
     QString defaultDirectory;
     QString proposedFileName;
     QStringList filterList;
     QString defaultFilter;
     QScopedPointer<QFileDialog> fileDialog;
     QString mimeType;
     bool swapExtensionOrder;
 };
 
 KoFileDialog::KoFileDialog(QWidget *parent,
                            KoFileDialog::DialogType type,
                            const QString &dialogName)
     : d(new Private(parent, type, "", getUsedDir(dialogName), dialogName))
 {
 }
 
 KoFileDialog::~KoFileDialog()
 {
     delete d;
 }
 
 void KoFileDialog::setCaption(const QString &caption)
 {
     d->caption = caption;
 }
 
 void KoFileDialog::setDefaultDir(const QString &defaultDir, bool force)
 {
     if (!defaultDir.isEmpty()) {
         if (d->defaultDirectory.isEmpty() || force) {
             QFileInfo f(defaultDir);
             if (f.isDir()) {
                 d->defaultDirectory = defaultDir;
             }
             else {
                 d->defaultDirectory = f.absolutePath();
             }
         }
         if (!QFileInfo(defaultDir).isDir()) {
             d->proposedFileName = QFileInfo(defaultDir).fileName();
         }
     }
 }
 
 void KoFileDialog::setImageFilters()
 {
     QStringList imageFilters;
     // add filters for all formats supported by QImage
     Q_FOREACH (const QByteArray &format, QImageReader::supportedImageFormats()) {
         imageFilters << QLatin1String("image/") + format;
     }
     setMimeTypeFilters(imageFilters);
 }
 
 void KoFileDialog::setMimeTypeFilters(const QStringList &mimeTypeList, QString defaultMimeType)
 {
     d->filterList = getFilterStringListFromMime(mimeTypeList, true);
 
     QString defaultFilter;
 
     if (!defaultMimeType.isEmpty()) {
         QString suffix = KisMimeDatabase::suffixesForMimeType(defaultMimeType).first();
 
         if (!d->proposedFileName.isEmpty()) {
             d->proposedFileName = QFileInfo(d->proposedFileName).completeBaseName() + "." + suffix;
         }
 
         QStringList defaultFilters = getFilterStringListFromMime(QStringList() << defaultMimeType, false);
         if (defaultFilters.size() > 0) {
             defaultFilter = defaultFilters.first();
         }
     }
 
     d->defaultFilter = defaultFilter;
 }
 
 QString KoFileDialog::selectedNameFilter() const
 {
     return d->fileDialog->selectedNameFilter();
 }
 
 QString KoFileDialog::selectedMimeType() const
 {
     return d->mimeType;
 }
 
 void KoFileDialog::createFileDialog()
 {
     d->fileDialog.reset(new QFileDialog(d->parent, d->caption, d->defaultDirectory + "/" + d->proposedFileName));
     KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
 
     bool dontUseNative = true;
 #ifdef Q_OS_UNIX
     if (qgetenv("XDG_CURRENT_DESKTOP") == "KDE") {
         dontUseNative = false;
     }
 #endif
 #ifdef Q_OS_WIN
     dontUseNative = false;
 #endif
 
-    d->fileDialog->setOption(QFileDialog::DontUseNativeDialog, group.readEntry("DontUseNativeFileDialog", dontUseNative));
+    bool optionDontUseNative = group.readEntry("DontUseNativeFileDialog", dontUseNative);
+    d->fileDialog->setOption(QFileDialog::DontUseNativeDialog, optionDontUseNative);
     d->fileDialog->setOption(QFileDialog::DontConfirmOverwrite, false);
     d->fileDialog->setOption(QFileDialog::HideNameFilterDetails, dontUseNative ? true : false);
 
 #ifdef Q_OS_MACOS
     QList<QUrl> urls = d->fileDialog->sidebarUrls();
     QUrl volumes = QUrl::fromLocalFile("/Volumes");
     if (!urls.contains(volumes)) {
         urls.append(volumes);
     }
 
     d->fileDialog->setSidebarUrls(urls);
 #endif
 
     if (d->type == SaveFile) {
         d->fileDialog->setAcceptMode(QFileDialog::AcceptSave);
         d->fileDialog->setFileMode(QFileDialog::AnyFile);
     }
     else { // open / import
 
         d->fileDialog->setAcceptMode(QFileDialog::AcceptOpen);
 
         if (d->type == ImportDirectory || d->type == OpenDirectory){
             d->fileDialog->setFileMode(QFileDialog::Directory);
             d->fileDialog->setOption(QFileDialog::ShowDirsOnly, true);
         }
         else { // open / import file(s)
             if (d->type == OpenFile
                     || d->type == ImportFile)
             {
                 d->fileDialog->setFileMode(QFileDialog::ExistingFile);
             }
             else { // files
                 d->fileDialog->setFileMode(QFileDialog::ExistingFiles);
             }
         }
     }
 
     d->fileDialog->setNameFilters(d->filterList);
 
     if (!d->proposedFileName.isEmpty()) {
         QString mime = KisMimeDatabase::mimeTypeForFile(d->proposedFileName, d->type == KoFileDialog::SaveFile ? false : true);
 
         QString description = KisMimeDatabase::descriptionForMimeType(mime);
         Q_FOREACH(const QString &filter, d->filterList) {
             if (filter.startsWith(description)) {
                 d->fileDialog->selectNameFilter(filter);
                 break;
             }
         }
     }
     else if (!d->defaultFilter.isEmpty()) {
         d->fileDialog->selectNameFilter(d->defaultFilter);
     }
 
     if (d->type == ImportDirectory ||
             d->type == ImportFile || d->type == ImportFiles ||
             d->type == SaveFile) {
-        d->fileDialog->setWindowModality(Qt::WindowModal);
+
+        bool allowModal = true;
+// MacOS do not declare native file dialog as modal BUG:413241.
+#ifdef Q_OS_MACOS
+        allowModal = optionDontUseNative;
+#endif
+        if (allowModal) {
+            d->fileDialog->setWindowModality(Qt::WindowModal);
+        }
     }
 }
 
 QString KoFileDialog::filename()
 {
     QString url;
     createFileDialog();
     if (d->fileDialog->exec() == QDialog::Accepted) {
         url = d->fileDialog->selectedFiles().first();
     }
 
     if (!url.isEmpty()) {
         QString suffix = QFileInfo(url).suffix();
         if (KisMimeDatabase::mimeTypeForSuffix(suffix).isEmpty()) {
             suffix = "";
         }
 
         if (d->type == SaveFile && suffix.isEmpty()) {
             QString selectedFilter;
             // index 0 is all supported; if that is chosen, saveDocument will automatically make it .kra
             for (int i = 1; i < d->filterList.size(); ++i) {
                 if (d->filterList[i].startsWith(d->fileDialog->selectedNameFilter())) {
                     selectedFilter = d->filterList[i];
                     break;
                 }
             }
             int start = selectedFilter.indexOf("*.") + 1;
             int end = selectedFilter.indexOf(" ", start);
             int n = end - start;
             QString extension = selectedFilter.mid(start, n);
             if (!(extension.contains(".") || url.endsWith("."))) {
                 extension = "." + extension;
             }
             url = url + extension;
         }
 
         d->mimeType = KisMimeDatabase::mimeTypeForFile(url, d->type == KoFileDialog::SaveFile ? false : true);
         saveUsedDir(url, d->dialogName);
     }
     return url;
 }
 
 QStringList KoFileDialog::filenames()
 {
     QStringList urls;
 
     createFileDialog();
     if (d->fileDialog->exec() == QDialog::Accepted) {
         urls = d->fileDialog->selectedFiles();
     }
     if (urls.size() > 0) {
         saveUsedDir(urls.first(), d->dialogName);
     }
     return urls;
 }
 
 QStringList KoFileDialog::splitNameFilter(const QString &nameFilter, QStringList *mimeList)
 {
     Q_ASSERT(mimeList);
 
     QStringList filters;
     QString description;
 
     if (nameFilter.contains("(")) {
         description = nameFilter.left(nameFilter.indexOf("(") -1).trimmed();
     }
 
     QStringList entries = nameFilter.mid(nameFilter.indexOf("(") + 1).split(" ",QString::SkipEmptyParts );
     entries.sort();
     Q_FOREACH (QString entry, entries) {
 
         entry = entry.remove("*");
         entry = entry.remove(")");
 
         QString mimeType = KisMimeDatabase::mimeTypeForSuffix(entry);
         if (mimeType != "application/octet-stream") {
             if (!mimeList->contains(mimeType)) {
                 mimeList->append(mimeType);
                 filters.append(KisMimeDatabase::descriptionForMimeType(mimeType) + " ( *" + entry + " )");
             }
         }
         else {
             filters.append(entry.remove(".").toUpper() + " " + description + " ( *." + entry + " )");
         }
     }
     return filters;
 }
 
 const QStringList KoFileDialog::getFilterStringListFromMime(const QStringList &_mimeList,
                                                             bool withAllSupportedEntry)
 {
     QStringList mimeSeen;
 
     // 1
     QString allSupported;
     // 2
     QString kritaNative;
     // 3
     QString ora;
 
     QStringList ret;
     QStringList mimeList = _mimeList;
     mimeList.sort();
     Q_FOREACH(const QString &mimeType, mimeList) {
         if (!mimeSeen.contains(mimeType)) {
             QString description = KisMimeDatabase::descriptionForMimeType(mimeType);
             if (description.isEmpty() && !mimeType.isEmpty()) {
                 description = mimeType.split("/")[1];
                 if (description.startsWith("x-")) {
                     description = description.remove(0, 2);
                 }
             }
 
 
             QString oneFilter;
             QStringList patterns = KisMimeDatabase::suffixesForMimeType(mimeType);
             QStringList globPatterns;
             Q_FOREACH(const QString &pattern, patterns) {
                 if (pattern.startsWith(".")) {
                     globPatterns << "*" + pattern;
                 }
                 else if (pattern.startsWith("*.")) {
                     globPatterns << pattern;
                 }
                 else {
                     globPatterns << "*." + pattern;
                 }
             }
 
             Q_FOREACH(const QString &glob, globPatterns) {
                 if (d->swapExtensionOrder) {
                     oneFilter.prepend(glob + " ");
                     if (withAllSupportedEntry) {
                         allSupported.prepend(glob + " ");
                     }
 #ifdef Q_OS_LINUX
                     if (qgetenv("XDG_CURRENT_DESKTOP") == "GNOME") {
                         oneFilter.prepend(glob.toUpper() + " ");
                         if (withAllSupportedEntry) {
                             allSupported.prepend(glob.toUpper() + " ");
                         }
                     }
 #endif
 
                 }
                 else {
                     oneFilter.append(glob + " ");
                     if (withAllSupportedEntry) {
                         allSupported.append(glob + " ");
                     }
 #ifdef Q_OS_LINUX
                     if (qgetenv("XDG_CURRENT_DESKTOP") == "GNOME") {
                         oneFilter.append(glob.toUpper() + " ");
                         if (withAllSupportedEntry) {
                             allSupported.append(glob.toUpper() + " ");
                         }
                     }
 #endif
                 }
             }
 
             Q_ASSERT(!description.isEmpty());
 
             oneFilter = description + " ( " + oneFilter + ")";
 
 
             if (mimeType == "application/x-krita") {
                 kritaNative = oneFilter;
                 continue;
             }
             if (mimeType == "image/openraster") {
                 ora = oneFilter;
                 continue;
             }
             else {
                 ret << oneFilter;
             }
             mimeSeen << mimeType;
         }
     }
 
     ret.sort();
     ret.removeDuplicates();
 
     if (!ora.isEmpty()) ret.prepend(ora);
     if (!kritaNative.isEmpty())  ret.prepend(kritaNative);
     if (!allSupported.isEmpty()) ret.prepend(i18n("All supported formats") + " ( " + allSupported + (")"));
 
     return ret;
 
 }
 
 QString KoFileDialog::getUsedDir(const QString &dialogName)
 {
     if (dialogName.isEmpty()) return "";
 
     KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
     QString dir = group.readEntry(dialogName, "");
     return dir;
 }
 
 void KoFileDialog::saveUsedDir(const QString &fileName,
                                const QString &dialogName)
 {
 
     if (dialogName.isEmpty()) return;
 
     QFileInfo fileInfo(fileName);
     KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
     group.writeEntry(dialogName, fileInfo.absolutePath());
 
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
index 1a3df3dc6d..8c2deba887 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
@@ -1,576 +1,573 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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
  */
 
 #include "kis_color_selector_base.h"
 
 #include <QMouseEvent>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QTimer>
 #include <QCursor>
 #include <QPainter>
 #include <QMimeData>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node.h"
 #include "KisViewManager.h"
 #include <KisView.h>
 #include "kis_image.h"
 #include "kis_global.h"
 #include "kis_display_color_converter.h"
 
 #include <resources/KoGamutMask.h>
 
 class KisColorPreviewPopup : public QWidget {
 public:
     KisColorPreviewPopup(KisColorSelectorBase* parent)
         : QWidget(parent), m_parent(parent)
     {
         setWindowFlags(Qt::ToolTip | Qt::NoDropShadowWindowHint);
         setQColor(QColor(0,0,0));
         m_baseColor = QColor(0,0,0,0);
         m_previousColor = QColor(0,0,0,0);
         m_lastUsedColor = QColor(0,0,0,0);
     }
 
     void show()
     {
         updatePosition();
         QWidget::show();
     }
 
     void updatePosition()
     {
         QPoint parentPos = m_parent->mapToGlobal(QPoint(0,0));
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         QPoint targetPos;
         if ( parentPos.x() - 100 > availRect.x() ) {
             targetPos =  QPoint(parentPos.x() - 100, parentPos.y());
         } else if ( parentPos.x() + m_parent->width() + 100 < availRect.right()) {
             targetPos = m_parent->mapToGlobal(QPoint(m_parent->width(), 0));
         } else if ( parentPos.y() - 100 > availRect.y() ) {
             targetPos =  QPoint(parentPos.x(), parentPos.y() - 100);
         } else {
             targetPos =  QPoint(parentPos.x(), parentPos.y() + m_parent->height());
         }
         setGeometry(targetPos.x(), targetPos.y(), 100, 150);
         setAttribute(Qt::WA_TranslucentBackground);
     }
 
     void setQColor(const QColor& color)
     {
         m_color = color;
         update();
     }
 
     void setPreviousColor()
     {
         m_previousColor = m_baseColor;
     }
 
     void setBaseColor(const QColor& color)
     {
         m_baseColor = color;
         update();
     }
 
     void setLastUsedColor(const QColor& color)
     {
         m_lastUsedColor = color;
         update();
     }
 
 protected:
     void paintEvent(QPaintEvent *e) override {
         Q_UNUSED(e);
         QPainter p(this);
         p.fillRect(0, 0, width(), width(), m_color);
         p.fillRect(50, width(), width(), height(), m_previousColor);
         p.fillRect(0, width(), 50, height(), m_lastUsedColor);
     }
 
     void enterEvent(QEvent *e) override {
         QWidget::enterEvent(e);
         m_parent->tryHideAllPopups();
     }
 
     void leaveEvent(QEvent *e) override {
         QWidget::leaveEvent(e);
         m_parent->tryHideAllPopups();
     }
 
 private:
     KisColorSelectorBase* m_parent;
     QColor m_color;
     QColor m_baseColor;
     QColor m_previousColor;
     QColor m_lastUsedColor;
 };
 
 KisColorSelectorBase::KisColorSelectorBase(QWidget *parent) :
     QWidget(parent),
     m_canvas(0),
     m_popup(0),
     m_parent(0),
     m_colorUpdateAllowed(true),
     m_colorUpdateSelf(false),
     m_hideTimer(new QTimer(this)),
     m_popupOnMouseOver(false),
     m_popupOnMouseClick(true),
     m_colorSpace(0),
     m_isPopup(false),
     m_hideOnMouseClick(false),
     m_colorPreviewPopup(new KisColorPreviewPopup(this))
 {
     m_hideTimer->setInterval(0);
     m_hideTimer->setSingleShot(true);
     connect(m_hideTimer, SIGNAL(timeout()), this, SLOT(hidePopup()));
 
     using namespace std::placeholders; // For _1 placeholder
     auto function = std::bind(&KisColorSelectorBase::slotUpdateColorAndPreview, this, _1);
     m_updateColorCompressor.reset(new ColorCompressorType(20 /* ms */, function));
 }
 
 KisColorSelectorBase::~KisColorSelectorBase()
 {
     delete m_popup;
     delete m_colorPreviewPopup;
 }
 
 void KisColorSelectorBase::setPopupBehaviour(bool onMouseOver, bool onMouseClick)
 {
     m_popupOnMouseClick = onMouseClick;
     m_popupOnMouseOver = onMouseOver;
     if(onMouseClick) {
         m_popupOnMouseOver = false;
     }
 
     if(m_popupOnMouseOver) {
         setMouseTracking(true);
     }
 }
 
 void KisColorSelectorBase::setColorSpace(const KoColorSpace *colorSpace)
 {
     m_colorSpace = colorSpace;
 }
 
 void KisColorSelectorBase::setCanvas(KisCanvas2 *canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
     m_canvas = canvas;
     if (m_canvas) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                 SLOT(canvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(reset()), Qt::UniqueConnection);
 
         connect(canvas->imageView()->resourceProvider(), SIGNAL(sigFGColorUsed(KoColor)),
                 this,                               SLOT(updateLastUsedColorPreview(KoColor)), Qt::UniqueConnection);
 
         if (m_canvas->viewManager() && m_canvas->viewManager()->canvasResourceProvider()) {
             setColor(Acs::currentColor(m_canvas->viewManager()->canvasResourceProvider(), Acs::Foreground));
         }
     }
     if (m_popup) {
         m_popup->setCanvas(canvas);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::unsetCanvas()
 {
     if (m_popup) {
         m_popup->unsetCanvas();
     }
     m_canvas = 0;
 }
 
 
 
 void KisColorSelectorBase::mousePressEvent(QMouseEvent* event)
 {
     event->accept();
 
-
-//this boolean here is to check if the color selector is updating the resource, so it won't update itself when the resource is updated//
-   if (m_colorUpdateSelf==false)
-   {m_colorUpdateSelf=true;}
-
     if(!m_isPopup && m_popupOnMouseClick &&
        event->button() == Qt::MidButton) {
 
         lazyCreatePopup();
 
         int x = event->globalX();
         int y = event->globalY();
         int popupsize = m_popup->width();
         x-=popupsize/2;
         y-=popupsize/2;
 
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         if(x<availRect.x())
             x = availRect.x();
         if(y<availRect.y())
             y = availRect.y();
         if(x+m_popup->width()>availRect.x()+availRect.width())
             x = availRect.x()+availRect.width()-m_popup->width();
         if(y+m_popup->height()>availRect.y()+availRect.height())
             y = availRect.y()+availRect.height()-m_popup->height();
 
+        m_colorUpdateSelf=false;
         m_popup->move(x, y);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
 
     } else if (m_isPopup && event->button() == Qt::MidButton) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     } else {
+        m_colorUpdateSelf=true;
         showColorPreview();
         event->ignore();
     }
 }
 
 void KisColorSelectorBase::mouseReleaseEvent(QMouseEvent *e) {
 
    Q_UNUSED(e);
 
     if (e->button() == Qt::MidButton) {
         e->accept();
     } else if (m_isPopup &&
                (m_hideOnMouseClick && !m_popupOnMouseOver) &&
                !m_hideTimer->isActive()) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     }
 }
 
 void KisColorSelectorBase::enterEvent(QEvent *e)
 {
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->stop();
     }
 
     if (m_isPopup && m_hideTimer->isActive()) {
         m_hideTimer->stop();
     }
 
     // do not show the popup when boxed in
     // the configuration dialog (m_canvas == 0)
 
     if (m_canvas &&
         !m_isPopup && m_popupOnMouseOver &&
         (!m_popup || m_popup->isHidden())) {
 
         lazyCreatePopup();
 
         const QRect availRect = QApplication::desktop()->availableGeometry(this);
 
         QPoint proposedTopLeft = rect().center() - m_popup->rect().center();
         proposedTopLeft = mapToGlobal(proposedTopLeft);
 
         QRect popupRect = QRect(proposedTopLeft, m_popup->size());
         popupRect = kisEnsureInRect(popupRect, availRect);
 
         m_popup->setGeometry(popupRect);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
     }
 
     QWidget::enterEvent(e);
 }
 
 void KisColorSelectorBase::leaveEvent(QEvent *e)
 {
     tryHideAllPopups();
     QWidget::leaveEvent(e);
 }
 
 void KisColorSelectorBase::keyPressEvent(QKeyEvent *)
 {
     if (m_isPopup) {
         hidePopup();
     }
 }
 
 void KisColorSelectorBase::dragEnterEvent(QDragEnterEvent *e)
 {
     if(e->mimeData()->hasColor())
         e->acceptProposedAction();
     if(e->mimeData()->hasText() && QColor(e->mimeData()->text()).isValid())
         e->acceptProposedAction();
 }
 
 void KisColorSelectorBase::dropEvent(QDropEvent *e)
 {
     QColor color;
     if(e->mimeData()->hasColor()) {
         color = qvariant_cast<QColor>(e->mimeData()->colorData());
     }
     else if(e->mimeData()->hasText()) {
         color.setNamedColor(e->mimeData()->text());
         if(!color.isValid())
             return;
     }
 
     KoColor kocolor(color , KoColorSpaceRegistry::instance()->rgb8());
     updateColor(kocolor, Acs::Foreground, true);
 }
 
 void KisColorSelectorBase::updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset)
 {
     commitColor(color, role);
 
     if (needsExplicitColorReset) {
         setColor(color);
     }
 }
 
 void KisColorSelectorBase::requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role)
 {
     m_updateColorCompressor->start(qMakePair(color, role));
 }
 
 void KisColorSelectorBase::slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color)
 {
     updateColorPreview(color.first);
     updateColor(color.first, color.second, false);
 }
 
 void KisColorSelectorBase::setColor(const KoColor& color)
 {
     Q_UNUSED(color);
 }
 
 void KisColorSelectorBase::setHidingTime(int time)
 {
     KIS_ASSERT_RECOVER_NOOP(m_isPopup);
 
     m_hideTimer->setInterval(time);
 }
 
 void KisColorSelectorBase::lazyCreatePopup()
 {
     if (!m_popup) {
         m_popup = createPopup();
         Q_ASSERT(m_popup);
         m_popup->setParent(this);
 
         // Setting Qt::BypassWindowManagerHint will prevent
         // the WM from showing another taskbar entry,
         // but will require that we handle window activation manually
         m_popup->setWindowFlags(Qt::FramelessWindowHint |
                                 Qt::Window |
                                 Qt::NoDropShadowWindowHint |
                                 Qt::BypassWindowManagerHint);
         m_popup->m_parent = this;
         m_popup->m_isPopup = true;
     }
     m_popup->setCanvas(m_canvas);
     m_popup->updateSettings();
 }
 
 void KisColorSelectorBase::showPopup(Move move)
 {
     // This slot may be called by some action,
     // so we need to be able to handle it
     lazyCreatePopup();
 
     QPoint cursorPos = QCursor::pos();
 
     if (move == MoveToMousePosition) {
         m_popup->move(QPoint(cursorPos.x()-m_popup->width()/2, cursorPos.y()-m_popup->height()/2));
         QRect rc = m_popup->geometry();
         if (rc.x() < 0) rc.setX(0);
         if (rc.y() < 0) rc.setY(0);
         m_popup->setGeometry(rc);
     }
 
     if (m_colorPreviewPopup) {
         m_colorPreviewPopup->hide();
     }
 
     m_popup->show();
     m_popup->m_colorPreviewPopup->show();
 }
 
 void KisColorSelectorBase::hidePopup()
 {
     KIS_ASSERT_RECOVER_RETURN(m_isPopup);
 
     m_colorPreviewPopup->hide();
     hide();
 }
 
 void KisColorSelectorBase::commitColor(const KoColor& color, Acs::ColorRole role)
 {
     if (!m_canvas)
         return;
 
     m_colorUpdateAllowed=false;
 
     if (role == Acs::Foreground)
         m_canvas->resourceManager()->setForegroundColor(color);
     else
         m_canvas->resourceManager()->setBackgroundColor(color);
 
     m_colorUpdateAllowed=true;
 }
 
 void KisColorSelectorBase::showColorPreview()
 {
     if(m_colorPreviewPopup->isHidden()) {
         m_colorPreviewPopup->show();
     }
 }
 
 void KisColorSelectorBase::updateColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setQColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::canvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoColor realColor(v.value<KoColor>());
         updateColorPreview(realColor);
         if (m_colorUpdateAllowed && !m_colorUpdateSelf) {
             setColor(realColor);
         }
     }
 }
 
 const KoColorSpace* KisColorSelectorBase::colorSpace() const
 {
     return converter()->paintingColorSpace();
 }
 
 void KisColorSelectorBase::updateSettings()
 {
     if(m_popup) {
         m_popup->updateSettings();
     }
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
 
    int zoomSelectorOptions =  (int) cfg.readEntry("zoomSelectorOptions", 0) ;
    if (zoomSelectorOptions == 0)   {
        setPopupBehaviour(false, true);   // middle mouse button click will open zoom selector
    } else if (zoomSelectorOptions == 1)   {
        setPopupBehaviour(true, false);   // move over will open the zoom selector
    }
    else
    {
         setPopupBehaviour(false, false); // do not show zoom selector
    }
 
 
     if(m_isPopup) {
         m_hideOnMouseClick = cfg.readEntry("hidePopupOnClickCheck", false);
         const int zoomSize = cfg.readEntry("zoomSize", 280);
         resize(zoomSize, zoomSize);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::reset()
 {
     update();
 }
 
 void KisColorSelectorBase::updateBaseColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setBaseColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::updatePreviousColorPreview()
 {
     m_colorPreviewPopup->setPreviousColor();
 }
 
 void KisColorSelectorBase::updateLastUsedColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setLastUsedColor(converter()->toQColor(color));
 }
 
 KisDisplayColorConverter* KisColorSelectorBase::converter() const
 {
     return m_canvas ?
         m_canvas->displayColorConverter() :
                 KisDisplayColorConverter::dumbConverterInstance();
 }
 
 void KisColorSelectorBase::tryHideAllPopups()
 {
     if (m_colorPreviewPopup->isVisible()) {
         m_colorUpdateSelf=false; //this is for allowing advanced selector to listen to outside color-change events.
         m_colorPreviewPopup->hide();
     }
 
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->start();
     }
 
     if (m_isPopup && !m_hideTimer->isActive()) {
         m_hideTimer->start();
     }
 }
 
 
 void KisColorSelectorBase::mouseMoveEvent(QMouseEvent *event)
 {
     event->accept();
 }
 
 
 void KisColorSelectorBase::changeEvent(QEvent *event)
 {
     // hide the popup when another window becomes active, e.g. due to alt+tab
     if(m_isPopup && event->type() == QEvent::ActivationChange && !isActiveWindow()) {
         hidePopup();
     }
 
     QWidget::changeEvent(event);
 }
 
 void KisColorSelectorBase::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     // manual activation required due to Qt::BypassWindowManagerHint
     if(m_isPopup) {
         activateWindow();
     }
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
index 90c275d210..6086b7c570 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
@@ -1,134 +1,136 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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
  */
 
 #ifndef KIS_COLOR_SELECTOR_BASE_H
 #define KIS_COLOR_SELECTOR_BASE_H
 
 #include <QWidget>
 #include <QRgb>
 #include <QPointer>
 #include <kis_canvas2.h>
 #include "kis_acs_types.h"
 #include "kis_signal_compressor_with_param.h"
 
 
 class KoColor;
 class QTimer;
 class KoColorSpace;
 class KisCanvas2;
 class KisColorPreviewPopup;
 class KisDisplayColorConverter;
 class KoGamutMask;
 
 
 /// Base class for all color selectors, that should support color management and zooming.
 class KisColorSelectorBase : public QWidget
 {
 Q_OBJECT
 public:
     enum Move {MoveToMousePosition, DontMove};
     explicit KisColorSelectorBase(QWidget *parent = 0);
     ~KisColorSelectorBase() override;
 
     void setPopupBehaviour(bool onMouseOver, bool onMouseClick);
     void setColorSpace(const KoColorSpace* colorSpace);
     virtual void setCanvas(KisCanvas2* canvas);
     virtual void unsetCanvas();
     const KoColorSpace* colorSpace() const;
 
     KisDisplayColorConverter* converter() const;
 
     void tryHideAllPopups();
 
 public:
     void updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset);
     void updateColorPreview(const KoColor &color);
     void showColorPreview();
     void updateBaseColorPreview(const KoColor &color);
     void updatePreviousColorPreview();
 
     virtual void setColor(const KoColor& color);
 
 public Q_SLOTS:
     /**
      * Flushes caches and redraws the selectors
      */
     virtual void reset();
 
     virtual void updateSettings();
     virtual void showPopup(Move move=MoveToMousePosition);
 
 public:
     void enterEvent(QEvent *e) override;
     void leaveEvent(QEvent *e) override;
 
     void mousePressEvent(QMouseEvent *) override;
     void mouseReleaseEvent(QMouseEvent *) override;
 
 protected:
     void keyPressEvent(QKeyEvent *) override;
     virtual KisColorSelectorBase* createPopup() const = 0;
     void dragEnterEvent(QDragEnterEvent *) override;
     void dropEvent(QDropEvent *) override;
     void setHidingTime(int time);
     bool isPopup() const { return m_isPopup; }
     void mouseMoveEvent(QMouseEvent *event) override;
     void changeEvent(QEvent *event) override;
     void showEvent(QShowEvent *event) override;
     void requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role);
 
 private:
     void commitColor(const KoColor& koColor, Acs::ColorRole role);
 
 
 protected Q_SLOTS:
     void hidePopup();
 
     /// if you overwrite this, keep in mind, that you should set the color only, if m_colorUpdateAllowed is true
     virtual void canvasResourceChanged(int key, const QVariant& v);
 
     void updateLastUsedColorPreview(const KoColor &color);
 
 public:
     // This is a private interface for signal compressor, don't use it.
     // Use requestUpdateColorAndPreview() instead
     void slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color);
 
 private:
     void lazyCreatePopup();
 
 protected:
     QPointer<KisCanvas2> m_canvas;
     KisColorSelectorBase* m_popup;
     QWidget* m_parent;
     bool m_colorUpdateAllowed;
+
+    // This boolean here is to check if the color selector is updating the resource, so it won't update itself when the resource is updated.
     bool m_colorUpdateSelf;
 
 private:
     QTimer* m_hideTimer;
     bool m_popupOnMouseOver;
     bool m_popupOnMouseClick;
     mutable const KoColorSpace* m_colorSpace;
     bool m_isPopup; //this instance is a popup
     bool m_hideOnMouseClick;
     KisColorPreviewPopup* m_colorPreviewPopup;
 
     typedef KisSignalCompressorWithParam<QPair<KoColor, Acs::ColorRole>> ColorCompressorType;
     QScopedPointer<ColorCompressorType> m_updateColorCompressor;
 };
 
 #endif
diff --git a/plugins/dockers/animation/tests/timeline_model_test.cpp b/plugins/dockers/animation/tests/timeline_model_test.cpp
index eb44be5abc..12636bb056 100644
--- a/plugins/dockers/animation/tests/timeline_model_test.cpp
+++ b/plugins/dockers/animation/tests/timeline_model_test.cpp
@@ -1,314 +1,317 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_model_test.h"
 
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_paint_device.h"
 
 #include <QDialog>
 #include <QDoubleSpinBox>
 #include <QSpinBox>
 #include <QVBoxLayout>
 
 #include "kis_image_animation_interface.h"
 #include "KisDocument.h"
+#include "KisNodeDisplayModeAdapter.h"
 #include "KisPart.h"
 #include "kis_name_server.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_undo_adapter.h"
 
 #include "timeline_frames_view.h"
 #include "timeline_frames_model.h"
 
 #include "kis_node_dummies_graph.h"
 
 #include "commands/kis_image_layer_add_command.h"
 #include "commands/kis_image_layer_remove_command.h"
 
 #include "kis_double_parse_spin_box.h"
 #include "kis_int_parse_spin_box.h"
 
 #include  <sdk/tests/kistest.h>
 #include <sdk/tests/testutil.h>
 
 void TimelineModelTest::init()
 {
     m_doc = KisPart::instance()->createDocument();
 
     m_nameServer = new KisNameServer();
     m_shapeController = new KisShapeController(m_doc, m_nameServer);
+    m_displayModeAdapter = new KisNodeDisplayModeAdapter();
     //m_nodeModel = new KisNodeModel(0);
 
     initBase();
 
     m_doc->setCurrentImage(m_image);
 }
 
 void TimelineModelTest::cleanup()
 {
     cleanupBase();
 
     //delete m_nodeModel;
     delete m_shapeController;
     delete m_nameServer;
     delete m_doc;
+    delete m_displayModeAdapter;
 }
 
 #include "timeline_frames_index_converter.h"
 
 void TimelineModelTest::testConverter()
 {
     constructImage();
     addSelectionMasks();
     m_shapeController->setImage(m_image);
 
     m_layer1->enableAnimation();
 
     m_layer1->setUseInTimeline(true);
     m_layer2->setUseInTimeline(true);
     m_sel3->setUseInTimeline(true);
 
     TimelineFramesIndexConverter converter(m_shapeController);
 
     QCOMPARE(converter.rowCount(), 3);
     QCOMPARE(converter.rowForDummy(m_shapeController->dummyForNode(m_layer1)), 2);
     QCOMPARE(converter.rowForDummy(m_shapeController->dummyForNode(m_layer2)), 1);
     QCOMPARE(converter.rowForDummy(m_shapeController->dummyForNode(m_sel3)), 0);
 
     QCOMPARE(converter.dummyFromRow(2), m_shapeController->dummyForNode(m_layer1));
     QCOMPARE(converter.dummyFromRow(1), m_shapeController->dummyForNode(m_layer2));
     QCOMPARE(converter.dummyFromRow(0), m_shapeController->dummyForNode(m_sel3));
 
-    TimelineNodeListKeeper keeper(0, m_shapeController);
+    TimelineNodeListKeeper keeper(0, m_shapeController, m_displayModeAdapter);
 
     QCOMPARE(keeper.rowCount(), 3);
     QCOMPARE(keeper.rowForDummy(m_shapeController->dummyForNode(m_layer1)), 2);
     QCOMPARE(keeper.rowForDummy(m_shapeController->dummyForNode(m_layer2)), 1);
     QCOMPARE(keeper.rowForDummy(m_shapeController->dummyForNode(m_sel3)), 0);
 
     QCOMPARE(keeper.dummyFromRow(2), m_shapeController->dummyForNode(m_layer1));
     QCOMPARE(keeper.dummyFromRow(1), m_shapeController->dummyForNode(m_layer2));
     QCOMPARE(keeper.dummyFromRow(0), m_shapeController->dummyForNode(m_sel3));
 
     TimelineNodeListKeeper::OtherLayersList list = keeper.otherLayersList();
 
     Q_FOREACH (const TimelineNodeListKeeper::OtherLayer &l, list) {
         qDebug() << ppVar(l.name) << ppVar(l.dummy->node()->name());
     }
 
 }
 
 void TimelineModelTest::testModel()
 {
     QScopedPointer<TimelineFramesModel> model(new TimelineFramesModel(0));
 }
 
 struct TestingInterface : TimelineFramesModel::NodeManipulationInterface
 {
     TestingInterface(KisImageSP image) : m_image(image) {}
 
     KisLayerSP addPaintLayer() const override {
         KisNodeSP parent = m_image->root();
         KisNodeSP after = parent->lastChild();
 
 
         KisPaintLayerSP layer =
             new KisPaintLayer(const_cast<KisImage*>(m_image.data()),
                               m_image->nextLayerName(),
                               OPACITY_OPAQUE_U8,
                               m_image->colorSpace());
 
         m_image->undoAdapter()->addCommand(
             new KisImageLayerAddCommand(m_image, layer,
                                         parent,
                                         after,
                                         false, false));
 
         return layer;
     }
 
     void removeNode(KisNodeSP node) const override {
         m_image->undoAdapter()->addCommand(
             new KisImageLayerRemoveCommand(m_image, node));
     }
 
     bool setNodeProperties(KisNodeSP, KisImageSP, KisBaseNode::PropertyList) const override
     {
         return false;
     }
 
 private:
     KisImageSP m_image;
 };
 
 void TimelineModelTest::testView()
 {
 #ifndef ENABLE_GUI_TESTS
     return;
 #endif
 
     QDialog dlg;
 
     QFont font;
     font.setPointSizeF(9);
     dlg.setFont(font);
 
     QSpinBox *intFps = new KisIntParseSpinBox(&dlg);
     intFps->setValue(12);
 
     QSpinBox *intTime = new KisIntParseSpinBox(&dlg);
     intTime->setValue(0);
     intTime->setMaximum(10000);
 
     QSpinBox *intLayer = new KisIntParseSpinBox(&dlg);
     intLayer->setValue(0);
     intLayer->setMaximum(100);
 
     TimelineFramesView *framesTable = new TimelineFramesView(&dlg);
 
     TimelineFramesModel *model = new TimelineFramesModel(&dlg);
 
     constructImage();
     addSelectionMasks();
     m_shapeController->setImage(m_image);
 
     m_image->animationInterface()->requestTimeSwitchWithUndo(4);
 
     framesTable->setModel(model);
 
-    model->setDummiesFacade(m_shapeController, m_image);
+    model->setDummiesFacade(m_shapeController, m_image, m_displayModeAdapter);
     model->setNodeManipulationInterface(new TestingInterface(m_image));
 
     m_layer1->enableAnimation();
     m_layer1->setUseInTimeline(true);
 
     connect(intFps, SIGNAL(valueChanged(int)),
             m_image->animationInterface(), SLOT(setFramerate(int)));
 
     connect(intTime, SIGNAL(valueChanged(int)),
             SLOT(setCurrentTime(int)));
 
     connect(m_image->animationInterface(), SIGNAL(sigUiTimeChanged(int)),
             intTime, SLOT(setValue(int)));
 
     connect(intLayer, SIGNAL(valueChanged(int)),
             SLOT(setCurrentLayer(int)));
 
     connect(this, SIGNAL(sigRequestNodeChange(KisNodeSP)),
             model, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
     connect(model, SIGNAL(requestCurrentNodeChanged(KisNodeSP)),
             this, SLOT(slotGuiChangedNode(KisNodeSP)));
 
     QVBoxLayout *layout = new QVBoxLayout(&dlg);
 
     layout->addWidget(intFps);
     layout->addWidget(intTime);
     layout->addWidget(intLayer);
     layout->addWidget(framesTable);
 
     layout->setStretch(0, 0);
     layout->setStretch(1, 0);
     layout->setStretch(2, 0);
     layout->setStretch(3, 1);
 
     dlg.resize(600, 400);
 
     dlg.exec();
 }
 
 void TimelineModelTest::setCurrentTime(int time)
 {
     m_image->animationInterface()->requestTimeSwitchWithUndo(time);
 }
 
 KisNodeDummy* findNodeFromRowAny(KisNodeDummy *root, int &startCount)
 {
     if (!startCount) {
         return root;
     }
     startCount--;
 
     KisNodeDummy *dummy = root->lastChild();
     while (dummy) {
         KisNodeDummy *found = findNodeFromRowAny(dummy, startCount);
         if (found) return found;
 
         dummy = dummy->prevSibling();
     }
 
     return 0;
 }
 
 
 void TimelineModelTest::setCurrentLayer(int row)
 {
     KisNodeDummy *root = m_shapeController->rootDummy();
     KisNodeDummy *dummy = findNodeFromRowAny(root, row);
     if (!dummy) {
         qDebug() << "WARNING: Cannot find a node at pos" << row;
         return;
     } else {
         qDebug() << "NonGUI changed active node: " << dummy->node()->name();
     }
 
     emit sigRequestNodeChange(dummy->node());
 }
 
 void TimelineModelTest::slotGuiChangedNode(KisNodeSP node)
 {
     qDebug() << "GUI changed active node:" << node->name();
 }
 
 #include "kis_equalizer_column.h"
 #include "kis_equalizer_slider.h"
 #include "kis_equalizer_widget.h"
 
 void TimelineModelTest::testOnionSkins()
 {
 #ifndef ENABLE_GUI_TESTS
     return;
 #endif
     QDialog dlg;
 
     QFont font;
     font.setPointSizeF(9);
     dlg.setFont(font);
 
     QHBoxLayout *layout = new QHBoxLayout(&dlg);
 
     KisEqualizerWidget *w = new KisEqualizerWidget(10, &dlg);
     connect(w, SIGNAL(sigConfigChanged()), SLOT(slotBang()));
 
     layout->addWidget(w);
 
     dlg.setLayout(layout);
 
     dlg.resize(600, 400);
     dlg.exec();
 
 }
 
 void TimelineModelTest::slotBang()
 {
     ENTER_FUNCTION() << "!!!!";
 }
 
 KISTEST_MAIN(TimelineModelTest)
diff --git a/plugins/dockers/animation/tests/timeline_model_test.h b/plugins/dockers/animation/tests/timeline_model_test.h
index b9b9fbb909..257b768300 100644
--- a/plugins/dockers/animation/tests/timeline_model_test.h
+++ b/plugins/dockers/animation/tests/timeline_model_test.h
@@ -1,58 +1,60 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __TIMELINE_MODEL_TEST_H
 #define __TIMELINE_MODEL_TEST_H
 
 #include <QtTest>
 #include "empty_nodes_test.h"
 
 class KisDocument;
 class KisNameServer;
 class KisShapeController;
+class KisNodeDisplayModeAdapter;
 
 
 class TimelineModelTest : public QObject, public TestUtil::EmptyNodesTest
 {
     Q_OBJECT
 private Q_SLOTS:
     void init();
     void cleanup();
 
     void testConverter();
     void testModel();
     void testView();
     void testOnionSkins();
 
 private Q_SLOTS:
     void setCurrentTime(int time);
     void setCurrentLayer(int row);
     void slotGuiChangedNode(KisNodeSP node);
 
     void slotBang();
 
 Q_SIGNALS:
     void sigRequestNodeChange(KisNodeSP node);
 
 private:
     KisDocument *m_doc;
     KisNameServer *m_nameServer;
     KisShapeController *m_shapeController;
+    KisNodeDisplayModeAdapter *m_displayModeAdapter;
 };
 
 #endif /* __TIMELINE_MODEL_TEST_H */
diff --git a/plugins/dockers/animation/timeline_docker.cpp b/plugins/dockers/animation/timeline_docker.cpp
index 66e807f107..1c6a74b1c6 100644
--- a/plugins/dockers/animation/timeline_docker.cpp
+++ b/plugins/dockers/animation/timeline_docker.cpp
@@ -1,164 +1,166 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@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 "timeline_docker.h"
 
 #include "kis_canvas2.h"
 #include "kis_image.h"
 #include <KoIcon.h>
 #include "KisViewManager.h"
 #include "kis_paint_layer.h"
 #include "KisDocument.h"
 #include "kis_dummies_facade.h"
 #include "kis_shape_controller.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_frames_view.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_image_animation_interface.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_node_manager.h"
 
 #include <QPointer>
 
 struct TimelineDocker::Private
 {
     Private(QWidget *parent)
         : model(new TimelineFramesModel(parent)),
           view(new TimelineFramesView(parent))
     {
         view->setModel(model);
     }
 
     TimelineFramesModel *model;
     TimelineFramesView *view;
 
     QPointer<KisCanvas2> canvas;
 
     KisSignalAutoConnectionsStore canvasConnections;
 };
 
 TimelineDocker::TimelineDocker()
     : QDockWidget(i18n("Timeline"))
     , m_d(new Private(this))
 {
     setWidget(m_d->view);
 }
 
 TimelineDocker::~TimelineDocker()
 {
 }
 
 struct NodeManagerInterface : TimelineFramesModel::NodeManipulationInterface
 {
     NodeManagerInterface(KisNodeManager *manager) : m_manager(manager) {}
 
     KisLayerSP addPaintLayer() const override {
         return m_manager->createPaintLayer();
     }
 
     void removeNode(KisNodeSP node) const override {
         m_manager->removeSingleNode(node);
     }
 
     bool setNodeProperties(KisNodeSP node, KisImageSP image, KisBaseNode::PropertyList properties) const override
     {
         return m_manager->trySetNodeProperties(node, image, properties);
     }
 
 private:
     KisNodeManager *m_manager;
 };
 
 void TimelineDocker::setCanvas(KoCanvasBase * canvas)
 {
     if (canvas && m_d->canvas == canvas) return;
 
     if (m_d->model->hasConnectionToCanvas()) {
         m_d->canvasConnections.clear();
-        m_d->model->setDummiesFacade(0, 0);
+        m_d->model->setDummiesFacade(0, 0, 0);
         m_d->model->setFrameCache(0);
         m_d->model->setAnimationPlayer(0);
         m_d->model->setNodeManipulationInterface(0);
 
         if (m_d->canvas) {
             m_d->canvas->disconnectCanvasObserver(this);
         }
     }
 
     m_d->canvas = dynamic_cast<KisCanvas2*>(canvas);
     setEnabled(m_d->canvas != 0);
 
     if(m_d->canvas) {
         KisDocument *doc = static_cast<KisDocument*>(m_d->canvas->imageView()->document());
         KisShapeController *kritaShapeController = dynamic_cast<KisShapeController*>(doc->shapeController());
-        m_d->model->setDummiesFacade(kritaShapeController, m_d->canvas->image());
+        m_d->model->setDummiesFacade(kritaShapeController,
+                                     m_d->canvas->image(),
+                                     m_d->canvas->viewManager()->nodeManager()->nodeDisplayModeAdapter());
 
         slotUpdateFrameCache();
         m_d->model->setAnimationPlayer(m_d->canvas->animationPlayer());
 
         m_d->model->setNodeManipulationInterface(
             new NodeManagerInterface(m_d->canvas->viewManager()->nodeManager()));
 
         m_d->canvasConnections.addConnection(
             m_d->canvas->viewManager()->nodeManager(), SIGNAL(sigNodeActivated(KisNodeSP)),
             m_d->model, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
         m_d->canvasConnections.addConnection(
             m_d->model, SIGNAL(requestCurrentNodeChanged(KisNodeSP)),
             m_d->canvas->viewManager()->nodeManager(), SLOT(slotNonUiActivatedNode(KisNodeSP)));
 
         m_d->model->slotCurrentNodeChanged(m_d->canvas->viewManager()->activeNode());
 
         m_d->canvasConnections.addConnection(
                     m_d->canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()),
                     this, SLOT(slotUpdateIcons()));
 
         m_d->canvasConnections.addConnection(
                     m_d->canvas, SIGNAL(sigCanvasEngineChanged()),
                     this, SLOT(slotUpdateFrameCache()));
     }
 
 }
 
 void TimelineDocker::slotUpdateIcons()
 {
     if (m_d->view) {
         m_d->view->slotUpdateIcons();
     }
 }
 
 void TimelineDocker::slotUpdateFrameCache()
 {
     m_d->model->setFrameCache(m_d->canvas->frameCache());
 }
 
 void TimelineDocker::unsetCanvas()
 {
     setCanvas(0);
 }
 
 void TimelineDocker::setViewManager(KisViewManager *view)
 {
     KisActionManager *actionManager = view->actionManager();
 
     m_d->view->setShowInTimeline(actionManager->actionByName("show_in_timeline"));
     m_d->view->setActionManager(actionManager);
 }
diff --git a/plugins/dockers/animation/timeline_frames_index_converter.cpp b/plugins/dockers/animation/timeline_frames_index_converter.cpp
index 34fefc1513..c33b7dc9f9 100644
--- a/plugins/dockers/animation/timeline_frames_index_converter.cpp
+++ b/plugins/dockers/animation/timeline_frames_index_converter.cpp
@@ -1,139 +1,152 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_frames_index_converter.h"
 
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 
 
 TimelineFramesIndexConverter::TimelineFramesIndexConverter(KisDummiesFacadeBase *dummiesFacade)
     : m_dummiesFacade(dummiesFacade),
-      m_activeDummy(0)
+      m_activeDummy(0),
+      m_showGlobalSelectionMask(false)
 {
 }
 
 TimelineFramesIndexConverter::~TimelineFramesIndexConverter()
 {
 }
 
 bool TimelineFramesIndexConverter::calcNodesInPath(KisNodeDummy *root, int &startCount, KisNodeDummy *endDummy)
 {
     if (isDummyVisible(root)) {
         if (endDummy && root == endDummy) {
             return true;
         }
 
         startCount++;
     }
 
     KisNodeDummy *dummy = root->lastChild();
     while (dummy) {
         if (calcNodesInPath(dummy, startCount, endDummy)) {
             return true;
         }
 
         dummy = dummy->prevSibling();
     }
 
     return false;
 }
 
 KisNodeDummy* TimelineFramesIndexConverter::findNodeFromRow(KisNodeDummy *root, int &startCount)
 {
     if (isDummyVisible(root)) {
         if (!startCount) {
             return root;
         }
 
         startCount--;
     }
 
     KisNodeDummy *dummy = root->lastChild();
     while (dummy) {
         KisNodeDummy *found = findNodeFromRow(dummy, startCount);
         if (found) return found;
 
         dummy = dummy->prevSibling();
     }
 
     return 0;
 }
 
 KisNodeDummy* TimelineFramesIndexConverter::dummyFromRow(int row)
 {
     KisNodeDummy *root = m_dummiesFacade->rootDummy();
     if(!root) return 0;
 
     return findNodeFromRow(root, row);
 }
 
 int TimelineFramesIndexConverter::rowForDummy(KisNodeDummy *dummy)
 {
     if (!dummy) return -1;
 
     KisNodeDummy *root = m_dummiesFacade->rootDummy();
     if(!root) return -1;
 
     int count = 0;
     return calcNodesInPath(root, count, dummy) ? count : -1;
 }
 
 int TimelineFramesIndexConverter::rowCount()
 {
     KisNodeDummy *root = m_dummiesFacade->rootDummy();
     if(!root) return 0;
 
     int count = 0;
     calcNodesInPath(root, count, 0);
     return count;
 }
 
 KisNodeDummy* TimelineFramesIndexConverter::activeDummy() const
 {
     return m_activeDummy;
 }
 
 void TimelineFramesIndexConverter::updateActiveDummy(KisNodeDummy *dummy,
                                                      bool *oldRemoved,
                                                      bool *newAdded)
 {
     if (m_activeDummy == dummy) return;
 
     if (m_activeDummy && !m_activeDummy->node()->useInTimeline()) {
         *oldRemoved = true;
     }
 
     m_activeDummy = dummy;
 
     if (m_activeDummy && !m_activeDummy->node()->useInTimeline()) {
         *newAdded = true;
     }
 }
 
 void TimelineFramesIndexConverter::notifyDummyRemoved(KisNodeDummy *dummy)
 {
     if (m_activeDummy && m_activeDummy == dummy) {
         m_activeDummy = 0;
     }
 }
 
+void TimelineFramesIndexConverter::setShowGlobalSelectionMask(bool value)
+{
+    m_showGlobalSelectionMask = value;
+}
+
+bool TimelineFramesIndexConverter::isDummyAvailableForTimeline(KisNodeDummy *dummy) const
+{
+    return dummy->isGUIVisible(m_showGlobalSelectionMask);
+}
+
 bool TimelineFramesIndexConverter::isDummyVisible(KisNodeDummy *dummy) const
 {
-    return (dummy->node()->useInTimeline() && dummy->parent()) || dummy == m_activeDummy;
+    return (isDummyAvailableForTimeline(dummy) &&
+            dummy->node()->useInTimeline()) ||
+            dummy == m_activeDummy;
 }
diff --git a/plugins/dockers/animation/timeline_frames_index_converter.h b/plugins/dockers/animation/timeline_frames_index_converter.h
index 9974d5df81..4a6f273368 100644
--- a/plugins/dockers/animation/timeline_frames_index_converter.h
+++ b/plugins/dockers/animation/timeline_frames_index_converter.h
@@ -1,54 +1,57 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __TIMELINE_FRAMES_INDEX_CONVERTER_H
 #define __TIMELINE_FRAMES_INDEX_CONVERTER_H
 
 #include "kritaanimationdocker_export.h"
 
 class KisNodeDummy;
 
 class KisDummiesFacadeBase;
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineFramesIndexConverter
 {
 public:
     TimelineFramesIndexConverter(KisDummiesFacadeBase *dummiesFacade);
     ~TimelineFramesIndexConverter();
 
     KisNodeDummy* dummyFromRow(int row);
     int rowForDummy(KisNodeDummy *dummy);
     int rowCount();
 
     KisNodeDummy* activeDummy() const;
     void updateActiveDummy(KisNodeDummy *dummy, bool *oldRemoved, bool *newAdded);
     void notifyDummyRemoved(KisNodeDummy *dummy);
 
+    void setShowGlobalSelectionMask(bool value);
 
+    bool isDummyAvailableForTimeline(KisNodeDummy *dummy) const;
     bool isDummyVisible(KisNodeDummy *dummy) const;
 
 private:
     KisNodeDummy* findNodeFromRow(KisNodeDummy *root, int &startCount);
     bool calcNodesInPath(KisNodeDummy *root, int &startCount, KisNodeDummy *endDummy);
 
 private:
     KisDummiesFacadeBase *m_dummiesFacade;
     KisNodeDummy *m_activeDummy;
+    bool m_showGlobalSelectionMask;
 };
 
 #endif /* __TIMELINE_FRAMES_INDEX_CONVERTER_H */
diff --git a/plugins/dockers/animation/timeline_frames_model.cpp b/plugins/dockers/animation/timeline_frames_model.cpp
index 92007fabdc..6d3cb1aabf 100644
--- a/plugins/dockers/animation/timeline_frames_model.cpp
+++ b/plugins/dockers/animation/timeline_frames_model.cpp
@@ -1,1023 +1,1026 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_frames_model.h"
 #include <QFont>
 #include <QSize>
 #include <QColor>
 #include <QMimeData>
 #include <QPointer>
 #include <KoResourceModel.h>
 
 #include "kis_layer.h"
 #include "kis_config.h"
 
 #include "kis_global.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_undo_adapter.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
+#include "KisNodeDisplayModeAdapter.h"
 #include "kis_signal_compressor.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_keyframe_channel.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include <commands/kis_node_property_list_command.h>
 #include <commands_new/kis_switch_current_time_command.h>
 
 #include "kis_animation_utils.h"
 #include "timeline_color_scheme.h"
 #include "kis_node_model.h"
 #include "kis_projection_leaf.h"
 #include "kis_time_range.h"
 
 #include "kis_node_view_color_scheme.h"
 #include "krita_utils.h"
 #include "KisPart.h"
 #include <QApplication>
 #include "KisDocument.h"
 #include "KisViewManager.h"
 #include "kis_processing_applicator.h"
 #include <KisImageBarrierLockerWithFeedback.h>
 #include "kis_node_uuid_info.h"
 
 
 struct TimelineFramesModel::Private
 {
     Private()
         : activeLayerIndex(0),
           dummiesFacade(0),
           needFinishInsertRows(false),
           needFinishRemoveRows(false),
           updateTimer(200, KisSignalCompressor::FIRST_INACTIVE),
           parentOfRemovedNode(0)
     {}
 
     int activeLayerIndex;
 
     QPointer<KisDummiesFacadeBase> dummiesFacade;
     KisImageWSP image;
     bool needFinishInsertRows;
     bool needFinishRemoveRows;
 
     QList<KisNodeDummy*> updateQueue;
     KisSignalCompressor updateTimer;
 
     KisNodeDummy* parentOfRemovedNode;
     QScopedPointer<TimelineNodeListKeeper> converter;
 
     QScopedPointer<NodeManipulationInterface> nodeInterface;
 
     QPersistentModelIndex lastClickedIndex;
 
     QVariant layerName(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
         return dummy->node()->name();
     }
 
     bool layerEditable(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return true;
         return dummy->node()->visible() && !dummy->node()->userLocked();
     }
 
     bool frameExists(int row, int column) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         return (primaryChannel && primaryChannel->keyframeAt(column));
     }
 
     bool frameHasContent(int row, int column) {
 
         KisNodeDummy *dummy = converter->dummyFromRow(row);
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return false;
 
         // first check if we are a key frame
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return false;
 
         return frame->hasContent();
     }
 
     bool specialKeyframeExists(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
         Q_FOREACH(KisKeyframeChannel *channel, dummy->node()->keyframeChannels()) {
             if (channel->id() != KisKeyframeChannel::Content.id() && channel->keyframeAt(column)) {
                 return true;
             }
         }
         return false;
     }
 
     int frameColorLabel(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return -1;
 
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return -1;
 
         return frame->colorLabel();
     }
 
     void setFrameColorLabel(int row, int column, int color) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return;
 
         KisKeyframeSP frame = primaryChannel->keyframeAt(column);
         if (!frame) return;
 
         frame->setColorLabel(color);
     }
 
     int layerColorLabel(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
         return dummy->node()->colorLabelIndex();
     }
 
     QVariant layerProperties(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
 
         PropertyList props = dummy->node()->sectionModelProperties();
         return QVariant::fromValue(props);
     }
 
     bool setLayerProperties(int row, PropertyList props) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         nodeInterface->setNodeProperties(dummy->node(), image, props);
         return true;
     }
 
     bool addKeyframe(int row, int column, bool copy) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodeSP node = dummy->node();
         if (!KisAnimationUtils::supportsContentFrames(node)) return false;
 
         KisAnimationUtils::createKeyframeLazy(image, node, KisKeyframeChannel::Content.id(), column, copy);
         return true;
     }
 
     bool addNewLayer(int row) {
         Q_UNUSED(row);
 
         if (nodeInterface) {
             KisLayerSP layer = nodeInterface->addPaintLayer();
             layer->setUseInTimeline(true);
         }
 
         return true;
     }
 
     bool removeLayer(int row) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         if (nodeInterface) {
             nodeInterface->removeNode(dummy->node());
         }
 
         return true;
     }
 };
 
 TimelineFramesModel::TimelineFramesModel(QObject *parent)
     : ModelWithExternalNotifications(parent),
       m_d(new Private)
 {
     connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
 }
 
 TimelineFramesModel::~TimelineFramesModel()
 {
 }
 
 bool TimelineFramesModel::hasConnectionToCanvas() const
 {
     return m_d->dummiesFacade;
 }
 
 void TimelineFramesModel::setNodeManipulationInterface(NodeManipulationInterface *iface)
 {
     m_d->nodeInterface.reset(iface);
 }
 
 KisNodeSP TimelineFramesModel::nodeAt(QModelIndex index) const
 {
     /**
      * The dummy might not exist because the user could (quickly) change
      * active layer and the list of the nodes in m_d->converter will change.
      */
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
     return dummy ? dummy->node() : 0;
 }
 
 QMap<QString, KisKeyframeChannel*> TimelineFramesModel::channelsAt(QModelIndex index) const
 {
     KisNodeDummy *srcDummy = m_d->converter->dummyFromRow(index.row());
     return srcDummy->node()->keyframeChannels();
 }
 
-void TimelineFramesModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image)
+void TimelineFramesModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade,
+                                           KisImageSP image,
+                                           KisNodeDisplayModeAdapter *displayModeAdapter)
 {
     KisDummiesFacadeBase *oldDummiesFacade = m_d->dummiesFacade;
 
     if (m_d->dummiesFacade && m_d->image) {
         m_d->image->animationInterface()->disconnect(this);
         m_d->image->disconnect(this);
         m_d->dummiesFacade->disconnect(this);
     }
 
     m_d->image = image;
     KisTimeBasedItemModel::setImage(image);
 
     m_d->dummiesFacade = dummiesFacade;
     m_d->converter.reset();
 
     if (m_d->dummiesFacade) {
-        m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade));
+        m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade, displayModeAdapter));
         connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                 SLOT(slotDummyChanged(KisNodeDummy*)));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigFullClipRangeChanged()), SIGNAL(sigInfiniteTimelineUpdateNeeded()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioChannelChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioVolumeChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image, SIGNAL(sigImageModified()), SLOT(slotImageContentChanged()));
     }
 
     if (m_d->dummiesFacade != oldDummiesFacade) {
         beginResetModel();
         endResetModel();
     }
 
     if (m_d->dummiesFacade) {
         emit sigInfiniteTimelineUpdateNeeded();
         emit sigAudioChannelChanged();
     }
 }
 
 void TimelineFramesModel::slotDummyChanged(KisNodeDummy *dummy)
 {
     if (!m_d->updateQueue.contains(dummy)) {
         m_d->updateQueue.append(dummy);
     }
     m_d->updateTimer.start();
 }
 
 void TimelineFramesModel::slotImageContentChanged()
 {
     if (m_d->activeLayerIndex < 0) return;
 
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
     if (!dummy) return;
 
     slotDummyChanged(dummy);
 }
 
 void TimelineFramesModel::processUpdateQueue()
 {
     if (!m_d->converter) return;
 
     Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
         int row = m_d->converter->rowForDummy(dummy);
 
         if (row >= 0) {
             emit headerDataChanged (Qt::Vertical, row, row);
             emit dataChanged(this->index(row, 0), this->index(row, columnCount() - 1));
         }
     }
     m_d->updateQueue.clear();
 }
 
 void TimelineFramesModel::slotCurrentNodeChanged(KisNodeSP node)
 {
     if (!node) {
         m_d->activeLayerIndex = -1;
         return;
     }
 
     KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
     if (!dummy) {
         // It's perfectly normal that dummyForNode returns 0; that happens
         // when views get activated while Krita is closing down.
         return;
     }
 
     m_d->converter->updateActiveDummy(dummy);
 
     const int row = m_d->converter->rowForDummy(dummy);
     if (row < 0) {
         qWarning() << "WARNING: TimelineFramesModel::slotCurrentNodeChanged: node not found!";
     }
 
     if (row >= 0 && m_d->activeLayerIndex != row) {
         setData(index(row, 0), true, ActiveLayerRole);
     }
 }
 
 int TimelineFramesModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     if(!m_d->dummiesFacade) return 0;
 
     return m_d->converter->rowCount();
 }
 
 QVariant TimelineFramesModel::data(const QModelIndex &index, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     switch (role) {
     case ActiveLayerRole: {
         return index.row() == m_d->activeLayerIndex;
     }
     case FrameEditableRole: {
         return m_d->layerEditable(index.row());
     }
     case FrameHasContent: {
         return m_d->frameHasContent(index.row(), index.column());
     }
     case FrameExistsRole: {
         return m_d->frameExists(index.row(), index.column());
     }
     case SpecialKeyframeExists: {
         return m_d->specialKeyframeExists(index.row(), index.column());
     }
     case FrameColorLabelIndexRole: {
         int label = m_d->frameColorLabel(index.row(), index.column());
         return label > 0 ? label : QVariant();
     }
     case Qt::DisplayRole: {
         return m_d->layerName(index.row());
     }
     case Qt::TextAlignmentRole: {
         return QVariant(Qt::AlignHCenter | Qt::AlignVCenter);
     }
     case KoResourceModel::LargeThumbnailRole: {
         KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
         if (!dummy) {
             return  QVariant();
         }
         const int maxSize = 200;
 
         QSize size = dummy->node()->extent().size();
         size.scale(maxSize, maxSize, Qt::KeepAspectRatio);
         if (size.width() == 0 || size.height() == 0) {
             // No thumbnail can be shown if there isn't width or height...
             return QVariant();
         }
         QImage image(dummy->node()->createThumbnailForFrame(size.width(), size.height(), index.column()));
         return image;
     }
     }
 
     return ModelWithExternalNotifications::data(index, role);
 }
 
 bool TimelineFramesModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid() || !m_d->dummiesFacade) return false;
 
     switch (role) {
     case ActiveLayerRole: {
         if (value.toBool() &&
             index.row() != m_d->activeLayerIndex) {
 
             int prevLayer = m_d->activeLayerIndex;
             m_d->activeLayerIndex = index.row();
 
             emit dataChanged(this->index(prevLayer, 0), this->index(prevLayer, columnCount() - 1));
             emit dataChanged(this->index(m_d->activeLayerIndex, 0), this->index(m_d->activeLayerIndex, columnCount() - 1));
 
             emit headerDataChanged(Qt::Vertical, prevLayer, prevLayer);
             emit headerDataChanged(Qt::Vertical, m_d->activeLayerIndex, m_d->activeLayerIndex);
 
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
             KIS_ASSERT_RECOVER(dummy) { return true; }
 
             emit requestCurrentNodeChanged(dummy->node());
             emit sigEnsureRowVisible(m_d->activeLayerIndex);
         }
         break;
     }
     case FrameColorLabelIndexRole: {
         m_d->setFrameColorLabel(index.row(), index.column(), value.toInt());
     }
         break;
     }
 
     return ModelWithExternalNotifications::setData(index, value, role);
 }
 
 QVariant TimelineFramesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole:
             return section == m_d->activeLayerIndex;
         case Qt::DisplayRole: {
             QVariant value = headerData(section, orientation, Qt::ToolTipRole);
             if (!value.isValid()) return value;
 
             QString name = value.toString();
             const int maxNameSize = 13;
 
             if (name.size() > maxNameSize) {
                 name = QString("%1...").arg(name.left(maxNameSize));
             }
 
             return name;
         }
         case Qt::TextColorRole: {
             // WARNING: this role doesn't work for header views! Use
             //          bold font to show isolated mode instead!
             return QVariant();
         }
         case Qt::FontRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             KisNodeSP node = dummy->node();
 
             QFont baseFont;
             if (node->projectionLeaf()->isDroppedNode()) {
                 baseFont.setStrikeOut(true);
             } else if (m_d->image && m_d->image->isolatedModeRoot() &&
                        KisNodeModel::belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade)) {
                 baseFont.setBold(true);
             }
             return baseFont;
         }
         case Qt::ToolTipRole: {
             return m_d->layerName(section);
         }
         case TimelinePropertiesRole: {
             return QVariant::fromValue(m_d->layerProperties(section));
         }
         case OtherLayersRole: {
             TimelineNodeListKeeper::OtherLayersList list =
                 m_d->converter->otherLayersList();
 
             return QVariant::fromValue(list);
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             return dummy->node()->useInTimeline();
         }
         case Qt::BackgroundRole: {
             int label = m_d->layerColorLabel(section);
             if (label > 0) {
                 KisNodeViewColorScheme scm;
                 QColor color = scm.colorLabel(label);
                 QPalette pal = qApp->palette();
                 color = KritaUtils::blendColors(color, pal.color(QPalette::Button), 0.3);
                 return QBrush(color);
             } else {
                 return QVariant();
             }
         }
         }
     }
 
     return ModelWithExternalNotifications::headerData(section, orientation, role);
 }
 
 bool TimelineFramesModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (!m_d->dummiesFacade) return false;
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole: {
             setData(index(section, 0), value, role);
             break;
         }
         case TimelinePropertiesRole: {
             TimelineFramesModel::PropertyList props = value.value<TimelineFramesModel::PropertyList>();
 
             int result = m_d->setLayerProperties(section, props);
             emit headerDataChanged (Qt::Vertical, section, section);
             return result;
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return false;
             dummy->node()->setUseInTimeline(value.toBool());
             return true;
         }
         }
     }
 
     return ModelWithExternalNotifications::setHeaderData(section, orientation, value, role);
 }
 
 Qt::DropActions TimelineFramesModel::supportedDragActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 Qt::DropActions TimelineFramesModel::supportedDropActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 QStringList TimelineFramesModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-krita-frame");
     return types;
 }
 
 void TimelineFramesModel::setLastClickedIndex(const QModelIndex &index)
 {
     m_d->lastClickedIndex = index;
 }
 
 QMimeData* TimelineFramesModel::mimeData(const QModelIndexList &indexes) const
 {
     return mimeDataExtended(indexes, m_d->lastClickedIndex, UndefinedPolicy);
 }
 
 QMimeData *TimelineFramesModel::mimeDataExtended(const QModelIndexList &indexes,
                                                  const QModelIndex &baseIndex,
                                                  TimelineFramesModel::MimeCopyPolicy copyPolicy) const
 {
     QMimeData *data = new QMimeData();
 
     QByteArray encoded;
     QDataStream stream(&encoded, QIODevice::WriteOnly);
 
     const int baseRow = baseIndex.row();
     const int baseColumn = baseIndex.column();
 
     const QByteArray uuidDataRoot = m_d->image->root()->uuid().toRfc4122();
     stream << int(uuidDataRoot.size());
     stream.writeRawData(uuidDataRoot.data(), uuidDataRoot.size());
 
     stream << indexes.size();
     stream << baseRow << baseColumn;
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         KisNodeSP node = nodeAt(index);
         KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
         stream << index.row() - baseRow << index.column() - baseColumn;
 
         const QByteArray uuidData = node->uuid().toRfc4122();
         stream << int(uuidData.size());
         stream.writeRawData(uuidData.data(), uuidData.size());
     }
 
     stream << int(copyPolicy);
     data->setData("application/x-krita-frame", encoded);
 
     return data;
 }
 
 inline void decodeBaseIndex(QByteArray *encoded, int *row, int *col)
 {
     int size_UNUSED = 0;
 
     QDataStream stream(encoded, QIODevice::ReadOnly);
     stream >> size_UNUSED >> *row >> *col;
 }
 
 bool TimelineFramesModel::canDropFrameData(const QMimeData */*data*/, const QModelIndex &index)
 {
     if (!index.isValid()) return false;
 
     /**
      * Now we support D&D around any layer, so just return 'true' all
      * the time.
      */
     return true;
 }
 
 bool TimelineFramesModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     Q_UNUSED(row);
     Q_UNUSED(column);
 
     return dropMimeDataExtended(data, action, parent);
 }
 
 bool TimelineFramesModel::dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved)
 {
     bool result = false;
 
     if ((action != Qt::MoveAction && action != Qt::CopyAction) ||
         !parent.isValid()) return result;
 
     QByteArray encoded = data->data("application/x-krita-frame");
     QDataStream stream(&encoded, QIODevice::ReadOnly);
 
     int uuidLenRoot = 0;
     stream >> uuidLenRoot;
     QByteArray uuidDataRoot(uuidLenRoot, '\0');
     stream.readRawData(uuidDataRoot.data(), uuidLenRoot);
     QUuid nodeUuidRoot = QUuid::fromRfc4122(uuidDataRoot);
 
     KisPart *partInstance = KisPart::instance();
     QList<QPointer<KisDocument>> documents = partInstance->documents();
 
     KisImageSP srcImage = 0;
     Q_FOREACH(KisDocument *doc, documents) {
         KisImageSP tmpSrcImage = doc->image();
         if (tmpSrcImage->root()->uuid() == nodeUuidRoot) {
             srcImage = tmpSrcImage;
             break;
         }
     }
 
     if (!srcImage) {
         KisPart *kisPartInstance = KisPart::instance();
         kisPartInstance->currentMainwindow()->viewManager()->showFloatingMessage(
                     i18n("Dropped frames are not available in this Krita instance")
                     , QIcon());
         return false;
     }
 
     int size, baseRow, baseColumn;
     stream >> size >> baseRow >> baseColumn;
 
     const QPoint offset(parent.column() - baseColumn, parent.row() - baseRow);
 
     KisAnimationUtils::FrameMovePairList frameMoves;
 
     for (int i = 0; i < size; i++) {
         int relRow, relColumn;
         stream >> relRow >> relColumn;
 
         const int srcRow = baseRow + relRow;
         const int srcColumn = baseColumn + relColumn;
 
         int uuidLen = 0;
         stream >> uuidLen;
         QByteArray uuidData(uuidLen, '\0');
         stream.readRawData(uuidData.data(), uuidLen);
         QUuid nodeUuid = QUuid::fromRfc4122(uuidData);
 
         KisNodeSP srcNode;
 
         if (!nodeUuid.isNull()) {
             KisNodeUuidInfo nodeInfo(nodeUuid);
             srcNode = nodeInfo.findNode(srcImage->root());
         } else {
             QModelIndex index = this->index(srcRow, srcColumn);
             srcNode = nodeAt(index);
         }
 
         KIS_SAFE_ASSERT_RECOVER(srcNode) { continue; }
 
         const QModelIndex dstRowIndex = this->index(srcRow + offset.y(), 0);
         if (!dstRowIndex.isValid()) continue;
 
         KisNodeSP dstNode = nodeAt(dstRowIndex);
         KIS_SAFE_ASSERT_RECOVER(dstNode) { continue; }
 
         Q_FOREACH (KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
             KisAnimationUtils::FrameItem srcItem(srcNode, channel->id(), srcColumn);
             KisAnimationUtils::FrameItem dstItem(dstNode, channel->id(), srcColumn + offset.x());
             frameMoves << std::make_pair(srcItem, dstItem);
         }
     }
 
     MimeCopyPolicy copyPolicy = UndefinedPolicy;
 
     if (!stream.atEnd()) {
         int value = 0;
         stream >> value;
         copyPolicy = MimeCopyPolicy(value);
     }
 
     const bool copyFrames =
         copyPolicy == UndefinedPolicy ?
         action == Qt::CopyAction :
         copyPolicy == CopyFramesPolicy;
 
     if (dataMoved) {
         *dataMoved = !copyFrames;
     }
 
     KUndo2Command *cmd = 0;
 
     if (!frameMoves.isEmpty()) {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
         cmd = KisAnimationUtils::createMoveKeyframesCommand(frameMoves, copyFrames, false, 0);
     }
 
     if (cmd) {
         KisProcessingApplicator::runSingleCommandStroke(m_d->image, cmd,
                                                         KisStrokeJobData::BARRIER,
                                                         KisStrokeJobData::EXCLUSIVE);
     }
 
     return cmd;
 }
 
 Qt::ItemFlags TimelineFramesModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = ModelWithExternalNotifications::flags(index);
     if (!index.isValid()) return flags;
 
     if (m_d->frameExists(index.row(), index.column()) || m_d->specialKeyframeExists(index.row(), index.column())) {
         if (data(index, FrameEditableRole).toBool()) {
             flags |= Qt::ItemIsDragEnabled;
         }
     }
 
     /**
      * Basically we should forbid overrides only if we D&D a single frame
      * and allow it when we D&D multiple frames. But we cannot distinguish
      * it here... So allow all the time.
      */
     flags |= Qt::ItemIsDropEnabled;
 
     return flags;
 }
 
 bool TimelineFramesModel::insertRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
 
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row > rowCount()) return false;
 
     bool result = m_d->addNewLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row >= rowCount()) return false;
 
     bool result = m_d->removeLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::insertOtherLayer(int index, int dstRow)
 {
     Q_UNUSED(dstRow);
 
     TimelineNodeListKeeper::OtherLayersList list =
         m_d->converter->otherLayersList();
 
     if (index < 0 || index >= list.size()) return false;
 
     list[index].dummy->node()->setUseInTimeline(true);
     dstRow = m_d->converter->rowForDummy(list[index].dummy);
     setData(this->index(dstRow, 0), true, ActiveLayerRole);
 
     return true;
 }
 
 int TimelineFramesModel::activeLayerRow() const
 {
     return m_d->activeLayerIndex;
 }
 
 bool TimelineFramesModel::createFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), false);
 }
 
 bool TimelineFramesModel::copyFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), true);
 }
 
 bool TimelineFramesModel::insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing)
 {
     if (dstRows.isEmpty() || count <= 0) return true;
     timing = qMax(timing, 1);
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QModelIndexList indexes;
 
         Q_FOREACH (int row, dstRows) {
             for (int column = dstColumn; column < columnCount(); column++) {
                 indexes << index(row, column);
             }
         }
 
         setLastVisibleFrame(columnCount() + (count * timing) - 1);
 
         createOffsetFramesCommand(indexes, QPoint((count * timing), 0), false, false, parentCommand);
 
         Q_FOREACH (int row, dstRows) {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
             if (!dummy) continue;
 
             KisNodeSP node = dummy->node();
             if (!KisAnimationUtils::supportsContentFrames(node)) continue;
 
             for (int column = dstColumn; column < dstColumn + (count * timing); column += timing) {
                 KisAnimationUtils::createKeyframeCommand(m_d->image, node, KisKeyframeChannel::Content.id(), column, false, parentCommand);
             }
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = dstColumn > oldTime ? dstColumn : dstColumn + (count * timing) - 1;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand,
                                                     KisStrokeJobData::BARRIER,
                                                     KisStrokeJobData::EXCLUSIVE);
 
     return true;
 }
 
 bool TimelineFramesModel::insertHoldFrames(QModelIndexList selectedIndexes, int count)
 {
     if (selectedIndexes.isEmpty() || count == 0) return true;
 
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count)));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QSet<KisKeyframeSP> uniqueKeyframesInSelection;
 
         int minSelectedTime = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, selectedIndexes) {
             KisNodeSP node = nodeAt(index);
             KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (!channel) continue;
 
             minSelectedTime = qMin(minSelectedTime, index.column());
             KisKeyframeSP keyFrame = channel->activeKeyframeAt(index.column());
 
             if (keyFrame) {
                 uniqueKeyframesInSelection.insert(keyFrame);
             }
         }
 
         QList<KisKeyframeSP> keyframesToMove;
 
         for (auto it = uniqueKeyframesInSelection.begin(); it != uniqueKeyframesInSelection.end(); ++it) {
             KisKeyframeSP keyframe = *it;
 
             KisKeyframeChannel *channel = keyframe->channel();
             KisKeyframeSP nextKeyframe = channel->nextKeyframe(keyframe);
 
             if (nextKeyframe) {
                 keyframesToMove << nextKeyframe;
             }
         }
 
         std::sort(keyframesToMove.begin(), keyframesToMove.end(),
             [] (KisKeyframeSP lhs, KisKeyframeSP rhs) {
                 return lhs->time() > rhs->time();
             });
 
         if (keyframesToMove.isEmpty()) return true;
 
         const int maxColumn = columnCount();
 
         if (count > 0) {
             setLastVisibleFrame(columnCount() + count);
         }
 
         Q_FOREACH (KisKeyframeSP keyframe, keyframesToMove) {
             int plannedFrameMove = count;
 
             if (count < 0) {
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe->time() > 0, false);
 
                 KisKeyframeSP prevFrame = keyframe->channel()->previousKeyframe(keyframe);
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(prevFrame, false);
 
                 plannedFrameMove = qMax(count, prevFrame->time() - keyframe->time() + 1);
 
                 minSelectedTime = qMin(minSelectedTime, prevFrame->time());
             }
 
             KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(keyframe->channel()->node());
             KIS_SAFE_ASSERT_RECOVER(dummy) { continue; }
 
             const int row = m_d->converter->rowForDummy(dummy);
             KIS_SAFE_ASSERT_RECOVER(row >= 0) { continue; }
 
             QModelIndexList indexes;
             for (int column = keyframe->time(); column < maxColumn; column++) {
                 indexes << index(row, column);
             }
 
             createOffsetFramesCommand(indexes,
                                       QPoint(plannedFrameMove, 0),
                                       false, true, parentCommand.data());
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minSelectedTime;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand.data());
     }
 
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand.take(),
                                                     KisStrokeJobData::BARRIER,
                                                     KisStrokeJobData::EXCLUSIVE);
     return true;
 }
 
 QString TimelineFramesModel::audioChannelFileName() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioChannelFileName() : QString();
 }
 
 void TimelineFramesModel::setAudioChannelFileName(const QString &fileName)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioChannelFileName(fileName);
 }
 
 bool TimelineFramesModel::isAudioMuted() const
 {
     return m_d->image ? m_d->image->animationInterface()->isAudioMuted() : false;
 }
 
 void TimelineFramesModel::setAudioMuted(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioMuted(value);
 }
 
 qreal TimelineFramesModel::audioVolume() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioVolume() : 0.5;
 }
 
 void TimelineFramesModel::setAudioVolume(qreal value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioVolume(value);
 }
 
 void TimelineFramesModel::setFullClipRangeStart(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeStartTime(column);
 }
 
 void TimelineFramesModel::setFullClipRangeEnd(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeEndTime(column);
 }
diff --git a/plugins/dockers/animation/timeline_frames_model.h b/plugins/dockers/animation/timeline_frames_model.h
index 8f8d5edabe..21880dd76c 100644
--- a/plugins/dockers/animation/timeline_frames_model.h
+++ b/plugins/dockers/animation/timeline_frames_model.h
@@ -1,154 +1,157 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __TIMELINE_FRAMES_MODEL_H
 #define __TIMELINE_FRAMES_MODEL_H
 
 
 #include <QScopedPointer>
 #include <QIcon>
 
 #include "kritaanimationdocker_export.h"
 #include "kis_node_model.h"
 #include "kis_types.h"
 #include "kis_node.h"
 #include "timeline_node_list_keeper.h"
 
 class KisNodeDummy;
 class KisDummiesFacadeBase;
 class KisAnimationPlayer;
+class KisNodeDisplayModeAdapter;
 
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineFramesModel : public TimelineNodeListKeeper::ModelWithExternalNotifications
 {
     Q_OBJECT
 
 public:
     enum MimeCopyPolicy {
         UndefinedPolicy = 0,
         MoveFramesPolicy,
         CopyFramesPolicy
     };
 
 public:
     TimelineFramesModel(QObject *parent);
     ~TimelineFramesModel() override;
 
     bool hasConnectionToCanvas() const;
 
-    void setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image);
+    void setDummiesFacade(KisDummiesFacadeBase *dummiesFacade,
+                          KisImageSP image,
+                          KisNodeDisplayModeAdapter *displayModeAdapter);
 
     bool canDropFrameData(const QMimeData *data, const QModelIndex &index);
     bool insertOtherLayer(int index, int dstRow);
     int activeLayerRow() const;
 
     bool createFrame(const QModelIndex &dstIndex);
     bool copyFrame(const QModelIndex &dstIndex);
 
     bool insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing = 1);
 
     bool insertHoldFrames(QModelIndexList selectedIndexes, int count);
 
     QString audioChannelFileName() const;
     void setAudioChannelFileName(const QString &fileName);
 
     bool isAudioMuted() const;
     void setAudioMuted(bool value);
 
     qreal audioVolume() const;
     void setAudioVolume(qreal value);
 
     void setFullClipRangeStart(int column);
     void setFullClipRangeEnd(int column);
 
     void setLastClickedIndex(const QModelIndex &index);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role) override;
     QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
     bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role) override;
 
     Qt::DropActions supportedDragActions() const override;
     Qt::DropActions supportedDropActions() const override;
     QStringList mimeTypes() const override;
     QMimeData *mimeData(const QModelIndexList &indexes) const override;
     QMimeData *mimeDataExtended(const QModelIndexList &indexes, const QModelIndex &baseIndex, MimeCopyPolicy copyPolicy) const;
     bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
 
     bool dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved = 0);
 
     Qt::ItemFlags flags(const QModelIndex &index) const override;
 
     bool insertRows(int row, int count, const QModelIndex &parent) override;
     bool removeRows(int row, int count, const QModelIndex &parent) override;
 
     enum ItemDataRole
     {
         ActiveLayerRole = KisTimeBasedItemModel::UserRole,
         TimelinePropertiesRole,
         OtherLayersRole,
         LayerUsedInTimelineRole,
         FrameColorLabelIndexRole
     };
 
     // metatype is added by the original implementation
     typedef KisBaseNode::Property Property;
     typedef KisBaseNode::PropertyList PropertyList;
 
     typedef TimelineNodeListKeeper::OtherLayer OtherLayer;
     typedef TimelineNodeListKeeper::OtherLayersList OtherLayersList;
 
 
     struct NodeManipulationInterface {
         virtual ~NodeManipulationInterface() {}
         virtual KisLayerSP addPaintLayer() const = 0;
         virtual void removeNode(KisNodeSP node) const = 0;
         virtual bool setNodeProperties(KisNodeSP node, KisImageSP image, KisBaseNode::PropertyList properties) const = 0;
     };
 
     /**
      * NOTE: the model has an ownership over the interface, that is it'll
      *       be deleted automatically later
      */
     void setNodeManipulationInterface(NodeManipulationInterface *iface);
     KisNodeSP nodeAt(QModelIndex index) const override;
 
 protected:
     QMap<QString, KisKeyframeChannel *> channelsAt(QModelIndex index) const override;
 
 private Q_SLOTS:
     void slotDummyChanged(KisNodeDummy *dummy);
     void slotImageContentChanged();
     void processUpdateQueue();
 
 public Q_SLOTS:
     void slotCurrentNodeChanged(KisNodeSP node);
 
 Q_SIGNALS:
     void requestCurrentNodeChanged(KisNodeSP node);
     void sigInfiniteTimelineUpdateNeeded();
     void sigAudioChannelChanged();
     void sigEnsureRowVisible(int row);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __TIMELINE_FRAMES_MODEL_H */
diff --git a/plugins/dockers/animation/timeline_node_list_keeper.cpp b/plugins/dockers/animation/timeline_node_list_keeper.cpp
index 0ea8d90e9f..a12611e17b 100644
--- a/plugins/dockers/animation/timeline_node_list_keeper.cpp
+++ b/plugins/dockers/animation/timeline_node_list_keeper.cpp
@@ -1,249 +1,287 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_node_list_keeper.h"
 
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "timeline_frames_index_converter.h"
 
 #include <QSet>
 #include <KisSignalMapper.h>
 #include "kis_keyframe_channel.h"
+#include "KisNodeDisplayModeAdapter.h"
 
 
 struct TimelineNodeListKeeper::Private
 {
     Private(TimelineNodeListKeeper *_q,
             ModelWithExternalNotifications *_model,
-            KisDummiesFacadeBase *_dummiesFacade)
+            KisDummiesFacadeBase *_dummiesFacade,
+            KisNodeDisplayModeAdapter *_displayModeAdapter)
         : q(_q),
           model(_model),
           dummiesFacade(_dummiesFacade),
+          displayModeAdapter(_displayModeAdapter),
+          showGlobalSelectionMask(_displayModeAdapter->showGlobalSelectionMask()),
           converter(dummiesFacade)
     {
+        converter.setShowGlobalSelectionMask(showGlobalSelectionMask);
     }
 
     TimelineNodeListKeeper *q;
     ModelWithExternalNotifications *model;
     KisDummiesFacadeBase *dummiesFacade;
+    KisNodeDisplayModeAdapter *displayModeAdapter;
+    bool showGlobalSelectionMask;
 
     TimelineFramesIndexConverter converter;
 
     QVector<KisNodeDummy*> dummiesList;
     KisSignalMapper dummiesUpdateMapper;
     QSet<KisNodeDummy*> connectionsSet;
 
     void populateDummiesList() {
         const int rowCount = converter.rowCount();
         for (int i = 0; i < rowCount; ++i) {
             KisNodeDummy *dummy = converter.dummyFromRow(i);
 
             dummiesList.append(dummy);
             tryConnectDummy(dummy);
         }
     }
 
     void tryConnectDummy(KisNodeDummy *dummy);
     void disconnectDummy(KisNodeDummy *dummy);
+
+    void findOtherLayers(KisNodeDummy *root,
+                         TimelineNodeListKeeper::OtherLayersList *list,
+                         const QString &prefix);
+
 };
 
-TimelineNodeListKeeper::TimelineNodeListKeeper(ModelWithExternalNotifications *model, KisDummiesFacadeBase *dummiesFacade)
-    : m_d(new Private(this, model, dummiesFacade))
+TimelineNodeListKeeper::TimelineNodeListKeeper(ModelWithExternalNotifications *model,
+                                               KisDummiesFacadeBase *dummiesFacade,
+                                               KisNodeDisplayModeAdapter *displayModeAdapter)
+    : m_d(new Private(this, model, dummiesFacade, displayModeAdapter))
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->dummiesFacade);
 
     connect(m_d->dummiesFacade, SIGNAL(sigEndInsertDummy(KisNodeDummy*)),
             SLOT(slotEndInsertDummy(KisNodeDummy*)));
     connect(m_d->dummiesFacade, SIGNAL(sigBeginRemoveDummy(KisNodeDummy*)),
             SLOT(slotBeginRemoveDummy(KisNodeDummy*)));
     connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
             SLOT(slotDummyChanged(KisNodeDummy*)));
 
     m_d->populateDummiesList();
 
     connect(&m_d->dummiesUpdateMapper, SIGNAL(mapped(QObject*)), SLOT(slotUpdateDummyContent(QObject*)));
+
+    connect(m_d->displayModeAdapter, SIGNAL(sigNodeDisplayModeChanged(bool, bool)), SLOT(slotDisplayModeChanged()));
 }
 
 TimelineNodeListKeeper::~TimelineNodeListKeeper()
 {
 }
 
 KisNodeDummy* TimelineNodeListKeeper::dummyFromRow(int row)
 {
     if (row >= 0 && row < m_d->dummiesList.size()) {
         return m_d->dummiesList[row];
     }
 
     return 0;
 }
 
 int TimelineNodeListKeeper::rowForDummy(KisNodeDummy *dummy)
 {
     return m_d->dummiesList.indexOf(dummy);
 }
 
 int TimelineNodeListKeeper::rowCount()
 {
     return m_d->dummiesList.size();
 }
 
 void TimelineNodeListKeeper::updateActiveDummy(KisNodeDummy *dummy)
 {
     bool oldRemoved = false;
     bool newAdded = false;
 
     KisNodeDummy *oldActiveDummy = m_d->converter.activeDummy();
     m_d->converter.updateActiveDummy(dummy, &oldRemoved, &newAdded);
 
     if (oldRemoved) {
         slotBeginRemoveDummy(oldActiveDummy);
     }
 
     if (newAdded) {
         slotEndInsertDummy(dummy);
     }
 }
 
 void TimelineNodeListKeeper::slotUpdateDummyContent(QObject *_dummy)
 {
     KisNodeDummy *dummy = qobject_cast<KisNodeDummy*>(_dummy);
     int pos = m_d->converter.rowForDummy(dummy);
     if (pos < 0) return;
 
     QModelIndex index0 = m_d->model->index(pos, 0);
     QModelIndex index1 = m_d->model->index(pos, m_d->model->columnCount() - 1);
     m_d->model->callIndexChanged(index0, index1);
 }
 
 void TimelineNodeListKeeper::Private::tryConnectDummy(KisNodeDummy *dummy)
 {
     QMap<QString, KisKeyframeChannel*> channels = dummy->node()->keyframeChannels();
 
     if (channels.isEmpty()) {
         if (connectionsSet.contains(dummy)) {
             connectionsSet.remove(dummy);
         }
 
         return;
     }
 
     if (connectionsSet.contains(dummy)) return;
 
     Q_FOREACH(KisKeyframeChannel *channel, channels) {
         connect(channel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)),
                 &dummiesUpdateMapper, SLOT(map()));
         connect(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframeSP)),
                 &dummiesUpdateMapper, SLOT(map()));
         connect(channel, SIGNAL(sigKeyframeMoved(KisKeyframeSP,int)),
                 &dummiesUpdateMapper, SLOT(map()));
 
         dummiesUpdateMapper.setMapping(channel, (QObject*)dummy);
     }
     connectionsSet.insert(dummy);
 }
 
 void TimelineNodeListKeeper::Private::disconnectDummy(KisNodeDummy *dummy)
 {
     if (!connectionsSet.contains(dummy)) return;
 
     QMap<QString, KisKeyframeChannel*> channels = dummy->node()->keyframeChannels();
 
     if (channels.isEmpty()) {
         if (connectionsSet.contains(dummy)) {
             connectionsSet.remove(dummy);
         }
         return;
     }
 
     Q_FOREACH(KisKeyframeChannel *channel, channels) {
         channel->disconnect(&dummiesUpdateMapper);
     }
 
     connectionsSet.remove(dummy);
 }
 
 void TimelineNodeListKeeper::slotEndInsertDummy(KisNodeDummy *dummy)
 {
     KIS_ASSERT_RECOVER_RETURN(!m_d->dummiesList.contains(dummy));
 
     if (m_d->converter.isDummyVisible(dummy)) {
         int pos = m_d->converter.rowForDummy(dummy);
 
         m_d->model->callBeginInsertRows(QModelIndex(), pos, pos);
         m_d->dummiesList.insert(pos, 1, dummy);
         m_d->tryConnectDummy(dummy);
         m_d->model->callEndInsertRows();
     }
 }
 
 void TimelineNodeListKeeper::slotBeginRemoveDummy(KisNodeDummy *dummy)
 {
     if (m_d->dummiesList.contains(dummy)) {
         int pos = m_d->dummiesList.indexOf(dummy);
 
         m_d->model->callBeginRemoveRows(QModelIndex(), pos, pos);
         m_d->disconnectDummy(dummy);
         m_d->dummiesList.remove(pos);
         m_d->model->callEndRemoveRows();
     }
 
     m_d->converter.notifyDummyRemoved(dummy);
 }
 
 void TimelineNodeListKeeper::slotDummyChanged(KisNodeDummy *dummy)
 {
     const bool present = m_d->dummiesList.contains(dummy);
     const bool shouldBe = m_d->converter.isDummyVisible(dummy);
 
     m_d->tryConnectDummy(dummy);
 
     if (!present && shouldBe) {
         slotEndInsertDummy(dummy);
     } else if (present && !shouldBe) {
         slotBeginRemoveDummy(dummy);
     }
 }
 
-void findOtherLayers(KisNodeDummy *root,
-                     TimelineNodeListKeeper::OtherLayersList *list,
-                     const QString &prefix)
+void TimelineNodeListKeeper::slotDisplayModeChanged()
+{
+    if (m_d->showGlobalSelectionMask != m_d->displayModeAdapter->showGlobalSelectionMask()) {
+
+        m_d->model->callBeginResetModel();
+
+        Q_FOREACH (KisNodeDummy *dummy, m_d->dummiesList) {
+            m_d->disconnectDummy(dummy);
+        }
+        m_d->dummiesList.clear();
+
+        m_d->showGlobalSelectionMask = m_d->displayModeAdapter->showGlobalSelectionMask();
+        m_d->converter.setShowGlobalSelectionMask(m_d->showGlobalSelectionMask);
+
+        m_d->populateDummiesList();
+
+        m_d->model->callEndResetModel();
+    }
+}
+
+void TimelineNodeListKeeper::Private::findOtherLayers(KisNodeDummy *root,
+                                                      TimelineNodeListKeeper::OtherLayersList *list,
+                                                      const QString &prefix)
 {
     KisNodeSP node = root->node();
 
-    if (root->parent() && !node->useInTimeline()) {
+    if (converter.isDummyAvailableForTimeline(root) &&
+        !root->node()->useInTimeline()) {
+
         *list <<
             TimelineNodeListKeeper::OtherLayer(
                 QString(prefix + node->name()),
                 root);
     }
 
     KisNodeDummy *dummy = root->lastChild();
     while(dummy) {
         findOtherLayers(dummy, list, prefix + " ");
         dummy = dummy->prevSibling();
     }
 }
 
 TimelineNodeListKeeper::OtherLayersList
 TimelineNodeListKeeper::otherLayersList() const
 {
     OtherLayersList list;
-    findOtherLayers(m_d->dummiesFacade->rootDummy(), &list, "");
+    m_d->findOtherLayers(m_d->dummiesFacade->rootDummy(), &list, "");
     return list;
 }
diff --git a/plugins/dockers/animation/timeline_node_list_keeper.h b/plugins/dockers/animation/timeline_node_list_keeper.h
index 0182aecefc..abddf4eaa9 100644
--- a/plugins/dockers/animation/timeline_node_list_keeper.h
+++ b/plugins/dockers/animation/timeline_node_list_keeper.h
@@ -1,107 +1,120 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __TIMELINE_NODE_LIST_KEEPER_H
 #define __TIMELINE_NODE_LIST_KEEPER_H
 
 #include <QObject>
 #include <QList>
 #include <QScopedPointer>
 #include <QAbstractTableModel>
 
 #include "kritaanimationdocker_export.h"
 
 #include "kis_time_based_item_model.h"
 
 class KisNodeDummy;
 class KisDummiesFacadeBase;
+class KisNodeDisplayModeAdapter;
 
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineNodeListKeeper : public QObject
 {
     Q_OBJECT
 public:
     struct ModelWithExternalNotifications;
 
     struct OtherLayer;
     typedef QList<OtherLayer> OtherLayersList;
 
 
-    TimelineNodeListKeeper(ModelWithExternalNotifications *model, KisDummiesFacadeBase *dummiesFacade);
+    TimelineNodeListKeeper(ModelWithExternalNotifications *model,
+                           KisDummiesFacadeBase *dummiesFacade,
+                           KisNodeDisplayModeAdapter *displayModeAdapter);
     ~TimelineNodeListKeeper() override;
 
     KisNodeDummy* dummyFromRow(int row);
     int rowForDummy(KisNodeDummy *dummy);
     int rowCount();
 
     OtherLayersList otherLayersList() const;
 
     void updateActiveDummy(KisNodeDummy *dummy);
 
 private Q_SLOTS:
     void slotEndInsertDummy(KisNodeDummy *dummy);
     void slotBeginRemoveDummy(KisNodeDummy *dummy);
     void slotDummyChanged(KisNodeDummy *dummy);
 
     void slotUpdateDummyContent(QObject *dummy);
 
+    void slotDisplayModeChanged();
+
 public:
     struct ModelWithExternalNotifications : public KisTimeBasedItemModel {
         ModelWithExternalNotifications(QObject *parent)
             : KisTimeBasedItemModel(parent) {}
 
+        void callBeginResetModel() {
+            beginResetModel();
+        }
+
+        void callEndResetModel() {
+            endResetModel();
+        }
+
         void callBeginInsertRows(const QModelIndex &parent, int first, int last) {
             beginInsertRows(parent, first, last);
         }
 
         void callEndInsertRows() {
             endInsertRows();
         }
 
         void callBeginRemoveRows(const QModelIndex &parent, int first, int last) {
             beginRemoveRows(parent, first, last);
         }
 
         void callEndRemoveRows() {
             endRemoveRows();
         }
 
         void callIndexChanged(const QModelIndex &index0, const QModelIndex &index1) {
             emit dataChanged(index0, index1);
         }
     };
 
     struct OtherLayer {
         OtherLayer(const QString &_name, KisNodeDummy *_dummy)
             : name(_name),
               dummy(_dummy)
         {
         }
 
         QString name;
         KisNodeDummy *dummy;
     };
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 Q_DECLARE_METATYPE( TimelineNodeListKeeper::OtherLayersList )
 
 #endif /* __TIMELINE_NODE_LIST_KEEPER_H */
diff --git a/plugins/dockers/overview/overviewwidget.cc b/plugins/dockers/overview/overviewwidget.cc
index 1b53b0b1d3..5cf840c60d 100644
--- a/plugins/dockers/overview/overviewwidget.cc
+++ b/plugins/dockers/overview/overviewwidget.cc
@@ -1,384 +1,385 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2014 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #include "overviewwidget.h"
 
 #include <QMouseEvent>
 #include <QPainter>
 #include <QCursor>
 #include <QMutex>
 
 #include <KoCanvasController.h>
 #include <KoZoomController.h>
 
 #include <kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_signal_compressor.h>
 #include <kis_config.h>
 #include "kis_idle_watcher.h"
 #include "krita_utils.h"
 #include "kis_painter.h"
 #include <KoUpdater.h>
 #include "kis_transform_worker.h"
 #include "kis_filter_strategy.h"
 #include <KoColorSpaceRegistry.h>
 #include <QApplication>
 
 const qreal oversample = 2.;
 const int thumbnailTileDim = 128;
 
 struct OverviewThumbnailStrokeStrategy::Private {
 
     class ProcessData : public KisStrokeJobData
     {
     public:
         ProcessData(KisPaintDeviceSP _dev, KisPaintDeviceSP _thumbDev, const QSize& _thumbnailSize, const QRect &_rect)
             : KisStrokeJobData(CONCURRENT),
               dev(_dev), thumbDev(_thumbDev), thumbnailSize(_thumbnailSize), tileRect(_rect)
         {}
 
         KisPaintDeviceSP dev;
         KisPaintDeviceSP thumbDev;
         QSize thumbnailSize;
         QRect tileRect;
     };
     class FinishProcessing : public KisStrokeJobData
     {
     public:
         FinishProcessing(KisPaintDeviceSP _thumbDev, const QSize& _thumbnailSize)
             : KisStrokeJobData(SEQUENTIAL),
               thumbDev(_thumbDev), thumbnailSize(_thumbnailSize)
         {}
         KisPaintDeviceSP thumbDev;
         QSize thumbnailSize;
     };
 };
 
 OverviewWidget::OverviewWidget(QWidget * parent)
     : QWidget(parent)
     , m_canvas(0)
     , m_dragging(false)
     , m_imageIdleWatcher(250)
 {
     setMouseTracking(true);
     KisConfig cfg(true);
     slotThemeChanged();
 }
 
 OverviewWidget::~OverviewWidget()
 {
 }
 
 void OverviewWidget::setCanvas(KoCanvasBase * canvas)
 {
     if (m_canvas) {
         m_canvas->image()->disconnect(this);
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_imageIdleWatcher.setTrackedImage(m_canvas->image());
 
         connect(&m_imageIdleWatcher, &KisIdleWatcher::startedIdleMode, this, &OverviewWidget::generateThumbnail);
 
         connect(m_canvas->image(), SIGNAL(sigImageUpdated(QRect)),SLOT(startUpdateCanvasProjection()));
         connect(m_canvas->image(), SIGNAL(sigSizeChanged(QPointF,QPointF)),SLOT(startUpdateCanvasProjection()));
 
         connect(m_canvas->canvasController()->proxyObject, SIGNAL(canvasOffsetXChanged(int)), this, SLOT(update()), Qt::UniqueConnection);
         connect(m_canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotThemeChanged()));
         generateThumbnail();
     }
 }
 
 QSize OverviewWidget::recalculatePreviewSize()
 {
     QSize imageSize(m_canvas->image()->bounds().size());
 
     const qreal hScale = 1.0 * this->width() / imageSize.width();
     const qreal vScale = 1.0 * this->height() / imageSize.height();
 
     m_previewScale = qMin(hScale, vScale);
 
     return imageSize * m_previewScale;
 }
 
 QPointF OverviewWidget::previewOrigin()
 {
     const QSize previewSize = recalculatePreviewSize();
     return QPointF((width() - previewSize.width()) / 2.0f, (height() - previewSize.height()) / 2.0f);
 }
 
 QPolygonF OverviewWidget::previewPolygon()
 {
     if (m_canvas) {
         const QRectF &canvasRect = QRectF(m_canvas->canvasWidget()->rect());
         return canvasToPreviewTransform().map(canvasRect);
     }
     return QPolygonF();
 }
 
 QTransform OverviewWidget::previewToCanvasTransform()
 {
     QTransform previewToImage =
             QTransform::fromTranslate(-this->width() / 2.0, -this->height() / 2.0) *
             QTransform::fromScale(1.0 / m_previewScale, 1.0 / m_previewScale) *
             QTransform::fromTranslate(m_canvas->image()->width() / 2.0, m_canvas->image()->height() / 2.0);
 
     return previewToImage * m_canvas->coordinatesConverter()->imageToWidgetTransform();
 }
 
 QTransform OverviewWidget::canvasToPreviewTransform()
 {
     return previewToCanvasTransform().inverted();
 }
 
 void OverviewWidget::startUpdateCanvasProjection()
 {
     m_imageIdleWatcher.startCountdown();
 }
 
 void OverviewWidget::showEvent(QShowEvent *event)
 {
     Q_UNUSED(event);
     m_imageIdleWatcher.startCountdown();
 }
 
 void OverviewWidget::resizeEvent(QResizeEvent *event)
 {
     Q_UNUSED(event);
     if (m_canvas) {
         if (!m_oldPixmap.isNull()) {
             QSize newSize = recalculatePreviewSize();
             m_pixmap = m_oldPixmap.scaled(newSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
         }
         m_imageIdleWatcher.startCountdown();
     }
 }
 
 void OverviewWidget::mousePressEvent(QMouseEvent* event)
 {
     if (m_canvas) {
         QPointF previewPos = event->pos();
 
         if (!previewPolygon().containsPoint(previewPos, Qt::WindingFill)) {
             const QRect& canvasRect = m_canvas->canvasWidget()->rect();
             const QPointF newCanvasPos = previewToCanvasTransform().map(previewPos) -
                     QPointF(canvasRect.width() / 2.0f, canvasRect.height() / 2.0f);
             m_canvas->canvasController()->pan(newCanvasPos.toPoint());
         }
         m_lastPos = previewPos;
         m_dragging = true;
     }
     event->accept();
     update();
 }
 
 void OverviewWidget::mouseMoveEvent(QMouseEvent* event)
 {
     if (m_dragging) {
         QPointF previewPos = event->pos();
         const QPointF lastCanvasPos = previewToCanvasTransform().map(m_lastPos);
         const QPointF newCanvasPos = previewToCanvasTransform().map(event->pos());
 
         QPointF diff = newCanvasPos - lastCanvasPos;
         m_canvas->canvasController()->pan(diff.toPoint());
         m_lastPos = previewPos;
     }
     event->accept();
 }
 
 void OverviewWidget::mouseReleaseEvent(QMouseEvent* event)
 {
     m_dragging = false;
     event->accept();
     update();
 }
 
 void OverviewWidget::wheelEvent(QWheelEvent* event)
 {
 	if (m_canvas) {
 		float delta = event->delta();
 
 		if (delta > 0) {
 			m_canvas->viewManager()->zoomController()->zoomAction()->zoomIn();
 		} else {
 			m_canvas->viewManager()->zoomController()->zoomAction()->zoomOut();
 		}
 	}
 }
 
 void OverviewWidget::generateThumbnail()
 {
     if (isVisible()) {
         QMutexLocker locker(&mutex);
         if (m_canvas) {
             QSize previewSize = recalculatePreviewSize();
             if(previewSize.isValid()){
                 KisImageSP image = m_canvas->image();
 
                 if (!strokeId.isNull()) {
                     image->cancelStroke(strokeId);
                     strokeId.clear();
                 }
 
                 OverviewThumbnailStrokeStrategy* stroke = new OverviewThumbnailStrokeStrategy(image);
                 connect(stroke, SIGNAL(thumbnailUpdated(QImage)), this, SLOT(updateThumbnail(QImage)));
 
                 strokeId = image->startStroke(stroke);
                 KisPaintDeviceSP dev = image->projection();
                 KisPaintDeviceSP thumbDev = new KisPaintDevice(dev->colorSpace());
 
                 //creating a special stroke that computes thumbnail image in small chunks that can be quickly interrupted
                 //if user starts painting
                 QList<KisStrokeJobData*> jobs = OverviewThumbnailStrokeStrategy::createJobsData(dev, image->bounds(), thumbDev, previewSize);
 
                 Q_FOREACH (KisStrokeJobData *jd, jobs) {
                     image->addJob(strokeId, jd);
                 }
                 image->endStroke(strokeId);
             }
         }
     }
 }
 
 void OverviewWidget::updateThumbnail(QImage pixmap)
 {
     m_pixmap = QPixmap::fromImage(pixmap);
     m_oldPixmap = m_pixmap.copy();
     update();
 }
 
 void OverviewWidget::slotThemeChanged()
 {
     m_outlineColor = qApp->palette().color(QPalette::Highlight);
 }
 
 
 void OverviewWidget::paintEvent(QPaintEvent* event)
 {
     QWidget::paintEvent(event);
 
     if (m_canvas) {
         QPainter p(this);
 
         const QSize previewSize = recalculatePreviewSize();
         const QRectF previewRect = QRectF(previewOrigin(), previewSize);
         p.drawPixmap(previewRect.toRect(), m_pixmap);
 
         QRect r = rect();
         QPolygonF outline;
         outline << r.topLeft() << r.topRight() << r.bottomRight() << r.bottomLeft();
 
         QPen pen;
         pen.setColor(m_outlineColor);
         pen.setStyle(Qt::DashLine);
 
         p.setPen(pen);
         p.drawPolygon(outline.intersected(previewPolygon()));
 
         pen.setStyle(Qt::SolidLine);
         p.setPen(pen);
         p.drawPolygon(previewPolygon());
     }
 }
 
 OverviewThumbnailStrokeStrategy::OverviewThumbnailStrokeStrategy(KisImageWSP image)
-    : KisSimpleStrokeStrategy("OverviewThumbnail"), m_image(image)
+    : KisSimpleStrokeStrategy(QLatin1String("OverviewThumbnail")),
+      m_image(image)
 {
     enableJob(KisSimpleStrokeStrategy::JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
     //enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
     enableJob(KisSimpleStrokeStrategy::JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     setRequestsOtherStrokesToEnd(false);
     setClearsRedoOnStart(false);
     setCanForgetAboutMe(true);
 }
 
 QList<KisStrokeJobData *> OverviewThumbnailStrokeStrategy::createJobsData(KisPaintDeviceSP dev, const QRect& imageRect, KisPaintDeviceSP thumbDev, const QSize& thumbnailSize)
 {
     QSize thumbnailOversampledSize = oversample * thumbnailSize;
 
     if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
         thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     QVector<QRect> tileRects = KritaUtils::splitRectIntoPatches(QRect(QPoint(0, 0), thumbnailOversampledSize), QSize(thumbnailTileDim, thumbnailTileDim));
     QList<KisStrokeJobData*> jobsData;
 
     Q_FOREACH (const QRect &tileRectangle, tileRects) {
         jobsData << new OverviewThumbnailStrokeStrategy::Private::ProcessData(dev, thumbDev, thumbnailOversampledSize, tileRectangle);
     }
     jobsData << new OverviewThumbnailStrokeStrategy::Private::FinishProcessing(thumbDev, thumbnailSize);
 
     return jobsData;
 }
 
 OverviewThumbnailStrokeStrategy::~OverviewThumbnailStrokeStrategy()
 {
 }
 
 
 void OverviewThumbnailStrokeStrategy::initStrokeCallback()
 {
 }
 
 void OverviewThumbnailStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     Private::ProcessData *d_pd = dynamic_cast<Private::ProcessData*>(data);
     if (d_pd) {
         //we aren't going to use oversample capability of createThumbnailDevice because it recomputes exact bounds for each small patch, which is
         //slow. We'll handle scaling separately.
         KisPaintDeviceSP thumbnailTile = d_pd->dev->createThumbnailDeviceOversampled(d_pd->thumbnailSize.width(), d_pd->thumbnailSize.height(), 1, m_image->bounds(), d_pd->tileRect);
         {
             QMutexLocker locker(&m_thumbnailMergeMutex);
             KisPainter gc(d_pd->thumbDev);
             gc.bitBlt(QPoint(d_pd->tileRect.x(), d_pd->tileRect.y()), thumbnailTile, d_pd->tileRect);
         }
         return;
     }
 
 
     Private::FinishProcessing *d_fp = dynamic_cast<Private::FinishProcessing*>(data);
     if (d_fp) {
         QImage overviewImage;
 
         KoDummyUpdater updater;
         KisTransformWorker worker(d_fp->thumbDev, 1 / oversample, 1 / oversample, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                                   &updater, KisFilterStrategyRegistry::instance()->value("Bilinear"));
         worker.run();
 
         overviewImage = d_fp->thumbDev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(),
                                                         QRect(QPoint(0,0), d_fp->thumbnailSize));
         emit thumbnailUpdated(overviewImage);
         return;
     }
 }
 
 void OverviewThumbnailStrokeStrategy::finishStrokeCallback()
 {
 }
 
 void OverviewThumbnailStrokeStrategy::cancelStrokeCallback()
 {
 }
diff --git a/plugins/extensions/animationrenderer/AnimationRenderer.cpp b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
index 718941a02e..c053c3c537 100644
--- a/plugins/extensions/animationrenderer/AnimationRenderer.cpp
+++ b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
@@ -1,206 +1,206 @@
 /*
  * Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "AnimationRenderer.h"
 
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <kis_image.h>
 #include <KisViewManager.h>
 #include <KoUpdater.h>
 #include <kis_node_manager.h>
 #include <kis_image_manager.h>
 #include <kis_action.h>
 #include <kis_image_animation_interface.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <KisDocument.h>
 #include <KisMimeDatabase.h>
 #include <kis_time_range.h>
 #include <KisImportExportManager.h>
 #include <KisImportExportErrorCode.h>
 
 #include "DlgAnimationRenderer.h"
 #include <dialogs/KisAsyncAnimationFramesSaveDialog.h>
 
 #include "video_saver.h"
 #include "KisAnimationRenderingOptions.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(AnimaterionRendererFactory, "kritaanimationrenderer.json", registerPlugin<AnimaterionRenderer>();)
 
 AnimaterionRenderer::AnimaterionRenderer(QObject *parent, const QVariantList &)
     : KisActionPlugin(parent)
 {
     // Shows the big dialog
     KisAction *action = createAction("render_animation");
     action->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
     connect(action,  SIGNAL(triggered()), this, SLOT(slotRenderAnimation()));
 
     // Re-renders the image sequence as defined in the last render
     action = createAction("render_animation_again");
     action->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
     connect(action,  SIGNAL(triggered()), this, SLOT(slotRenderSequenceAgain()));
 }
 
 AnimaterionRenderer::~AnimaterionRenderer()
 {
 }
 
 void AnimaterionRenderer::slotRenderAnimation()
 {
     KisImageWSP image = viewManager()->image();
 
     if (!image) return;
     if (!image->animationInterface()->hasAnimation()) return;
 
     KisDocument *doc = viewManager()->document();
 
     DlgAnimationRenderer dlgAnimationRenderer(doc, viewManager()->mainWindow());
 
     dlgAnimationRenderer.setCaption(i18n("Render Animation"));
 
     if (dlgAnimationRenderer.exec() == QDialog::Accepted) {
         KisAnimationRenderingOptions encoderOptions = dlgAnimationRenderer.getEncoderOptions();
         renderAnimationImpl(doc, encoderOptions);
     }
 }
 
 void AnimaterionRenderer::slotRenderSequenceAgain()
 {
     KisImageWSP image = viewManager()->image();
 
     if (!image) return;
     if (!image->animationInterface()->hasAnimation()) return;
 
     KisDocument *doc = viewManager()->document();
 
     KisConfig cfg(true);
 
     KisPropertiesConfigurationSP settings = cfg.exportConfiguration("ANIMATION_EXPORT");
 
     KisAnimationRenderingOptions encoderOptions;
     encoderOptions.fromProperties(settings);
 
     renderAnimationImpl(doc, encoderOptions);
 }
 
 void AnimaterionRenderer::renderAnimationImpl(KisDocument *doc, KisAnimationRenderingOptions encoderOptions)
 {
     const QString frameMimeType = encoderOptions.frameMimeType;
     const QString framesDirectory = encoderOptions.resolveAbsoluteFramesDirectory();
     const QString extension = KisMimeDatabase::suffixesForMimeType(frameMimeType).first();
     const QString baseFileName = QString("%1/%2.%3").arg(framesDirectory)
             .arg(encoderOptions.basename)
             .arg(extension);
 
 
     /**
      * The dialog should ensure that the size of the video is even
      */
     KIS_SAFE_ASSERT_RECOVER(
         !((encoderOptions.width & 0x1 || encoderOptions.height & 0x1)
           && (encoderOptions.videoMimeType == "video/mp4" ||
               encoderOptions.videoMimeType == "video/x-matroska"))) {
 
         encoderOptions.width = encoderOptions.width + (encoderOptions.width & 0x1);
         encoderOptions.height = encoderOptions.height + (encoderOptions.height & 0x1);
     }
 
     const QSize scaledSize =
         doc->image()->bounds().size().scaled(
             encoderOptions.width, encoderOptions.height,
             Qt::KeepAspectRatio);
 
     if ((scaledSize.width() & 0x1 || scaledSize.height() & 0x1)
             && (encoderOptions.videoMimeType == "video/mp4" ||
                 encoderOptions.videoMimeType == "video/x-matroska")) {
         QString m = "Mastroska (.mkv)";
         if (encoderOptions.videoMimeType == "video/mp4") {
             m = "Mpeg4 (.mp4)";
         }
         qWarning() << m <<"requires width and height to be even, resize and try again!";
         doc->setErrorMessage(i18n("%1 requires width and height to be even numbers.  Please resize or crop the image before exporting.", m));
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not render animation:\n%1", doc->errorMessage()));
         return;
     }
 
     const bool batchMode = false; // TODO: fetch correctly!
     KisAsyncAnimationFramesSaveDialog exporter(doc->image(),
                                                KisTimeRange::fromTime(encoderOptions.firstFrame,
                                                                       encoderOptions.lastFrame),
                                                baseFileName,
                                                encoderOptions.sequenceStart,
                                                encoderOptions.frameExportConfig);
     exporter.setBatchMode(batchMode);
 
 
     KisAsyncAnimationFramesSaveDialog::Result result =
         exporter.regenerateRange(viewManager()->mainWindow()->viewManager());
 
     // the folder could have been read-only or something else could happen
     if (encoderOptions.shouldEncodeVideo &&
         result == KisAsyncAnimationFramesSaveDialog::RenderComplete) {
 
         const QString savedFilesMask = exporter.savedFilesMask();
 
         const QString resultFile = encoderOptions.resolveAbsoluteVideoFilePath();
-        KIS_SAFE_ASSERT_RECOVER_NOOP(QFileInfo(resultFile).isAbsolute())
+        KIS_SAFE_ASSERT_RECOVER_NOOP(QFileInfo(resultFile).isAbsolute());
 
         {
             const QFileInfo info(resultFile);
             QDir dir(info.absolutePath());
 
             if (!dir.exists()) {
                 dir.mkpath(info.absolutePath());
             }
             KIS_SAFE_ASSERT_RECOVER_NOOP(dir.exists());
         }
 
         KisImportExportErrorCode res;
         QFile fi(resultFile);
         if (!fi.open(QIODevice::WriteOnly)) {
             qWarning() << "Could not open" << fi.fileName() << "for writing!";
             res = KisImportExportErrorCannotWrite(fi.error());
         } else {
             fi.close();
         }
 
         QScopedPointer<VideoSaver> encoder(new VideoSaver(doc, batchMode));
         res = encoder->convert(doc, savedFilesMask, encoderOptions, batchMode);
 
         if (!res.isOk()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not render animation:\n%1", res.errorMessage()));
         }
 
         if (encoderOptions.shouldDeleteSequence) {
             QDir d(framesDirectory);
             QStringList sequenceFiles = d.entryList(QStringList() << encoderOptions.basename + "*." + extension, QDir::Files);
             Q_FOREACH(const QString &f, sequenceFiles) {
                 d.remove(f);
             }
         }
 
     } else if (result == KisAsyncAnimationFramesSaveDialog::RenderFailed) {
         viewManager()->mainWindow()->viewManager()->showFloatingMessage(i18n("Failed to render animation frames!"), QIcon());
     }
 }
 
 #include "AnimationRenderer.moc"
diff --git a/plugins/impex/jp2/CMakeLists.txt b/plugins/impex/jp2/CMakeLists.txt
index 63bf879f8a..c9393f6cfa 100644
--- a/plugins/impex/jp2/CMakeLists.txt
+++ b/plugins/impex/jp2/CMakeLists.txt
@@ -1,31 +1,35 @@
 add_subdirectory(tests)
 
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenJPEG_CFLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenJPEG_CFLAGS}")
+add_definitions(${OpenJPEG_DEFINITIONS})
+
 include_directories(SYSTEM ${OpenJPEG_INCLUDE_DIR})
 
 set(libkritaconverter_LIB_SRCS
     jp2_converter.cc
 )
 
 set(kritajp2import_SOURCES
     jp2_import.cc
     ${libkritaconverter_LIB_SRCS}
 )
 
 add_library(kritajp2import MODULE ${kritajp2import_SOURCES})
 
 target_link_libraries(kritajp2import kritaui ${OpenJPEG_LIBRARIES} )
 
 install(TARGETS kritajp2import DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 
 #set(kritajp2export_SOURCES
 #    jp2_export.cc
 #    ${libkritaconverter_LIB_SRCS}
 #)
 #
 #ki18n_wrap_ui(kritajp2export_SOURCES kis_wdg_options_jp2.ui )
 #
 #add_library(kritajp2export MODULE ${kritajp2export_SOURCES})
 #
 #target_link_libraries(kritajp2export kritaui  ${OPENJPEG_LIBRARIES} )
 #install(TARGETS kritajp2export  DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 install( PROGRAMS  krita_jp2.desktop  DESTINATION ${XDG_APPS_INSTALL_DIR})
diff --git a/plugins/impex/libkra/kis_kra_savexml_visitor.cpp b/plugins/impex/libkra/kis_kra_savexml_visitor.cpp
index 35343d3adf..0620f90504 100644
--- a/plugins/impex/libkra/kis_kra_savexml_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_savexml_visitor.cpp
@@ -1,500 +1,500 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *
  *  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_kra_savexml_visitor.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_layer_properties_icons.h"
 
 #include <QTextStream>
 #include <QDir>
 
 #include <KoProperties.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 
 #include <kis_debug.h>
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_clone_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <lazybrush/kis_colorize_mask.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <KisReferenceImage.h>
 #include <KisReferenceImagesLayer.h>
 #include "kis_keyframe_channel.h"
 #include "kis_dom_utils.h"
 
 using namespace KRA;
 
 KisSaveXmlVisitor::KisSaveXmlVisitor(QDomDocument doc, const QDomElement & element, quint32 &count, const QString &url, bool root)
     : KisNodeVisitor()
     , m_doc(doc)
     , m_count(count)
     , m_url(url)
     , m_root(root)
 {
     Q_ASSERT(!element.isNull());
     m_elem = element;
 }
 
 void KisSaveXmlVisitor::setSelectedNodes(vKisNodeSP selectedNodes)
 {
     m_selectedNodes = selectedNodes;
 }
 
 QStringList KisSaveXmlVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 bool KisSaveXmlVisitor::visit(KisExternalLayer * layer)
 {
     if (layer->inherits("KisReferenceImagesLayer")) {
         return saveReferenceImagesLayer(layer);
     } else if (layer->inherits("KisShapeLayer")) {
         QDomElement layerElement = m_doc.createElement(LAYER);
         saveLayer(layerElement, SHAPE_LAYER, layer);
         m_elem.appendChild(layerElement);
         m_count++;
         return saveMasks(layer, layerElement);
     }
     else if (layer->inherits("KisFileLayer")) {
         QDomElement layerElement = m_doc.createElement(LAYER);
         saveLayer(layerElement, FILE_LAYER, layer);
 
         KisFileLayer *fileLayer = dynamic_cast<KisFileLayer*>(layer);
 
         QString path = fileLayer->path();
 
         QDir d(QFileInfo(m_url).absolutePath());
 
         layerElement.setAttribute("source", d.relativeFilePath(path));
 
         if (fileLayer->scalingMethod() == KisFileLayer::ToImagePPI) {
             layerElement.setAttribute("scale", "true");
         }
         else {
             layerElement.setAttribute("scale", "false");
         }
         layerElement.setAttribute("scalingmethod", (int)fileLayer->scalingMethod());
         layerElement.setAttribute(COLORSPACE_NAME, layer->original()->colorSpace()->id());
 
         m_elem.appendChild(layerElement);
         m_count++;
         return saveMasks(layer, layerElement);
     }
     return false;
 }
 
 QDomElement KisSaveXmlVisitor::savePaintLayerAttributes(KisPaintLayer *layer, QDomDocument &doc)
 {
     QDomElement element = doc.createElement(LAYER);
     saveLayer(element, PAINT_LAYER, layer);
     element.setAttribute(CHANNEL_LOCK_FLAGS, flagsToString(layer->channelLockFlags()));
     element.setAttribute(COLORSPACE_NAME, layer->paintDevice()->colorSpace()->id());
 
     element.setAttribute(ONION_SKIN_ENABLED, layer->onionSkinEnabled());
     element.setAttribute(VISIBLE_IN_TIMELINE, layer->useInTimeline());
 
     return element;
 }
 
 void KisSaveXmlVisitor::loadPaintLayerAttributes(const QDomElement &el, KisPaintLayer *layer)
 {
     loadLayerAttributes(el, layer);
 
     if (el.hasAttribute(CHANNEL_LOCK_FLAGS)) {
         layer->setChannelLockFlags(stringToFlags(el.attribute(CHANNEL_LOCK_FLAGS)));
     }
 }
 
 bool KisSaveXmlVisitor::visit(KisPaintLayer *layer)
 {
     QDomElement layerElement = savePaintLayerAttributes(layer, m_doc);
     m_elem.appendChild(layerElement);
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisGroupLayer *layer)
 {
     QDomElement layerElement;
 
     if (m_root) // if this is the root we fake so not to save it
         layerElement = m_elem;
     else {
         layerElement = m_doc.createElement(LAYER);
         saveLayer(layerElement, GROUP_LAYER, layer);
         layerElement.setAttribute(PASS_THROUGH_MODE, layer->passThroughMode());
         m_elem.appendChild(layerElement);
     }
     QDomElement elem = m_doc.createElement(LAYERS);
     Q_ASSERT(!layerElement.isNull());
     layerElement.appendChild(elem);
     KisSaveXmlVisitor visitor(m_doc, elem, m_count, m_url, false);
     visitor.setSelectedNodes(m_selectedNodes);
     m_count++;
     bool success = visitor.visitAllInverse(layer);
 
     m_errorMessages.append(visitor.errorMessages());
     if (!m_errorMessages.isEmpty()) {
         return false;
     }
 
     QMapIterator<const KisNode*, QString> i(visitor.nodeFileNames());
     while (i.hasNext()) {
         i.next();
         m_nodeFileNames[i.key()] = i.value();
     }
 
     i = QMapIterator<const KisNode*, QString>(visitor.keyframeFileNames());
     while (i.hasNext()) {
         i.next();
         m_keyframeFileNames[i.key()] = i.value();
     }
 
     return success;
 }
 
 bool KisSaveXmlVisitor::visit(KisAdjustmentLayer* layer)
 {
     if (!layer->filter()) {
         return false;
     }
     QDomElement layerElement = m_doc.createElement(LAYER);
     saveLayer(layerElement, ADJUSTMENT_LAYER, layer);
     layerElement.setAttribute(FILTER_NAME, layer->filter()->name());
     layerElement.setAttribute(FILTER_VERSION, layer->filter()->version());
     m_elem.appendChild(layerElement);
 
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisGeneratorLayer *layer)
 {
     QDomElement layerElement = m_doc.createElement(LAYER);
     saveLayer(layerElement, GENERATOR_LAYER, layer);
     layerElement.setAttribute(GENERATOR_NAME, layer->filter()->name());
     layerElement.setAttribute(GENERATOR_VERSION, layer->filter()->version());
     m_elem.appendChild(layerElement);
 
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisCloneLayer *layer)
 {
     QDomElement layerElement = m_doc.createElement(LAYER);
     saveLayer(layerElement, CLONE_LAYER, layer);
     layerElement.setAttribute(CLONE_FROM, layer->copyFromInfo().name());
     layerElement.setAttribute(CLONE_FROM_UUID, layer->copyFromInfo().uuid().toString());
     layerElement.setAttribute(CLONE_TYPE, layer->copyType());
     m_elem.appendChild(layerElement);
 
     m_count++;
     return saveMasks(layer, layerElement);
 }
 
 bool KisSaveXmlVisitor::visit(KisFilterMask *mask)
 {
     Q_ASSERT(mask);
     if (!mask->filter()) {
         return false;
     }
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, FILTER_MASK, mask);
     el.setAttribute(FILTER_NAME, mask->filter()->name());
     el.setAttribute(FILTER_VERSION, mask->filter()->version());
 
     m_elem.appendChild(el);
 
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisTransformMask *mask)
 {
     Q_ASSERT(mask);
 
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, TRANSFORM_MASK, mask);
 
     m_elem.appendChild(el);
 
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisTransparencyMask *mask)
 {
     Q_ASSERT(mask);
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, TRANSPARENCY_MASK, mask);
     m_elem.appendChild(el);
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisColorizeMask *mask)
 {
     Q_ASSERT(mask);
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, COLORIZE_MASK, mask);
     m_elem.appendChild(el);
     m_count++;
     return true;
 }
 
 bool KisSaveXmlVisitor::visit(KisSelectionMask *mask)
 {
     Q_ASSERT(mask);
 
     QDomElement el = m_doc.createElement(MASK);
     saveMask(el, SELECTION_MASK, mask);
     m_elem.appendChild(el);
     m_count++;
     return true;
 }
 
 
 void KisSaveXmlVisitor::loadLayerAttributes(const QDomElement &el, KisLayer *layer)
 {
     if (el.hasAttribute(NAME)) {
         QString layerName = el.attribute(NAME);
         if (layerName != layer->name()) {
             // Make the EXR layername leading in case of conflicts
             layer->setName(layerName);
         }
     }
 
     if (el.hasAttribute(CHANNEL_FLAGS)) {
         layer->setChannelFlags(stringToFlags(el.attribute(CHANNEL_FLAGS)));
     }
 
     if (el.hasAttribute(OPACITY)) {
         layer->setOpacity(el.attribute(OPACITY).toInt());
     }
 
     if (el.hasAttribute(COMPOSITE_OP)) {
         layer->setCompositeOpId(el.attribute(COMPOSITE_OP));
     }
 
     if (el.hasAttribute(VISIBLE)) {
         layer->setVisible(el.attribute(VISIBLE).toInt());
     }
 
     if (el.hasAttribute(LOCKED)) {
         layer->setUserLocked(el.attribute(LOCKED).toInt());
     }
 
     if (el.hasAttribute(X)) {
         layer->setX(el.attribute(X).toInt());
     }
 
     if (el.hasAttribute(Y)) {
         layer->setY(el.attribute(Y).toInt());
     }
 
     if (el.hasAttribute(UUID)) {
         layer->setUuid(el.attribute(UUID));
     }
 
     if (el.hasAttribute(COLLAPSED)) {
         layer->setCollapsed(el.attribute(COLLAPSED).toInt());
     }
 
     if (el.hasAttribute(COLOR_LABEL)) {
         layer->setColorLabelIndex(el.attribute(COLOR_LABEL).toInt());
     }
 
     if (el.hasAttribute(VISIBLE_IN_TIMELINE)) {
         layer->setUseInTimeline(el.attribute(VISIBLE_IN_TIMELINE).toInt());
     }
 
     if (el.hasAttribute(LAYER_STYLE_UUID)) {
         QString uuidString = el.attribute(LAYER_STYLE_UUID);
         QUuid uuid(uuidString);
         if (!uuid.isNull()) {
             KisPSDLayerStyleSP dumbLayerStyle(new KisPSDLayerStyle());
             dumbLayerStyle->setUuid(uuid);
             layer->setLayerStyle(dumbLayerStyle);
         } else {
             warnKrita << "WARNING: Layer style for layer" << layer->name() << "contains invalid UUID" << uuidString;
         }
     }
 }
 
 void KisSaveXmlVisitor::saveNodeKeyframes(const KisNode* node, QString nodeFilename, QDomElement& nodeElement)
 {
     if (node->isAnimated()) {
         QString keyframeFile = nodeFilename + ".keyframes.xml";
         m_keyframeFileNames[node] = keyframeFile;
         nodeElement.setAttribute(KEYFRAME_FILE, keyframeFile);
     }
 }
 
 void KisSaveXmlVisitor::saveLayer(QDomElement & el, const QString & layerType, const KisLayer * layer)
 {
     QString filename = LAYER + QString::number(m_count);
 
     el.setAttribute(CHANNEL_FLAGS, flagsToString(layer->channelFlags()));
     el.setAttribute(NAME, layer->name());
     el.setAttribute(OPACITY, layer->opacity());
     el.setAttribute(COMPOSITE_OP, layer->compositeOp()->id());
     el.setAttribute(VISIBLE, layer->visible());
     el.setAttribute(LOCKED, layer->userLocked());
     el.setAttribute(NODE_TYPE, layerType);
     el.setAttribute(FILE_NAME, filename);
     el.setAttribute(X, layer->x());
     el.setAttribute(Y, layer->y());
     el.setAttribute(UUID, layer->uuid().toString());
     el.setAttribute(COLLAPSED, layer->collapsed());
     el.setAttribute(COLOR_LABEL, layer->colorLabelIndex());
     el.setAttribute(VISIBLE_IN_TIMELINE, layer->useInTimeline());
 
     if (layer->layerStyle()) {
         el.setAttribute(LAYER_STYLE_UUID, layer->layerStyle()->uuid().toString());
     }
 
     Q_FOREACH (KisNodeSP node, m_selectedNodes) {
         if (node.data() == layer) {
             el.setAttribute("selected", "true");
             break;
         }
     }
 
     saveNodeKeyframes(layer, filename, el);
 
     m_nodeFileNames[layer] = filename;
 
     dbgFile << "Saved layer "
             << layer->name()
             << " of type " << layerType
             << " with filename " << LAYER + QString::number(m_count);
 }
 
 void KisSaveXmlVisitor::saveMask(QDomElement & el, const QString & maskType, const KisMaskSP mask)
 {
     QString filename = MASK + QString::number(m_count);
 
     el.setAttribute(NAME, mask->name());
     el.setAttribute(VISIBLE, mask->visible());
     el.setAttribute(LOCKED, mask->userLocked());
     el.setAttribute(NODE_TYPE, maskType);
     el.setAttribute(FILE_NAME, filename);
     el.setAttribute(X, mask->x());
     el.setAttribute(Y, mask->y());
     el.setAttribute(UUID, mask->uuid().toString());
 
     if (maskType == SELECTION_MASK) {
         el.setAttribute(ACTIVE, mask->nodeProperties().boolProperty("active"));
     } else if (maskType == COLORIZE_MASK) {
         el.setAttribute(COLORSPACE_NAME, mask->colorSpace()->id());
         el.setAttribute(COMPOSITE_OP, mask->compositeOpId());
         el.setAttribute(COLORIZE_EDIT_KEYSTROKES, KisLayerPropertiesIcons::nodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool());
         el.setAttribute(COLORIZE_SHOW_COLORING, KisLayerPropertiesIcons::nodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, true).toBool());
 
         const KisColorizeMask *colorizeMask = dynamic_cast<const KisColorizeMask*>(mask.data());
         KIS_SAFE_ASSERT_RECOVER_NOOP(colorizeMask);
 
         if (colorizeMask) {
             el.setAttribute(COLORIZE_USE_EDGE_DETECTION, colorizeMask->useEdgeDetection());
             el.setAttribute(COLORIZE_EDGE_DETECTION_SIZE, KisDomUtils::toString(colorizeMask->edgeDetectionSize()));
             el.setAttribute(COLORIZE_FUZZY_RADIUS, KisDomUtils::toString(colorizeMask->fuzzyRadius()));
             el.setAttribute(COLORIZE_CLEANUP, int(100 * colorizeMask->cleanUpAmount()));
             el.setAttribute(COLORIZE_LIMIT_TO_DEVICE, colorizeMask->limitToDeviceBounds());
         }
     }
 
     saveNodeKeyframes(mask, filename, el);
 
     m_nodeFileNames[mask] = filename;
 
     dbgFile << "Saved mask "
             << mask->name()
             << " of type " << maskType
             << " with filename " << filename;
 }
 
 bool KisSaveXmlVisitor::saveMasks(KisNode * node, QDomElement & layerElement)
 {
     if (node->childCount() > 0) {
         QDomElement elem = m_doc.createElement(MASKS);
         Q_ASSERT(!layerElement.isNull());
         layerElement.appendChild(elem);
         KisSaveXmlVisitor visitor(m_doc, elem, m_count, m_url, false);
         visitor.setSelectedNodes(m_selectedNodes);
         bool success = visitor.visitAllInverse(node);
         m_errorMessages.append(visitor.errorMessages());
         if (!m_errorMessages.isEmpty()) {
             return false;
         }
 
         QMapIterator<const KisNode*, QString> i(visitor.nodeFileNames());
         while (i.hasNext()) {
             i.next();
             m_nodeFileNames[i.key()] = i.value();
         }
 
         i = QMapIterator<const KisNode*, QString>(visitor.keyframeFileNames());
         while (i.hasNext()) {
             i.next();
             m_keyframeFileNames[i.key()] = i.value();
         }
 
         return success;
     }
     return true;
 }
 
 bool KisSaveXmlVisitor::saveReferenceImagesLayer(KisExternalLayer *layer)
 {
     auto *referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer);
-    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(referencesLayer, false)
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(referencesLayer, false);
 
     QDomElement layerElement = m_doc.createElement(LAYER);
     layerElement.setAttribute(NODE_TYPE, REFERENCE_IMAGES_LAYER);
 
     int nextId = 0;
     Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
         auto *reference = dynamic_cast<KisReferenceImage*>(shape);
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, false);
         reference->saveXml(m_doc, layerElement, nextId);
         nextId++;
     }
 
     m_elem.appendChild(layerElement);
     m_count++;
     return true;
 }
 
 
diff --git a/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp b/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp
index 586dbdee2f..37d77da314 100644
--- a/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp
+++ b/plugins/paintops/defaultpaintops/brush/KisDabRenderingJob.cpp
@@ -1,169 +1,176 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KisDabRenderingJob.h"
 
 #include <QElapsedTimer>
 
 #include <KisRunnableStrokeJobsInterface.h>
 #include <KisRunnableStrokeJobData.h>
 
 #include "KisDabCacheUtils.h"
 #include "KisDabRenderingQueue.h"
 
 #include <tool/strokes/FreehandStrokeRunnableJobDataWithUpdate.h>
 
 
 KisDabRenderingJob::KisDabRenderingJob()
 {
 }
 
 KisDabRenderingJob::KisDabRenderingJob(int _seqNo, KisDabCacheUtils::DabGenerationInfo _generationInfo, KisDabRenderingJob::JobType _type)
     : seqNo(_seqNo),
       generationInfo(_generationInfo),
       type(_type)
 {
 }
 
 KisDabRenderingJob::KisDabRenderingJob(const KisDabRenderingJob &rhs)
     : seqNo(rhs.seqNo),
       generationInfo(rhs.generationInfo),
       type(rhs.type),
       originalDevice(rhs.originalDevice),
       postprocessedDevice(rhs.postprocessedDevice),
       status(rhs.status),
       opacity(rhs.opacity),
       flow(rhs.flow)
 {
 }
 
 KisDabRenderingJob &KisDabRenderingJob::operator=(const KisDabRenderingJob &rhs)
 {
     seqNo = rhs.seqNo;
     generationInfo = rhs.generationInfo;
     type = rhs.type;
     originalDevice = rhs.originalDevice;
     postprocessedDevice = rhs.postprocessedDevice;
     status = rhs.status;
     opacity = rhs.opacity;
     flow = rhs.flow;
 
     return *this;
 }
 
 QPoint KisDabRenderingJob::dstDabOffset() const
 {
-    return generationInfo.dstDabRect.topLeft();
+    /// Recenter generated low-res dab around the center
+    /// of the idel theoretical dab rect
+    const QPoint p1 = generationInfo.dstDabRect.topLeft();
+    const QPoint s1 = QPoint(generationInfo.dstDabRect.width(),
+                             generationInfo.dstDabRect.height());
+    const QPoint s2 = QPoint(postprocessedDevice->bounds().width(),
+                             postprocessedDevice->bounds().height());
+    return p1 + (s1 - s2) / 2;
 }
 
 
 
 KisDabRenderingJobRunner::KisDabRenderingJobRunner(KisDabRenderingJobSP job,
                                                    KisDabRenderingQueue *parentQueue,
                                                    KisRunnableStrokeJobsInterface *runnableJobsInterface)
     : m_job(job),
       m_parentQueue(parentQueue),
       m_runnableJobsInterface(runnableJobsInterface)
 {
 }
 
 KisDabRenderingJobRunner::~KisDabRenderingJobRunner()
 {
 }
 
 int KisDabRenderingJobRunner::executeOneJob(KisDabRenderingJob *job,
                                             KisDabCacheUtils::DabRenderingResources *resources,
                                             KisDabRenderingQueue *parentQueue)
 {
     using namespace KisDabCacheUtils;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(job->type == KisDabRenderingJob::Dab ||
                                  job->type == KisDabRenderingJob::Postprocess);
 
     QElapsedTimer executionTime;
     executionTime.start();
 
     resources->syncResourcesToSeqNo(job->seqNo, job->generationInfo.info);
 
     if (job->type == KisDabRenderingJob::Dab) {
         // TODO: thing about better interface for the reverse queue link
         job->originalDevice = parentQueue->fetchCachedPaintDevce();
 
         generateDab(job->generationInfo, resources, &job->originalDevice);
     }
 
     // by now the original device should be already prepared
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(job->originalDevice, 0);
 
     if (job->type == KisDabRenderingJob::Dab ||
         job->type == KisDabRenderingJob::Postprocess) {
 
         if (job->generationInfo.needsPostprocessing) {
             // TODO: cache postprocessed device
 
             if (!job->postprocessedDevice ||
                 *job->originalDevice->colorSpace() != *job->postprocessedDevice->colorSpace()) {
 
                 job->postprocessedDevice = parentQueue->fetchCachedPaintDevce();
                 *job->postprocessedDevice = *job->originalDevice;
             } else {
                 *job->postprocessedDevice = *job->originalDevice;
             }
 
             postProcessDab(job->postprocessedDevice,
                            job->generationInfo.dstDabRect.topLeft(),
                            job->generationInfo.info,
                            resources);
         } else {
             job->postprocessedDevice = job->originalDevice;
         }
     }
 
     return executionTime.nsecsElapsed() / 1000;
 }
 
 void KisDabRenderingJobRunner::run()
 {
     int executionTime = 0;
 
     KisDabCacheUtils::DabRenderingResources *resources = m_parentQueue->fetchResourcesFromCache();
 
     executionTime = executeOneJob(m_job.data(), resources, m_parentQueue);
     QList<KisDabRenderingJobSP> jobs = m_parentQueue->notifyJobFinished(m_job->seqNo, executionTime);
 
     while (!jobs.isEmpty()) {
         QVector<KisRunnableStrokeJobData*> dataList;
 
         // start all-but-the-first jobs asynchronously
         for (int i = 1; i < jobs.size(); i++) {
             dataList.append(new FreehandStrokeRunnableJobDataWithUpdate(
                                 new KisDabRenderingJobRunner(jobs[i], m_parentQueue, m_runnableJobsInterface),
                                 KisStrokeJobData::CONCURRENT));
         }
 
         m_runnableJobsInterface->addRunnableJobs(dataList);
 
 
         // execute the first job in the current thread
         KisDabRenderingJobSP job = jobs.first();
         executionTime = executeOneJob(job.data(), resources, m_parentQueue);
         jobs = m_parentQueue->notifyJobFinished(job->seqNo, executionTime);
     }
 
     m_parentQueue->putResourcesToCache(resources);
 }
diff --git a/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp b/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp
index 36eab97e30..ca6ac8943f 100644
--- a/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp
+++ b/plugins/tools/basictools/KisMoveBoundsCalculationJob.cpp
@@ -1,60 +1,68 @@
 /*
  *  Copyright (c) 2019 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 "KisMoveBoundsCalculationJob.h"
 #include "kis_node.h"
 #include "kis_selection.h"
 #include "kis_layer_utils.h"
 
 KisMoveBoundsCalculationJob::KisMoveBoundsCalculationJob(KisNodeList nodes,
                                                          KisSelectionSP selection,
                                                          QObject *requestedBy)
     : m_nodes(nodes),
       m_selection(selection),
       m_requestedBy(requestedBy)
 {
     setExclusive(true);
 }
 
 void KisMoveBoundsCalculationJob::run()
 {
     QRect handlesRect;
 
     Q_FOREACH (KisNodeSP node, m_nodes) {
         handlesRect |= KisLayerUtils::recursiveNodeExactBounds(node);
     }
 
     if (m_selection) {
         handlesRect &= m_selection->selectedExactRect();
     }
 
     emit sigCalcualtionFinished(handlesRect);
 }
 
 bool KisMoveBoundsCalculationJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisMoveBoundsCalculationJob *otherJob =
         dynamic_cast<const KisMoveBoundsCalculationJob*>(_otherJob);
 
     return otherJob && otherJob->m_requestedBy == m_requestedBy;
 }
 
 int KisMoveBoundsCalculationJob::levelOfDetail() const
 {
     return 0;
 }
+
+QString KisMoveBoundsCalculationJob::debugName() const
+{
+    QString result;
+    QDebug dbg(&result);
+    dbg << "KisMoveBoundsCalculationJob" << ppVar(m_requestedBy) << m_nodes;
+    return result;
+}
diff --git a/plugins/tools/basictools/KisMoveBoundsCalculationJob.h b/plugins/tools/basictools/KisMoveBoundsCalculationJob.h
index 0c1f2037c3..a408512fc6 100644
--- a/plugins/tools/basictools/KisMoveBoundsCalculationJob.h
+++ b/plugins/tools/basictools/KisMoveBoundsCalculationJob.h
@@ -1,46 +1,48 @@
 /*
  *  Copyright (c) 2019 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 KISMOVEBOUNDSCALCULATIONJOB_H
 #define KISMOVEBOUNDSCALCULATIONJOB_H
 
 #include <QObject>
 #include "kis_spontaneous_job.h"
 #include "kis_types.h"
 #include "kis_selection.h"
 
 class KisMoveBoundsCalculationJob : public QObject, public KisSpontaneousJob
 {
     Q_OBJECT
 public:
     KisMoveBoundsCalculationJob(KisNodeList nodes, KisSelectionSP selection, QObject *requestedBy);
 
     void run() override;
     bool overrides(const KisSpontaneousJob *otherJob) override;
     int levelOfDetail() const override;
 
+    QString debugName() const override;
+
 Q_SIGNALS:
     void sigCalcualtionFinished(const QRect &bounds);
 
 private:
     KisNodeList m_nodes;
     KisSelectionSP m_selection;
     QObject *m_requestedBy;
 };
 
 #endif // KISMOVEBOUNDSCALCULATIONJOB_H
diff --git a/plugins/tools/basictools/kis_tool_move.cc b/plugins/tools/basictools/kis_tool_move.cc
index a905497b3e..1b1af76d28 100644
--- a/plugins/tools/basictools/kis_tool_move.cc
+++ b/plugins/tools/basictools/kis_tool_move.cc
@@ -1,714 +1,715 @@
 /*
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                2002 Patrick Julien <freak@codepimps.org>
  *                2004 Boudewijn Rempt <boud@valdyas.org>
  *                2016 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_move.h"
 
 #include <QPoint>
 
 
 #include "kis_cursor.h"
 #include "kis_selection.h"
 #include "kis_canvas2.h"
 #include "kis_image.h"
 
 #include "kis_tool_utils.h"
 #include "kis_paint_layer.h"
 #include "strokes/move_stroke_strategy.h"
 #include "kis_tool_movetooloptionswidget.h"
 #include "strokes/move_selection_stroke_strategy.h"
 #include "kis_resources_snapshot.h"
 #include "kis_action_registry.h"
 #include "krita_utils.h"
 
 #include <KisViewManager.h>
 #include <KisDocument.h>
 
 #include "kis_node_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_signals_blocker.h"
 #include <boost/operators.hpp>
 #include "KisMoveBoundsCalculationJob.h"
 
 
 struct KisToolMoveState : KisToolChangesTrackerData, boost::equality_comparable<KisToolMoveState>
 {
     KisToolMoveState(QPoint _accumulatedOffset) : accumulatedOffset(_accumulatedOffset) {}
     KisToolChangesTrackerData* clone() const override { return new KisToolMoveState(*this); }
 
     bool operator ==(const KisToolMoveState &rhs) {
         return accumulatedOffset == rhs.accumulatedOffset;
     }
 
     QPoint accumulatedOffset;
 };
 
 
 KisToolMove::KisToolMove(KoCanvasBase *canvas)
     : KisTool(canvas, KisCursor::moveCursor())
     , m_updateCursorCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
 {
     setObjectName("tool_move");
 
     m_showCoordinatesAction = action("movetool-show-coordinates");
     m_showCoordinatesAction = action("movetool-show-coordinates");
     connect(&m_updateCursorCompressor, SIGNAL(timeout()), this, SLOT(resetCursorStyle()));
 
     m_optionsWidget = new MoveToolOptionsWidget(0, currentImage()->xRes(), toolId());
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(m_optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     m_optionsWidget->layout()->addWidget(specialSpacer);
 
     m_optionsWidget->setFixedHeight(m_optionsWidget->sizeHint().height());
 
     m_showCoordinatesAction->setChecked(m_optionsWidget->showCoordinates());
 
     m_optionsWidget->slotSetTranslate(m_handlesRect.topLeft() + currentOffset());
 
     connect(m_optionsWidget, SIGNAL(sigSetTranslateX(int)), SLOT(moveBySpinX(int)), Qt::UniqueConnection);
     connect(m_optionsWidget, SIGNAL(sigSetTranslateY(int)), SLOT(moveBySpinY(int)), Qt::UniqueConnection);
     connect(m_optionsWidget, SIGNAL(sigRequestCommitOffsetChanges()), this, SLOT(commitChanges()), Qt::UniqueConnection);
 
     connect(this, SIGNAL(moveInNewPosition(QPoint)), m_optionsWidget, SLOT(slotSetTranslate(QPoint)), Qt::UniqueConnection);
-
-    connect(qobject_cast<KisCanvas2*>(canvas)->viewManager()->nodeManager(), SIGNAL(sigUiNeedChangeSelectedNodes(KisNodeList)), this, SLOT(slotNodeChanged(KisNodeList)), Qt::UniqueConnection);
-    connect(qobject_cast<KisCanvas2*>(canvas)->viewManager()->selectionManager(), SIGNAL(currentSelectionChanged()), this, SLOT(slotSelectionChanged()), Qt::UniqueConnection);
 }
 
 KisToolMove::~KisToolMove()
 {
     endStroke();
 }
 
 void KisToolMove::resetCursorStyle()
 {
     KisTool::resetCursorStyle();
 
     if (!isActive()) return;
     KisImageSP image = this->image();
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image, currentNode(), canvas()->resourceManager());
     KisSelectionSP selection = resources->activeSelection();
     KisNodeList nodes = fetchSelectedNodes(moveToolMode(), &m_lastCursorPos, selection);
 
     if (nodes.isEmpty()) {
         canvas()->setCursor(Qt::ForbiddenCursor);
     }
 }
 
 KisNodeList KisToolMove::fetchSelectedNodes(MoveToolMode mode, const QPoint *pixelPoint, KisSelectionSP selection)
 {
     KisNodeList nodes;
 
     KisImageSP image = this->image();
     if (mode != MoveSelectedLayer && pixelPoint) {
         const bool wholeGroup = !selection &&  mode == MoveGroup;
         KisNodeSP node = KisToolUtils::findNode(image->root(), *pixelPoint, wholeGroup);
         if (node) {
             nodes = {node};
         }
     }
 
     if (nodes.isEmpty()) {
         nodes = this->selectedNodes();
 
         KritaUtils::filterContainer<KisNodeList>(nodes,
                                                  [](KisNodeSP node) {
                                                      return node->isEditable();
                                                  });
     }
 
     return nodes;
 }
 
 bool KisToolMove::startStrokeImpl(MoveToolMode mode, const QPoint *pos)
 {
     KisNodeSP node;
     KisImageSP image = this->image();
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image, currentNode(), canvas()->resourceManager());
     KisSelectionSP selection = resources->activeSelection();
 
     KisNodeList nodes = fetchSelectedNodes(mode, pos, selection);
 
     if (nodes.size() == 1) {
         node = nodes.first();
     }
 
     if (nodes.isEmpty()) {
         return false;
     }
 
     /**
      * If the target node has changed, the stroke should be
      * restarted. Otherwise just continue processing current node.
      */
     if (m_strokeId && !tryEndPreviousStroke(nodes)) {
         return true;
     }
 
     KisStrokeStrategy *strategy;
 
     KisPaintLayerSP paintLayer = node ?
         dynamic_cast<KisPaintLayer*>(node.data()) : 0;
 
     bool isMoveSelection = false;
 
     if (paintLayer && selection &&
         (!selection->selectedRect().isEmpty() &&
          !selection->selectedExactRect().isEmpty())) {
 
         MoveSelectionStrokeStrategy *moveStrategy =
             new MoveSelectionStrokeStrategy(paintLayer,
                                             selection,
                                             image.data(),
                                             image.data());
 
         connect(moveStrategy,
                 SIGNAL(sigHandlesRectCalculated(const QRect&)),
                 SLOT(slotHandlesRectCalculated(const QRect&)));
 
         strategy = moveStrategy;
         isMoveSelection = true;
 
     } else {
 
         MoveStrokeStrategy *moveStrategy =
             new MoveStrokeStrategy(nodes, image.data(), image.data());
         connect(moveStrategy,
                 SIGNAL(sigHandlesRectCalculated(const QRect&)),
                 SLOT(slotHandlesRectCalculated(const QRect&)));
 
         strategy = moveStrategy;
     }
 
     // disable outline feedback until the stroke calcualtes
     // correct bounding rect
     m_handlesRect = QRect();
     m_strokeId = image->startStroke(strategy);
     m_currentlyProcessingNodes = nodes;
     m_accumulatedOffset = QPoint();
 
     if (!isMoveSelection) {
         m_asyncUpdateHelper.startUpdateStream(image.data(), m_strokeId);
     }
 
     KIS_SAFE_ASSERT_RECOVER(m_changesTracker.isEmpty()) {
         m_changesTracker.reset();
     }
     commitChanges();
 
     return true;
 }
 
 QPoint KisToolMove::currentOffset() const
 {
     return m_accumulatedOffset + m_dragPos - m_dragStart;
 }
 
 void KisToolMove::notifyGuiAfterMove(bool showFloatingMessage)
 {
     if (!m_optionsWidget) return;
     if (m_handlesRect.isEmpty()) return;
 
     const QPoint currentTopLeft = m_handlesRect.topLeft() + currentOffset();
 
     KisSignalsBlocker b(m_optionsWidget);
     emit moveInNewPosition(currentTopLeft);
 
     // TODO: fetch this info not from options widget, but from config
     const bool showCoordinates = m_optionsWidget->showCoordinates();
 
     if (showCoordinates && showFloatingMessage) {
         KisCanvas2 *kisCanvas = static_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in move tool",
                       "X: %1 px, Y: %2 px",
                       QLocale().toString(currentTopLeft.x()),
                       QLocale().toString(currentTopLeft.y())),
                 QIcon(), 1000, KisFloatingMessage::High);
     }
 }
 
 bool KisToolMove::tryEndPreviousStroke(const KisNodeList &nodes)
 {
     if (!m_strokeId) return false;
 
     bool strokeEnded = false;
 
     if (!KritaUtils::compareListsUnordered(nodes, m_currentlyProcessingNodes)) {
         endStroke();
         strokeEnded = true;
     }
 
     return strokeEnded;
 }
 
 void KisToolMove::commitChanges()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_strokeId);
 
     QSharedPointer<KisToolMoveState> newState(new KisToolMoveState(m_accumulatedOffset));
     KisToolMoveState *lastState = dynamic_cast<KisToolMoveState*>(m_changesTracker.lastState().data());
     if (lastState && *lastState == *newState) return;
 
     m_changesTracker.commitConfig(newState);
 }
 
 void KisToolMove::slotHandlesRectCalculated(const QRect &handlesRect)
 {
     m_handlesRect = handlesRect;
     notifyGuiAfterMove(false);
 }
 
 void KisToolMove::moveDiscrete(MoveDirection direction, bool big)
 {
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     if (!currentNode()) return;
     if (!image()) return;
     if (!currentNode()->isEditable()) return; // Don't move invisible nodes
 
     if (startStrokeImpl(MoveSelectedLayer, 0)) {
         setMode(KisTool::PAINT_MODE);
     }
 
     // Larger movement if "shift" key is pressed.
     qreal scale = big ? m_optionsWidget->moveScale() : 1.0;
     qreal moveStep = m_optionsWidget->moveStep() * scale;
 
     const QPoint offset =
         direction == Up   ? QPoint( 0, -moveStep) :
         direction == Down ? QPoint( 0,  moveStep) :
         direction == Left ? QPoint(-moveStep,  0) :
         QPoint( moveStep,  0) ;
 
     m_accumulatedOffset += offset;
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
     notifyGuiAfterMove();
     commitChanges();
     setMode(KisTool::HOVER_MODE);
 }
 
 void KisToolMove::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisTool::activate(toolActivation, shapes);
 
     m_actionConnections.addConnection(action("movetool-move-up"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteUp()));
     m_actionConnections.addConnection(action("movetool-move-down"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteDown()));
     m_actionConnections.addConnection(action("movetool-move-left"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteLeft()));
     m_actionConnections.addConnection(action("movetool-move-right"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteRight()));
 
     m_actionConnections.addConnection(action("movetool-move-up-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteUpMore()));
     m_actionConnections.addConnection(action("movetool-move-down-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteDownMore()));
     m_actionConnections.addConnection(action("movetool-move-left-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteLeftMore()));
     m_actionConnections.addConnection(action("movetool-move-right-more"), SIGNAL(triggered(bool)),
                                       this, SLOT(slotMoveDiscreteRightMore()));
 
+    m_canvasConnections.addUniqueConnection(qobject_cast<KisCanvas2*>(canvas())->viewManager()->nodeManager(), SIGNAL(sigUiNeedChangeSelectedNodes(KisNodeList)), this, SLOT(slotNodeChanged(KisNodeList)));
+    m_canvasConnections.addUniqueConnection(qobject_cast<KisCanvas2*>(canvas())->viewManager()->selectionManager(), SIGNAL(currentSelectionChanged()), this, SLOT(slotSelectionChanged()));
+
     connect(m_showCoordinatesAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(setShowCoordinates(bool)), Qt::UniqueConnection);
     connect(m_optionsWidget, SIGNAL(showCoordinatesChanged(bool)), m_showCoordinatesAction, SLOT(setChecked(bool)), Qt::UniqueConnection);
 
     connect(&m_changesTracker,
             SIGNAL(sigConfigChanged(KisToolChangesTrackerDataSP)),
             SLOT(slotTrackerChangedConfig(KisToolChangesTrackerDataSP)));
 
 
     slotNodeChanged(this->selectedNodes());
 }
 
 
 
 void KisToolMove::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     if (m_strokeId && !m_handlesRect.isEmpty()) {
         QPainterPath handles;
         handles.addRect(m_handlesRect.translated(currentOffset()));
 
         QPainterPath path = pixelToView(handles);
         paintToolOutline(&gc, path);
     }
 }
 
 void KisToolMove::deactivate()
 {
     m_actionConnections.clear();
+    m_canvasConnections.clear();
 
     disconnect(m_showCoordinatesAction, 0, this, 0);
     disconnect(m_optionsWidget, 0, this, 0);
 
     endStroke();
     KisTool::deactivate();
 }
 
 void KisToolMove::requestStrokeEnd()
 {
     endStroke();
 }
 
 void KisToolMove::requestStrokeCancellation()
 {
     cancelStroke();
 }
 
 void KisToolMove::requestUndoDuringStroke()
 {
     if (!m_strokeId) return;
 
     if (m_changesTracker.isEmpty()) {
         cancelStroke();
     } else {
         m_changesTracker.requestUndo();
     }
 }
 
 void KisToolMove::beginPrimaryAction(KoPointerEvent *event)
 {
     startAction(event, moveToolMode());
 }
 
 void KisToolMove::continuePrimaryAction(KoPointerEvent *event)
 {
     continueAction(event);
 }
 
 void KisToolMove::endPrimaryAction(KoPointerEvent *event)
 {
     endAction(event);
 }
 
 void KisToolMove::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     // Ctrl+Right click toggles between moving current layer and moving layer w/ content
     if (action == PickFgNode || action == PickBgImage) {
         MoveToolMode mode = moveToolMode();
 
         if (mode == MoveSelectedLayer) {
             mode = MoveFirstLayer;
         } else if (mode == MoveFirstLayer) {
             mode = MoveSelectedLayer;
         }
 
         startAction(event, mode);
     } else {
         startAction(event, MoveGroup);
     }
 }
 
 void KisToolMove::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(action)
     continueAction(event);
 }
 
 void KisToolMove::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(action)
     endAction(event);
 }
 
 void KisToolMove::mouseMoveEvent(KoPointerEvent *event)
 {
     m_lastCursorPos = convertToPixelCoord(event).toPoint();
     KisTool::mouseMoveEvent(event);
 
     if (moveToolMode() == MoveFirstLayer) {
         m_updateCursorCompressor.start();
     }
 }
 
 void KisToolMove::startAction(KoPointerEvent *event, MoveToolMode mode)
 {
     QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
     m_dragStart = pos;
     m_dragPos = pos;
 
     if (startStrokeImpl(mode, &pos)) {
         setMode(KisTool::PAINT_MODE);
     } else {
         event->ignore();
         m_dragPos = QPoint();
         m_dragStart = QPoint();
     }
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::continueAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     if (!m_strokeId) return;
 
     QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
     pos = applyModifiers(event->modifiers(), pos);
     m_dragPos = pos;
 
     drag(pos);
     notifyGuiAfterMove();
 
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::endAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     setMode(KisTool::HOVER_MODE);
     if (!m_strokeId) return;
 
     QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
     pos = applyModifiers(event->modifiers(), pos);
     drag(pos);
 
     m_accumulatedOffset += pos - m_dragStart;
     m_dragStart = QPoint();
     m_dragPos = QPoint();
     commitChanges();
 
     notifyGuiAfterMove();
 
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::drag(const QPoint& newPos)
 {
     KisImageWSP image = currentImage();
 
     QPoint offset = m_accumulatedOffset + newPos - m_dragStart;
 
     image->addJob(m_strokeId,
                   new MoveStrokeStrategy::Data(offset));
 }
 
 void KisToolMove::endStroke()
 {
     if (!m_strokeId) return;
 
     if (m_asyncUpdateHelper.isActive()) {
         m_asyncUpdateHelper.endUpdateStream();
     }
 
     KisImageSP image = currentImage();
     image->endStroke(m_strokeId);
     m_strokeId.clear();
     m_changesTracker.reset();
     m_currentlyProcessingNodes.clear();
     m_accumulatedOffset = QPoint();
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 void KisToolMove::slotTrackerChangedConfig(KisToolChangesTrackerDataSP state)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_strokeId);
 
     KisToolMoveState *newState = dynamic_cast<KisToolMoveState*>(state.data());
     KIS_SAFE_ASSERT_RECOVER_RETURN(newState);
 
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     m_accumulatedOffset = newState->accumulatedOffset;
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
     notifyGuiAfterMove();
 }
 
 void KisToolMove::slotMoveDiscreteLeft()
 {
     moveDiscrete(MoveDirection::Left, false);
 }
 
 void KisToolMove::slotMoveDiscreteRight()
 {
     moveDiscrete(MoveDirection::Right, false);
 }
 
 void KisToolMove::slotMoveDiscreteUp()
 {
     moveDiscrete(MoveDirection::Up, false);
 }
 
 void KisToolMove::slotMoveDiscreteDown()
 {
     moveDiscrete(MoveDirection::Down, false);
 }
 
 void KisToolMove::slotMoveDiscreteLeftMore()
 {
     moveDiscrete(MoveDirection::Left, true);
 }
 
 void KisToolMove::slotMoveDiscreteRightMore()
 {
     moveDiscrete(MoveDirection::Right, true);
 }
 
 void KisToolMove::slotMoveDiscreteUpMore()
 {
     moveDiscrete(MoveDirection::Up, true);
 }
 
 void KisToolMove::slotMoveDiscreteDownMore()
 {
     moveDiscrete(MoveDirection::Down, true);
 }
 
 void KisToolMove::cancelStroke()
 {
     if (!m_strokeId) return;
 
     if (m_asyncUpdateHelper.isActive()) {
         m_asyncUpdateHelper.cancelUpdateStream();
     }
 
     KisImageSP image = currentImage();
     image->cancelStroke(m_strokeId);
     m_strokeId.clear();
     m_changesTracker.reset();
     m_currentlyProcessingNodes.clear();
     m_accumulatedOffset = QPoint();
     notifyGuiAfterMove();
     qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
 }
 
 QWidget* KisToolMove::createOptionWidget()
 {
     return m_optionsWidget;
 }
 
 KisToolMove::MoveToolMode KisToolMove::moveToolMode() const
 {
     if (m_optionsWidget)
         return m_optionsWidget->mode();
     return MoveSelectedLayer;
 }
 
 QPoint KisToolMove::applyModifiers(Qt::KeyboardModifiers modifiers, QPoint pos)
 {
     QPoint move = pos - m_dragStart;
 
     // Snap to axis
     if (modifiers & Qt::ShiftModifier) {
         move = snapToClosestAxis(move);
     }
 
     // "Precision mode" - scale down movement by 1/5
     if (modifiers & Qt::AltModifier) {
         const qreal SCALE_FACTOR = .2;
         move = SCALE_FACTOR * move;
     }
 
     return m_dragStart + move;
 }
 
 void KisToolMove::moveBySpinX(int newX)
 {
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     if (!currentNode()->isEditable()) return; // Don't move invisible nodes
 
     if (startStrokeImpl(MoveSelectedLayer, 0)) {
         setMode(KisTool::PAINT_MODE);
     }
 
     m_accumulatedOffset.rx() =  newX - m_handlesRect.x();
 
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
     notifyGuiAfterMove(false);
     setMode(KisTool::HOVER_MODE);
 }
 
 void KisToolMove::moveBySpinY(int newY)
 {
     if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
     if (!currentNode()->isEditable()) return; // Don't move invisible nodes
 
     if (startStrokeImpl(MoveSelectedLayer, 0)) {
         setMode(KisTool::PAINT_MODE);
     }
 
     m_accumulatedOffset.ry() =  newY - m_handlesRect.y();
 
     image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
     notifyGuiAfterMove(false);
     setMode(KisTool::HOVER_MODE);
 }
 
 void KisToolMove::requestHandlesRectUpdate()
 {
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image(), currentNode(), canvas()->resourceManager());
     KisSelectionSP selection = resources->activeSelection();
 
     KisMoveBoundsCalculationJob *job = new KisMoveBoundsCalculationJob(this->selectedNodes(),
                                                                        selection, this);
     connect(job,
             SIGNAL(sigCalcualtionFinished(const QRect&)),
             SLOT(slotHandlesRectCalculated(const QRect &)));
 
     KisImageSP image = this->image();
     image->addSpontaneousJob(job);
 
     notifyGuiAfterMove(false);
 }
 
 void KisToolMove::slotNodeChanged(const KisNodeList &nodes)
 {
     if (m_strokeId && !tryEndPreviousStroke(nodes)) {
         return;
     }
     requestHandlesRectUpdate();
 }
 
 void KisToolMove::slotSelectionChanged()
 {
     if (m_strokeId) return;
     requestHandlesRectUpdate();
 }
 
 QList<QAction *> KisToolMoveFactory::createActionsImpl()
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
     QList<QAction *> actions = KisToolPaintFactoryBase::createActionsImpl();
 
     actions << actionRegistry->makeQAction("movetool-move-up");
     actions << actionRegistry->makeQAction("movetool-move-down");
     actions << actionRegistry->makeQAction("movetool-move-left");
     actions << actionRegistry->makeQAction("movetool-move-right");
     actions << actionRegistry->makeQAction("movetool-move-up-more");
     actions << actionRegistry->makeQAction("movetool-move-down-more");
     actions << actionRegistry->makeQAction("movetool-move-left-more");
     actions << actionRegistry->makeQAction("movetool-move-right-more");
     actions << actionRegistry->makeQAction("movetool-show-coordinates");
 
     return actions;
 
 }
diff --git a/plugins/tools/basictools/kis_tool_move.h b/plugins/tools/basictools/kis_tool_move.h
index d6271f06bb..f7f07666c8 100644
--- a/plugins/tools/basictools/kis_tool_move.h
+++ b/plugins/tools/basictools/kis_tool_move.h
@@ -1,208 +1,209 @@
 /*
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                2003 Patrick Julien  <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_MOVE_H_
 #define KIS_TOOL_MOVE_H_
 
 #include <KisToolPaintFactoryBase.h>
 #include <kis_types.h>
 #include <kis_tool.h>
 #include <flake/kis_node_shape.h>
 #include <kis_icon.h>
 #include <QKeySequence>
 #include <QWidget>
 #include <QGroupBox>
 #include <QRadioButton>
 #include "KisToolChangesTracker.h"
 #include "kis_signal_compressor.h"
 #include "kis_signal_auto_connection.h"
 #include "KisAsyncronousStrokeUpdateHelper.h"
 
 #include "kis_canvas2.h"
 
 
 class KoCanvasBase;
 class MoveToolOptionsWidget;
 class KisDocument;
 
 class KisToolMove : public KisTool
 {
     Q_OBJECT
     Q_ENUMS(MoveToolMode);
 public:
     KisToolMove(KoCanvasBase * canvas);
     ~KisToolMove() override;
 
     /**
      * @brief wantsAutoScroll
      * reimplemented from KoToolBase
      * there's an issue where autoscrolling with this tool never makes the
      * stroke end, so we return false here so that users don't get stuck with
      * the tool. See bug 362659
      * @return false
      */
     bool wantsAutoScroll() const override {
         return false;
     }
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
 
 public Q_SLOTS:
     void requestStrokeEnd() override;
     void requestStrokeCancellation() override;
     void requestUndoDuringStroke() override;
 
 protected Q_SLOTS:
     void resetCursorStyle() override;
 
 public:
     enum MoveToolMode {
         MoveSelectedLayer,
         MoveFirstLayer,
         MoveGroup
     };
 
     enum MoveDirection {
         Up,
         Down,
         Left,
         Right
     };
 
     void beginPrimaryAction(KoPointerEvent *event) override;
     void continuePrimaryAction(KoPointerEvent *event) override;
     void endPrimaryAction(KoPointerEvent *event) override;
 
     void beginAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void continueAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void endAlternateAction(KoPointerEvent *event, AlternateAction action) override;
 
     void mouseMoveEvent(KoPointerEvent *event) override;
 
     void startAction(KoPointerEvent *event, MoveToolMode mode);
     void continueAction(KoPointerEvent *event);
     void endAction(KoPointerEvent *event);
 
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
     QWidget *createOptionWidget() override;
     void updateUIUnit(int newUnit);
 
     MoveToolMode moveToolMode() const;
 
     void setShowCoordinates(bool value);
 
 public Q_SLOTS:
     void moveDiscrete(MoveDirection direction, bool big);
 
     void moveBySpinX(int newX);
     void moveBySpinY(int newY);
 
     void slotNodeChanged(const KisNodeList &nodes);
     void slotSelectionChanged();
     void commitChanges();
 
     void slotHandlesRectCalculated(const QRect &handlesRect);
 
 Q_SIGNALS:
     void moveToolModeChanged();
     void moveInNewPosition(QPoint);
 
 private:
     void drag(const QPoint& newPos);
     void cancelStroke();
     QPoint applyModifiers(Qt::KeyboardModifiers modifiers, QPoint pos);
 
     bool startStrokeImpl(MoveToolMode mode, const QPoint *pos);
 
     QPoint currentOffset() const;
     void notifyGuiAfterMove(bool showFloatingMessage = true);
     bool tryEndPreviousStroke(const KisNodeList &nodes);
     KisNodeList fetchSelectedNodes(MoveToolMode mode, const QPoint *pixelPoint, KisSelectionSP selection);
     void requestHandlesRectUpdate();
 
 
 private Q_SLOTS:
     void endStroke();
     void slotTrackerChangedConfig(KisToolChangesTrackerDataSP state);
 
     void slotMoveDiscreteLeft();
     void slotMoveDiscreteRight();
     void slotMoveDiscreteUp();
     void slotMoveDiscreteDown();
     void slotMoveDiscreteLeftMore();
     void slotMoveDiscreteRightMore();
     void slotMoveDiscreteUpMore();
     void slotMoveDiscreteDownMore();
 
 private:
 
     MoveToolOptionsWidget* m_optionsWidget {0};
     QPoint m_dragStart; ///< Point where current cursor dragging began
     QPoint m_accumulatedOffset; ///< Total offset including multiple clicks, up/down/left/right keys, etc. added together
 
     KisStrokeId m_strokeId;
 
     KisNodeList m_currentlyProcessingNodes;
 
     int m_resolution;
 
     QAction *m_showCoordinatesAction {0};
 
     QPoint m_dragPos;
     QRect m_handlesRect;
 
     KisToolChangesTracker m_changesTracker;
 
     QPoint m_lastCursorPos;
     KisSignalCompressor m_updateCursorCompressor;
     KisSignalAutoConnectionsStore m_actionConnections;
+    KisSignalAutoConnectionsStore m_canvasConnections;
 
     KisAsyncronousStrokeUpdateHelper m_asyncUpdateHelper;
 };
 
 
 class KisToolMoveFactory : public KisToolPaintFactoryBase
 {
 
 public:
     KisToolMoveFactory()
             : KisToolPaintFactoryBase("KritaTransform/KisToolMove") {
         setToolTip(i18n("Move Tool"));
         setSection(TOOL_TYPE_TRANSFORM);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
         setPriority(3);
         setIconName(koIconNameCStr("krita_tool_move"));
         setShortcut(QKeySequence(Qt::Key_T));
     }
 
     ~KisToolMoveFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase *canvas) override {
         return new KisToolMove(canvas);
     }
 
     QList<QAction *> createActionsImpl() override;
 };
 
 #endif // KIS_TOOL_MOVE_H_
 
diff --git a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
index 9bea3bdc80..1293d8f3a3 100644
--- a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
+++ b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
@@ -1,307 +1,307 @@
 /*
  * Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "ToolReferenceImages.h"
 
 #include <QDesktopServices>
 #include <QFile>
 #include <QLayout>
 #include <QMenu>
 #include <QMessageBox>
 #include <QVector>
 #include <QAction>
 
 #include <KoSelection.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeManager.h>
 #include <KoShapeController.h>
 #include <KoFileDialog.h>
 
 #include <kis_action_registry.h>
 #include <kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 #include <kis_image.h>
 
 #include "ToolReferenceImagesWidget.h"
 #include "KisReferenceImageCollection.h"
 
 ToolReferenceImages::ToolReferenceImages(KoCanvasBase * canvas)
     : DefaultTool(canvas, false)
 {
     setObjectName("ToolReferenceImages");
 }
 
 ToolReferenceImages::~ToolReferenceImages()
 {
 }
 
 void ToolReferenceImages::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     DefaultTool::activate(toolActivation, shapes);
 
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     connect(kisCanvas->image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)), this, SLOT(slotNodeAdded(KisNodeSP)));
     connect(kisCanvas->imageView()->document(), &KisDocument::sigReferenceImagesLayerChanged, this, &ToolReferenceImages::slotNodeAdded);
 
     auto referenceImageLayer = document()->referenceImagesLayer();
     if (referenceImageLayer) {
         setReferenceImageLayer(referenceImageLayer);
     }
 }
 
 void ToolReferenceImages::deactivate()
 {
     DefaultTool::deactivate();
 }
 
 void ToolReferenceImages::slotNodeAdded(KisNodeSP node)
 {
     auto *referenceImagesLayer = dynamic_cast<KisReferenceImagesLayer*>(node.data());
 
     if (referenceImagesLayer) {
         setReferenceImageLayer(referenceImagesLayer);
     }
 }
 
 void ToolReferenceImages::setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
 {
     m_layer = layer;
     connect(layer.data(), SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
 }
 
 void ToolReferenceImages::addReferenceImage()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImage");
     dialog.setCaption(i18n("Select a Reference Image"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     auto *reference = KisReferenceImage::fromFile(filename, *kisCanvas->coordinatesConverter(), canvas()->canvasWidget());
 
     if (reference) {
         KisDocument *doc = document();
         doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, {reference}));
     }
 }
 
 void ToolReferenceImages::pasteReferenceImage()
 {
     KisCanvas2* kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KisReferenceImage* reference = KisReferenceImage::fromClipboard(*kisCanvas->coordinatesConverter());
     if(reference) {
         KisDocument *doc = document();
         doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, {reference}));
     }
 }
 
 
 
 void ToolReferenceImages::removeAllReferenceImages()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     canvas()->addCommand(layer->removeReferenceImages(document(), layer->shapes()));
 }
 
 void ToolReferenceImages::loadReferenceImages()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Load Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1'.", filename));
         return;
     }
 
     KisReferenceImageCollection collection;
     if (collection.load(&file)) {
         QList<KoShape*> shapes;
         Q_FOREACH(auto *reference, collection.referenceImages()) {
             shapes.append(reference);
         }
 
         KisDocument *doc = document();
         doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, shapes));
     } else {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not load reference images from '%1'.", filename));
     }
     file.close();
 }
 
 void ToolReferenceImages::saveReferenceImages()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer || layer->shapeCount() == 0) return;
 
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
             KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::SaveFile, "SaveReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Save Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::WriteOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1' for saving.", filename));
         return;
     }
 
     KisReferenceImageCollection collection(layer->referenceImages());
     bool ok = collection.save(&file);
     file.close();
 
     if (!ok) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Failed to save reference images."));
     }
 }
 
 void ToolReferenceImages::slotSelectionChanged()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     m_optionsWidget->selectionChanged(layer->shapeManager()->selection());
     updateActions();
 }
 
 QList<QPointer<QWidget>> ToolReferenceImages::createOptionWidgets()
 {
     // Instead of inheriting DefaultTool's multi-tab implementation, inherit straight from KoToolBase
     return KoToolBase::createOptionWidgets();
 }
 
 QWidget *ToolReferenceImages::createOptionWidget()
 {
     if (!m_optionsWidget) {
         m_optionsWidget = new ToolReferenceImagesWidget(this);
         // See https://bugs.kde.org/show_bug.cgi?id=316896
         QWidget *specialSpacer = new QWidget(m_optionsWidget);
         specialSpacer->setObjectName("SpecialSpacer");
         specialSpacer->setFixedSize(0, 0);
         m_optionsWidget->layout()->addWidget(specialSpacer);
     }
     return m_optionsWidget;
 }
 
 bool ToolReferenceImages::isValidForCurrentLayer() const
 {
     return true;
 }
 
 KoShapeManager *ToolReferenceImages::shapeManager() const
 {
     auto layer = m_layer.toStrongRef();
     return layer ? layer->shapeManager() : nullptr;
 }
 
 KoSelection *ToolReferenceImages::koSelection() const
 {
     auto manager = shapeManager();
     return manager ? manager->selection() : nullptr;
 }
 
 void ToolReferenceImages::updateDistinctiveActions(const QList<KoShape*> &)
 {
     action("object_group")->setEnabled(false);
     action("object_unite")->setEnabled(false);
     action("object_intersect")->setEnabled(false);
     action("object_subtract")->setEnabled(false);
     action("object_split")->setEnabled(false);
     action("object_ungroup")->setEnabled(false);
 }
 
 void ToolReferenceImages::deleteSelection()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     QList<KoShape *> shapes = koSelection()->selectedShapes();
 
     if (!shapes.empty()) {
         canvas()->addCommand(layer->removeReferenceImages(document(), shapes));
     }
 }
 
 KisDocument *ToolReferenceImages::document() const
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     return kisCanvas->imageView()->document();
 }
 
 QList<QAction *> ToolReferenceImagesFactory::createActionsImpl()
 {
     QList<QAction *> defaultActions = DefaultToolFactory::createActionsImpl();
     QList<QAction *> actions;
 
     QStringList actionNames;
     actionNames << "object_order_front"
                 << "object_order_raise"
                 << "object_order_lower"
                 << "object_order_back"
                 << "object_transform_rotate_90_cw"
                 << "object_transform_rotate_90_ccw"
                 << "object_transform_rotate_180"
                 << "object_transform_mirror_horizontally"
                 << "object_transform_mirror_vertically"
                 << "object_transform_reset";
 
     Q_FOREACH(QAction *action, defaultActions) {
         if (actionNames.contains(action->objectName())) {
             actions << action;
         }
     }
     return actions;
 }
diff --git a/plugins/tools/selectiontools/KisToolSelectMagnetic.cc b/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
index 44f3bc1093..a25b234455 100644
--- a/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
+++ b/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
@@ -1,739 +1,739 @@
 /*
  *  Copyright (c) 2019 Kuntal Majumder <hellozee@disroot.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 "KisToolSelectMagnetic.h"
 
 #include <QApplication>
 #include <QPainter>
 #include <QWidget>
 #include <QPainterPath>
 #include <QLayout>
 #include <QVBoxLayout>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoShapeController.h>
 #include <KoPathShape.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KoViewConverter.h>
 
 #include <kis_layer.h>
 #include <kis_selection_options.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_registry.h>
 #include "canvas/kis_canvas2.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection_tool_helper.h"
 
 #include "kis_algebra_2d.h"
 
 #include "KisHandlePainterHelper.h"
 
 #include <kis_slider_spin_box.h>
 
 #define FEEDBACK_LINE_WIDTH 2
 
 KisToolSelectMagnetic::KisToolSelectMagnetic(KoCanvasBase *canvas)
     : KisToolSelect(canvas,
                     KisCursor::load("tool_magnetic_selection_cursor.png", 5, 5),
                     i18n("Magnetic Selection")),
     m_continuedMode(false), m_complete(false), m_selected(false), m_finished(false),
     m_worker(image()->projection()), m_threshold(70), m_searchRadius(30), m_anchorGap(30),
     m_filterRadius(3.0), m_mouseHoverCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
 
 { }
 
 void KisToolSelectMagnetic::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Control) {
         m_continuedMode = true;
     }
 
     KisToolSelect::keyPressEvent(event);
 }
 
 /*
  * Calculates the checkpoints responsible to determining the last point from where
  * the edge is calculated.
  * Takes 3 point, min, median and max, searches for an edge point from median to max, if fails,
  * searches for the same from median to min, if fails, median becomes that edge point.
  */
 void KisToolSelectMagnetic::calculateCheckPoints(vQPointF points)
 {
     qreal totalDistance = 0.0;
     int checkPoint      = 0;
     int finalPoint      = 2;
     int midPoint        = 1;
     int minPoint        = 0;
     qreal maxFactor     = 2;
 
     for (; finalPoint < points.count(); finalPoint++) {
         totalDistance += kisDistance(points[finalPoint], points[finalPoint - 1]);
 
         if (totalDistance <= m_anchorGap / 3) {
             minPoint = finalPoint;
         }
 
         if (totalDistance <= m_anchorGap) {
             midPoint = finalPoint;
         }
 
         if (totalDistance > maxFactor * m_anchorGap) {
             break;
         }
     }
 
     if (totalDistance > maxFactor * m_anchorGap) {
         bool foundSomething = false;
 
         for (int i = midPoint; i < finalPoint; i++) {
             if (m_worker.intensity(points.at(i).toPoint()) >= m_threshold) {
                 m_lastAnchor = points.at(i).toPoint();
                 m_anchorPoints.push_back(m_lastAnchor);
 
                 vQPointF temp;
                 for (int j = 0; j <= i; j++) {
                     temp.push_back(points[j]);
                 }
 
                 m_pointCollection.push_back(temp);
                 foundSomething = true;
                 checkPoint     = i;
                 break;
             }
         }
 
         if (!foundSomething) {
             for (int i = midPoint - 1; i >= minPoint; i--) {
                 if (m_worker.intensity(points.at(i).toPoint()) >= m_threshold) {
                     m_lastAnchor = points.at(i).toPoint();
                     m_anchorPoints.push_back(m_lastAnchor);
                     vQPointF temp;
                     for (int j = midPoint - 1; j >= i; j--) {
                         temp.push_front(points[j]);
                     }
 
                     m_pointCollection.push_back(temp);
                     foundSomething = true;
                     checkPoint     = i;
                     break;
                 }
             }
         }
 
         if (!foundSomething) {
             m_lastAnchor = points[midPoint].toPoint();
             m_anchorPoints.push_back(m_lastAnchor);
             vQPointF temp;
 
             for (int j = 0; j <= midPoint; j++) {
                 temp.push_back(points[j]);
             }
 
             m_pointCollection.push_back(temp);
             checkPoint     = midPoint;
             foundSomething = true;
         }
     }
 
     totalDistance = 0.0;
     reEvaluatePoints();
 
     for (; finalPoint < points.count(); finalPoint++) {
         totalDistance += kisDistance(points[finalPoint], points[checkPoint]);
         if (totalDistance > maxFactor * m_anchorGap) {
             points.remove(0, checkPoint + 1);
             calculateCheckPoints(points);
             break;
         }
     }
 } // KisToolSelectMagnetic::calculateCheckPoints
 
 void KisToolSelectMagnetic::keyReleaseEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Control ||
         !(event->modifiers() & Qt::ControlModifier))
     {
         m_continuedMode = false;
         if (mode() != PAINT_MODE && !m_points.isEmpty()) {
             finishSelectionAction();
         }
     }
 
     KisToolSelect::keyReleaseEvent(event);
 }
 
 vQPointF KisToolSelectMagnetic::computeEdgeWrapper(QPoint a, QPoint b)
 {
     return m_worker.computeEdge(m_searchRadius, a, b, m_filterRadius);
 }
 
 // the cursor is still tracked even when no mousebutton is pressed
 void KisToolSelectMagnetic::mouseMoveEvent(KoPointerEvent *event)
 {
     m_lastCursorPos = convertToPixelCoord(event);
     KisToolSelect::mouseMoveEvent(event);
     updatePaintPath();
 } // KisToolSelectMagnetic::mouseMoveEvent
 
 // press primary mouse button
 void KisToolSelectMagnetic::beginPrimaryAction(KoPointerEvent *event)
 {
     setMode(KisTool::PAINT_MODE);
     QPointF temp(convertToPixelCoord(event));
 
     if (!image()->bounds().contains(temp.toPoint())) {
         return;
     }
 
     m_cursorOnPress = temp;
 
     checkIfAnchorIsSelected(temp);
 
     if (m_complete || m_selected) {
         return;
     }
 
     if (m_anchorPoints.count() != 0) {
         vQPointF edge = computeEdgeWrapper(m_anchorPoints.last(), temp.toPoint());
         m_points.append(edge);
         m_pointCollection.push_back(edge);
     } else {
         updateInitialAnchorBounds(temp.toPoint());
     }
 
     m_lastAnchor = temp.toPoint();
     m_anchorPoints.push_back(m_lastAnchor);
     m_lastCursorPos = temp;
     reEvaluatePoints();
     updateCanvasPixelRect(image()->bounds());
 } // KisToolSelectMagnetic::beginPrimaryAction
 
 void KisToolSelectMagnetic::checkIfAnchorIsSelected(QPointF temp)
 {
     Q_FOREACH (const QPoint pt, m_anchorPoints) {
         qreal zoomLevel = canvas()->viewConverter()->zoom();
         int sides       = (int) std::ceil(10.0 / zoomLevel);
         QRect r         = QRect(QPoint(0, 0), QSize(sides, sides));
         r.moveCenter(pt);
         if (r.contains(temp.toPoint())) {
             m_selected       = true;
             m_selectedAnchor = m_anchorPoints.lastIndexOf(pt);
             return;
         }
     }
 }
 
 void KisToolSelectMagnetic::beginPrimaryDoubleClickAction(KoPointerEvent *event)
 {
     QPointF temp = convertToPixelCoord(event);
 
     if (!image()->bounds().contains(temp.toPoint())) {
         return;
     }
 
     checkIfAnchorIsSelected(temp);
 
     if (m_selected) {
         deleteSelectedAnchor();
         return;
     }
 
     if (m_complete) {
         int pointA = 0, pointB = 1;
         double dist = std::numeric_limits<double>::max();
         int total   = m_anchorPoints.count();
         for (int i = 0; i < total; i++) {
             double distToCompare = kisDistance(m_anchorPoints[i], temp) +
                                    kisDistance(temp, m_anchorPoints[(i + 1) % total]);
             if (distToCompare < dist) {
                 pointA = i;
                 pointB = (i + 1) % total;
                 dist   = distToCompare;
             }
         }
 
         vQPointF path1 = computeEdgeWrapper(m_anchorPoints[pointA], temp.toPoint());
         vQPointF path2 = computeEdgeWrapper(temp.toPoint(), m_anchorPoints[pointB]);
 
         m_pointCollection[pointA] = path1;
         m_pointCollection.insert(pointB, path2);
         m_anchorPoints.insert(pointB, temp.toPoint());
 
         reEvaluatePoints();
     }
 } // KisToolSelectMagnetic::beginPrimaryDoubleClickAction
 
 // drag while primary mouse button is pressed
 void KisToolSelectMagnetic::continuePrimaryAction(KoPointerEvent *event)
 {
     if (m_selected) {
         m_anchorPoints[m_selectedAnchor] = convertToPixelCoord(event).toPoint();
     } else if (!m_complete) {
         m_lastCursorPos = convertToPixelCoord(event);
         if(kisDistance(m_lastCursorPos, m_cursorOnPress) >= m_anchorGap)
             m_mouseHoverCompressor.start();
     }
     KisToolSelectBase::continuePrimaryAction(event);
 }
 
 void KisToolSelectMagnetic::slotCalculateEdge()
 {
     QPoint current    = m_lastCursorPos.toPoint();
     if (!image()->bounds().contains(current))
         return;
 
     if(kisDistance(m_lastAnchor, current) < m_anchorGap)
         return;
 
     vQPointF pointSet = computeEdgeWrapper(m_lastAnchor, current);
     calculateCheckPoints(pointSet);
 }
 
 // release primary mouse button
 void KisToolSelectMagnetic::endPrimaryAction(KoPointerEvent *event)
 {
     if (m_selected && convertToPixelCoord(event) != m_cursorOnPress) {
         if (!image()->bounds().contains(m_anchorPoints[m_selectedAnchor])) {
             deleteSelectedAnchor();
         } else {
             updateSelectedAnchor();
         }
     } else if (m_selected) {
         QPointF temp(convertToPixelCoord(event));
 
         if (!image()->bounds().contains(temp.toPoint())) {
             return;
         }
 
         if (m_snapBound.contains(temp) && m_anchorPoints.count() > 1) {
             if(m_complete){
                 finishSelectionAction();
                 return;
             }
             vQPointF edge = computeEdgeWrapper(m_anchorPoints.last(), temp.toPoint());
             m_points.append(edge);
             m_pointCollection.push_back(edge);
             m_complete = true;
         }
     }
     if (m_mouseHoverCompressor.isActive()) {
         m_mouseHoverCompressor.stop();
         slotCalculateEdge();
     }
     m_selected = false;
     KisToolSelectBase::endPrimaryAction(event);
 } // KisToolSelectMagnetic::endPrimaryAction
 
 void KisToolSelectMagnetic::deleteSelectedAnchor()
 {
     if (m_anchorPoints.isEmpty())
         return;
 
     // if it is the initial anchor
     if (m_selectedAnchor == 0) {
         m_anchorPoints.pop_front();
         if (m_anchorPoints.isEmpty()) {
             // it was the only point lol
             resetVariables();
             reEvaluatePoints();
             return;
         }
         m_pointCollection.pop_front();
         if (m_complete) {
             m_pointCollection[0] = computeEdgeWrapper(m_anchorPoints.first(), m_anchorPoints.last());
         }
         reEvaluatePoints();
         return;
     }
 
     // if it is the last anchor
     if (m_selectedAnchor == m_anchorPoints.count() - 1) {
         m_anchorPoints.pop_back();
         m_pointCollection.pop_back();
         if (m_complete) {
             m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints.last(), m_anchorPoints.first());
         }
         reEvaluatePoints();
         return;
     }
 
     // it is in the middle
     m_anchorPoints.remove(m_selectedAnchor);
     m_pointCollection.remove(m_selectedAnchor);
     m_pointCollection[m_selectedAnchor - 1] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                                                                  m_anchorPoints[m_selectedAnchor]);
     reEvaluatePoints();
 } // KisToolSelectMagnetic::deleteSelectedAnchor
 
 void KisToolSelectMagnetic::updateSelectedAnchor()
 {
     // initial
     if (m_selectedAnchor == 0 && m_anchorPoints.count() > 1) {
         m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints[0], m_anchorPoints[1]);
         if (m_complete) {
             m_pointCollection[m_anchorPoints.count() - 1] = computeEdgeWrapper(m_anchorPoints.last(),
                                                                                m_anchorPoints.first());
         }
         reEvaluatePoints();
         return;
     }
 
     // last
     if (m_selectedAnchor == m_anchorPoints.count() - 1) {
         m_pointCollection[m_selectedAnchor - 1] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                                                                      m_anchorPoints.last());
         if (m_complete) {
             m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints.last(), m_anchorPoints.first());
         }
         reEvaluatePoints();
         return;
     }
 
     // middle
     m_pointCollection[m_selectedAnchor - 1] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                                                                  m_anchorPoints[m_selectedAnchor]);
     m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints[m_selectedAnchor],
                                                              m_anchorPoints[m_selectedAnchor + 1]);
     reEvaluatePoints();
 }
 
 int KisToolSelectMagnetic::updateInitialAnchorBounds(QPoint pt)
 {
     qreal zoomLevel = canvas()->viewConverter()->zoom();
     int sides       = (int) std::ceil(10.0 / zoomLevel);
     m_snapBound = QRectF(QPoint(0, 0), QSize(sides, sides));
     m_snapBound.moveCenter(pt);
     return sides;
 }
 
 void KisToolSelectMagnetic::reEvaluatePoints()
 {
     m_points.clear();
     Q_FOREACH (const vQPointF vec, m_pointCollection) {
         m_points.append(vec);
     }
 
     updatePaintPath();
 }
 
 void KisToolSelectMagnetic::finishSelectionAction()
 {
     KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
     setMode(KisTool::HOVER_MODE);
     m_complete = false;
     m_finished = true;
 
     // just for testing out
     // m_worker.saveTheImage(m_points);
 
     QRectF boundingViewRect =
         pixelToView(KisAlgebra2D::accumulateBounds(m_points));
 
     KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Magnetic Selection"));
 
     if (m_points.count() > 2 &&
         !helper.tryDeselectCurrentSelection(boundingViewRect, selectionAction()))
     {
         QApplication::setOverrideCursor(KisCursor::waitCursor());
 
         const SelectionMode mode =
             helper.tryOverrideSelectionMode(kisCanvas->viewManager()->selection(),
                                             selectionMode(),
                                             selectionAction());
         if (mode == PIXEL_SELECTION) {
             KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
 
             KisPainter painter(tmpSel);
             painter.setPaintColor(KoColor(Qt::black, tmpSel->colorSpace()));
             painter.setAntiAliasPolygonFill(antiAliasSelection());
             painter.setFillStyle(KisPainter::FillStyleForegroundColor);
             painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
             painter.paintPolygon(m_points);
 
             QPainterPath cache;
             cache.addPolygon(m_points);
             cache.closeSubpath();
             tmpSel->setOutlineCache(cache);
 
             helper.selectPixelSelection(tmpSel, selectionAction());
         } else {
             KoPathShape *path = new KoPathShape();
             path->setShapeId(KoPathShapeId);
 
             QTransform resolutionMatrix;
             resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
             path->moveTo(resolutionMatrix.map(m_points[0]));
             for (int i = 1; i < m_points.count(); i++)
                 path->lineTo(resolutionMatrix.map(m_points[i]));
             path->close();
             path->normalize();
             helper.addSelectionShape(path, selectionAction());
         }
         QApplication::restoreOverrideCursor();
     }
 
     resetVariables();
 } // KisToolSelectMagnetic::finishSelectionAction
 
 void KisToolSelectMagnetic::resetVariables()
 {
     m_points.clear();
     m_anchorPoints.clear();
     m_pointCollection.clear();
     m_paintPath = QPainterPath();
 }
 
 void KisToolSelectMagnetic::updatePaintPath()
 {
     m_paintPath = QPainterPath();
     if (m_points.size() > 0) {
         m_paintPath.moveTo(pixelToView(m_points[0]));
     }
     for (int i = 1; i < m_points.count(); i++) {
         m_paintPath.lineTo(pixelToView(m_points[i]));
     }
 
     updateFeedback();
 
     if (m_continuedMode && mode() != PAINT_MODE) {
         updateContinuedMode();
     }
 
     updateCanvasPixelRect(image()->bounds());
 }
 
 void KisToolSelectMagnetic::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter)
     updatePaintPath();
     if ((mode() == KisTool::PAINT_MODE || m_continuedMode) &&
         !m_anchorPoints.isEmpty())
     {
         QPainterPath outline = m_paintPath;
         if (m_continuedMode && mode() != KisTool::PAINT_MODE) {
             outline.lineTo(pixelToView(m_lastCursorPos));
         }
         paintToolOutline(&gc, outline);
         drawAnchors(gc);
     }
 }
 
 void KisToolSelectMagnetic::drawAnchors(QPainter &gc)
 {
     int sides = updateInitialAnchorBounds(m_anchorPoints.first());
     Q_FOREACH (const QPoint pt, m_anchorPoints) {
         KisHandlePainterHelper helper(&gc, handleRadius());
         QRect r(QPoint(0, 0), QSize(sides, sides));
         r.moveCenter(pt);
         if (r.contains(m_lastCursorPos.toPoint())) {
             helper.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles());
         } else {
             helper.setHandleStyle(KisHandleStyle::primarySelection());
         }
         helper.drawHandleRect(pixelToView(pt), 4, QPoint(0, 0));
     }
 }
 
 void KisToolSelectMagnetic::updateFeedback()
 {
     if (m_points.count() > 1) {
         qint32 lastPointIndex = m_points.count() - 1;
 
         QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_points[lastPointIndex]).normalized();
         updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
         updateCanvasPixelRect(updateRect);
     }
 }
 
 void KisToolSelectMagnetic::updateContinuedMode()
 {
     if (!m_points.isEmpty()) {
         qint32 lastPointIndex = m_points.count() - 1;
 
         QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_lastCursorPos).normalized();
         updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
         updateCanvasPixelRect(updateRect);
     }
 }
 
 void KisToolSelectMagnetic::activate(KoToolBase::ToolActivation activation, const QSet<KoShape *> &shapes)
 {
     m_worker      = KisMagneticWorker(image()->projection());
     m_configGroup = KSharedConfig::openConfig()->group(toolId());
     connect(action("undo_polygon_selection"), SIGNAL(triggered()), SLOT(undoPoints()), Qt::UniqueConnection);
     connect(&m_mouseHoverCompressor, SIGNAL(timeout()), this, SLOT(slotCalculateEdge()));
     KisToolSelect::activate(activation, shapes);
 }
 
 void KisToolSelectMagnetic::deactivate()
 {
     KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
-    KIS_ASSERT_RECOVER_RETURN(kisCanvas)
+    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
     resetVariables();
     m_continuedMode = false;
     disconnect(action("undo_polygon_selection"), nullptr, this, nullptr);
 
     KisTool::deactivate();
 }
 
 void KisToolSelectMagnetic::undoPoints()
 {
     if (m_complete) return;
 
     if(m_anchorPoints.count() <= 1){
         resetVariables();
         return;
     }
 
     m_anchorPoints.pop_back();
     m_pointCollection.pop_back();
     reEvaluatePoints();
 }
 
 void KisToolSelectMagnetic::requestStrokeEnd()
 {
     if (m_finished || m_anchorPoints.count() < 2) return;
 
     finishSelectionAction();
     m_finished = false;
 }
 
 void KisToolSelectMagnetic::requestStrokeCancellation()
 {
     m_complete = false;
     m_finished = false;
     resetVariables();
 }
 
 QWidget * KisToolSelectMagnetic::createOptionWidget()
 {
     KisToolSelectBase::createOptionWidget();
     KisSelectionOptions *selectionWidget = selectionOptionWidget();
     QHBoxLayout *f1 = new QHBoxLayout();
     QLabel *filterRadiusLabel = new QLabel(i18n("Filter Radius: "), selectionWidget);
     f1->addWidget(filterRadiusLabel);
 
     KisDoubleSliderSpinBox *filterRadiusInput = new KisDoubleSliderSpinBox(selectionWidget);
     filterRadiusInput->setObjectName("radius");
     filterRadiusInput->setRange(2.5, 100.0, 2);
     filterRadiusInput->setSingleStep(0.5);
     filterRadiusInput->setToolTip("Radius of the filter for the detecting edges, might take some time to calculate");
     f1->addWidget(filterRadiusInput);
     connect(filterRadiusInput, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetFilterRadius(qreal)));
 
     QHBoxLayout *f2        = new QHBoxLayout();
     QLabel *thresholdLabel = new QLabel(i18n("Threshold: "), selectionWidget);
     f2->addWidget(thresholdLabel);
 
     KisSliderSpinBox *thresholdInput = new KisSliderSpinBox(selectionWidget);
     thresholdInput->setObjectName("threshold");
     thresholdInput->setRange(1, 255);
     thresholdInput->setSingleStep(10);
     thresholdInput->setToolTip("Threshold for determining the minimum intensity of the edges");
     f2->addWidget(thresholdInput);
     connect(thresholdInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetThreshold(int)));
 
     QHBoxLayout *f3 = new QHBoxLayout();
     QLabel *searchRadiusLabel = new QLabel(i18n("Search Radius: "), selectionWidget);
     f3->addWidget(searchRadiusLabel);
 
     KisSliderSpinBox *searchRadiusInput = new KisSliderSpinBox(selectionWidget);
     searchRadiusInput->setObjectName("frequency");
     searchRadiusInput->setRange(20, 200);
     searchRadiusInput->setSingleStep(10);
     searchRadiusInput->setToolTip("Extra area to be searched");
     searchRadiusInput->setSuffix(" px");
     f3->addWidget(searchRadiusInput);
     connect(searchRadiusInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetSearchRadius(int)));
 
     QHBoxLayout *f4        = new QHBoxLayout();
     QLabel *anchorGapLabel = new QLabel(i18n("Anchor Gap: "), selectionWidget);
     f4->addWidget(anchorGapLabel);
 
     KisSliderSpinBox *anchorGapInput = new KisSliderSpinBox(selectionWidget);
     anchorGapInput->setObjectName("anchorgap");
     anchorGapInput->setRange(20, 200);
     anchorGapInput->setSingleStep(10);
     anchorGapInput->setToolTip("Gap between 2 anchors in interative mode");
     anchorGapInput->setSuffix(" px");
     f4->addWidget(anchorGapInput);
 
     connect(anchorGapInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetAnchorGap(int)));
 
     QVBoxLayout *l = dynamic_cast<QVBoxLayout *>(selectionWidget->layout());
 
     l->insertLayout(1, f1);
     l->insertLayout(2, f2);
     l->insertLayout(3, f3);
     l->insertLayout(5, f4);
 
     filterRadiusInput->setValue(m_configGroup.readEntry("filterradius", 3.0));
     thresholdInput->setValue(m_configGroup.readEntry("threshold", 100));
     searchRadiusInput->setValue(m_configGroup.readEntry("searchradius", 30));
     anchorGapInput->setValue(m_configGroup.readEntry("anchorgap", 20));
 
     return selectionWidget;
 } // KisToolSelectMagnetic::createOptionWidget
 
 void KisToolSelectMagnetic::slotSetFilterRadius(qreal r)
 {
     m_filterRadius = r;
     m_configGroup.writeEntry("filterradius", r);
 }
 
 void KisToolSelectMagnetic::slotSetThreshold(int t)
 {
     m_threshold = t;
     m_configGroup.writeEntry("threshold", t);
 }
 
 void KisToolSelectMagnetic::slotSetSearchRadius(int r)
 {
     m_searchRadius = r;
     m_configGroup.writeEntry("searchradius", r);
 }
 
 void KisToolSelectMagnetic::slotSetAnchorGap(int g)
 {
     m_anchorGap = g;
     m_configGroup.writeEntry("anchorgap", g);
 }
 
 void KisToolSelectMagnetic::resetCursorStyle()
 {
     if (selectionAction() == SELECTION_ADD) {
         useCursor(KisCursor::load("tool_magnetic_selection_cursor_add.png", 6, 6));
     } else if (selectionAction() == SELECTION_SUBTRACT) {
         useCursor(KisCursor::load("tool_magnetic_selection_cursor_sub.png", 6, 6));
     } else {
         KisToolSelect::resetCursorStyle();
     }
 }
diff --git a/plugins/tools/tool_polygon/kis_tool_polygon.cc b/plugins/tools/tool_polygon/kis_tool_polygon.cc
index 9644f53682..c886ab38fc 100644
--- a/plugins/tools/tool_polygon/kis_tool_polygon.cc
+++ b/plugins/tools/tool_polygon/kis_tool_polygon.cc
@@ -1,81 +1,86 @@
 /*
  *  kis_tool_polygon.cc -- part of Krita
  *
  *  Copyright (c) 2004 Michael Thaler <michael.thaler@physik.tu-muenchen.de>
  *  Copyright (c) 2009 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  * Copyright (C) 2010 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_tool_polygon.h"
 
 #include <KoPointerEvent.h>
 #include <KoCanvasBase.h>
 #include <KoPathShape.h>
 #include <KoShapeStroke.h>
 
 #include <brushengine/kis_paintop_registry.h>
 #include "kis_figure_painting_tool_helper.h"
 
 KisToolPolygon::KisToolPolygon(KoCanvasBase *canvas)
         : KisToolPolylineBase(canvas,  KisToolPolylineBase::PAINT, KisCursor::load("tool_polygon_cursor.png", 6, 6))
 {
     setObjectName("tool_polygon");
     setSupportOutline(true);
 }
 
 KisToolPolygon::~KisToolPolygon()
 {
 }
 
 void KisToolPolygon::resetCursorStyle()
 {
     KisToolPolylineBase::resetCursorStyle();
     overrideCursorIfNotEditable();
 }
 
 void KisToolPolygon::finishPolyline(const QVector<QPointF>& points)
 {
     const KisToolShape::ShapeAddInfo info =
         shouldAddShape(currentNode());
 
     if (!info.shouldAddShape) {
         KisFigurePaintingToolHelper helper(kundo2_i18n("Draw Polygon"),
                                            image(),
                                            currentNode(),
                                            canvas()->resourceManager(),
                                            strokeStyle(),
                                            fillStyle());
         helper.paintPolygon(points);
     } else {
+        // remove the last point if it overlaps with the first
+        QVector<QPointF> newPoints = points;
+        if (newPoints.size() > 1 && newPoints.first() == newPoints.last()) {
+            newPoints.removeLast();
+        }
         KoPathShape* path = new KoPathShape();
         path->setShapeId(KoPathShapeId);
 
         QTransform resolutionMatrix;
         resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
-        path->moveTo(resolutionMatrix.map(points[0]));
-        for (int i = 1; i < points.count(); i++)
-            path->lineTo(resolutionMatrix.map(points[i]));
+        path->moveTo(resolutionMatrix.map(newPoints[0]));
+        for (int i = 1; i < newPoints.size(); i++)
+            path->lineTo(resolutionMatrix.map(newPoints[i]));
         path->close();
         path->normalize();
 
         info.markAsSelectionShapeIfNeeded(path);
 
         addShape(path);
     }
 }
 
diff --git a/plugins/tools/tool_transform2/kis_tool_transform.cc b/plugins/tools/tool_transform2/kis_tool_transform.cc
index 6bb1debe59..32ace87044 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform.cc
+++ b/plugins/tools/tool_transform2/kis_tool_transform.cc
@@ -1,1139 +1,1125 @@
 /*
  *  kis_tool_transform.cc -- part of Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2010 Marc Pegon <pe.marc@free.fr>
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_transform.h"
 
 
 #include <math.h>
 #include <limits>
 
 #include <QPainter>
 #include <QPen>
 #include <QPushButton>
 #include <QObject>
 #include <QLabel>
 #include <QComboBox>
 #include <QApplication>
 #include <QMatrix4x4>
 #include <QMenu>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoID.h>
 #include <KoCanvasBase.h>
 #include <KoViewConverter.h>
 #include <KoSelection.h>
 #include <KoCompositeOp.h>
 
 #include <kis_global.h>
 #include <canvas/kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_painter.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 #include <kis_undo_adapter.h>
 #include <kis_transaction.h>
 #include <kis_selection.h>
 #include <kis_filter_strategy.h>
 #include <widgets/kis_cmb_idlist.h>
 #include <kis_statusbar.h>
 #include <kis_transform_worker.h>
 #include <kis_perspectivetransform_worker.h>
 #include <kis_warptransform_worker.h>
 #include <kis_pixel_selection.h>
 #include <kis_shape_selection.h>
 #include <kis_selection_manager.h>
 #include <krita_utils.h>
 #include <kis_resources_snapshot.h>
 
 #include <KoShapeTransformCommand.h>
 
 #include "widgets/kis_progress_widget.h"
 
 #include "kis_transform_utils.h"
 #include "kis_warp_transform_strategy.h"
 #include "kis_cage_transform_strategy.h"
 #include "kis_liquify_transform_strategy.h"
 #include "kis_free_transform_strategy.h"
 #include "kis_perspective_transform_strategy.h"
 
 #include "kis_transform_mask.h"
 #include "kis_transform_mask_adapter.h"
 
 #include "krita_container_utils.h"
 #include "kis_layer_utils.h"
 #include <KisDelayedUpdateNodeInterface.h>
 
 #include "strokes/transform_stroke_strategy.h"
 
 KisToolTransform::KisToolTransform(KoCanvasBase * canvas)
     : KisTool(canvas, KisCursor::rotateCursor())
     , m_workRecursively(true)
     , m_warpStrategy(
         new KisWarpTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             m_currentArgs, m_transaction))
     , m_cageStrategy(
         new KisCageTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             m_currentArgs, m_transaction))
     , m_liquifyStrategy(
         new KisLiquifyTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             m_currentArgs, m_transaction, canvas->resourceManager()))
     , m_freeStrategy(
         new KisFreeTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
             m_currentArgs, m_transaction))
     , m_perspectiveStrategy(
         new KisPerspectiveTransformStrategy(
             dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
             dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
             m_currentArgs, m_transaction))
 {
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
     Q_ASSERT(m_canvas);
 
     setObjectName("tool_transform");
     useCursor(KisCursor::selectCursor());
     m_optionsWidget = 0;
 
     warpAction = new KisAction(i18n("Warp"));
     liquifyAction = new KisAction(i18n("Liquify"));
     cageAction = new KisAction(i18n("Cage"));
     freeTransformAction = new KisAction(i18n("Free"));
     perspectiveAction = new KisAction(i18n("Perspective"));
 
     // extra actions for free transform that are in the tool options
     mirrorHorizontalAction = new KisAction(i18n("Mirror Horizontal"));
     mirrorVericalAction = new KisAction(i18n("Mirror Vertical"));
     rotateNinteyCWAction = new KisAction(i18n("Rotate 90 degrees Clockwise"));
     rotateNinteyCCWAction = new KisAction(i18n("Rotate 90 degrees CounterClockwise"));
 
     applyTransformation = new KisAction(i18n("Apply"));
     resetTransformation = new KisAction(i18n("Reset"));
 
     m_contextMenu.reset(new QMenu());
 
     connect(m_warpStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_cageStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_liquifyStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_liquifyStrategy.data(), SIGNAL(requestCursorOutlineUpdate(QPointF)), SLOT(cursorOutlineUpdateRequested(QPointF)));
     connect(m_liquifyStrategy.data(), SIGNAL(requestUpdateOptionWidget()), SLOT(updateOptionWidget()));
     connect(m_freeStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_freeStrategy.data(), SIGNAL(requestResetRotationCenterButtons()), SLOT(resetRotationCenterButtonsRequested()));
     connect(m_freeStrategy.data(), SIGNAL(requestShowImageTooBig(bool)), SLOT(imageTooBigRequested(bool)));
     connect(m_perspectiveStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
     connect(m_perspectiveStrategy.data(), SIGNAL(requestShowImageTooBig(bool)), SLOT(imageTooBigRequested(bool)));
 
     connect(&m_changesTracker, SIGNAL(sigConfigChanged(KisToolChangesTrackerDataSP)),
             this, SLOT(slotTrackerChangedConfig(KisToolChangesTrackerDataSP)));
 }
 
 KisToolTransform::~KisToolTransform()
 {
     cancelStroke();
 }
 
 void KisToolTransform::outlineChanged()
 {
     emit freeTransformChanged();
     m_canvas->updateCanvas();
 }
 
 void KisToolTransform::canvasUpdateRequested()
 {
     m_canvas->updateCanvas();
 }
 
 void KisToolTransform::resetCursorStyle()
 {
     setFunctionalCursor();
 }
 
 void KisToolTransform::resetRotationCenterButtonsRequested()
 {
     if (!m_optionsWidget) return;
     m_optionsWidget->resetRotationCenterButtons();
 }
 
 void KisToolTransform::imageTooBigRequested(bool value)
 {
     if (!m_optionsWidget) return;
     m_optionsWidget->setTooBigLabelVisible(value);
 }
 
 KisTransformStrategyBase* KisToolTransform::currentStrategy() const
 {
     if (m_currentArgs.mode() == ToolTransformArgs::FREE_TRANSFORM) {
         return m_freeStrategy.data();
     } else if (m_currentArgs.mode() == ToolTransformArgs::WARP) {
         return m_warpStrategy.data();
     } else if (m_currentArgs.mode() == ToolTransformArgs::CAGE) {
         return m_cageStrategy.data();
     } else if (m_currentArgs.mode() == ToolTransformArgs::LIQUIFY) {
         return m_liquifyStrategy.data();
     } else /* if (m_currentArgs.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) */ {
         return m_perspectiveStrategy.data();
     }
 }
 
 void KisToolTransform::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     if (!m_strokeId || !m_transaction.rootNode()) return;
 
     QRectF newRefRect = KisTransformUtils::imageToFlake(m_canvas->coordinatesConverter(), QRectF(0.0,0.0,1.0,1.0));
     if (m_refRect != newRefRect) {
         m_refRect = newRefRect;
         currentStrategy()->externalConfigChanged();
     }
 
-    gc.save();
-    if (m_optionsWidget && m_optionsWidget->showDecorations()) {
-        gc.setOpacity(0.3);
-        gc.fillPath(m_selectionPath, Qt::black);
-    }
-    gc.restore();
-
     currentStrategy()->paint(gc);
 
 
     if (!m_cursorOutline.isEmpty()) {
         QPainterPath mappedOutline =
             KisTransformUtils::imageToFlakeTransform(
                 m_canvas->coordinatesConverter()).map(m_cursorOutline);
         paintToolOutline(&gc, mappedOutline);
     }
 }
 
 void KisToolTransform::setFunctionalCursor()
 {
     if (overrideCursorIfNotEditable()) {
         return;
     }
 
     if (!m_strokeId) {
         useCursor(KisCursor::pointingHandCursor());
     } else if (m_strokeId && !m_transaction.rootNode()) {
         // we are in the middle of stroke initialization
         useCursor(KisCursor::waitCursor());
     } else {
         useCursor(currentStrategy()->getCurrentCursor());
     }
 }
 
 void KisToolTransform::cursorOutlineUpdateRequested(const QPointF &imagePos)
 {
     QRect canvasUpdateRect;
 
     if (!m_cursorOutline.isEmpty()) {
         canvasUpdateRect = m_canvas->coordinatesConverter()->
             imageToDocument(m_cursorOutline.boundingRect()).toAlignedRect();
     }
 
     m_cursorOutline = currentStrategy()->
         getCursorOutline().translated(imagePos);
 
     if (!m_cursorOutline.isEmpty()) {
         canvasUpdateRect |=
             m_canvas->coordinatesConverter()->
             imageToDocument(m_cursorOutline.boundingRect()).toAlignedRect();
     }
 
     if (!canvasUpdateRect.isEmpty()) {
         // grow rect a bit to follow interpolation fuzziness
         canvasUpdateRect = kisGrowRect(canvasUpdateRect, 2);
         m_canvas->updateCanvas(canvasUpdateRect);
     }
 }
 
 void KisToolTransform::beginActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)
 {
     if (!nodeEditable()) {
         event->ignore();
         return;
     }
 
     if (!m_strokeId) {
         startStroke(m_currentArgs.mode(), false);
     } else if (m_transaction.rootNode()) {
         bool result = false;
 
         if (usePrimaryAction) {
             result = currentStrategy()->beginPrimaryAction(event);
         } else {
             result = currentStrategy()->beginAlternateAction(event, action);
         }
 
         if (result) {
             setMode(KisTool::PAINT_MODE);
         }
     }
 
     m_actuallyMoveWhileSelected = false;
 
     outlineChanged();
 }
 
 void KisToolTransform::continueActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)
 {
     if (mode() != KisTool::PAINT_MODE) return;
     if (!m_transaction.rootNode()) return;
 
     m_actuallyMoveWhileSelected = true;
 
     if (usePrimaryAction) {
         currentStrategy()->continuePrimaryAction(event);
     } else {
         currentStrategy()->continueAlternateAction(event, action);
     }
 
     updateOptionWidget();
     outlineChanged();
 }
 
 void KisToolTransform::endActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)
 {
     if (mode() != KisTool::PAINT_MODE) return;
 
     setMode(KisTool::HOVER_MODE);
 
     if (m_actuallyMoveWhileSelected ||
         currentStrategy()->acceptsClicks()) {
 
         bool result = false;
 
         if (usePrimaryAction) {
             result = currentStrategy()->endPrimaryAction(event);
         } else {
             result = currentStrategy()->endAlternateAction(event, action);
         }
 
         if (result) {
             commitChanges();
         }
 
         outlineChanged();
     }
 
     updateOptionWidget();
     updateApplyResetAvailability();
 }
 
 QMenu*  KisToolTransform::popupActionsMenu()
 {
     if (m_contextMenu) {
         m_contextMenu->clear();
 
         m_contextMenu->addSection(i18n("Transform Tool Actions"));
         m_contextMenu->addSeparator();
         // add a quick switch to different transform types
         m_contextMenu->addAction(freeTransformAction);
         m_contextMenu->addAction(perspectiveAction);
         m_contextMenu->addAction(warpAction);
         m_contextMenu->addAction(cageAction);
         m_contextMenu->addAction(liquifyAction);
 
         // extra options if free transform is selected
         if (transformMode() == FreeTransformMode) {
             m_contextMenu->addSeparator();
             m_contextMenu->addAction(mirrorHorizontalAction);
             m_contextMenu->addAction(mirrorVericalAction);
             m_contextMenu->addAction(rotateNinteyCWAction);
             m_contextMenu->addAction(rotateNinteyCCWAction);
         }
 
         m_contextMenu->addSeparator();
         m_contextMenu->addAction(applyTransformation);
         m_contextMenu->addAction(resetTransformation);
     }
 
     return m_contextMenu.data();
 }
 
 void KisToolTransform::beginPrimaryAction(KoPointerEvent *event)
 {
     beginActionImpl(event, true, KisTool::NONE);
 }
 
 void KisToolTransform::continuePrimaryAction(KoPointerEvent *event)
 {
     continueActionImpl(event, true, KisTool::NONE);
 }
 
 void KisToolTransform::endPrimaryAction(KoPointerEvent *event)
 {
     endActionImpl(event, true, KisTool::NONE);
 }
 
 void KisToolTransform::activatePrimaryAction()
 {
     currentStrategy()->activatePrimaryAction();
     setFunctionalCursor();
 }
 
 void KisToolTransform::deactivatePrimaryAction()
 {
     currentStrategy()->deactivatePrimaryAction();
 }
 
 void KisToolTransform::activateAlternateAction(AlternateAction action)
 {
     currentStrategy()->activateAlternateAction(action);
     setFunctionalCursor();
 }
 
 void KisToolTransform::deactivateAlternateAction(AlternateAction action)
 {
     currentStrategy()->deactivateAlternateAction(action);
 }
 
 void KisToolTransform::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     beginActionImpl(event, false, action);
 }
 
 void KisToolTransform::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     continueActionImpl(event, false, action);
 }
 
 void KisToolTransform::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     endActionImpl(event, false, action);
 }
 
 void KisToolTransform::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
 }
 
 void KisToolTransform::mouseMoveEvent(KoPointerEvent *event)
 {
     QPointF mousePos = m_canvas->coordinatesConverter()->documentToImage(event->point);
 
     cursorOutlineUpdateRequested(mousePos);
 
     if (this->mode() != KisTool::PAINT_MODE) {
         currentStrategy()->hoverActionCommon(event);
         setFunctionalCursor();
         KisTool::mouseMoveEvent(event);
         return;
     }
 }
 
 void KisToolTransform::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
 }
 
 void KisToolTransform::applyTransform()
 {
     slotApplyTransform();
 }
 
 KisToolTransform::TransformToolMode KisToolTransform::transformMode() const
 {
     TransformToolMode mode = FreeTransformMode;
 
     switch (m_currentArgs.mode())
     {
     case ToolTransformArgs::FREE_TRANSFORM:
         mode = FreeTransformMode;
         break;
     case ToolTransformArgs::WARP:
         mode = WarpTransformMode;
         break;
     case ToolTransformArgs::CAGE:
         mode = CageTransformMode;
         break;
     case ToolTransformArgs::LIQUIFY:
         mode = LiquifyTransformMode;
         break;
     case ToolTransformArgs::PERSPECTIVE_4POINT:
         mode = PerspectiveTransformMode;
         break;
     default:
         KIS_ASSERT_RECOVER_NOOP(0 && "unexpected transform mode");
     }
 
     return mode;
 }
 
 double KisToolTransform::translateX() const
 {
     return m_currentArgs.transformedCenter().x();
 }
 
 double KisToolTransform::translateY() const
 {
     return m_currentArgs.transformedCenter().y();
 }
 
 double KisToolTransform::rotateX() const
 {
     return m_currentArgs.aX();
 }
 
 double KisToolTransform::rotateY() const
 {
     return m_currentArgs.aY();
 }
 
 double KisToolTransform::rotateZ() const
 {
     return m_currentArgs.aZ();
 }
 
 double KisToolTransform::scaleX() const
 {
     return m_currentArgs.scaleX();
 }
 
 double KisToolTransform::scaleY() const
 {
     return m_currentArgs.scaleY();
 }
 
 double KisToolTransform::shearX() const
 {
     return m_currentArgs.shearX();
 }
 
 double KisToolTransform::shearY() const
 {
     return m_currentArgs.shearY();
 }
 
 KisToolTransform::WarpType KisToolTransform::warpType() const
 {
     switch(m_currentArgs.warpType()) {
     case KisWarpTransformWorker::AFFINE_TRANSFORM:
         return AffineWarpType;
     case KisWarpTransformWorker::RIGID_TRANSFORM:
         return RigidWarpType;
     case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
         return SimilitudeWarpType;
     default:
         return RigidWarpType;
     }
 }
 
 double KisToolTransform::warpFlexibility() const
 {
     return m_currentArgs.alpha();
 }
 
 int KisToolTransform::warpPointDensity() const
 {
     return m_currentArgs.numPoints();
 }
 
 void KisToolTransform::setTransformMode(KisToolTransform::TransformToolMode newMode)
 {
     ToolTransformArgs::TransformMode mode = ToolTransformArgs::FREE_TRANSFORM;
 
     switch (newMode) {
     case FreeTransformMode:
         mode = ToolTransformArgs::FREE_TRANSFORM;
         break;
     case WarpTransformMode:
         mode = ToolTransformArgs::WARP;
         break;
     case CageTransformMode:
         mode = ToolTransformArgs::CAGE;
         break;
     case LiquifyTransformMode:
         mode = ToolTransformArgs::LIQUIFY;
         break;
     case PerspectiveTransformMode:
         mode = ToolTransformArgs::PERSPECTIVE_4POINT;
         break;
     default:
         KIS_ASSERT_RECOVER_NOOP(0 && "unexpected transform mode");
     }
 
     if( mode != m_currentArgs.mode() ) {
         if( newMode == FreeTransformMode ) {
             m_optionsWidget->slotSetFreeTransformModeButtonClicked( true );
         } else if( newMode == WarpTransformMode ) {
             m_optionsWidget->slotSetWarpModeButtonClicked( true );
         } else if( newMode == CageTransformMode ) {
             m_optionsWidget->slotSetCageModeButtonClicked( true );
         } else if( newMode == LiquifyTransformMode ) {
             m_optionsWidget->slotSetLiquifyModeButtonClicked( true );
         } else if( newMode == PerspectiveTransformMode ) {
             m_optionsWidget->slotSetPerspectiveModeButtonClicked( true );
         }
         emit transformModeChanged();
     }
 }
 
 void KisToolTransform::setRotateX( double rotation )
 {
     m_currentArgs.setAX( normalizeAngle(rotation) );
 }
 
 void KisToolTransform::setRotateY( double rotation )
 {
     m_currentArgs.setAY( normalizeAngle(rotation) );
 }
 
 void KisToolTransform::setRotateZ( double rotation )
 {
     m_currentArgs.setAZ( normalizeAngle(rotation) );
 }
 
 void KisToolTransform::setWarpType( KisToolTransform::WarpType type )
 {
     switch( type ) {
     case RigidWarpType:
         m_currentArgs.setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
         break;
     case AffineWarpType:
         m_currentArgs.setWarpType(KisWarpTransformWorker::AFFINE_TRANSFORM);
         break;
     case SimilitudeWarpType:
         m_currentArgs.setWarpType(KisWarpTransformWorker::SIMILITUDE_TRANSFORM);
         break;
     default:
         break;
     }
 }
 
 void KisToolTransform::setWarpFlexibility( double flexibility )
 {
     m_currentArgs.setAlpha( flexibility );
 }
 
 void KisToolTransform::setWarpPointDensity( int density )
 {
     m_optionsWidget->slotSetWarpDensity(density);
 }
 
 void KisToolTransform::initTransformMode(ToolTransformArgs::TransformMode mode)
 {
     m_currentArgs = KisTransformUtils::resetArgsForMode(mode, m_currentArgs.filterId(), m_transaction);
     initGuiAfterTransformMode();
 }
 
 void KisToolTransform::initGuiAfterTransformMode()
 {
     currentStrategy()->externalConfigChanged();
     outlineChanged();
     updateOptionWidget();
     updateApplyResetAvailability();
     setFunctionalCursor();
 }
 
-void KisToolTransform::updateSelectionPath(const QPainterPath &selectionOutline)
-{
-    m_selectionPath = selectionOutline;
-
-    const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
-    QTransform i2f = converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
-
-    m_selectionPath = i2f.map(selectionOutline);
-}
-
 void KisToolTransform::initThumbnailImage(KisPaintDeviceSP previewDevice)
 {
     QImage origImg;
     m_selectedPortionCache = previewDevice;
 
     QTransform thumbToImageTransform;
 
     const int maxSize = 2000;
 
     QRect srcRect(m_transaction.originalRect().toAlignedRect());
     int x, y, w, h;
     srcRect.getRect(&x, &y, &w, &h);
 
     if (m_selectedPortionCache) {
         if (w > maxSize || h > maxSize) {
             qreal scale = qreal(maxSize) / (w > h ? w : h);
             QTransform scaleTransform = QTransform::fromScale(scale, scale);
 
             QRect thumbRect = scaleTransform.mapRect(m_transaction.originalRect()).toAlignedRect();
 
             origImg = m_selectedPortionCache->
                     createThumbnail(thumbRect.width(),
                                     thumbRect.height(),
                                     srcRect, 1,
                                     KoColorConversionTransformation::internalRenderingIntent(),
                                     KoColorConversionTransformation::internalConversionFlags());
             thumbToImageTransform = scaleTransform.inverted();
 
         } else {
             origImg = m_selectedPortionCache->convertToQImage(0, x, y, w, h,
                                                               KoColorConversionTransformation::internalRenderingIntent(),
                                                               KoColorConversionTransformation::internalConversionFlags());
             thumbToImageTransform = QTransform();
         }
     }
 
     // init both strokes since the thumbnail is initialized only once
     // during the stroke
     m_freeStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_perspectiveStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_warpStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_cageStrategy->setThumbnailImage(origImg, thumbToImageTransform);
     m_liquifyStrategy->setThumbnailImage(origImg, thumbToImageTransform);
 }
 
 void KisToolTransform::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisTool::activate(toolActivation, shapes);
 
     if (currentNode()) {
         m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
     }
 
     startStroke(ToolTransformArgs::FREE_TRANSFORM, false);
 }
 
 void KisToolTransform::deactivate()
 {
     endStroke();
     m_canvas->updateCanvas();
     KisTool::deactivate();
 }
 
 void KisToolTransform::requestUndoDuringStroke()
 {
-    if (!m_strokeId) return;
+    if (!m_strokeId || !m_transaction.rootNode()) return;
 
     if (m_changesTracker.isEmpty()) {
         cancelStroke();
     } else {
         m_changesTracker.requestUndo();
     }
 }
 
 void KisToolTransform::requestStrokeEnd()
 {
     endStroke();
 }
 
 void KisToolTransform::requestStrokeCancellation()
 {
-    if (m_currentArgs.isIdentity()) {
+    if (!m_transaction.rootNode() || m_currentArgs.isIdentity()) {
         cancelStroke();
     } else {
         slotResetTransform();
     }
 }
 
 void KisToolTransform::startStroke(ToolTransformArgs::TransformMode mode, bool forceReset)
 {
     Q_ASSERT(!m_strokeId);
 
     // set up and null checks before we do anything
     KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
     KisNodeSP currentNode = resources->currentNode();
     if (!currentNode || !currentNode->isEditable()) return;
 
     m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
     m_currentArgs = ToolTransformArgs();
 
     // some layer types cannot be transformed. Give a message and return if a user tries it
     if (currentNode->inherits("KisColorizeMask") ||
         currentNode->inherits("KisFileLayer") ||
         currentNode->inherits("KisCloneLayer")) {
 
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Layer type cannot use the transform tool"),
                  koIcon("object-locked"), 4000, KisFloatingMessage::High);
 
         return;
     }
 
     if (m_optionsWidget) {
         m_workRecursively = m_optionsWidget->workRecursively() ||
             !currentNode->paintDevice();
     }
 
     KisSelectionSP selection = resources->activeSelection();
 
     /**
      * When working with transform mask, selections are not
      * taken into account.
      */
     if (selection && dynamic_cast<KisTransformMask*>(currentNode.data())) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Selections are not used when editing transform masks "),
                 QIcon(), 4000, KisFloatingMessage::Low);
 
         selection = 0;
     }
 
     TransformStrokeStrategy *strategy = new TransformStrokeStrategy(mode, m_workRecursively, m_currentArgs.filterId(), forceReset, currentNode, selection, image().data(), image().data());
-    connect(strategy, SIGNAL(sigPreviewDeviceReady(KisPaintDeviceSP, QPainterPath)), SLOT(slotPreviewDeviceGenerated(KisPaintDeviceSP, QPainterPath)));
-    connect(strategy, SIGNAL(sigTransactionGenerated(TransformTransactionProperties, ToolTransformArgs)), SLOT(slotTransactionGenerated(TransformTransactionProperties, ToolTransformArgs)));
-
+    connect(strategy, SIGNAL(sigPreviewDeviceReady(KisPaintDeviceSP)), SLOT(slotPreviewDeviceGenerated(KisPaintDeviceSP)));
+    connect(strategy, SIGNAL(sigTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)), SLOT(slotTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)));
+
+    // save unique identifier of the stroke so we could
+    // recognize it when sigTransactionGenerated() is
+    // recieved (theoretically, the user can start two
+    // strokes at the same time, if he is quick enough)
+    m_strokeStrategyCookie = strategy;
     m_strokeId = image()->startStroke(strategy);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_changesTracker.isEmpty());
 
-    slotPreviewDeviceGenerated(0, QPainterPath());
+    slotPreviewDeviceGenerated(0);
 }
 
 void KisToolTransform::endStroke()
 {
     if (!m_strokeId) return;
 
-    if (!m_currentArgs.isIdentity()) {
+    if (m_transaction.rootNode() && !m_currentArgs.isIdentity()) {
         image()->addJob(m_strokeId,
                         new TransformStrokeStrategy::TransformAllData(m_currentArgs));
-        image()->endStroke(m_strokeId);
-    } else {
-        image()->cancelStroke(m_strokeId);
     }
+    image()->endStroke(m_strokeId);
 
+    m_strokeStrategyCookie = 0;
     m_strokeId.clear();
     m_changesTracker.reset();
     m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
     outlineChanged();
 }
 
-void KisToolTransform::slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args)
+void KisToolTransform::slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args, void *strokeStrategyCookie)
 {
+    if (!m_strokeId || strokeStrategyCookie != m_strokeStrategyCookie) return;
+
     if (transaction.transformedNodes().isEmpty()) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Cannot transform empty layer "),
                 QIcon(), 1000, KisFloatingMessage::Medium);
 
         cancelStroke();
         return;
     }
 
     m_transaction = transaction;
     m_currentArgs = args;
     m_transaction.setCurrentConfigLocation(&m_currentArgs);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_changesTracker.isEmpty());
     commitChanges();
 
     initGuiAfterTransformMode();
 
     if (m_transaction.hasInvisibleNodes()) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Invisible sublayers will also be transformed. Lock layers if you do not want them to be transformed "),
                 QIcon(), 4000, KisFloatingMessage::Low);
     }
 }
 
-void KisToolTransform::slotPreviewDeviceGenerated(KisPaintDeviceSP device, const QPainterPath &selectionOutline)
+void KisToolTransform::slotPreviewDeviceGenerated(KisPaintDeviceSP device)
 {
     if (device && device->exactBounds().isEmpty()) {
         KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in transformation tool",
                       "Cannot transform empty layer "),
                 QIcon(), 1000, KisFloatingMessage::Medium);
 
         cancelStroke();
     } else {
         initThumbnailImage(device);
-        updateSelectionPath(selectionOutline);
         initGuiAfterTransformMode();
     }
 }
 
 void KisToolTransform::cancelStroke()
 {
     if (!m_strokeId) return;
 
-    if (m_currentArgs.continuedTransform()) {
-        m_currentArgs.restoreContinuedState();
-        endStroke();
-    } else {
-        image()->cancelStroke(m_strokeId);
-        m_strokeId.clear();
-        m_changesTracker.reset();
-        m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
-        outlineChanged();
-    }
+    image()->cancelStroke(m_strokeId);
+    m_strokeStrategyCookie = 0;
+    m_strokeId.clear();
+    m_changesTracker.reset();
+    m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
+    outlineChanged();
 }
 
 void KisToolTransform::commitChanges()
 {
-    if (!m_strokeId) return;
+    if (!m_strokeId || !m_transaction.rootNode()) return;
 
     m_changesTracker.commitConfig(toQShared(m_currentArgs.clone()));
 }
 
 void KisToolTransform::slotTrackerChangedConfig(KisToolChangesTrackerDataSP status)
 {
     const ToolTransformArgs *newArgs = dynamic_cast<const ToolTransformArgs*>(status.data());
     KIS_SAFE_ASSERT_RECOVER_RETURN(newArgs);
 
     *m_transaction.currentConfig() = *newArgs;
 
     slotUiChangedConfig();
     updateOptionWidget();
 }
 
 QList<KisNodeSP> KisToolTransform::fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive)
 {
     QList<KisNodeSP> result;
 
     auto fetchFunc =
         [&result, mode, root] (KisNodeSP node) {
         if (node->isEditable(node == root) &&
                 (!node->inherits("KisShapeLayer") || mode == ToolTransformArgs::FREE_TRANSFORM) &&
                 !node->inherits("KisFileLayer") &&
                 (!node->inherits("KisTransformMask") || node == root)) {
 
                 result << node;
             }
     };
 
     if (recursive) {
         KisLayerUtils::recursiveApplyNodes(root, fetchFunc);
     } else {
         fetchFunc(root);
     }
 
     return result;
 }
 
 QWidget* KisToolTransform::createOptionWidget()
 {
     if (!m_canvas) return 0;
 
     m_optionsWidget = new KisToolTransformConfigWidget(&m_transaction, m_canvas, m_workRecursively, 0);
     Q_CHECK_PTR(m_optionsWidget);
     m_optionsWidget->setObjectName(toolId() + " option widget");
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(m_optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     m_optionsWidget->layout()->addWidget(specialSpacer);
 
 
     connect(m_optionsWidget, SIGNAL(sigConfigChanged()),
             this, SLOT(slotUiChangedConfig()));
 
     connect(m_optionsWidget, SIGNAL(sigApplyTransform()),
             this, SLOT(slotApplyTransform()));
 
     connect(m_optionsWidget, SIGNAL(sigResetTransform()),
             this, SLOT(slotResetTransform()));
 
     connect(m_optionsWidget, SIGNAL(sigRestartTransform()),
             this, SLOT(slotRestartTransform()));
 
     connect(m_optionsWidget, SIGNAL(sigEditingFinished()),
             this, SLOT(slotEditingFinished()));
 
 
     connect(mirrorHorizontalAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotFlipX()));
     connect(mirrorVericalAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotFlipY()));
     connect(rotateNinteyCWAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotRotateCW()));
     connect(rotateNinteyCCWAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotRotateCCW()));
 
 
     connect(warpAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToWarpType()));
     connect(perspectiveAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToPerspectiveType()));
     connect(freeTransformAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToFreeTransformType()));
     connect(liquifyAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToLiquifyType()));
     connect(cageAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToCageType()));
 
     connect(applyTransformation, SIGNAL(triggered(bool)), this, SLOT(slotApplyTransform()));
     connect(resetTransformation, SIGNAL(triggered(bool)), this, SLOT(slotResetTransform()));
 
 
     updateOptionWidget();
 
     return m_optionsWidget;
 }
 
 void KisToolTransform::updateOptionWidget()
 {
     if (!m_optionsWidget) return;
 
     if (!currentNode()) {
         m_optionsWidget->setEnabled(false);
         return;
     }
     else {
         m_optionsWidget->setEnabled(true);
         m_optionsWidget->updateConfig(m_currentArgs);
     }
 }
 
 void KisToolTransform::updateApplyResetAvailability()
 {
     if (m_optionsWidget) {
         m_optionsWidget->setApplyResetDisabled(m_currentArgs.isIdentity());
     }
 }
 
 void KisToolTransform::slotUiChangedConfig()
 {
     if (mode() == KisTool::PAINT_MODE) return;
 
     currentStrategy()->externalConfigChanged();
 
     if (m_currentArgs.mode() == ToolTransformArgs::LIQUIFY) {
         m_currentArgs.saveLiquifyTransformMode();
     }
 
     outlineChanged();
     updateApplyResetAvailability();
 }
 
 void KisToolTransform::slotApplyTransform()
 {
     QApplication::setOverrideCursor(KisCursor::waitCursor());
     endStroke();
     QApplication::restoreOverrideCursor();
 }
 
 void KisToolTransform::slotResetTransform()
 {
+    if (!m_strokeId || !m_transaction.rootNode()) return;
+
     if (m_currentArgs.continuedTransform()) {
         ToolTransformArgs::TransformMode savedMode = m_currentArgs.mode();
 
         /**
          * Our reset transform button can be used for two purposes:
          *
          * 1) Reset current transform to the initial one, which was
          *    loaded from the previous user action.
          *
          * 2) Reset transform frame to infinity when the frame is unchanged
          */
 
         const bool transformDiffers = !m_currentArgs.continuedTransform()->isSameMode(m_currentArgs);
 
         if (transformDiffers &&
             m_currentArgs.continuedTransform()->mode() == savedMode) {
             m_currentArgs.restoreContinuedState();
             initGuiAfterTransformMode();
             slotEditingFinished();
 
         } else {
             KisNodeSP root = m_transaction.rootNode() ? m_transaction.rootNode() : image()->root();
             cancelStroke();
             startStroke(savedMode, true);
 
             KIS_ASSERT_RECOVER_NOOP(!m_currentArgs.continuedTransform());
         }
     } else {
         initTransformMode(m_currentArgs.mode());
         slotEditingFinished();
     }
 }
 
 void KisToolTransform::slotRestartTransform()
 {
-    if (!m_strokeId) return;
+    if (!m_strokeId || !m_transaction.rootNode()) return;
 
     KisNodeSP root = m_transaction.rootNode();
     KIS_ASSERT_RECOVER_RETURN(root); // the stroke is guaranteed to be started by an 'if' above
 
     ToolTransformArgs savedArgs(m_currentArgs);
     cancelStroke();
     startStroke(savedArgs.mode(), true);
 }
 
 void KisToolTransform::slotEditingFinished()
 {
     commitChanges();
 }
 
 void KisToolTransform::slotUpdateToWarpType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::WarpTransformMode);
 }
 
 void KisToolTransform::slotUpdateToPerspectiveType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::PerspectiveTransformMode);
 }
 
 void KisToolTransform::slotUpdateToFreeTransformType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::FreeTransformMode);
 }
 
 void KisToolTransform::slotUpdateToLiquifyType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::LiquifyTransformMode);
 }
 
 void KisToolTransform::slotUpdateToCageType()
 {
     setTransformMode(KisToolTransform::TransformToolMode::CageTransformMode);
 }
 
 void KisToolTransform::setShearY(double shear)
 {
     m_optionsWidget->slotSetShearY(shear);
 }
 
 void KisToolTransform::setShearX(double shear)
 {
     m_optionsWidget->slotSetShearX(shear);
 }
 
 void KisToolTransform::setScaleY(double scale)
 {
     m_optionsWidget->slotSetScaleY(scale);
 }
 
 void KisToolTransform::setScaleX(double scale)
 {
     m_optionsWidget->slotSetScaleX(scale);
 }
 
 void KisToolTransform::setTranslateY(double translation)
 {
     m_optionsWidget->slotSetTranslateY(translation);
 }
 
 void KisToolTransform::setTranslateX(double translation)
 {
     m_optionsWidget->slotSetTranslateX(translation);
 }
diff --git a/plugins/tools/tool_transform2/kis_tool_transform.h b/plugins/tools/tool_transform2/kis_tool_transform.h
index 52c9ccf65e..6b616a4757 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform.h
+++ b/plugins/tools/tool_transform2/kis_tool_transform.h
@@ -1,353 +1,353 @@
 /*
  *  kis_tool_transform.h - part of Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2010 Marc Pegon <pe.marc@free.fr>
  *
  *  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_TRANSFORM_H_
 #define KIS_TOOL_TRANSFORM_H_
 
 #include <kis_icon.h>
 
 #include <QPoint>
 #include <QPointF>
 #include <QVector2D>
 #include <QVector3D>
 #include <QButtonGroup>
 #include <QPointer>
 
 #include <QKeySequence>
 
 #include <KoToolFactoryBase.h>
 
 #include <kis_shape_selection.h>
 #include <kis_undo_adapter.h>
 #include <kis_types.h>
 #include <flake/kis_node_shape.h>
 #include <kis_tool.h>
 #include <kis_canvas2.h>
 #include <kis_action.h>
 
 
 #include "tool_transform_args.h"
 #include "KisToolChangesTracker.h"
 #include "kis_tool_transform_config_widget.h"
 #include "transform_transaction_properties.h"
 
 class QTouchEvent;
 class KisTransformStrategyBase;
 class KisWarpTransformStrategy;
 class KisCageTransformStrategy;
 class KisLiquifyTransformStrategy;
 class KisFreeTransformStrategy;
 class KisPerspectiveTransformStrategy;
 
 
 /**
  * Transform tool
  * This tool offers several modes.
  * - Free Transform mode allows the user to translate, scale, shear, rotate and
  *   apply a perspective transformation to a selection or the whole canvas.
  * - Warp mode allows the user to warp the selection of the canvas by grabbing
  *   and moving control points placed on the image. The user can either work
  *   with default control points, like a grid whose density can be modified, or
  *   place the control points manually. The modifications made on the selected
  *   pixels are applied only when the user clicks the Apply button : the
  *   semi-transparent image displayed until the user click that button is only a
  *   preview.
  * - Cage transform is similar to warp transform with control points exactly
  *   placed on the outer boundary. The user draws a boundary polygon, the
  *   vertices of which become control points.
  * - Perspective transform applies a two-point perspective transformation. The
  *   user can manipulate the corners of the selection. If the vanishing points
  *   of the resulting quadrilateral are on screen, the user can manipulate those
  *   as well.
  * - Liquify transform transforms the selection by painting motions, as if the
  *   user were fingerpainting.
  */
 class KisToolTransform : public KisTool
 {
 
     Q_OBJECT
 
     Q_PROPERTY(TransformToolMode transformMode READ transformMode WRITE setTransformMode NOTIFY transformModeChanged)
 
     Q_PROPERTY(double translateX READ translateX WRITE setTranslateX NOTIFY freeTransformChanged)
     Q_PROPERTY(double translateY READ translateY WRITE setTranslateY NOTIFY freeTransformChanged)
 
     Q_PROPERTY(double rotateX READ rotateX WRITE setRotateX NOTIFY freeTransformChanged)
     Q_PROPERTY(double rotateY READ rotateY WRITE setRotateY NOTIFY freeTransformChanged)
     Q_PROPERTY(double rotateZ READ rotateZ WRITE setRotateZ NOTIFY freeTransformChanged)
 
     Q_PROPERTY(double scaleX READ scaleX WRITE setScaleX NOTIFY freeTransformChanged)
     Q_PROPERTY(double scaleY READ scaleY WRITE setScaleY NOTIFY freeTransformChanged)
 
     Q_PROPERTY(double shearX READ shearX WRITE setShearX NOTIFY freeTransformChanged)
     Q_PROPERTY(double shearY READ shearY WRITE setShearY NOTIFY freeTransformChanged)
 
     Q_PROPERTY(WarpType warpType READ warpType WRITE setWarpType NOTIFY warpTransformChanged)
     Q_PROPERTY(double warpFlexibility READ warpFlexibility WRITE setWarpFlexibility NOTIFY warpTransformChanged)
     Q_PROPERTY(int warpPointDensity READ warpPointDensity WRITE setWarpPointDensity NOTIFY warpTransformChanged)
 
 
 
 public:
     enum TransformToolMode {
         FreeTransformMode,
         WarpTransformMode,
         CageTransformMode,
         LiquifyTransformMode,
         PerspectiveTransformMode
     };
     Q_ENUMS(TransformToolMode)
 
     enum WarpType {
         RigidWarpType,
         AffineWarpType,
         SimilitudeWarpType
     };
     Q_ENUMS(WarpType)
 
     KisToolTransform(KoCanvasBase * canvas);
     ~KisToolTransform() override;
 
     /**
      * @brief wantsAutoScroll
      * reimplemented from KoToolBase
      * there's an issue where autoscrolling with this tool never makes the
      * stroke end, so we return false here so that users don't get stuck with
      * the tool. See bug 362659
      * @return false
      */
     bool wantsAutoScroll() const override {
         return false;
     }
 
     QWidget* createOptionWidget() override;
 
     void mousePressEvent(KoPointerEvent *e) override;
     void mouseMoveEvent(KoPointerEvent *e) override;
     void mouseReleaseEvent(KoPointerEvent *e) override;
     void beginActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action);
     void continueActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action);
     void endActionImpl(KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action);
     QMenu* popupActionsMenu() override;
 
     void activatePrimaryAction() override;
     void deactivatePrimaryAction() 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;
 
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
     TransformToolMode transformMode() const;
 
     double translateX() const;
     double translateY() const;
 
     double rotateX() const;
     double rotateY() const;
     double rotateZ() const;
 
     double scaleX() const;
     double scaleY() const;
 
     double shearX() const;
     double shearY() const;
 
     WarpType warpType() const;
     double warpFlexibility() const;
     int warpPointDensity() const;
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
     // Applies the current transformation to the original paint device and commits it to the undo stack
     void applyTransform();
 
     void setTransformMode( KisToolTransform::TransformToolMode newMode );
 
     void setTranslateX(double translateX);
     void setTranslateY(double translateY);
 
     void setRotateX(double rotation);
     void setRotateY(double rotation);
     void setRotateZ(double rotation);
 
     void setScaleX(double scaleX);
     void setScaleY(double scaleY);
 
     void setShearX(double shearX);
     void setShearY(double shearY);
 
     void setWarpType(WarpType type);
     void setWarpFlexibility(double flexibility);
     void setWarpPointDensity(int density);
 
 protected Q_SLOTS:
     void resetCursorStyle() override;
 
 Q_SIGNALS:
     void transformModeChanged();
     void freeTransformChanged();
     void warpTransformChanged();
 
 public Q_SLOTS:
     void requestUndoDuringStroke() override;
     void requestStrokeEnd() override;
     void requestStrokeCancellation() override;
     void canvasUpdateRequested();
     void cursorOutlineUpdateRequested(const QPointF &imagePos);
 
     // Update the widget according to m_currentArgs
     void updateOptionWidget();
 
     void resetRotationCenterButtonsRequested();
     void imageTooBigRequested(bool value);
 
 private:
     QList<KisNodeSP> fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive);
     QScopedPointer<QMenu> m_contextMenu;
 
     void startStroke(ToolTransformArgs::TransformMode mode, bool forceReset);
     void endStroke();
     void cancelStroke();
 
 private:
     void outlineChanged();
     // Sets the cursor according to mouse position (doesn't take shearing into account well yet)
     void setFunctionalCursor();
     // Sets m_function according to mouse position and modifier
     void setTransformFunction(QPointF mousePos, Qt::KeyboardModifiers modifiers);
 
     void commitChanges();
 
     void initTransformMode(ToolTransformArgs::TransformMode mode);
     void initGuiAfterTransformMode();
 
     void initThumbnailImage(KisPaintDeviceSP previewDevice);
-    void updateSelectionPath(const QPainterPath &selectionOutline);
     void updateApplyResetAvailability();
 
 private:
     ToolTransformArgs m_currentArgs;
 
     bool m_actuallyMoveWhileSelected; // true <=> selection has been moved while clicked
 
     KisPaintDeviceSP m_selectedPortionCache;
     KisStrokeId m_strokeId;
+    void *m_strokeStrategyCookie = 0;
 
     bool m_workRecursively;
 
     QPainterPath m_selectionPath; // original (unscaled) selection outline, used for painting decorations
 
     KisToolTransformConfigWidget *m_optionsWidget;
     QPointer<KisCanvas2> m_canvas;
 
     TransformTransactionProperties m_transaction;
     KisToolChangesTracker m_changesTracker;
 
 
     /// actions for the context click menu
     KisAction* warpAction;
     KisAction* liquifyAction;
     KisAction* cageAction;
     KisAction* freeTransformAction;
     KisAction* perspectiveAction;
     KisAction* applyTransformation;
     KisAction* resetTransformation;
 
     // a few extra context click options if free transform is active
     KisAction* mirrorHorizontalAction;
     KisAction* mirrorVericalAction;
     KisAction* rotateNinteyCWAction;
     KisAction* rotateNinteyCCWAction;
 
 
 
 
     /**
      * This artificial rect is used to store the image to flake
      * transformation. We check against this rect to get to know
      * whether zoom has changed.
      */
     QRectF m_refRect;
 
     QScopedPointer<KisWarpTransformStrategy> m_warpStrategy;
     QScopedPointer<KisCageTransformStrategy> m_cageStrategy;
     QScopedPointer<KisLiquifyTransformStrategy> m_liquifyStrategy;
     QScopedPointer<KisFreeTransformStrategy> m_freeStrategy;
     QScopedPointer<KisPerspectiveTransformStrategy> m_perspectiveStrategy;
     KisTransformStrategyBase* currentStrategy() const;
 
     QPainterPath m_cursorOutline;
 
 private Q_SLOTS:
     void slotTrackerChangedConfig(KisToolChangesTrackerDataSP status);
     void slotUiChangedConfig();
     void slotApplyTransform();
     void slotResetTransform();
     void slotRestartTransform();
     void slotEditingFinished();
 
-    void slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args);
-    void slotPreviewDeviceGenerated(KisPaintDeviceSP device, const QPainterPath &selectionOutline);
+    void slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args, void *strokeStrategyCookie);
+    void slotPreviewDeviceGenerated(KisPaintDeviceSP device);
 
     // context menu options for updating the transform type
     // this is to help with discoverability since come people can't find the tool options
     void slotUpdateToWarpType();
     void slotUpdateToPerspectiveType();
     void slotUpdateToFreeTransformType();
     void slotUpdateToLiquifyType();
     void slotUpdateToCageType();
 };
 
 class KisToolTransformFactory : public KoToolFactoryBase
 {
 public:
 
     KisToolTransformFactory()
             : KoToolFactoryBase("KisToolTransform") {
         setToolTip(i18n("Transform a layer or a selection"));
         setSection(TOOL_TYPE_TRANSFORM);
         setIconName(koIconNameCStr("krita_tool_transform"));
         setShortcut(QKeySequence(Qt::CTRL + Qt::Key_T));
         setPriority(2);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
     }
 
     ~KisToolTransformFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase *canvas) override {
         return new KisToolTransform(canvas);
     }
 
 };
 
 
 
 #endif // KIS_TOOL_TRANSFORM_H_
 
diff --git a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
index 4b96943a06..17c8df7dc7 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
@@ -1,1297 +1,1288 @@
 /*
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_transform_config_widget.h"
 
 #include <kis_icon.h>
 #include "rotation_icons.h"
 #include "kis_canvas2.h"
 #include <KisSignalMapper.h>
 #include "kis_liquify_properties.h"
 
 #include "KisMainWindow.h"
 #include "KisViewManager.h"
 #include "kis_transform_utils.h"
 
 
 template<typename T> inline T sign(T x) {
     return x > 0 ? 1 : x == (T)0 ? 0 : -1;
 }
 
 const int KisToolTransformConfigWidget::DEFAULT_POINTS_PER_LINE = 3;
 
 
 KisToolTransformConfigWidget::KisToolTransformConfigWidget(TransformTransactionProperties *transaction, KisCanvas2 *canvas, bool workRecursively, QWidget *parent)
     : QWidget(parent),
       m_transaction(transaction),
       m_notificationsBlocked(0),
       m_uiSlotsBlocked(0),
       m_configChanged(false)
 {
     setupUi(this);
-    showDecorationsBox->setIcon(KisIconUtils::loadIcon("krita_tool_transform"));
     chkWorkRecursively->setIcon(KisIconUtils::loadIcon("krita_tool_transform_recursive"));
     flipXButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_x"));
     flipYButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_y"));
     rotateCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_cw"));
     rotateCCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_ccw"));
 
     chkWorkRecursively->setChecked(workRecursively);
     connect(chkWorkRecursively, SIGNAL(toggled(bool)), this, SIGNAL(sigRestartTransform()));
 
     // Granularity can only be specified in the power of 2's
     QStringList granularityValues{"4","8","16","32"};
     changeGranularity->addItems(granularityValues);
     changeGranularity->setCurrentIndex(1);
     granularityPreview->addItems(granularityValues);
     granularityPreview->setCurrentIndex(2);
 
     connect(changeGranularity,SIGNAL(currentIndexChanged(QString)),
             this,SLOT(slotGranularityChanged(QString)));
     connect(granularityPreview, SIGNAL(currentIndexChanged(QString)),
             this,SLOT(slotPreviewGranularityChanged(QString)));
 
     // Init Filter  combo
     cmbFilter->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     cmbFilter->setCurrent("Bicubic");
     cmbFilter->setToolTip(i18nc("@info:tooltip",
                                 "<p>Select filtering mode:\n"
                                 "<ul>"
                                 "<li><b>Bilinear</b> for areas with uniform color to avoid artifacts</li>"
                                 "<li><b>Bicubic</b> for smoother results</li>"
                                 "<li><b>Lanczos3</b> for sharp results. May produce aerials.</li>"
                                 "</ul></p>"));
     connect(cmbFilter, SIGNAL(activated(KoID)),
             this, SLOT(slotFilterChanged(KoID)));
 
     // Init Warp Type combo
     cmbWarpType->insertItem(KisWarpTransformWorker::AFFINE_TRANSFORM,i18n("Default (Affine)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::RIGID_TRANSFORM,i18n("Strong (Rigid)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::SIMILITUDE_TRANSFORM,i18n("Strongest (Similitude)"));
     cmbWarpType->setCurrentIndex(KisWarpTransformWorker::AFFINE_TRANSFORM);
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotWarpTypeChanged(int)));
 
     // Init Rotation Center buttons
     m_handleDir[0] = QPointF(1, 0);
     m_handleDir[1] = QPointF(1, -1);
     m_handleDir[2] = QPointF(0, -1);
     m_handleDir[3] = QPointF(-1, -1);
     m_handleDir[4] = QPointF(-1, 0);
     m_handleDir[5] = QPointF(-1, 1);
     m_handleDir[6] = QPointF(0, 1);
     m_handleDir[7] = QPointF(1, 1);
     m_handleDir[8] = QPointF(0, 0); // also add the center
 
     m_rotationCenterButtons = new QButtonGroup(0);
     // we set the ids to match m_handleDir
     m_rotationCenterButtons->addButton(middleRightButton, 0);
     m_rotationCenterButtons->addButton(topRightButton, 1);
     m_rotationCenterButtons->addButton(middleTopButton, 2);
     m_rotationCenterButtons->addButton(topLeftButton, 3);
     m_rotationCenterButtons->addButton(middleLeftButton, 4);
     m_rotationCenterButtons->addButton(bottomLeftButton, 5);
     m_rotationCenterButtons->addButton(middleBottomButton, 6);
     m_rotationCenterButtons->addButton(bottomRightButton, 7);
     m_rotationCenterButtons->addButton(centerButton, 8);
 
     QToolButton *nothingSelected = new QToolButton(0);
     nothingSelected->setCheckable(true);
     nothingSelected->setAutoExclusive(true);
     nothingSelected->hide(); // a convenient button for when no button is checked in the group
     m_rotationCenterButtons->addButton(nothingSelected, 9);
 
 
     // initialize values for free transform sliders
     shearXBox->setSuffix(i18n(" px"));
     shearYBox->setSuffix(i18n(" px"));
     shearXBox->setRange(-5.0, 5.0, 2);
     shearYBox->setRange(-5.0, 5.0, 2);
     shearXBox->setSingleStep(0.01);
     shearYBox->setSingleStep(0.01);
     shearXBox->setValue(0.0);
     shearYBox->setValue(0.0);
 
 
     translateXBox->setSuffix(i18n(" px"));
     translateYBox->setSuffix(i18n(" px"));
     translateXBox->setRange(-10000, 10000);
     translateYBox->setRange(-10000, 10000);
 
 
     scaleXBox->setRange(-10000, 10000);
     scaleYBox->setRange(-10000, 10000);
     scaleXBox->setValue(100.0);
     scaleYBox->setValue(100.0);
 
     m_scaleRatio = 1.0;
 
     aXBox->setSuffix(QChar(Qt::Key_degree));
     aYBox->setSuffix(QChar(Qt::Key_degree));
     aZBox->setSuffix(QChar(Qt::Key_degree));
     aXBox->setRange(0.0, 360.0, 2);
     aYBox->setRange(0.0, 360.0, 2);
     aZBox->setRange(0.0, 360.0, 2);
     aXBox->setValue(0.0);
     aYBox->setValue(0.0);
     aZBox->setValue(0.0);
     aXBox->setSingleStep(1.0);
     aYBox->setSingleStep(1.0);
     aZBox->setSingleStep(1.0);
 
 
 
 
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(slotRotationCenterChanged(int)));
     connect(btnTransformAroundPivotPoint, SIGNAL(clicked(bool)), this, SLOT(slotTransformAroundRotationCenter(bool)));
 
     // Init Free Transform Values
     connect(scaleXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleX(int)));
     connect(scaleYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleY(int)));
     connect(shearXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearX(qreal)));
     connect(shearYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearY(qreal)));
     connect(translateXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateX(int)));
     connect(translateYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateY(int)));
     connect(aXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAX(qreal)));
     connect(aYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAY(qreal)));
     connect(aZBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAZ(qreal)));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotSetKeepAspectRatio(bool)));
     connect(flipXButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipX()));
     connect(flipYButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipY()));
     connect(rotateCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCW()));
     connect(rotateCCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCCW()));
 
     // toggle visibility of different free buttons
     connect(freeMoveRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeRotationRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeScaleRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeShearRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
 
     // only first group for free transform
     rotationGroup->hide();
     moveGroup->show();
     scaleGroup->hide();
     shearGroup->hide();
 
 
 
     // Init Warp Transform Values
     alphaBox->setSingleStep(0.1);
     alphaBox->setRange(0, 10, 1);
 
     connect(alphaBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetWarpAlpha(qreal)));
     connect(densityBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetWarpDensity(int)));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpDefaultPointsButtonClicked(bool)));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpCustomPointsButtonClicked(bool)));
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpLockPointsButtonClicked()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpResetPointsButtonClicked()));
 
     // Init Cage Transform Values
     cageTransformButtonGroup->setId(cageAddEditRadio, 0); // we need to set manually since Qt Designer generates negative by default
     cageTransformButtonGroup->setId(cageDeformRadio, 1);
     connect(cageTransformButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(slotCageOptionsChanged(int)));
 
     // Init Liquify Transform Values
     liquifySizeSlider->setRange(KisLiquifyProperties::minSize(),
                                 KisLiquifyProperties::maxSize(), 2);
     liquifySizeSlider->setExponentRatio(4);
     liquifySizeSlider->setValue(60.0);
     connect(liquifySizeSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySizeChanged(qreal)));
     liquifySizeSlider->setToolTip(i18nc("@info:tooltip", "Size of the deformation brush"));
 
     liquifyAmountSlider->setRange(0.0, 1.0, 2);
     liquifyAmountSlider->setValue(0.05);
     connect(liquifyAmountSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyAmountChanged(qreal)));
     liquifyAmountSlider->setToolTip(i18nc("@info:tooltip", "Amount of the deformation you get"));
 
     liquifyFlowSlider->setRange(0.0, 1.0, 2);
     liquifyFlowSlider->setValue(1.0);
     connect(liquifyFlowSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyFlowChanged(qreal)));
     liquifyFlowSlider->setToolTip(i18nc("@info:tooltip", "When in non-buildup mode, shows how fast the deformation limit is reached."));
 
     buidupModeComboBox->setCurrentIndex(0); // set to build-up mode by default
     connect(buidupModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(liquifyBuildUpChanged(int)));
     buidupModeComboBox->setToolTip("<p>" + i18nc("@info:tooltip", "Switch between Build Up and Wash mode of painting. Build Up mode adds deformations one on top of the other without any limits. Wash mode gradually deforms the piece to the selected deformation level.") + "</p>");
 
     liquifySpacingSlider->setRange(0.0, 3.0, 2);
     liquifySizeSlider->setExponentRatio(3);
     liquifySpacingSlider->setSingleStep(0.01);
     liquifySpacingSlider->setValue(0.2);
     connect(liquifySpacingSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySpacingChanged(qreal)));
     liquifySpacingSlider->setToolTip(i18nc("@info:tooltip", "Space between two sequential applications of the deformation"));
 
     liquifySizePressureBox->setChecked(true);
     connect(liquifySizePressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifySizePressureChanged(bool)));
     liquifySizePressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Size</b> value according to current stylus pressure"));
 
     liquifyAmountPressureBox->setChecked(true);
     connect(liquifyAmountPressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifyAmountPressureChanged(bool)));
     liquifyAmountPressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Amount</b> value according to current stylus pressure"));
 
     liquifyReverseDirectionChk->setChecked(false);
     connect(liquifyReverseDirectionChk, SIGNAL(toggled(bool)), this, SLOT(liquifyReverseDirectionChanged(bool)));
     liquifyReverseDirectionChk->setToolTip(i18nc("@info:tooltip", "Reverse direction of the current deformation tool"));
 
     KisSignalMapper *liquifyModeMapper = new KisSignalMapper(this);
     connect(liquifyMove, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyScale, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyRotate, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyOffset, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyUndo, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     liquifyModeMapper->setMapping(liquifyMove, (int)KisLiquifyProperties::MOVE);
     liquifyModeMapper->setMapping(liquifyScale, (int)KisLiquifyProperties::SCALE);
     liquifyModeMapper->setMapping(liquifyRotate, (int)KisLiquifyProperties::ROTATE);
     liquifyModeMapper->setMapping(liquifyOffset, (int)KisLiquifyProperties::OFFSET);
     liquifyModeMapper->setMapping(liquifyUndo, (int)KisLiquifyProperties::UNDO);
     connect(liquifyModeMapper, SIGNAL(mapped(int)), SLOT(slotLiquifyModeChanged(int)));
 
     liquifyMove->setToolTip(i18nc("@info:tooltip", "Move: drag the image along the brush stroke"));
     liquifyScale->setToolTip(i18nc("@info:tooltip", "Scale: grow/shrink image under cursor"));
     liquifyRotate->setToolTip(i18nc("@info:tooltip", "Rotate: twirl image under cursor"));
     liquifyOffset->setToolTip(i18nc("@info:tooltip", "Offset: shift the image to the right of the stroke direction"));
     liquifyUndo->setToolTip(i18nc("@info:tooltip", "Undo: erase actions of other tools"));
 
     // Connect all edit boxes to the Editing Finished signal
     connect(densityBox, SIGNAL(editingFinished()), this, SLOT(notifyEditingFinished()));
 
 
 
     // Connect other widget (not having editingFinished signal) to
     // the same slot. From Qt 4.6 onwards the sequence of the signal
     // delivery is definite.
     connect(cmbFilter, SIGNAL(activated(KoID)), this, SLOT(notifyEditingFinished()));
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(notifyEditingFinished()));
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(notifyEditingFinished()));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(notifyEditingFinished()));
 
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
 
     // Liquify
     //
     // liquify brush options do not affect the image directly and are not
     // saved to undo, so we don't emit notifyEditingFinished() for them
 
     // Connect Apply/Reset buttons
     connect(buttonBox, SIGNAL(clicked(QAbstractButton*)), this, SLOT(slotButtonBoxClicked(QAbstractButton*)));
 
     // Mode switch buttons
     connect(freeTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetFreeTransformModeButtonClicked(bool)));
     connect(warpButton, SIGNAL(clicked(bool)), this, SLOT(slotSetWarpModeButtonClicked(bool)));
     connect(cageButton, SIGNAL(clicked(bool)), this, SLOT(slotSetCageModeButtonClicked(bool)));
     connect(perspectiveTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetPerspectiveModeButtonClicked(bool)));
     connect(liquifyButton, SIGNAL(clicked(bool)), this, SLOT(slotSetLiquifyModeButtonClicked(bool)));
 
-    // Connect Decorations switcher
-    connect(showDecorationsBox, SIGNAL(toggled(bool)), canvas, SLOT(updateCanvas()));
-
     tooBigLabelWidget->hide();
 
     connect(canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), SLOT(slotUpdateIcons()), Qt::UniqueConnection);
     slotUpdateIcons();
 }
 
 void KisToolTransformConfigWidget::slotUpdateIcons()
 {
     freeTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_main"));
     warpButton->setIcon(KisIconUtils::loadIcon("transform_icons_warp"));
     cageButton->setIcon(KisIconUtils::loadIcon("transform_icons_cage"));
     perspectiveTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_perspective"));
     liquifyButton->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_main"));
 
     liquifyMove->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_move"));
     liquifyScale->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_resize"));
     liquifyRotate->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_rotate"));
     liquifyOffset->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_offset"));
     liquifyUndo->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_erase"));
 
 
 
     middleRightButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     topRightButton->setIcon(KisIconUtils::loadIcon("arrow-topright"));
     middleTopButton->setIcon(KisIconUtils::loadIcon("arrow-up"));
     topLeftButton->setIcon(KisIconUtils::loadIcon("arrow-topleft"));
     middleLeftButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     bottomLeftButton->setIcon(KisIconUtils::loadIcon("arrow-downleft"));
     middleBottomButton->setIcon(KisIconUtils::loadIcon("arrow-down"));
     bottomRightButton->setIcon(KisIconUtils::loadIcon("arrow-downright"));
 
     btnTransformAroundPivotPoint->setIcon(KisIconUtils::loadIcon("pivot-point"));
 
 
     // pressure icons
     liquifySizePressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     liquifyAmountPressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
 }
 
 double KisToolTransformConfigWidget::radianToDegree(double rad)
 {
     double piX2 = 2 * M_PI;
 
     if (rad < 0 || rad >= piX2) {
         rad = fmod(rad, piX2);
         if (rad < 0) {
             rad += piX2;
         }
     }
 
     return (rad * 360. / piX2);
 }
 
 double KisToolTransformConfigWidget::degreeToRadian(double degree)
 {
     if (degree < 0. || degree >= 360.) {
         degree = fmod(degree, 360.);
         if (degree < 0)
             degree += 360.;
     }
 
     return (degree * M_PI / 180.);
 }
 
 void KisToolTransformConfigWidget::updateLiquifyControls()
 {
     blockUiSlots();
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     const bool useWashMode = props->useWashMode();
 
     liquifySizeSlider->setValue(props->size());
     liquifyAmountSlider->setValue(props->amount());
     liquifyFlowSlider->setValue(props->flow());
     buidupModeComboBox->setCurrentIndex(useWashMode);
 
     liquifySpacingSlider->setValue(props->spacing());
     liquifySizePressureBox->setChecked(props->sizeHasPressure());
     liquifyAmountPressureBox->setChecked(props->amountHasPressure());
     liquifyReverseDirectionChk->setChecked(props->reverseDirection());
 
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(props->mode());
 
     bool canInverseDirection =
         mode != KisLiquifyProperties::UNDO;
 
     bool canUseWashMode = mode != KisLiquifyProperties::UNDO;
 
     liquifyReverseDirectionChk->setEnabled(canInverseDirection);
     liquifyFlowSlider->setEnabled(canUseWashMode && useWashMode);
     buidupModeComboBox->setEnabled(canUseWashMode);
 
     const qreal maxAmount = canUseWashMode ? 5.0 : 1.0;
     liquifyAmountSlider->setRange(0.0, maxAmount, 2);
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::slotLiquifyModeChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(value);
 
     if (mode == props->mode()) return;
 
     props->setMode(mode);
     props->loadMode();
 
     updateLiquifyControls();
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizeChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSize(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmount(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyFlowChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setFlow(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyBuildUpChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setUseWashMode(value); // 0 == build up mode / 1 == wash mode
 
     notifyConfigChanged();
 
     // we need to enable/disable flow slider
     updateLiquifyControls();
 }
 
 void KisToolTransformConfigWidget::liquifySpacingChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSpacing(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizePressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSizeHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountPressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmountHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyReverseDirectionChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setReverseDirection(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::updateConfig(const ToolTransformArgs &config)
 {
     blockUiSlots();
 
     if (config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
         config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) {
 
         quickTransformGroup->setEnabled(config.mode() == ToolTransformArgs::FREE_TRANSFORM);
 
         stackedWidget->setCurrentIndex(0);
 
         bool freeTransformIsActive = config.mode() == ToolTransformArgs::FREE_TRANSFORM;
 
         if (freeTransformIsActive)
         {
             freeTransformButton->setChecked(true);
         }
         else
         {
             perspectiveTransformButton->setChecked(true);
         }
 
         aXBox->setEnabled(freeTransformIsActive);
         aYBox->setEnabled(freeTransformIsActive);
         aZBox->setEnabled(freeTransformIsActive);
         freeRotationRadioButton->setEnabled(freeTransformIsActive);
 
         scaleXBox->setValue(config.scaleX() * 100.);
         scaleYBox->setValue(config.scaleY() * 100.);
         shearXBox->setValue(config.shearX());
         shearYBox->setValue(config.shearY());
 
         const QPointF anchorPoint = config.originalCenter() + config.rotationCenterOffset();
         const KisTransformUtils::MatricesPack m(config);
         const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
 
         translateXBox->setValue(anchorPointView.x());
         translateYBox->setValue(anchorPointView.y());
 
         aXBox->setValue(radianToDegree(config.aX()));
         aYBox->setValue(radianToDegree(config.aY()));
         aZBox->setValue(radianToDegree(config.aZ()));
         aspectButton->setKeepAspectRatio(config.keepAspectRatio());
         cmbFilter->setCurrent(config.filterId());
 
         QPointF pt = m_transaction->currentConfig()->rotationCenterOffset();
         pt.rx() /= m_transaction->originalHalfWidth();
         pt.ry() /= m_transaction->originalHalfHeight();
 
         for (int i = 0; i < 9; i++) {
             if (qFuzzyCompare(m_handleDir[i].x(), pt.x()) &&
                 qFuzzyCompare(m_handleDir[i].y(), pt.y())) {
 
                 m_rotationCenterButtons->button(i)->setChecked(true);
                 break;
             }
         }
 
         btnTransformAroundPivotPoint->setChecked(config.transformAroundRotationCenter());
 
     } else if (config.mode() == ToolTransformArgs::WARP) {
 
         stackedWidget->setCurrentIndex(1);
         warpButton->setChecked(true);
 
         if (config.defaultPoints()) {
             densityBox->setValue(std::sqrt(config.numPoints()));
         }
 
         cmbWarpType->setCurrentIndex((int)config.warpType());
         defaultRadioButton->setChecked(config.defaultPoints());
         customRadioButton->setChecked(!config.defaultPoints());
         densityBox->setEnabled(config.defaultPoints());
         customWarpWidget->setEnabled(!config.defaultPoints());
 
         updateLockPointsButtonCaption();
 
     } else if (config.mode() == ToolTransformArgs::CAGE) {
 
         // default UI options
         resetUIOptions();
 
         // we need at least 3 point before we can start actively deforming
         if (config.origPoints().size() >= 3)
         {
             cageTransformDirections->setText(i18n("Switch between editing and deforming cage"));
             cageAddEditRadio->setVisible(true);
             cageDeformRadio->setVisible(true);
 
             // update to correct radio button
             if (config.isEditingTransformPoints())
                 cageAddEditRadio->setChecked(true);
             else
                  cageDeformRadio->setChecked(true);
 
             changeGranularity->setCurrentIndex(log2(config.pixelPrecision()) - 2);
             granularityPreview->setCurrentIndex(log2(config.previewPixelPrecision()) - 2);
 
         }
 
     } else if (config.mode() == ToolTransformArgs::LIQUIFY) {
 
         stackedWidget->setCurrentIndex(3);
         liquifyButton->setChecked(true);
 
         const KisLiquifyProperties *props =
             config.liquifyProperties();
 
         switch (props->mode()) {
         case KisLiquifyProperties::MOVE:
             liquifyMove->setChecked(true);
             break;
         case KisLiquifyProperties::SCALE:
             liquifyScale->setChecked(true);
             break;
         case KisLiquifyProperties::ROTATE:
             liquifyRotate->setChecked(true);
             break;
         case KisLiquifyProperties::OFFSET:
             liquifyOffset->setChecked(true);
             break;
         case KisLiquifyProperties::UNDO:
             liquifyUndo->setChecked(true);
             break;
         case KisLiquifyProperties::N_MODES:
             qFatal("Unsupported mode");
         }
 
         updateLiquifyControls();
     }
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::updateLockPointsButtonCaption()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     if (config->isEditingTransformPoints()) {
         lockUnlockPointsButton->setText(i18n("Lock Points"));
     } else {
         lockUnlockPointsButton->setText(i18n("Unlock Points"));
     }
 }
 
 void KisToolTransformConfigWidget::setApplyResetDisabled(bool disabled)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     Q_ASSERT(applyButton);
     Q_ASSERT(resetButton);
 
     applyButton->setDisabled(disabled);
     resetButton->setDisabled(disabled);
 }
 
 void KisToolTransformConfigWidget::resetRotationCenterButtons()
 {
     int checkedId = m_rotationCenterButtons->checkedId();
 
     if (checkedId >= 0 && checkedId <= 8) {
         // uncheck the current checked button
         m_rotationCenterButtons->button(9)->setChecked(true);
     }
 }
 
 bool KisToolTransformConfigWidget::workRecursively() const
 {
     return chkWorkRecursively->isChecked();
 }
 
 void KisToolTransformConfigWidget::setTooBigLabelVisible(bool value)
 {
     tooBigLabelWidget->setVisible(value);
 }
 
-bool KisToolTransformConfigWidget::showDecorations() const
-{
-    return showDecorationsBox->isChecked();
-}
-
 void KisToolTransformConfigWidget::blockNotifications()
 {
     m_notificationsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockNotifications()
 {
     m_notificationsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyConfigChanged()
 {
     if (!m_notificationsBlocked) {
         emit sigConfigChanged();
     }
     m_configChanged = true;
 }
 
 void KisToolTransformConfigWidget::blockUiSlots()
 {
     m_uiSlotsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockUiSlots()
 {
     m_uiSlotsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyEditingFinished()
 {
     if (m_uiSlotsBlocked || m_notificationsBlocked || !m_configChanged) return;
 
     emit sigEditingFinished();
     m_configChanged = false;
 }
 
 
 void KisToolTransformConfigWidget::resetUIOptions()
 {
     // reset tool states since we are done (probably can encapsulate this later)
     ToolTransformArgs *config = m_transaction->currentConfig();
     if (config->mode() == ToolTransformArgs::CAGE)
     {
         cageAddEditRadio->setVisible(false);
         cageAddEditRadio->setChecked(true);
         cageDeformRadio->setVisible(false);
         cageTransformDirections->setText(i18n("Create 3 points on the canvas to begin"));
 
         // ensure we are on the right options view
         stackedWidget->setCurrentIndex(2);
     }
 
 
 
 }
 
 void KisToolTransformConfigWidget::slotButtonBoxClicked(QAbstractButton *button)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     resetUIOptions();
 
     if (button == applyButton) {
         emit sigApplyTransform();
     }
     else if (button == resetButton) {
         emit sigResetTransform();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetFreeTransformModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(freeTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::FREE_TRANSFORM);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(warpButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::WARP);
     config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::GRID);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetCageModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(cageButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::CAGE);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetLiquifyModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(liquifyButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::LIQUIFY);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetPerspectiveModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(perspectiveTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::PERSPECTIVE_4POINT);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotFilterChanged(const KoID &filterId)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setFilterId(filterId.id());
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotRotationCenterChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     if (index >= 0 && index <= 8) {
         ToolTransformArgs *config = m_transaction->currentConfig();
 
         double i = m_handleDir[index].x();
         double j = m_handleDir[index].y();
 
         config->setRotationCenterOffset(QPointF(i * m_transaction->originalHalfWidth(),
                                                 j * m_transaction->originalHalfHeight()));
 
         notifyConfigChanged();
         updateConfig(*config);
     }
 }
 
 void KisToolTransformConfigWidget::slotTransformAroundRotationCenter(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setTransformAroundRotationCenter(value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
 
         blockNotifications();
          int calculatedValue = int( value/ m_scaleRatio );
 
         scaleYBox->blockSignals(true);
         scaleYBox->setValue(calculatedValue);
         {
             KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
             config->setScaleY(calculatedValue / 100.);
         }
         scaleYBox->blockSignals(false);
 
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
         blockNotifications();
         int calculatedValue = int(m_scaleRatio * value);
         scaleXBox->blockSignals(true);
         scaleXBox->setValue(calculatedValue);
         {
             KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
             config->setScaleX(calculatedValue / 100.);
         }
         scaleXBox->blockSignals(false);
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearX((double)value);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearY((double)value);
     }
 
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(value, anchorPointView.y());
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(anchorPointView.x(), value);
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetAX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAX(degreeToRadian((double)value));
     }
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAY(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAZ(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipX()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(config->scaleX() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipY()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(config->scaleY() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() + M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() - M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 
 // change free transform setting we want to alter (all radio buttons call this)
 void KisToolTransformConfigWidget::slotTransformAreaVisible(bool value)
 {
     Q_UNUSED(value);
 
     //QCheckBox sender = (QCheckBox)(*)(QObject::sender());
     QString senderName = QObject::sender()->objectName();
 
 
     // only show setting with what we have selected
     rotationGroup->hide();
     shearGroup->hide();
     scaleGroup->hide();
     moveGroup->hide();
 
 
     if ("freeMoveRadioButton" == senderName)
     {
         moveGroup->show();
     }
     else  if ("freeShearRadioButton" == senderName)
     {
         shearGroup->show();
     }
     else if ("freeScaleRadioButton" == senderName)
     {
         scaleGroup->show();
     }
     else
     {
         rotationGroup->show();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetKeepAspectRatio(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setKeepAspectRatio(value);
 
     if (value) {
        blockNotifications();
        int tmpXScaleBox = scaleXBox->value();
        int tmpYScaleBox = scaleYBox->value();
        m_scaleRatio = (tmpXScaleBox / (double) tmpYScaleBox);
        unblockNotifications();
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpAlpha(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setAlpha((double)value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpDensity(int value)
 {
     if (m_uiSlotsBlocked) return;
     setDefaultWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::setDefaultWarpPoints(int pointsPerLine)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     KisTransformUtils::setDefaultWarpPoints(pointsPerLine, m_transaction, config);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::activateCustomWarpPoints(bool enabled)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     densityBox->setEnabled(!enabled);
     customWarpWidget->setEnabled(enabled);
 
     if (!enabled) {
         config->setEditingTransformPoints(false);
         setDefaultWarpPoints(densityBox->value());
         config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::GRID);
     } else {
         config->setEditingTransformPoints(true);
         config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::DRAW);
         setDefaultWarpPoints(0);
     }
 
 
 
 
     updateLockPointsButtonCaption();
 }
 
 void KisToolTransformConfigWidget::slotWarpDefaultPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(!value);
 }
 
 void KisToolTransformConfigWidget::slotWarpCustomPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::slotWarpResetPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(true);
 }
 
 void KisToolTransformConfigWidget::slotWarpLockPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setEditingTransformPoints(!config->isEditingTransformPoints());
 
     if (config->isEditingTransformPoints()) {
         // reinit the transf points to their original value
         ToolTransformArgs *config = m_transaction->currentConfig();
         int nbPoints = config->origPoints().size();
         for (int i = 0; i < nbPoints; ++i) {
             config->transfPoint(i) = config->origPoint(i);
         }
     }
 
     updateLockPointsButtonCaption();
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotWarpTypeChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     switch (index) {
     case KisWarpTransformWorker::AFFINE_TRANSFORM:
     case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
     case KisWarpTransformWorker::RIGID_TRANSFORM:
         config->setWarpType((KisWarpTransformWorker::WarpType)index);
         break;
     default:
         config->setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
         break;
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotCageOptionsChanged(int value)
 {
     if ( value == 0)
     {
         slotEditCagePoints(true);
     }
     else
     {
         slotEditCagePoints(false);
     }
 
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotEditCagePoints(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->refTransformedPoints() = config->origPoints();
 
     config->setEditingTransformPoints(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotGranularityChanged(QString value)
 {
     if (m_uiSlotsBlocked) return;
     KIS_SAFE_ASSERT_RECOVER_RETURN(value.toInt() > 1);
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setPixelPrecision(value.toInt());
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotPreviewGranularityChanged(QString value)
 {
     if (m_uiSlotsBlocked) return;
     KIS_SAFE_ASSERT_RECOVER_RETURN(value.toInt() > 1);
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setPreviewPixelPrecision(value.toInt());
     notifyConfigChanged();
 }
diff --git a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h
index 23304e360b..c78bd58ee3 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.h
@@ -1,152 +1,151 @@
 /*
  *  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_TOOL_TRANSFORM_CONFIG_WIDGET_H
 #define __KIS_TOOL_TRANSFORM_CONFIG_WIDGET_H
 
 #include "transform_transaction_properties.h"
 #include "tool_transform_args.h"
 #include "ui_wdg_tool_transform.h"
 
 class KisCanvas2;
 
 
 class KisToolTransformConfigWidget : public QWidget, private Ui::WdgToolTransform
 {
     Q_OBJECT
 
 public:
     KisToolTransformConfigWidget(TransformTransactionProperties *transaction, KisCanvas2 *canvas, bool workRecursively, QWidget *parent);
 
     void setApplyResetDisabled(bool disabled);
     void resetRotationCenterButtons();
     void setDefaultWarpPoints(int pointsPerLine = -1);
     void setTooBigLabelVisible(bool value);
-    bool showDecorations() const;
     bool workRecursively() const;
 
 public Q_SLOTS:
     void updateConfig(const ToolTransformArgs &config);
     void slotUpdateIcons();
 
 Q_SIGNALS:
     void sigConfigChanged();
     void sigApplyTransform();
     void sigResetTransform();
     void sigRestartTransform();
     void sigEditingFinished();
 
 public Q_SLOTS:
 
     void slotFilterChanged(const KoID &filter);
     void slotWarpTypeChanged(int index);
     void slotRotationCenterChanged(int index);
     void slotTransformAroundRotationCenter(bool value);
 
     void slotSetScaleX(int value);
     void slotSetScaleY(int value);
 
     void slotSetShearX(qreal value);
     void slotSetShearY(qreal value);
 
     void slotSetTranslateX(int value);
     void slotSetTranslateY(int value);
 
     void slotSetAX(qreal value);
     void slotSetAY(qreal value);
     void slotSetAZ(qreal value);
 
     void slotFlipX();
     void slotFlipY();
     void slotRotateCW();
     void slotRotateCCW();
 
     void slotSetWarpAlpha(qreal value);
     void slotSetWarpDensity(int value);
 
     void slotSetKeepAspectRatio(bool value);
 
     void slotTransformAreaVisible(bool value);
 
     void slotWarpDefaultPointsButtonClicked(bool value);
     void slotWarpCustomPointsButtonClicked(bool value);
     void slotWarpLockPointsButtonClicked();
     void slotWarpResetPointsButtonClicked();
 
     void slotSetFreeTransformModeButtonClicked(bool);
     void slotSetWarpModeButtonClicked(bool);
     void slotSetCageModeButtonClicked(bool);
     void slotCageOptionsChanged(int);
 
     void slotSetPerspectiveModeButtonClicked(bool);
     void slotSetLiquifyModeButtonClicked(bool);
     void slotButtonBoxClicked(QAbstractButton *button);
 
     void slotEditCagePoints(bool value);
 
     void liquifySizeChanged(qreal value);
     void liquifyAmountChanged(qreal value);
     void liquifyFlowChanged(qreal value);
     void liquifyBuildUpChanged(int value);
     void liquifySpacingChanged(qreal value);
     void liquifySizePressureChanged(bool value);
     void liquifyAmountPressureChanged(bool value);
     void liquifyReverseDirectionChanged(bool value);
 
     void slotLiquifyModeChanged(int value);
 
     void notifyEditingFinished();
 
     void slotGranularityChanged(QString value);
     void slotPreviewGranularityChanged(QString value);
 
 private:
     // rad being in |R, the returned value is in [0; 360]
     double radianToDegree(double rad);
     // degree being in |R, the returned value is in [0; 2*M_PI]
     double degreeToRadian(double degree);
 
     void blockNotifications();
     void unblockNotifications();
     void notifyConfigChanged();
 
     void blockUiSlots();
     void unblockUiSlots();
 
     void activateCustomWarpPoints(bool enabled);
 
     void updateLockPointsButtonCaption();
 
     void updateLiquifyControls();
 
     void resetUIOptions();
 
 private:
     static const int DEFAULT_POINTS_PER_LINE;
 
 private:
     TransformTransactionProperties *m_transaction;
     QPointF m_handleDir[9];
     QButtonGroup *m_rotationCenterButtons;
     int m_notificationsBlocked;
     int m_uiSlotsBlocked;
     double m_scaleRatio;
     bool m_configChanged;
 };
 
 #endif /* __KIS_TOOL_TRANSFORM_CONFIG_WIDGET_H */
diff --git a/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp b/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp
index ead75713ee..fdad9f32b2 100644
--- a/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp
+++ b/plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp
@@ -1,640 +1,647 @@
 /*
  *  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_warp_transform_strategy.h"
 
 #include <algorithm>
 
 #include <QPointF>
 #include <QPainter>
 
 #include "kis_coordinates_converter.h"
 #include "tool_transform_args.h"
 #include "transform_transaction_properties.h"
 #include "kis_painting_tweaks.h"
 #include "kis_cursor.h"
 #include "kis_transform_utils.h"
 #include "kis_algebra_2d.h"
 #include "KisHandlePainterHelper.h"
+#include "kis_signal_compressor.h"
 
 
 
 struct KisWarpTransformStrategy::Private
 {
     Private(KisWarpTransformStrategy *_q,
             const KisCoordinatesConverter *_converter,
             ToolTransformArgs &_currentArgs,
             TransformTransactionProperties &_transaction)
         : q(_q),
           converter(_converter),
           currentArgs(_currentArgs),
           transaction(_transaction),
           lastNumPoints(0),
           drawConnectionLines(false), // useful while developing
           drawOrigPoints(false),
           drawTransfPoints(true),
           closeOnStartPointClick(false),
           clipOriginalPointsPosition(true),
-          pointWasDragged(false)
+          pointWasDragged(false),
+          recalculateSignalCompressor(40, KisSignalCompressor::FIRST_ACTIVE)
     {
     }
 
     KisWarpTransformStrategy * const q;
 
     /// standard members ///
 
     const KisCoordinatesConverter *converter;
 
     //////
     ToolTransformArgs &currentArgs;
     //////
     TransformTransactionProperties &transaction;
 
     QTransform paintingTransform;
     QPointF paintingOffset;
 
     QTransform handlesTransform;
 
     /// custom members ///
 
     QImage transformedImage;
 
     int pointIndexUnderCursor;
 
     enum Mode {
         OVER_POINT = 0,
         MULTIPLE_POINT_SELECTION,
         MOVE_MODE,
         ROTATE_MODE,
         SCALE_MODE,
         NOTHING
     };
     Mode mode;
 
     QVector<int> pointsInAction;
     int lastNumPoints;
 
     bool drawConnectionLines;
     bool drawOrigPoints;
     bool drawTransfPoints;
     bool closeOnStartPointClick;
     bool clipOriginalPointsPosition;
     QPointF pointPosOnClick;
     bool pointWasDragged;
 
     QPointF lastMousePos;
 
     // cage transform also uses this logic. This helps this class know what transform type we are using
     TransformType transformType = TransformType::WARP_TRANSFORM;
+    KisSignalCompressor recalculateSignalCompressor;
 
     void recalculateTransformations();
     inline QPointF imageToThumb(const QPointF &pt, bool useFlakeOptimization);
 
     bool shouldCloseTheCage() const;
     QVector<QPointF*> getSelectedPoints(QPointF *center, bool limitToSelectedOnly = false) const;
 };
 
 KisWarpTransformStrategy::KisWarpTransformStrategy(const KisCoordinatesConverter *converter,
                                                    ToolTransformArgs &currentArgs,
                                                    TransformTransactionProperties &transaction)
     : KisSimplifiedActionPolicyStrategy(converter),
       m_d(new Private(this, converter, currentArgs, transaction))
 {
+    connect(&m_d->recalculateSignalCompressor, SIGNAL(timeout()),
+            SLOT(recalculateTransformations()));
 }
 
 KisWarpTransformStrategy::~KisWarpTransformStrategy()
 {
 }
 
 void KisWarpTransformStrategy::setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive)
 {
     double handleRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
 
     bool cursorOverPoint = false;
     m_d->pointIndexUnderCursor = -1;
 
     KisTransformUtils::HandleChooser<Private::Mode>
         handleChooser(mousePos, Private::NOTHING);
 
     const QVector<QPointF> &points = m_d->currentArgs.transfPoints();
     for (int i = 0; i < points.size(); ++i) {
         if (handleChooser.addFunction(points[i],
                                       handleRadius, Private::NOTHING)) {
 
             cursorOverPoint = true;
             m_d->pointIndexUnderCursor = i;
         }
     }
 
     if (cursorOverPoint) {
         m_d->mode = perspectiveModifierActive &&
             !m_d->currentArgs.isEditingTransformPoints() ?
             Private::MULTIPLE_POINT_SELECTION : Private::OVER_POINT;
 
     } else if (!m_d->currentArgs.isEditingTransformPoints()) {
         QPolygonF polygon(m_d->currentArgs.transfPoints());
         bool insidePolygon = polygon.boundingRect().contains(mousePos);
         m_d->mode = insidePolygon ? Private::MOVE_MODE :
             !perspectiveModifierActive ? Private::ROTATE_MODE :
             Private::SCALE_MODE;
     } else {
         m_d->mode = Private::NOTHING;
     }
 }
 
 QCursor KisWarpTransformStrategy::getCurrentCursor() const
 {
     QCursor cursor;
 
     switch (m_d->mode) {
     case Private::OVER_POINT:
         cursor = KisCursor::pointingHandCursor();
         break;
     case Private::MULTIPLE_POINT_SELECTION:
         cursor = KisCursor::crossCursor();
         break;
     case Private::MOVE_MODE:
         cursor = KisCursor::moveCursor();
         break;
     case Private::ROTATE_MODE:
         cursor = KisCursor::rotateCursor();
         break;
     case Private::SCALE_MODE:
         cursor = KisCursor::sizeVerCursor();
         break;
     case Private::NOTHING:
         cursor = KisCursor::arrowCursor();
         break;
     }
 
     return cursor;
 }
 
 void KisWarpTransformStrategy::overrideDrawingItems(bool drawConnectionLines,
                                                     bool drawOrigPoints,
                                                     bool drawTransfPoints)
 {
     m_d->drawConnectionLines = drawConnectionLines;
     m_d->drawOrigPoints = drawOrigPoints;
     m_d->drawTransfPoints = drawTransfPoints;
 }
 
 void KisWarpTransformStrategy::setCloseOnStartPointClick(bool value)
 {
     m_d->closeOnStartPointClick = value;
 }
 
 void KisWarpTransformStrategy::setClipOriginalPointsPosition(bool value)
 {
     m_d->clipOriginalPointsPosition = value;
 }
 
 void KisWarpTransformStrategy::setTransformType(TransformType type) {
     m_d->transformType = type;
 }
 
 void KisWarpTransformStrategy::drawConnectionLines(QPainter &gc,
                                                    const QVector<QPointF> &origPoints,
                                                    const QVector<QPointF> &transfPoints,
                                                    bool isEditingPoints)
 {
     Q_UNUSED(isEditingPoints);
 
     QPen antsPen;
     QPen outlinePen;
 
     KisPaintingTweaks::initAntsPen(&antsPen, &outlinePen);
 
     const int numPoints = origPoints.size();
 
     for (int i = 0; i < numPoints; ++i) {
         gc.setPen(outlinePen);
         gc.drawLine(transfPoints[i], origPoints[i]);
         gc.setPen(antsPen);
         gc.drawLine(transfPoints[i], origPoints[i]);
     }
 }
 
 void KisWarpTransformStrategy::paint(QPainter &gc)
 {
     // Draw preview image
 
     gc.save();
 
     gc.setOpacity(m_d->transaction.basePreviewOpacity());
     gc.setTransform(m_d->paintingTransform, true);
     gc.drawImage(m_d->paintingOffset, m_d->transformedImage);
 
     gc.restore();
 
 
     gc.save();
     gc.setTransform(m_d->handlesTransform, true);
 
     if (m_d->drawConnectionLines) {
         gc.setOpacity(0.5);
 
         drawConnectionLines(gc,
                             m_d->currentArgs.origPoints(),
                             m_d->currentArgs.transfPoints(),
                             m_d->currentArgs.isEditingTransformPoints());
     }
 
 
     QPen mainPen(Qt::black);
     QPen outlinePen(Qt::white);
 
     // draw handles
     {
         const int numPoints = m_d->currentArgs.origPoints().size();
 
 
 
         qreal handlesExtraScale = KisTransformUtils::scaleFromAffineMatrix(m_d->handlesTransform);
 
         qreal dstIn = 8 / handlesExtraScale;
         qreal dstOut = 10 / handlesExtraScale;
         qreal srcIn = 6 / handlesExtraScale;
         qreal srcOut = 6 / handlesExtraScale;
 
         QRectF handleRect1(-0.5 * dstIn, -0.5 * dstIn, dstIn, dstIn);
         QRectF handleRect2(-0.5 * dstOut, -0.5 * dstOut, dstOut, dstOut);
 
         if (m_d->drawTransfPoints) {
             gc.setOpacity(1.0);
 
             for (int i = 0; i < numPoints; ++i) {
                 gc.setPen(outlinePen);
                 gc.drawEllipse(handleRect2.translated(m_d->currentArgs.transfPoints()[i]));
                 gc.setPen(mainPen);
                 gc.drawEllipse(handleRect1.translated(m_d->currentArgs.transfPoints()[i]));
             }
 
             QPointF center;
             QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center, true);
 
             QBrush selectionBrush = selectedPoints.size() > 1 ? Qt::red : Qt::black;
 
             QBrush oldBrush = gc.brush();
             gc.setBrush(selectionBrush);
             Q_FOREACH (const QPointF *pt, selectedPoints) {
                 gc.drawEllipse(handleRect1.translated(*pt));
             }
             gc.setBrush(oldBrush);
 
         }
 
         if (m_d->drawOrigPoints) {
             QPainterPath inLine;
             inLine.moveTo(-0.5 * srcIn,            0);
             inLine.lineTo( 0.5 * srcIn,            0);
             inLine.moveTo(           0, -0.5 * srcIn);
             inLine.lineTo(           0,  0.5 * srcIn);
 
             QPainterPath outLine;
             outLine.moveTo(-0.5 * srcOut, -0.5 * srcOut);
             outLine.lineTo( 0.5 * srcOut, -0.5 * srcOut);
             outLine.lineTo( 0.5 * srcOut,  0.5 * srcOut);
             outLine.lineTo(-0.5 * srcOut,  0.5 * srcOut);
             outLine.lineTo(-0.5 * srcOut, -0.5 * srcOut);
 
             gc.setOpacity(0.5);
 
             for (int i = 0; i < numPoints; ++i) {
                 gc.setPen(outlinePen);
                 gc.drawPath(outLine.translated(m_d->currentArgs.origPoints()[i]));
                 gc.setPen(mainPen);
                 gc.drawPath(inLine.translated(m_d->currentArgs.origPoints()[i]));
             }
         }
 
     }
 
     // draw grid lines only if we are using the GRID mode. Also only use this logic for warp, not cage transforms
     if (m_d->currentArgs.warpCalculation() == KisWarpTransformWorker::WarpCalculation::GRID &&
         m_d->transformType == TransformType::WARP_TRANSFORM ) {
 
     // see how many rows we have. we are only going to do lines up to 6 divisions/
     // it is almost impossible to use with 6 even.
     const int numPoints = m_d->currentArgs.origPoints().size();
 
     // grid is always square, so get the square root to find # of rows
     int rowsInWarp = sqrt(m_d->currentArgs.origPoints().size());
 
 
         KisHandlePainterHelper handlePainter(&gc);
         handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
 
         // draw horizontal lines
         for (int i = 0; i < numPoints; i++) {
             if (i != 0 &&  i % rowsInWarp == rowsInWarp -1) {
                 // skip line if it is the last in the row
             } else {
                 handlePainter.drawConnectionLine(m_d->currentArgs.transfPoints()[i], m_d->currentArgs.transfPoints()[i+1]  );
             }
         }
 
         // draw vertical lines
         for (int i = 0; i < numPoints; i++) {
 
             if ( (numPoints - i - 1) < rowsInWarp ) {
                 // last row doesn't need to draw vertical lines
             } else {
                 handlePainter.drawConnectionLine(m_d->currentArgs.transfPoints()[i], m_d->currentArgs.transfPoints()[i+rowsInWarp] );
             }
         }
 
     } // end if statement
 
     gc.restore();
 }
 
 void KisWarpTransformStrategy::externalConfigChanged()
 {
     if (m_d->lastNumPoints != m_d->currentArgs.transfPoints().size()) {
         m_d->pointsInAction.clear();
     }
 
     m_d->recalculateTransformations();
 }
 
 bool KisWarpTransformStrategy::beginPrimaryAction(const QPointF &pt)
 {
     const bool isEditingPoints = m_d->currentArgs.isEditingTransformPoints();
     bool retval = false;
 
     if (m_d->mode == Private::OVER_POINT ||
         m_d->mode == Private::MULTIPLE_POINT_SELECTION ||
         m_d->mode == Private::MOVE_MODE ||
         m_d->mode == Private::ROTATE_MODE ||
         m_d->mode == Private::SCALE_MODE) {
 
         retval = true;
 
     } else if (isEditingPoints) {
         QPointF newPos = m_d->clipOriginalPointsPosition ?
             KisTransformUtils::clipInRect(pt, m_d->transaction.originalRect()) :
             pt;
 
         m_d->currentArgs.refOriginalPoints().append(newPos);
         m_d->currentArgs.refTransformedPoints().append(newPos);
 
         m_d->mode = Private::OVER_POINT;
         m_d->pointIndexUnderCursor = m_d->currentArgs.origPoints().size() - 1;
 
-        m_d->recalculateTransformations();
-        emit requestCanvasUpdate();
+        m_d->recalculateSignalCompressor.start();
 
         retval = true;
     }
 
     if (m_d->mode == Private::OVER_POINT) {
         m_d->pointPosOnClick =
             m_d->currentArgs.transfPoints()[m_d->pointIndexUnderCursor];
         m_d->pointWasDragged = false;
 
         m_d->pointsInAction.clear();
         m_d->pointsInAction << m_d->pointIndexUnderCursor;
         m_d->lastNumPoints = m_d->currentArgs.transfPoints().size();
     } else if (m_d->mode == Private::MULTIPLE_POINT_SELECTION) {
         QVector<int>::iterator it =
             std::find(m_d->pointsInAction.begin(),
                       m_d->pointsInAction.end(),
                       m_d->pointIndexUnderCursor);
 
         if (it != m_d->pointsInAction.end()) {
             m_d->pointsInAction.erase(it);
         } else {
             m_d->pointsInAction << m_d->pointIndexUnderCursor;
         }
 
         m_d->lastNumPoints = m_d->currentArgs.transfPoints().size();
     }
 
     m_d->lastMousePos = pt;
     return retval;
 }
 
 QVector<QPointF*> KisWarpTransformStrategy::Private::getSelectedPoints(QPointF *center, bool limitToSelectedOnly) const
 {
     QVector<QPointF> &points = currentArgs.refTransformedPoints();
 
     QRectF boundingRect;
     QVector<QPointF*> selectedPoints;
     if (limitToSelectedOnly || pointsInAction.size() > 1) {
         Q_FOREACH (int index, pointsInAction) {
             selectedPoints << &points[index];
             KisAlgebra2D::accumulateBounds(points[index], &boundingRect);
         }
     } else {
         QVector<QPointF>::iterator it = points.begin();
         QVector<QPointF>::iterator end = points.end();
         for (; it != end; ++it) {
             selectedPoints << &(*it);
             KisAlgebra2D::accumulateBounds(*it, &boundingRect);
         }
     }
 
     *center = boundingRect.center();
     return selectedPoints;
 }
 
 void KisWarpTransformStrategy::continuePrimaryAction(const QPointF &pt, bool shiftModifierActve, bool altModifierActive)
 {
     Q_UNUSED(shiftModifierActve);
     Q_UNUSED(altModifierActive);
 
     // toplevel code switches to HOVER mode if nothing is selected
     KIS_ASSERT_RECOVER_RETURN(m_d->mode == Private::MOVE_MODE ||
                               m_d->mode == Private::ROTATE_MODE ||
                               m_d->mode == Private::SCALE_MODE ||
                               (m_d->mode == Private::OVER_POINT &&
                                m_d->pointIndexUnderCursor >= 0 &&
                                m_d->pointsInAction.size() == 1) ||
                               (m_d->mode == Private::MULTIPLE_POINT_SELECTION &&
                                m_d->pointIndexUnderCursor >= 0));
 
     if (m_d->mode == Private::OVER_POINT) {
         if (m_d->currentArgs.isEditingTransformPoints()) {
             QPointF newPos = m_d->clipOriginalPointsPosition ?
                 KisTransformUtils::clipInRect(pt, m_d->transaction.originalRect()) :
                 pt;
             m_d->currentArgs.origPoint(m_d->pointIndexUnderCursor) = newPos;
             m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor) = newPos;
         } else {
             m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor) = pt;
         }
 
 
         const qreal handleRadiusSq = pow2(KisTransformUtils::effectiveHandleGrabRadius(m_d->converter));
         qreal dist =
             kisSquareDistance(
                 m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor),
                 m_d->pointPosOnClick);
 
         if (dist > handleRadiusSq) {
             m_d->pointWasDragged = true;
         }
     } else if (m_d->mode == Private::MOVE_MODE) {
         QPointF center;
         QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
         QPointF diff = pt - m_d->lastMousePos;
 
         QVector<QPointF*>::iterator it = selectedPoints.begin();
         QVector<QPointF*>::iterator end = selectedPoints.end();
         for (; it != end; ++it) {
             **it += diff;
         }
     } else if (m_d->mode == Private::ROTATE_MODE) {
         QPointF center;
         QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
         QPointF oldDirection = m_d->lastMousePos - center;
         QPointF newDirection = pt - center;
 
         qreal rotateAngle = KisAlgebra2D::angleBetweenVectors(oldDirection, newDirection);
         QTransform R;
         R.rotateRadians(rotateAngle);
 
         QTransform t =
             QTransform::fromTranslate(-center.x(), -center.y()) *
             R *
             QTransform::fromTranslate(center.x(), center.y());
 
         QVector<QPointF*>::iterator it = selectedPoints.begin();
         QVector<QPointF*>::iterator end = selectedPoints.end();
         for (; it != end; ++it) {
             **it = t.map(**it);
         }
     } else if (m_d->mode == Private::SCALE_MODE) {
         QPointF center;
         QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
         QPolygonF polygon(m_d->currentArgs.origPoints());
         QSizeF maxSize = polygon.boundingRect().size();
         qreal maxDimension = qMax(maxSize.width(), maxSize.height());
 
         qreal scale = 1.0 - (pt - m_d->lastMousePos).y() / maxDimension;
 
         QTransform t =
             QTransform::fromTranslate(-center.x(), -center.y()) *
             QTransform::fromScale(scale, scale) *
             QTransform::fromTranslate(center.x(), center.y());
 
         QVector<QPointF*>::iterator it = selectedPoints.begin();
         QVector<QPointF*>::iterator end = selectedPoints.end();
         for (; it != end; ++it) {
             **it = t.map(**it);
         }
     }
 
     m_d->lastMousePos = pt;
-    m_d->recalculateTransformations();
-    emit requestCanvasUpdate();
+    m_d->recalculateSignalCompressor.start();
+
 }
 
 bool KisWarpTransformStrategy::Private::shouldCloseTheCage() const
 {
     return currentArgs.isEditingTransformPoints() &&
         closeOnStartPointClick &&
         pointIndexUnderCursor == 0 &&
         currentArgs.origPoints().size() > 2 &&
         !pointWasDragged;
 }
 
 bool KisWarpTransformStrategy::acceptsClicks() const
 {
     return m_d->shouldCloseTheCage() ||
         m_d->currentArgs.isEditingTransformPoints();
 }
 
 bool KisWarpTransformStrategy::endPrimaryAction()
 {
     if (m_d->shouldCloseTheCage()) {
         m_d->currentArgs.setEditingTransformPoints(false);
     }
 
     return true;
 }
 
 inline QPointF KisWarpTransformStrategy::Private::imageToThumb(const QPointF &pt, bool useFlakeOptimization)
 {
     return useFlakeOptimization ? converter->imageToDocument(converter->documentToFlake((pt))) : q->thumbToImageTransform().inverted().map(pt);
 }
 
 void KisWarpTransformStrategy::Private::recalculateTransformations()
 {
     QTransform scaleTransform = KisTransformUtils::imageToFlakeTransform(converter);
 
     QTransform resultThumbTransform = q->thumbToImageTransform() * scaleTransform;
     qreal scale = KisTransformUtils::scaleFromAffineMatrix(resultThumbTransform);
     bool useFlakeOptimization = scale < 1.0 &&
         !KisTransformUtils::thumbnailTooSmall(resultThumbTransform, q->originalImage().rect());
 
     QVector<QPointF> thumbOrigPoints(currentArgs.numPoints());
     QVector<QPointF> thumbTransfPoints(currentArgs.numPoints());
 
     for (int i = 0; i < currentArgs.numPoints(); ++i) {
         thumbOrigPoints[i] = imageToThumb(currentArgs.origPoints()[i], useFlakeOptimization);
         thumbTransfPoints[i] = imageToThumb(currentArgs.transfPoints()[i], useFlakeOptimization);
     }
 
     paintingOffset = transaction.originalTopLeft();
 
     if (!q->originalImage().isNull() && !currentArgs.isEditingTransformPoints()) {
         QPointF origTLInFlake = imageToThumb(transaction.originalTopLeft(), useFlakeOptimization);
 
         if (useFlakeOptimization) {
             transformedImage = q->originalImage().transformed(resultThumbTransform);
             paintingTransform = QTransform();
         } else {
             transformedImage = q->originalImage();
             paintingTransform = resultThumbTransform;
 
         }
 
         transformedImage = q->calculateTransformedImage(currentArgs,
                                                         transformedImage,
                                                         thumbOrigPoints,
                                                         thumbTransfPoints,
                                                         origTLInFlake,
                                                         &paintingOffset);
     } else {
         transformedImage = q->originalImage();
         paintingOffset = imageToThumb(transaction.originalTopLeft(), false);
         paintingTransform = resultThumbTransform;
     }
 
     handlesTransform = scaleTransform;
+    emit q->requestCanvasUpdate();
 }
 
 QImage KisWarpTransformStrategy::calculateTransformedImage(ToolTransformArgs &currentArgs,
                                                            const QImage &srcImage,
                                                            const QVector<QPointF> &origPoints,
                                                            const QVector<QPointF> &transfPoints,
                                                            const QPointF &srcOffset,
                                                            QPointF *dstOffset)
 {
     return KisWarpTransformWorker::transformQImage(
         currentArgs.warpType(),
         origPoints, transfPoints,
         currentArgs.alpha(),
         srcImage,
         srcOffset, dstOffset);
 }
+
+#include "moc_kis_warp_transform_strategy.cpp"
diff --git a/plugins/tools/tool_transform2/kis_warp_transform_strategy.h b/plugins/tools/tool_transform2/kis_warp_transform_strategy.h
index 790fc1d0e6..b2dc7a5415 100644
--- a/plugins/tools/tool_transform2/kis_warp_transform_strategy.h
+++ b/plugins/tools/tool_transform2/kis_warp_transform_strategy.h
@@ -1,97 +1,100 @@
 /*
  *  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_WARP_TRANSFORM_STRATEGY_H
 #define __KIS_WARP_TRANSFORM_STRATEGY_H
 
 #include <QObject>
 #include <QScopedPointer>
 
 #include "kis_simplified_action_policy_strategy.h"
 
 class QPointF;
 class QPainter;
 class KisCoordinatesConverter;
 class ToolTransformArgs;
 class TransformTransactionProperties;
 class QCursor;
 class QImage;
 
 enum TransformType {
     WARP_TRANSFORM,
     CAGE_TRANSFORM
 };
 
 class KisWarpTransformStrategy : public KisSimplifiedActionPolicyStrategy
 {
     Q_OBJECT
 public:
     KisWarpTransformStrategy(const KisCoordinatesConverter *converter,
                              ToolTransformArgs &currentArgs,
                              TransformTransactionProperties &transaction);
     ~KisWarpTransformStrategy() override;
 
     void setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive) override;
     void setTransformType(TransformType type);
 
     void paint(QPainter &gc) override;
     QCursor getCurrentCursor() const override;
 
     void externalConfigChanged() override;
 
     using KisTransformStrategyBase::beginPrimaryAction;
     using KisTransformStrategyBase::continuePrimaryAction;
     using KisTransformStrategyBase::endPrimaryAction;
 
     bool beginPrimaryAction(const QPointF &pt) override;
     void continuePrimaryAction(const QPointF &pt, bool shiftModifierActve, bool altModifierActive) override;
     bool endPrimaryAction() override;
 
     bool acceptsClicks() const override;
 
+private:
+    Q_PRIVATE_SLOT(m_d, void recalculateTransformations());
+
 Q_SIGNALS:
     void requestCanvasUpdate();
 
 protected:
     // default is true
     void setClipOriginalPointsPosition(bool value);
 
     // default is false
     void setCloseOnStartPointClick(bool value);
 
     void overrideDrawingItems(bool drawConnectionLines,
                               bool drawOrigPoints,
                               bool drawTransfPoints);
 
     virtual void drawConnectionLines(QPainter &gc,
                                      const QVector<QPointF> &origPoints,
                                      const QVector<QPointF> &transfPoints,
                                      bool isEditingPoints);
 
     virtual QImage calculateTransformedImage(ToolTransformArgs &currentArgs,
                                              const QImage &srcImage,
                                              const QVector<QPointF> &origPoints,
                                              const QVector<QPointF> &transfPoints,
                                              const QPointF &srcOffset,
                                              QPointF *dstOffset);
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_WARP_TRANSFORM_STRATEGY_H */
diff --git a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp
index 886ccf91d0..9390384de0 100644
--- a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp
+++ b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.cpp
@@ -1,644 +1,697 @@
 /*
  *  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 "transform_stroke_strategy.h"
 
 #include <QMutexLocker>
 #include "kundo2commandextradata.h"
 
 #include "kis_node_progress_proxy.h"
 
 #include <klocalizedstring.h>
 #include <kis_node.h>
 #include <kis_group_layer.h>
 #include <kis_external_layer_iface.h>
 #include <kis_transaction.h>
 #include <kis_painter.h>
 #include <kis_transform_worker.h>
 #include <kis_transform_mask.h>
 #include "kis_transform_mask_adapter.h"
 #include "kis_transform_utils.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_recalculate_transform_mask_job.h"
 
 #include "kis_projection_leaf.h"
 #include "kis_modify_transform_mask_command.h"
 
 #include "kis_sequential_iterator.h"
 #include "kis_selection_mask.h"
 #include "kis_image_config.h"
 #include "kis_layer_utils.h"
 #include <QQueue>
 #include <KisDeleteLaterWrapper.h>
 #include "transform_transaction_properties.h"
 #include "krita_container_utils.h"
 #include "commands_new/kis_saved_commands.h"
 #include "kis_command_ids.h"
 #include "KisRunnableStrokeJobUtils.h"
 #include "commands_new/KisHoldUIUpdatesCommand.h"
 
 
 TransformStrokeStrategy::TransformStrokeStrategy(ToolTransformArgs::TransformMode mode,
                                                  bool workRecursively,
                                                  const QString &filterId,
                                                  bool forceReset,
                                                  KisNodeSP rootNode,
                                                  KisSelectionSP selection,
                                                  KisStrokeUndoFacade *undoFacade,
                                                  KisUpdatesFacade *updatesFacade)
     : KisStrokeStrategyUndoCommandBased(kundo2_i18n("Transform"), false, undoFacade),
       m_updatesFacade(updatesFacade),
       m_mode(mode),
       m_workRecursively(workRecursively),
       m_filterId(filterId),
       m_forceReset(forceReset),
       m_selection(selection)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(!selection || !dynamic_cast<KisTransformMask*>(rootNode.data()));
 
     m_rootNode = rootNode;
     setMacroId(KisCommandUtils::TransformToolId);
 }
 
 TransformStrokeStrategy::~TransformStrokeStrategy()
 {
 }
 
 KisPaintDeviceSP TransformStrokeStrategy::createDeviceCache(KisPaintDeviceSP dev)
 {
     KisPaintDeviceSP cache;
 
     if (m_selection) {
         QRect srcRect = m_selection->selectedExactRect();
 
         cache = dev->createCompositionSourceDevice();
         KisPainter gc(cache);
         gc.setSelection(m_selection);
         gc.bitBlt(srcRect.topLeft(), dev, srcRect);
     } else {
         cache = dev->createCompositionSourceDevice(dev);
     }
 
     return cache;
 }
 
 bool TransformStrokeStrategy::haveDeviceInCache(KisPaintDeviceSP src)
 {
     QMutexLocker l(&m_devicesCacheMutex);
     return m_devicesCacheHash.contains(src.data());
 }
 
 void TransformStrokeStrategy::putDeviceCache(KisPaintDeviceSP src, KisPaintDeviceSP cache)
 {
     QMutexLocker l(&m_devicesCacheMutex);
     m_devicesCacheHash.insert(src.data(), cache);
 }
 
 KisPaintDeviceSP TransformStrokeStrategy::getDeviceCache(KisPaintDeviceSP src)
 {
     QMutexLocker l(&m_devicesCacheMutex);
     KisPaintDeviceSP cache = m_devicesCacheHash.value(src.data());
     if (!cache) {
         warnKrita << "WARNING: Transform Stroke: the device is absent in cache!";
     }
 
     return cache;
 }
 
 bool TransformStrokeStrategy::checkBelongsToSelection(KisPaintDeviceSP device) const
 {
     return m_selection &&
         (device == m_selection->pixelSelection().data() ||
          device == m_selection->projection().data());
 }
 
 void TransformStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     TransformData *td = dynamic_cast<TransformData*>(data);
     ClearSelectionData *csd = dynamic_cast<ClearSelectionData*>(data);
     PreparePreviewData *ppd = dynamic_cast<PreparePreviewData*>(data);
     TransformAllData *runAllData = dynamic_cast<TransformAllData*>(data);
 
 
     if (runAllData) {
+        // here we only save the passed args, actual
+        // transformation will be performed during
+        // finish job
         m_savedTransformArgs = runAllData->config;
-
-        QVector<KisStrokeJobData *> mutatedJobs;
-        Q_FOREACH (KisNodeSP node, m_processedNodes) {
-            mutatedJobs << new TransformData(TransformData::PAINT_DEVICE,
-                                             runAllData->config,
-                                             node);
-        }
-        mutatedJobs << new TransformData(TransformData::SELECTION,
-                                         runAllData->config,
-                                         m_rootNode);
-        addMutatedJobs(mutatedJobs);
-
     } else if (ppd) {
         KisNodeSP rootNode = m_rootNode;
         KisNodeList processedNodes = m_processedNodes;
         KisPaintDeviceSP previewDevice;
 
 
         if (rootNode->childCount() || !rootNode->paintDevice()) {
             if (KisTransformMask* tmask =
                 dynamic_cast<KisTransformMask*>(rootNode.data())) {
                 previewDevice = createDeviceCache(tmask->buildPreviewDevice());
 
                 KIS_SAFE_ASSERT_RECOVER(!m_selection) {
                     m_selection = 0;
                 }
 
             } else if (KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(rootNode.data())) {
                 const QRect bounds = group->image()->bounds();
 
                 KisImageSP clonedImage = new KisImage(0,
                                                       bounds.width(),
                                                       bounds.height(),
                                                       group->colorSpace(),
                                                       "transformed_image");
 
                 KisGroupLayerSP clonedGroup = dynamic_cast<KisGroupLayer*>(group->clone().data());
 
                 // In case the group is pass-through, it needs to be disabled for the preview,
                 //   otherwise it will crash (no parent for a preview leaf).
                 // Also it needs to be done before setting the root layer for clonedImage.
                 // Result: preview for pass-through group is the same as for standard group
                 //   (i.e. filter layers in the group won't affect the layer stack for a moment).
                 clonedGroup->setPassThroughMode(false);
                 clonedImage->setRootLayer(clonedGroup);
 
                 QQueue<KisNodeSP> linearizedSrcNodes;
                 KisLayerUtils::recursiveApplyNodes(rootNode, [&linearizedSrcNodes] (KisNodeSP node) {
                     linearizedSrcNodes.enqueue(node);
                 });
 
                 KisLayerUtils::recursiveApplyNodes(KisNodeSP(clonedGroup), [&linearizedSrcNodes, processedNodes] (KisNodeSP node) {
                     KisNodeSP srcNode = linearizedSrcNodes.dequeue();
 
                     if (!processedNodes.contains(srcNode)) {
                         node->setVisible(false);
                     }
                 });
 
                 clonedImage->refreshGraph();
                 KisLayerUtils::refreshHiddenAreaAsync(clonedImage, clonedGroup, clonedImage->bounds());
 
                 KisLayerUtils::forceAllDelayedNodesUpdate(clonedGroup);
                 clonedImage->waitForDone();
 
                 previewDevice = createDeviceCache(clonedImage->projection());
                 previewDevice->setDefaultBounds(group->projection()->defaultBounds());
 
                 // we delete the cloned image in GUI thread to ensure
                 // no signals are still pending
                 makeKisDeleteLaterWrapper(clonedImage)->deleteLater();
 
             } else {
                 rootNode->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
                 previewDevice = createDeviceCache(rootNode->projection());
             }
 
 
 
         } else {
             KisPaintDeviceSP cacheDevice = createDeviceCache(rootNode->paintDevice());
 
             if (dynamic_cast<KisSelectionMask*>(rootNode.data())) {
                 KIS_SAFE_ASSERT_RECOVER (cacheDevice->colorSpace()->colorModelId() == GrayAColorModelID &&
                                          cacheDevice->colorSpace()->colorDepthId() == Integer8BitsColorDepthID) {
 
                     cacheDevice->convertTo(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id()));
                 }
 
                 previewDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
                 const QRect srcRect = cacheDevice->exactBounds();
 
                 KisSequentialConstIterator srcIt(cacheDevice, srcRect);
                 KisSequentialIterator dstIt(previewDevice, srcRect);
 
                 const int pixelSize = previewDevice->colorSpace()->pixelSize();
 
 
                 KisImageConfig cfg(true);
                 KoColor pixel(cfg.selectionOverlayMaskColor(), previewDevice->colorSpace());
 
                 const qreal coeff = 1.0 / 255.0;
                 const qreal baseOpacity = 0.5;
 
                 while (srcIt.nextPixel() && dstIt.nextPixel()) {
                     qreal gray = srcIt.rawDataConst()[0];
                     qreal alpha = srcIt.rawDataConst()[1];
 
                     pixel.setOpacity(quint8(gray * alpha * baseOpacity * coeff));
                     memcpy(dstIt.rawData(), pixel.data(), pixelSize);
                 }
 
             } else {
                 previewDevice = cacheDevice;
             }
 
             putDeviceCache(rootNode->paintDevice(), cacheDevice);
         }
 
-        QPainterPath selectionOutline;
-        if (m_selection && m_selection->outlineCacheValid()) {
-            selectionOutline = m_selection->outlineCache();
-        } else if (previewDevice) {
-            selectionOutline.addRect(previewDevice->exactBounds());
-        }
-
-        emit sigPreviewDeviceReady(previewDevice, selectionOutline);
+        emit sigPreviewDeviceReady(previewDevice);
     } else if(td) {
         if (td->destination == TransformData::PAINT_DEVICE) {
             QRect oldExtent = td->node->extent();
             KisPaintDeviceSP device = td->node->paintDevice();
 
             if (device && !checkBelongsToSelection(device)) {
                 KisPaintDeviceSP cachedPortion = getDeviceCache(device);
                 Q_ASSERT(cachedPortion);
 
                 KisTransaction transaction(device);
 
                 KisProcessingVisitor::ProgressHelper helper(td->node);
                 transformAndMergeDevice(td->config, cachedPortion,
                                         device, &helper);
 
                 runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                                   KisStrokeJobData::CONCURRENT,
                                   KisStrokeJobData::NORMAL);
 
                 td->node->setDirty(oldExtent | td->node->extent());
             } else if (KisExternalLayer *extLayer =
                   dynamic_cast<KisExternalLayer*>(td->node.data())) {
 
                 if (td->config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
                     (td->config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT &&
                      extLayer->supportsPerspectiveTransform())) {
 
                     QVector3D transformedCenter;
                     KisTransformWorker w = KisTransformUtils::createTransformWorker(td->config, 0, 0, &transformedCenter);
                     QTransform t = w.transform();
 
                     runAndSaveCommand(KUndo2CommandSP(extLayer->transform(t)),
                                       KisStrokeJobData::CONCURRENT,
                                       KisStrokeJobData::NORMAL);
                 }
 
             } else if (KisTransformMask *transformMask =
                        dynamic_cast<KisTransformMask*>(td->node.data())) {
 
                 runAndSaveCommand(KUndo2CommandSP(
                                       new KisModifyTransformMaskCommand(transformMask,
                                                                      KisTransformMaskParamsInterfaceSP(
                                                                          new KisTransformMaskAdapter(td->config)))),
                                   KisStrokeJobData::CONCURRENT,
                                   KisStrokeJobData::NORMAL);
             }
         } else if (m_selection) {
 
             /**
              * We use usual transaction here, because we cannot calsulate
              * transformation for perspective and warp workers.
              */
             KisTransaction transaction(m_selection->pixelSelection());
 
             KisProcessingVisitor::ProgressHelper helper(td->node);
             KisTransformUtils::transformDevice(td->config,
                                                m_selection->pixelSelection(),
                                                &helper);
 
             runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                               KisStrokeJobData::CONCURRENT,
                               KisStrokeJobData::NORMAL);
         }
     } else if (csd) {
         KisPaintDeviceSP device = csd->node->paintDevice();
 
         if (device && !checkBelongsToSelection(device)) {
             if (!haveDeviceInCache(device)) {
                 putDeviceCache(device, createDeviceCache(device));
             }
             clearSelection(device);
 
             /**
              * Selection masks might have an overlay enabled, we should disable that
              */
             if (KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(csd->node.data())) {
                 KisSelectionSP selection = mask->selection();
                 if (selection) {
                     selection->setVisible(false);
                     m_deactivatedSelections.append(selection);
                     mask->setDirty();
                 }
             }
         } else if (KisExternalLayer *externalLayer = dynamic_cast<KisExternalLayer*>(csd->node.data())) {
             externalLayer->projectionLeaf()->setTemporaryHiddenFromRendering(true);
             externalLayer->setDirty();
             m_hiddenProjectionLeaves.append(csd->node);
         } else if (KisTransformMask *transformMask =
                    dynamic_cast<KisTransformMask*>(csd->node.data())) {
 
             runAndSaveCommand(KUndo2CommandSP(
                                   new KisModifyTransformMaskCommand(transformMask,
                                                                  KisTransformMaskParamsInterfaceSP(
                                                                      new KisDumbTransformMaskParams(true)))),
                                   KisStrokeJobData::SEQUENTIAL,
                                   KisStrokeJobData::NORMAL);
         }
     } else {
         KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
     }
 }
 
 void TransformStrokeStrategy::clearSelection(KisPaintDeviceSP device)
 {
     KisTransaction transaction(device);
     if (m_selection) {
         device->clearSelection(m_selection);
     } else {
         QRect oldExtent = device->extent();
         device->clear();
         device->setDirty(oldExtent);
     }
     runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                       KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::NORMAL);
 }
 
 void TransformStrokeStrategy::transformAndMergeDevice(const ToolTransformArgs &config,
                                                       KisPaintDeviceSP src,
                                                       KisPaintDeviceSP dst,
                                                       KisProcessingVisitor::ProgressHelper *helper)
 {
     KoUpdaterPtr mergeUpdater = src != dst ? helper->updater() : 0;
 
     KisTransformUtils::transformDevice(config, src, helper);
     if (src != dst) {
         QRect mergeRect = src->extent();
         KisPainter painter(dst);
         painter.setProgress(mergeUpdater);
         painter.bitBlt(mergeRect.topLeft(), src, mergeRect);
         painter.end();
     }
 }
 
 struct TransformExtraData : public KUndo2CommandExtraData
 {
     ToolTransformArgs savedTransformArgs;
     KisNodeSP rootNode;
     KisNodeList transformedNodes;
 
     KUndo2CommandExtraData* clone() const override {
         return new TransformExtraData(*this);
     }
 };
 
 void TransformStrokeStrategy::postProcessToplevelCommand(KUndo2Command *command)
 {
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_savedTransformArgs);
+
     TransformExtraData *data = new TransformExtraData();
-    data->savedTransformArgs = m_savedTransformArgs;
+    data->savedTransformArgs = *m_savedTransformArgs;
     data->rootNode = m_rootNode;
     data->transformedNodes = m_processedNodes;
 
     command->setExtraData(data);
 
     KisSavedMacroCommand *macroCommand = dynamic_cast<KisSavedMacroCommand*>(command);
     KIS_SAFE_ASSERT_RECOVER_NOOP(macroCommand);
 
     if (m_overriddenCommand && macroCommand) {
         macroCommand->setOverrideInfo(m_overriddenCommand, m_skippedWhileMergeCommands);
     }
 
     KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(command);
 }
 
 bool TransformStrokeStrategy::fetchArgsFromCommand(const KUndo2Command *command, ToolTransformArgs *args, KisNodeSP *rootNode, KisNodeList *transformedNodes)
 {
     const TransformExtraData *data = dynamic_cast<const TransformExtraData*>(command->extraData());
 
     if (data) {
         *args = data->savedTransformArgs;
         *rootNode = data->rootNode;
         *transformedNodes = data->transformedNodes;
     }
 
     return bool(data);
 }
 
 QList<KisNodeSP> TransformStrokeStrategy::fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive)
 {
     QList<KisNodeSP> result;
 
     auto fetchFunc =
         [&result, mode, root] (KisNodeSP node) {
         if (node->isEditable(node == root) &&
                 (!node->inherits("KisShapeLayer") || mode == ToolTransformArgs::FREE_TRANSFORM) &&
                 !node->inherits("KisFileLayer") &&
                 (!node->inherits("KisTransformMask") || node == root)) {
 
                 result << node;
             }
     };
 
     if (recursive) {
         KisLayerUtils::recursiveApplyNodes(root, fetchFunc);
     } else {
         fetchFunc(root);
     }
 
     return result;
 }
 
 bool TransformStrokeStrategy::tryInitArgsFromNode(KisNodeSP node, ToolTransformArgs *args)
 {
     bool result = false;
 
     if (KisTransformMaskSP mask =
         dynamic_cast<KisTransformMask*>(node.data())) {
 
         KisTransformMaskParamsInterfaceSP savedParams =
             mask->transformParams();
 
         KisTransformMaskAdapter *adapter =
             dynamic_cast<KisTransformMaskAdapter*>(savedParams.data());
 
         if (adapter) {
             *args = adapter->transformArgs();
             result = true;
         }
     }
 
     return result;
 }
 
 bool TransformStrokeStrategy::tryFetchArgsFromCommandAndUndo(ToolTransformArgs *outArgs,
                                                              ToolTransformArgs::TransformMode mode,
                                                              KisNodeSP currentNode,
                                                              KisNodeList selectedNodes,
                                                              QVector<KisStrokeJobData *> *undoJobs)
 {
     bool result = false;
 
     const KUndo2Command *lastCommand = undoFacade()->lastExecutedCommand();
     KisNodeSP oldRootNode;
     KisNodeList oldTransformedNodes;
 
     ToolTransformArgs args;
 
     if (lastCommand &&
         TransformStrokeStrategy::fetchArgsFromCommand(lastCommand, &args, &oldRootNode, &oldTransformedNodes) &&
         args.mode() == mode &&
         oldRootNode == currentNode) {
 
         if (KritaUtils::compareListsUnordered(oldTransformedNodes, selectedNodes)) {
             args.saveContinuedState();
 
             *outArgs = args;
 
             const KisSavedMacroCommand *command = dynamic_cast<const KisSavedMacroCommand*>(lastCommand);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(command, false);
 
-            command->getCommandExecutionJobs(undoJobs, true);
-
+            // the jobs are fetched as !shouldGoToHistory,
+            // so there is no need to put them into
+            // m_skippedWhileMergeCommands
+            command->getCommandExecutionJobs(undoJobs, true, false);
             m_overriddenCommand = command;
-            Q_FOREACH (KisStrokeJobData *commonData, *undoJobs) {
-                Data *data = dynamic_cast<Data*>(commonData);
-                KIS_SAFE_ASSERT_RECOVER(data) { continue; }
-
-                m_skippedWhileMergeCommands << data->command.data();
-            }
-
 
             result = true;
         }
     }
 
     return result;
 }
 
 void TransformStrokeStrategy::initStrokeCallback()
 {
     KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
     if (m_selection) {
         m_selection->setVisible(false);
         m_deactivatedSelections.append(m_selection);
     }
 
+    KisSelectionMaskSP overlaySelectionMask =
+        dynamic_cast<KisSelectionMask*>(m_rootNode->graphListener()->graphOverlayNode());
+    if (overlaySelectionMask) {
+        overlaySelectionMask->selection()->setVisible(false);
+        overlaySelectionMask->setDirty();
+        m_deactivatedOverlaySelectionMask = overlaySelectionMask;
+    }
+
+
     ToolTransformArgs initialTransformArgs;
     m_processedNodes = fetchNodesList(m_mode, m_rootNode, m_workRecursively);
 
     bool argsAreInitialized = false;
     QVector<KisStrokeJobData *> lastCommandUndoJobs;
 
     if (!m_forceReset && tryFetchArgsFromCommandAndUndo(&initialTransformArgs,
                                                         m_mode,
                                                         m_rootNode,
                                                         m_processedNodes,
                                                         &lastCommandUndoJobs)) {
         argsAreInitialized = true;
     } else if (!m_forceReset && tryInitArgsFromNode(m_rootNode, &initialTransformArgs)) {
         argsAreInitialized = true;
     }
 
     QVector<KisStrokeJobData *> extraInitJobs;
 
     extraInitJobs << new Data(new KisHoldUIUpdatesCommand(m_updatesFacade, KisCommandUtils::FlipFlopCommand::INITIALIZING), false, KisStrokeJobData::BARRIER);
 
     extraInitJobs << lastCommandUndoJobs;
 
     KritaUtils::addJobSequential(extraInitJobs, [this]() {
         /**
          * We must request shape layers to rerender areas outside image bounds
          */
         KisLayerUtils::forceAllHiddenOriginalsUpdate(m_rootNode);
     });
 
     KritaUtils::addJobBarrier(extraInitJobs, [this]() {
         /**
          * We must ensure that the currently selected subtree
          * has finished all its updates.
          */
         KisLayerUtils::forceAllDelayedNodesUpdate(m_rootNode);
     });
 
     KritaUtils::addJobBarrier(extraInitJobs, [this, initialTransformArgs, argsAreInitialized]() mutable {
         QRect srcRect;
 
         if (m_selection) {
             srcRect = m_selection->selectedExactRect();
         } else {
             srcRect = QRect();
             Q_FOREACH (KisNodeSP node, m_processedNodes) {
                 // group layers may have a projection of layers
                 // that are locked and will not be transformed
                 if (node->inherits("KisGroupLayer")) continue;
 
                 if (const KisTransformMask *mask = dynamic_cast<const KisTransformMask*>(node.data())) {
                     srcRect |= mask->sourceDataBounds();
+                } else if (const KisSelectionMask *mask = dynamic_cast<const KisSelectionMask*>(node.data())) {
+                    srcRect |= mask->selection()->selectedExactRect();
                 } else {
                     srcRect |= node->exactBounds();
                 }
             }
         }
 
         TransformTransactionProperties transaction(srcRect, &initialTransformArgs, m_rootNode, m_processedNodes);
         if (!argsAreInitialized) {
             initialTransformArgs = KisTransformUtils::resetArgsForMode(m_mode, m_filterId, transaction);
         }
 
-        emit this->sigTransactionGenerated(transaction, initialTransformArgs);
+        this->m_initialTransformArgs = initialTransformArgs;
+        emit this->sigTransactionGenerated(transaction, initialTransformArgs, this);
     });
 
     extraInitJobs << new PreparePreviewData();
 
     Q_FOREACH (KisNodeSP node, m_processedNodes) {
         extraInitJobs << new ClearSelectionData(node);
     }
 
     extraInitJobs << new Data(toQShared(new KisHoldUIUpdatesCommand(m_updatesFacade, KisCommandUtils::FlipFlopCommand::FINALIZING)), false, KisStrokeJobData::BARRIER);
 
+    if (!lastCommandUndoJobs.isEmpty()) {
+        KIS_SAFE_ASSERT_RECOVER_NOOP(m_overriddenCommand);
+
+        for (auto it = extraInitJobs.begin(); it != extraInitJobs.end(); ++it) {
+            (*it)->setCancellable(false);
+        }
+    }
+
     addMutatedJobs(extraInitJobs);
 }
 
-void TransformStrokeStrategy::finishStrokeCallback()
+void TransformStrokeStrategy::finishStrokeImpl(bool applyTransform, const ToolTransformArgs &args)
 {
-    Q_FOREACH (KisSelectionSP selection, m_deactivatedSelections) {
-        selection->setVisible(true);
+    /**
+     * Since our finishStrokeCallback() initiates new jobs,
+     * cancellation request may come even after
+     * finishStrokeCallback() (cancellations may be called
+     * until there are no jobs left in the stroke's queue).
+     *
+     * Therefore we should check for double-entry here and
+     * make sure the finilizing jobs are no cancellable.
+     */
+
+    if (m_finalizingActionsStarted) return;
+    m_finalizingActionsStarted = true;
+
+    QVector<KisStrokeJobData *> mutatedJobs;
+
+    if (applyTransform) {
+        Q_FOREACH (KisNodeSP node, m_processedNodes) {
+            mutatedJobs << new TransformData(TransformData::PAINT_DEVICE,
+                                             args,
+                                             node);
+        }
+        mutatedJobs << new TransformData(TransformData::SELECTION,
+                                         args,
+                                         m_rootNode);
     }
 
-    Q_FOREACH (KisNodeSP node, m_hiddenProjectionLeaves) {
-        node->projectionLeaf()->setTemporaryHiddenFromRendering(false);
+    KritaUtils::addJobBarrier(mutatedJobs, [this, applyTransform]() {
+        Q_FOREACH (KisSelectionSP selection, m_deactivatedSelections) {
+            selection->setVisible(true);
+        }
+
+        Q_FOREACH (KisNodeSP node, m_hiddenProjectionLeaves) {
+            node->projectionLeaf()->setTemporaryHiddenFromRendering(false);
+        }
+
+        if (m_deactivatedOverlaySelectionMask) {
+            m_deactivatedOverlaySelectionMask->selection()->setVisible(true);
+            m_deactivatedOverlaySelectionMask->setDirty();
+        }
+
+        if (applyTransform) {
+            KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
+        } else {
+            KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
+        }
+    });
+
+    for (auto it = mutatedJobs.begin(); it != mutatedJobs.end(); ++it) {
+        (*it)->setCancellable(false);
     }
 
-    KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
+    addMutatedJobs(mutatedJobs);
+}
+
+void TransformStrokeStrategy::finishStrokeCallback()
+{
+    if (!m_savedTransformArgs || m_savedTransformArgs->isIdentity()) {
+        cancelStrokeCallback();
+        return;
+    }
+
+    finishStrokeImpl(true, *m_savedTransformArgs);
 }
 
 void TransformStrokeStrategy::cancelStrokeCallback()
 {
-    KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
+    const bool shouldRecoverSavedInitialState =
+        !m_initialTransformArgs.isIdentity();
 
-    Q_FOREACH (KisSelectionSP selection, m_deactivatedSelections) {
-        selection->setVisible(true);
+    if (shouldRecoverSavedInitialState) {
+        m_savedTransformArgs = m_initialTransformArgs;
     }
 
-    Q_FOREACH (KisNodeSP node, m_hiddenProjectionLeaves) {
-        node->projectionLeaf()->setTemporaryHiddenFromRendering(false);
-    }
+    finishStrokeImpl(shouldRecoverSavedInitialState, *m_savedTransformArgs);
 }
diff --git a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h
index 9b33fe0412..6e1d6dc276 100644
--- a/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h
+++ b/plugins/tools/tool_transform2/strokes/transform_stroke_strategy.h
@@ -1,171 +1,178 @@
 /*
  *  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 __TRANSFORM_STROKE_STRATEGY_H
 #define __TRANSFORM_STROKE_STRATEGY_H
 
 #include <QObject>
 #include <QMutex>
 #include <KoUpdater.h>
 #include <kis_stroke_strategy_undo_command_based.h>
 #include <kis_types.h>
 #include "tool_transform_args.h"
 #include <kis_processing_visitor.h>
 #include <kritatooltransform_export.h>
+#include <boost/optional.hpp>
 
 
 class KisPostExecutionUndoAdapter;
 class TransformTransactionProperties;
 class KisUpdatesFacade;
 
 
 class TransformStrokeStrategy : public QObject, public KisStrokeStrategyUndoCommandBased
 {
     Q_OBJECT
 public:
     struct TransformAllData : public KisStrokeJobData {
         TransformAllData(const ToolTransformArgs &_config)
             : KisStrokeJobData(SEQUENTIAL, NORMAL),
               config(_config) {}
 
         ToolTransformArgs config;
     };
 
 
     class TransformData : public KisStrokeJobData {
     public:
         enum Destination {
             PAINT_DEVICE,
             SELECTION,
         };
 
     public:
     TransformData(Destination _destination, const ToolTransformArgs &_config, KisNodeSP _node)
             : KisStrokeJobData(CONCURRENT, NORMAL),
             destination(_destination),
             config(_config),
             node(_node)
         {
         }
 
         Destination destination;
         ToolTransformArgs config;
         KisNodeSP node;
     };
 
     class ClearSelectionData : public KisStrokeJobData {
     public:
         ClearSelectionData(KisNodeSP _node)
             : KisStrokeJobData(SEQUENTIAL, NORMAL),
               node(_node)
         {
         }
         KisNodeSP node;
     };
 
     class PreparePreviewData : public KisStrokeJobData {
     public:
         PreparePreviewData()
             : KisStrokeJobData(BARRIER, NORMAL)
         {
         }
     };
 
 public:
     TransformStrokeStrategy(ToolTransformArgs::TransformMode mode,
                             bool workRecursively,
                             const QString &filterId,
                             bool forceReset,
                             KisNodeSP rootNode,
                             KisSelectionSP selection,
                             KisStrokeUndoFacade *undoFacade, KisUpdatesFacade *updatesFacade);
 
     ~TransformStrokeStrategy() override;
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     static bool fetchArgsFromCommand(const KUndo2Command *command, ToolTransformArgs *args, KisNodeSP *rootNode, KisNodeList *transformedNodes);
 
 Q_SIGNALS:
-    void sigTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args);
-    void sigPreviewDeviceReady(KisPaintDeviceSP device, const QPainterPath &selectionOutline);
+    void sigTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args, void *cookie);
+    void sigPreviewDeviceReady(KisPaintDeviceSP device);
 
 protected:
     void postProcessToplevelCommand(KUndo2Command *command) override;
 
 private:
     KoUpdaterPtr fetchUpdater(KisNodeSP node);
 
     void transformAndMergeDevice(const ToolTransformArgs &config,
                                  KisPaintDeviceSP src,
                                  KisPaintDeviceSP dst,
                                  KisProcessingVisitor::ProgressHelper *helper);
     void transformDevice(const ToolTransformArgs &config,
                          KisPaintDeviceSP device,
                          KisProcessingVisitor::ProgressHelper *helper);
 
     void clearSelection(KisPaintDeviceSP device);
     //void transformDevice(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisProcessingVisitor::ProgressHelper *helper);
 
     bool checkBelongsToSelection(KisPaintDeviceSP device) const;
 
     KisPaintDeviceSP createDeviceCache(KisPaintDeviceSP src);
 
     bool haveDeviceInCache(KisPaintDeviceSP src);
     void putDeviceCache(KisPaintDeviceSP src, KisPaintDeviceSP cache);
     KisPaintDeviceSP getDeviceCache(KisPaintDeviceSP src);
 
     QList<KisNodeSP> fetchNodesList(ToolTransformArgs::TransformMode mode, KisNodeSP root, bool recursive);
     ToolTransformArgs resetArgsForMode(ToolTransformArgs::TransformMode mode,
                                        const QString &filterId,
                                        const TransformTransactionProperties &transaction);
     bool tryInitArgsFromNode(KisNodeSP node, ToolTransformArgs *args);
     bool tryFetchArgsFromCommandAndUndo(ToolTransformArgs *args,
                                         ToolTransformArgs::TransformMode mode,
                                         KisNodeSP currentNode,
                                         KisNodeList selectedNodes, QVector<KisStrokeJobData *> *undoJobs);
 
+    void finishStrokeImpl(bool applyTransform,
+                          const ToolTransformArgs &args);
 
 private:
     KisUpdatesFacade *m_updatesFacade;
     ToolTransformArgs::TransformMode m_mode;
     bool m_workRecursively;
     QString m_filterId;
     bool m_forceReset;
 
     KisSelectionSP m_selection;
 
     QMutex m_devicesCacheMutex;
     QHash<KisPaintDevice*, KisPaintDeviceSP> m_devicesCacheHash;
 
     KisTransformMaskSP writeToTransformMask;
 
-    ToolTransformArgs m_savedTransformArgs;
+    ToolTransformArgs m_initialTransformArgs;
+    boost::optional<ToolTransformArgs> m_savedTransformArgs;
     KisNodeSP m_rootNode;
     KisNodeList m_processedNodes;
     QList<KisSelectionSP> m_deactivatedSelections;
     QList<KisNodeSP> m_hiddenProjectionLeaves;
+    KisSelectionMaskSP m_deactivatedOverlaySelectionMask;
 
     const KisSavedMacroCommand *m_overriddenCommand = 0;
     QVector<const KUndo2Command*> m_skippedWhileMergeCommands;
+
+    bool m_finalizingActionsStarted = false;
 };
 
 #endif /* __TRANSFORM_STROKE_STRATEGY_H */
diff --git a/plugins/tools/tool_transform2/wdg_tool_transform.ui b/plugins/tools/tool_transform2/wdg_tool_transform.ui
index 028721a566..fa83fe5ffd 100644
--- a/plugins/tools/tool_transform2/wdg_tool_transform.ui
+++ b/plugins/tools/tool_transform2/wdg_tool_transform.ui
@@ -1,2265 +1,2237 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgToolTransform</class>
  <widget class="QWidget" name="WdgToolTransform">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>499</width>
     <height>751</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="baseSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="layoutDirection">
    <enum>Qt::LeftToRight</enum>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_5">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <property name="bottomMargin">
       <number>4</number>
      </property>
      <item>
       <widget class="QFrame" name="frame">
        <property name="frameShape">
         <enum>QFrame::NoFrame</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Plain</enum>
        </property>
        <property name="lineWidth">
         <number>0</number>
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_7">
         <property name="leftMargin">
          <number>1</number>
         </property>
         <property name="topMargin">
          <number>1</number>
         </property>
         <property name="rightMargin">
          <number>1</number>
         </property>
         <property name="bottomMargin">
          <number>1</number>
         </property>
         <item>
          <layout class="QHBoxLayout" name="horizontalLayout_3">
           <property name="spacing">
            <number>0</number>
           </property>
           <item>
            <widget class="QToolButton" name="freeTransformButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Free</string>
             </property>
             <property name="text">
              <string>Free Transform</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="perspectiveTransformButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Perspective</string>
             </property>
             <property name="text">
              <string>Perspective</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="warpButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Warp</string>
             </property>
             <property name="text">
              <string>Warp</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="cageButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Cage</string>
             </property>
             <property name="text">
              <string>Cage</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QToolButton" name="liquifyButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Liquify</string>
             </property>
             <property name="text">
              <string>Liquify</string>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="autoExclusive">
              <bool>true</bool>
             </property>
             <property name="autoRaise">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </item>
        </layout>
       </widget>
      </item>
      <item>
       <widget class="QLabel" name="lblTransformType">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Free Transform</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QStackedWidget" name="stackedWidget">
      <property name="frameShape">
       <enum>QFrame::StyledPanel</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <property name="currentIndex">
       <number>2</number>
      </property>
      <widget class="QWidget" name="freeTransformWidget">
       <layout class="QVBoxLayout" name="verticalLayout">
        <property name="spacing">
         <number>0</number>
        </property>
        <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>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_5">
          <property name="spacing">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>12</number>
          </property>
          <item>
           <layout class="QGridLayout" name="freeMainOptions">
            <property name="sizeConstraint">
             <enum>QLayout::SetFixedSize</enum>
            </property>
            <property name="leftMargin">
             <number>10</number>
            </property>
            <property name="topMargin">
             <number>10</number>
            </property>
            <property name="rightMargin">
             <number>20</number>
            </property>
            <property name="horizontalSpacing">
             <number>10</number>
            </property>
            <property name="verticalSpacing">
             <number>15</number>
            </property>
            <item row="0" column="0">
             <widget class="QLabel" name="label_10">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="layoutDirection">
               <enum>Qt::RightToLeft</enum>
              </property>
              <property name="text">
               <string>&amp;Filter:</string>
              </property>
              <property name="alignment">
               <set>Qt::AlignCenter</set>
              </property>
              <property name="buddy">
               <cstring>cmbFilter</cstring>
              </property>
             </widget>
            </item>
            <item row="1" column="1">
             <layout class="QGridLayout" name="freeAnchorOriginGroup" rowstretch="0,0,0,0" columnstretch="0,0,0">
              <property name="sizeConstraint">
               <enum>QLayout::SetDefaultConstraint</enum>
              </property>
              <property name="spacing">
               <number>0</number>
              </property>
              <item row="1" column="0">
               <widget class="QToolButton" name="topLeftButton">
                <property name="enabled">
                 <bool>true</bool>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="2">
               <widget class="QToolButton" name="topRightButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="0">
               <widget class="QToolButton" name="bottomLeftButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QToolButton" name="centerButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="2">
               <widget class="QToolButton" name="middleRightButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="1">
               <widget class="QToolButton" name="middleBottomButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="2">
               <widget class="QToolButton" name="bottomRightButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QToolButton" name="middleTopButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QToolButton" name="middleLeftButton">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="autoExclusive">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item row="0" column="1">
             <widget class="KisCmbIDList" name="cmbFilter" native="true">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
             </widget>
            </item>
            <item row="1" column="0">
             <widget class="QToolButton" name="btnTransformAroundPivotPoint">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="toolTip">
               <string>Transform around pivot point (Alt)</string>
              </property>
              <property name="text">
               <string/>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
              <property name="autoExclusive">
               <bool>true</bool>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item>
           <layout class="QVBoxLayout" name="verticalLayout_4">
            <item>
             <widget class="QRadioButton" name="freeMoveRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Position</string>
              </property>
              <property name="checked">
               <bool>true</bool>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QRadioButton" name="freeRotationRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Rotate</string>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QRadioButton" name="freeScaleRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Scale</string>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QRadioButton" name="freeShearRadioButton">
              <property name="text">
               <string comment="@option:radio Type of transformation">Shear</string>
              </property>
              <attribute name="buttonGroup">
               <string notr="true">freeTransformRadioGroup</string>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="tooBigLabelWidget">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>0</width>
                <height>0</height>
               </size>
              </property>
              <property name="font">
               <font>
                <weight>75</weight>
                <bold>true</bold>
               </font>
              </property>
              <property name="toolTip">
               <string extracomment="warning: this string shouldn' be wider, as otherwise the widget would resize and flicker"/>
              </property>
              <property name="layoutDirection">
               <enum>Qt::LeftToRight</enum>
              </property>
              <property name="autoFillBackground">
               <bool>false</bool>
              </property>
              <property name="text">
               <string>off canvas</string>
              </property>
              <property name="textFormat">
               <enum>Qt::RichText</enum>
              </property>
              <property name="scaledContents">
               <bool>false</bool>
              </property>
              <property name="wordWrap">
               <bool>true</bool>
              </property>
              <property name="textInteractionFlags">
               <set>Qt::NoTextInteraction</set>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item>
           <spacer name="horizontalSpacer0">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QGroupBox" name="rotationGroup">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>100</height>
           </size>
          </property>
          <property name="title">
           <string>Rotation</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_3" stretch="0">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>7</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QFormLayout" name="formLayout">
             <property name="fieldGrowthPolicy">
              <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
             </property>
             <property name="horizontalSpacing">
              <number>5</number>
             </property>
             <property name="verticalSpacing">
              <number>5</number>
             </property>
             <item row="0" column="0">
              <widget class="QLabel" name="label_rotateX">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Rotate around X-Axis</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>&amp;x:</string>
               </property>
               <property name="buddy">
                <cstring>aXBox</cstring>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="KisDoubleSliderSpinBox" name="aXBox" native="true">
               <property name="toolTip">
                <string>Rotate around X-Axis</string>
               </property>
              </widget>
             </item>
             <item row="2" column="0">
              <widget class="QLabel" name="label_rotateY">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Rotate around Y-Axis</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>&amp;y:</string>
               </property>
               <property name="buddy">
                <cstring>aYBox</cstring>
               </property>
              </widget>
             </item>
             <item row="2" column="1">
              <widget class="KisDoubleSliderSpinBox" name="aYBox" native="true">
               <property name="toolTip">
                <string>Rotate around Y-Axis</string>
               </property>
              </widget>
             </item>
             <item row="3" column="1">
              <widget class="KisDoubleSliderSpinBox" name="aZBox" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Rotate around Z-Axis</string>
               </property>
              </widget>
             </item>
             <item row="3" column="0">
              <widget class="QLabel" name="label_rotateZ">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Rotate around Z-Axis</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>&amp;z:</string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="buddy">
                <cstring>aZBox</cstring>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="scaleGroup">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>70</height>
           </size>
          </property>
          <property name="title">
           <string>Scale</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_2">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_10">
             <item>
              <layout class="QFormLayout" name="formLayout_6">
               <property name="verticalSpacing">
                <number>5</number>
               </property>
               <item row="0" column="0">
                <widget class="QLabel" name="label_width">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="minimumSize">
                  <size>
                   <width>0</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="toolTip">
                  <string>Horizontal Scale</string>
                 </property>
                 <property name="text">
                  <string>Width:</string>
                 </property>
                 <property name="alignment">
                  <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                 </property>
                 <property name="buddy">
                  <cstring>scaleXBox</cstring>
                 </property>
                </widget>
               </item>
               <item row="0" column="1">
                <widget class="KisIntParseSpinBox" name="scaleXBox">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="toolTip">
                  <string>Horizontal Scale</string>
                 </property>
                 <property name="suffix">
                  <string> %</string>
                 </property>
                </widget>
               </item>
               <item row="1" column="1">
                <widget class="KisIntParseSpinBox" name="scaleYBox">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="toolTip">
                  <string>Vertical Scale</string>
                 </property>
                 <property name="suffix">
                  <string> %</string>
                 </property>
                </widget>
               </item>
               <item row="1" column="0">
                <widget class="QLabel" name="label_height">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="minimumSize">
                  <size>
                   <width>0</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="toolTip">
                  <string>Vertical Scale</string>
                 </property>
                 <property name="text">
                  <string>Height:</string>
                 </property>
                 <property name="alignment">
                  <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                 </property>
                 <property name="buddy">
                  <cstring>scaleYBox</cstring>
                 </property>
                </widget>
               </item>
              </layout>
             </item>
             <item>
              <widget class="KoAspectButton" name="aspectButton" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>20</width>
                 <height>25</height>
                </size>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="moveGroup">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>70</height>
           </size>
          </property>
          <property name="title">
           <string>Position</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_11">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QFormLayout" name="formLayout_3">
             <property name="fieldGrowthPolicy">
              <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
             </property>
             <item row="0" column="0">
              <widget class="QLabel" name="label_offsetX">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Translation</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
               <property name="text">
                <string>x:</string>
               </property>
               <property name="buddy">
                <cstring>translateXBox</cstring>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="KisIntParseSpinBox" name="translateXBox">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Translation</string>
               </property>
               <property name="layoutDirection">
                <enum>Qt::LeftToRight</enum>
               </property>
              </widget>
             </item>
             <item row="2" column="1">
              <widget class="KisIntParseSpinBox" name="translateYBox">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Vertical Translation</string>
               </property>
              </widget>
             </item>
             <item row="2" column="0">
              <widget class="QLabel" name="label_offsetY">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Vertical Translation</string>
               </property>
               <property name="text">
                <string>y:</string>
               </property>
               <property name="buddy">
                <cstring>translateYBox</cstring>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="shearGroup">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>240</width>
            <height>80</height>
           </size>
          </property>
          <property name="autoFillBackground">
           <bool>false</bool>
          </property>
          <property name="title">
           <string>Shear</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_12">
           <property name="spacing">
            <number>2</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <layout class="QFormLayout" name="formLayout_4">
             <property name="fieldGrowthPolicy">
              <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
             </property>
             <property name="verticalSpacing">
              <number>8</number>
             </property>
             <property name="leftMargin">
              <number>20</number>
             </property>
             <item row="0" column="0">
              <widget class="QLabel" name="label_shearX">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Shear</string>
               </property>
               <property name="text">
                <string>x:</string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="buddy">
                <cstring>shearXBox</cstring>
               </property>
              </widget>
             </item>
             <item row="1" column="1">
              <widget class="KisDoubleSliderSpinBox" name="shearYBox" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Vertical Shear</string>
               </property>
              </widget>
             </item>
             <item row="1" column="0">
              <widget class="QLabel" name="label_shearY">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="toolTip">
                <string>Vertical Shear</string>
               </property>
               <property name="text">
                <string>y:</string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="buddy">
                <cstring>shearYBox</cstring>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="KisDoubleSliderSpinBox" name="shearXBox" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Horizontal Shear</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer0">
          <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>10</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QGroupBox" name="quickTransformGroup">
          <layout class="QHBoxLayout" name="quickTransformLayout">
           <property name="spacing">
            <number>6</number>
           </property>
           <item>
            <widget class="QPushButton" name="flipXButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Flip selection horizontally</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="flipYButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Flip selection vertically</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalFlipRotateSpacer">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeType">
              <enum>QSizePolicy::Preferred</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item>
            <widget class="QPushButton" name="rotateCCWButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Rotate selection counter-clockwise 90 degrees</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="rotateCWButton">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>32</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Rotate the selection clockwise 90 degrees</string>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer1">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeType">
              <enum>QSizePolicy::Expanding</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer00">
          <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>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="warpTransformWidget">
       <layout class="QVBoxLayout" name="verticalLayout_10">
        <item>
         <layout class="QGridLayout" name="gridLayout_4">
          <property name="horizontalSpacing">
           <number>10</number>
          </property>
          <property name="verticalSpacing">
           <number>0</number>
          </property>
          <item row="1" column="1">
           <widget class="KisDoubleSliderSpinBox" name="alphaBox" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QLabel" name="flexibilityLabel">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>2</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Fle&amp;xibility:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>alphaBox</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QComboBox" name="cmbWarpType">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="warpTypeLabel">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Anc&amp;hor Strength:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>cmbWarpType</cstring>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox">
          <property name="autoFillBackground">
           <bool>false</bool>
          </property>
          <property name="title">
           <string>Anchor Points</string>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
          <property name="checkable">
           <bool>false</bool>
          </property>
          <layout class="QGridLayout" name="gridLayout">
           <item row="0" column="0">
            <layout class="QHBoxLayout" name="horizontalLayout_7">
             <property name="spacing">
              <number>0</number>
             </property>
             <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>
             <item>
              <widget class="QRadioButton" name="defaultRadioButton">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Subdi&amp;vide</string>
               </property>
               <property name="checked">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <attribute name="buttonGroup">
                <string notr="true">buttonGroup</string>
               </attribute>
              </widget>
             </item>
             <item>
              <widget class="KisIntParseSpinBox" name="densityBox">
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
               <property name="minimum">
                <number>2</number>
               </property>
               <property name="maximum">
                <number>30</number>
               </property>
               <property name="value">
                <number>3</number>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item row="1" column="0">
            <layout class="QHBoxLayout" name="horizontalLayout_8">
             <property name="spacing">
              <number>0</number>
             </property>
             <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>
             <item>
              <widget class="QRadioButton" name="customRadioButton">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Draw</string>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <attribute name="buttonGroup">
                <string notr="true">buttonGroup</string>
               </attribute>
              </widget>
             </item>
             <item>
              <widget class="QWidget" name="customWarpWidget" native="true">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <layout class="QHBoxLayout" name="horizontalLayout_9">
                <property name="spacing">
                 <number>0</number>
                </property>
                <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>
                <item>
                 <widget class="QPushButton" name="resetPointsButton">
                  <property name="text">
                   <string>Clear Points</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QPushButton" name="lockUnlockPointsButton">
                  <property name="text">
                   <string>Lock Points</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="cageTransformPage">
       <property name="layoutDirection">
        <enum>Qt::LeftToRight</enum>
       </property>
       <property name="autoFillBackground">
        <bool>false</bool>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_6">
        <item>
         <widget class="QLabel" name="cageTransformDirections">
          <property name="text">
           <string>Create 3 points on the canvas to begin</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QRadioButton" name="cageAddEditRadio">
          <property name="text">
           <string>Add/Ed&amp;it Anchor Points</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
          <attribute name="buttonGroup">
           <string notr="true">cageTransformButtonGroup</string>
          </attribute>
         </widget>
        </item>
        <item>
         <widget class="QRadioButton" name="cageDeformRadio">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="text">
           <string>Defor&amp;m Layer</string>
          </property>
          <attribute name="buttonGroup">
           <string notr="true">cageTransformButtonGroup</string>
          </attribute>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::Minimum</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>17</width>
            <height>17</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QLabel" name="adjustGranularity">
          <property name="font">
           <font>
            <weight>75</weight>
            <bold>true</bold>
           </font>
          </property>
          <property name="text">
           <string>Adjust Granularity :</string>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QVBoxLayout" name="verticalLayout_13">
          <item>
           <widget class="QLabel" name="previewGranularity">
            <property name="text">
             <string>Preview</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QComboBox" name="granularityPreview">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="realGranularity">
            <property name="text">
             <string>Real</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QComboBox" name="changeGranularity">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="liquifyTransformPage">
       <layout class="QVBoxLayout" name="verticalLayout_8">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_11" stretch="0,0">
          <property name="spacing">
           <number>0</number>
          </property>
          <item>
           <widget class="QFrame" name="liquifyOptionsLayout">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="whatsThis">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="frameShape">
             <enum>QFrame::NoFrame</enum>
            </property>
            <property name="frameShadow">
             <enum>QFrame::Plain</enum>
            </property>
            <property name="lineWidth">
             <number>0</number>
            </property>
            <layout class="QVBoxLayout" name="verticalLayout_9">
             <property name="leftMargin">
              <number>2</number>
             </property>
             <property name="topMargin">
              <number>2</number>
             </property>
             <property name="rightMargin">
              <number>15</number>
             </property>
             <item>
              <widget class="QToolButton" name="liquifyMove">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Move</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="checked">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyScale">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Scale</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyRotate">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Rotate</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyOffset">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Offset</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="liquifyUndo">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="text">
                <string>Undo</string>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="autoExclusive">
                <bool>true</bool>
               </property>
               <property name="autoRaise">
                <bool>true</bool>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <layout class="QGridLayout" name="gridLayout_3">
            <property name="horizontalSpacing">
             <number>3</number>
            </property>
            <property name="verticalSpacing">
             <number>5</number>
            </property>
            <item row="5" column="0">
             <widget class="QLabel" name="label">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>51</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Reverse:</string>
              </property>
             </widget>
            </item>
            <item row="4" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifySpacingSlider" native="true"/>
            </item>
            <item row="4" column="0">
             <widget class="QLabel" name="lblSpacing">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>49</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Spacing:</string>
              </property>
             </widget>
            </item>
            <item row="3" column="0">
             <widget class="QLabel" name="lblFlow">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>32</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Flow:</string>
              </property>
             </widget>
            </item>
            <item row="3" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifyFlowSlider" native="true"/>
            </item>
            <item row="1" column="0">
             <widget class="QLabel" name="lblSize">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>27</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Size:</string>
              </property>
             </widget>
            </item>
            <item row="1" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifySizeSlider" native="true"/>
            </item>
            <item row="2" column="0">
             <widget class="QLabel" name="lblAmount">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>51</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Amount:</string>
              </property>
             </widget>
            </item>
            <item row="2" column="1">
             <widget class="KisDoubleSliderSpinBox" name="liquifyAmountSlider" native="true"/>
            </item>
            <item row="0" column="0">
             <widget class="QLabel" name="label_2">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>38</width>
                <height>0</height>
               </size>
              </property>
              <property name="text">
               <string>Mode:</string>
              </property>
             </widget>
            </item>
            <item row="0" column="1">
             <widget class="QComboBox" name="buidupModeComboBox">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="currentIndex">
               <number>0</number>
              </property>
              <item>
               <property name="text">
                <string>Build Up</string>
               </property>
              </item>
              <item>
               <property name="text">
                <string>Wash</string>
               </property>
              </item>
             </widget>
            </item>
            <item row="5" column="1">
             <widget class="QCheckBox" name="liquifyReverseDirectionChk">
              <property name="enabled">
               <bool>true</bool>
              </property>
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string/>
              </property>
             </widget>
            </item>
            <item row="1" column="2">
             <widget class="QToolButton" name="liquifySizePressureBox">
              <property name="enabled">
               <bool>true</bool>
              </property>
              <property name="text">
               <string>Pressure</string>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
              <property name="autoExclusive">
               <bool>true</bool>
              </property>
              <property name="autoRaise">
               <bool>true</bool>
              </property>
             </widget>
            </item>
            <item row="2" column="2">
             <widget class="QToolButton" name="liquifyAmountPressureBox">
              <property name="text">
               <string>Pressure</string>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
              <property name="autoExclusive">
               <bool>true</bool>
              </property>
              <property name="autoRaise">
               <bool>true</bool>
              </property>
             </widget>
            </item>
           </layout>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer_5">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>0</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <property name="spacing">
       <number>6</number>
      </property>
      <property name="topMargin">
       <number>6</number>
      </property>
-     <item>
-      <widget class="QPushButton" name="showDecorationsBox">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="maximumSize">
-        <size>
-         <width>32</width>
-         <height>16777215</height>
-        </size>
-       </property>
-       <property name="toolTip">
-        <string>Show Decorations</string>
-       </property>
-       <property name="text">
-        <string/>
-       </property>
-       <property name="checkable">
-        <bool>true</bool>
-       </property>
-       <property name="checked">
-        <bool>false</bool>
-       </property>
-      </widget>
-     </item>
      <item>
       <widget class="QPushButton" name="chkWorkRecursively">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="maximumSize">
         <size>
          <width>32</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Work Recursively</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="checkable">
         <bool>true</bool>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_5">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>13</width>
          <height>13</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QDialogButtonBox" name="buttonBox">
        <property name="layoutDirection">
         <enum>Qt::LeftToRight</enum>
        </property>
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="standardButtons">
         <set>QDialogButtonBox::Apply|QDialogButtonBox::Reset</set>
        </property>
        <property name="centerButtons">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QWidget" name="SpecialSpacer" native="true"/>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends></extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
  <buttongroups>
-  <buttongroup name="freeTransformRadioGroup"/>
   <buttongroup name="cageTransformButtonGroup"/>
   <buttongroup name="buttonGroup"/>
+  <buttongroup name="freeTransformRadioGroup"/>
  </buttongroups>
 </ui>