diff --git a/libs/brush/kis_abr_brush_collection.cpp b/libs/brush/kis_abr_brush_collection.cpp
index 8ae392bde9..cf1a48404d 100644
--- a/libs/brush/kis_abr_brush_collection.cpp
+++ b/libs/brush/kis_abr_brush_collection.cpp
@@ -1,628 +1,627 @@
 /*
  *  Copyright (c) 2010 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2007 Eric Lamarque <eric.lamarque@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.
  */
 #include <QtEndian>
 
 #include "kis_abr_brush_collection.h"
 #include "kis_abr_brush.h"
 
 #include <QDomElement>
 #include <QFile>
 #include <QImage>
 #include <QPoint>
 #include <QColor>
-#include <QtEndian>
 #include <QByteArray>
 #include <kis_debug.h>
 #include <QString>
 #include <QBuffer>
 
 #include <klocalizedstring.h>
 
 #include <KoColor.h>
 
 
 struct AbrInfo {
     //big endian
     short version;
     short subversion;
     // count of the images (brushes) in the abr file
     short count;
 };
 
 /// save the QImages as png files to directory image_tests
 static QImage convertToQImage(char * buffer, qint32 width, qint32 height)
 {
     // create 8-bit indexed image
     QImage img(width, height, QImage::Format_RGB32);
     int pos = 0;
     int value = 0;
     for (int y = 0; y < height; y++) {
         QRgb *pixel = reinterpret_cast<QRgb *>(img.scanLine(y));
         for (int x = 0; x < width; x++, pos++) {
             value = 255 - buffer[pos];
             pixel[x] = qRgb(value, value , value);
         }
 
     }
 
     return img;
 }
 
 static qint32 rle_decode(QDataStream & abr, char *buffer, qint32 height)
 {
     qint32 n;
     char ptmp;
     char ch;
     int i, j, c;
     short *cscanline_len;
     char *data = buffer;
 
     // read compressed size foreach scanline
     cscanline_len = new short[ height ];
     for (i = 0; i < height; i++) {
         // short
         abr >> cscanline_len[i];
     }
 
     // unpack each scanline data
     for (i = 0; i < height; i++) {
         for (j = 0; j < cscanline_len[i];) {
             // char
             if (!abr.device()->getChar(&ptmp)) {
                 break;
             }
             n = ptmp;
 
             j++;
             if (n >= 128)     // force sign
                 n -= 256;
             if (n < 0) {      // copy the following char -n + 1 times
                 if (n == -128)  // it's a nop
                     continue;
                 n = -n + 1;
                 // char
                 if (!abr.device()->getChar(&ch)) {
                     break;
                 }
 
                 j++;
                 for (c = 0; c < n; c++, data++) {
                     *data = ch;
                 }
             }
             else {
                 // read the following n + 1 chars (no compr)
                 for (c = 0; c < n + 1; c++, j++, data++) {
                     // char
                     if (!abr.device()->getChar(data))  {
                         break;
                     }
                 }
             }
         }
     }
     delete [] cscanline_len;
     return 0;
 }
 
 
 static QString abr_v1_brush_name(const QString filename, qint32 id)
 {
     QString result = filename;
     int pos = filename.lastIndexOf('.');
     result.remove(pos, 4);
     QTextStream(&result) << "_" << id;
     return result;
 }
 
 static bool abr_supported_content(AbrInfo *abr_hdr)
 {
     switch (abr_hdr->version) {
     case 1:
     case 2:
         return true;
         break;
     case 6:
         if (abr_hdr->subversion == 1 || abr_hdr->subversion == 2)
             return true;
         break;
     }
     return false;
 }
 
 static bool abr_reach_8BIM_section(QDataStream & abr, const QString name)
 {
     char tag[4];
     char tagname[5];
     qint32 section_size = 0;
     int r;
 
     // find 8BIMname section
     while (!abr.atEnd()) {
         r = abr.readRawData(tag, 4);
 
         if (r != 4) {
             warnKrita << "Error: Cannot read 8BIM tag ";
             return false;
         }
 
         if (strncmp(tag, "8BIM", 4)) {
             warnKrita << "Error: Start tag not 8BIM but " << (int)tag[0] << (int)tag[1] << (int)tag[2] << (int)tag[3] << " at position " << abr.device()->pos();
             return false;
         }
 
         r = abr.readRawData(tagname, 4);
 
         if (r != 4) {
             warnKrita << "Error: Cannot read 8BIM tag name";
             return false;
         }
         tagname[4] = '\0';
 
         QString s1 = QString::fromLatin1(tagname, 4);
 
         if (!s1.compare(name)) {
             return true;
         }
 
         // long
         abr >> section_size;
         abr.device()->seek(abr.device()->pos() + section_size);
     }
     return true;
 }
 
 static qint32 find_sample_count_v6(QDataStream & abr, AbrInfo *abr_info)
 {
     qint64 origin;
     qint32 sample_section_size;
     qint32 sample_section_end;
     qint32 samples = 0;
     qint32 data_start;
 
     qint32 brush_size;
     qint32 brush_end;
 
     if (!abr_supported_content(abr_info))
         return 0;
 
     origin = abr.device()->pos();
 
     if (!abr_reach_8BIM_section(abr, "samp")) {
         // reset to origin
         abr.device()->seek(origin);
         return 0;
     }
 
     // long
     abr >> sample_section_size;
     sample_section_end = sample_section_size + abr.device()->pos();
 
     if(sample_section_end < 0 || sample_section_end > abr.device()->size())
         return 0;
 
     data_start = abr.device()->pos();
 
     while ((!abr.atEnd()) && (abr.device()->pos() < sample_section_end)) {
         // read long
         abr >> brush_size;
         brush_end = brush_size;
         // complement to 4
         while (brush_end % 4 != 0) brush_end++;
 
         qint64 newPos = abr.device()->pos() + brush_end;
         if(newPos > 0 && newPos < abr.device()->size()) {
             abr.device()->seek(newPos);
         }
         else
             return 0;
 
         samples++;
     }
 
     // set stream to samples data
     abr.device()->seek(data_start);
 
     //dbgKrita <<"samples : "<< samples;
     return samples;
 }
 
 
 
 static bool abr_read_content(QDataStream & abr, AbrInfo *abr_hdr)
 {
 
     abr >> abr_hdr->version;
     abr_hdr->subversion = 0;
     abr_hdr->count = 0;
 
     switch (abr_hdr->version) {
     case 1:
     case 2:
         abr >> abr_hdr->count;
         break;
     case 6:
         abr >> abr_hdr->subversion;
         abr_hdr->count = find_sample_count_v6(abr, abr_hdr);
         break;
     default:
         // unknown versions
         break;
     }
     // next bytes in abr are samples data
 
     return true;
 }
 
 
 static QString abr_read_ucs2_text(QDataStream & abr)
 {
     quint32 name_size;
     quint32 buf_size;
     uint   i;
     /* two-bytes characters encoded (UCS-2)
     *  format:
     *   long : size - number of characters in string
     *   data : zero terminated UCS-2 string
     */
 
     // long
     abr >> name_size;
     if (name_size == 0) {
         return QString();
     }
 
     //buf_size = name_size * 2;
     buf_size = name_size;
 
     //name_ucs2 = (char*) malloc (buf_size * sizeof (char));
     //name_ucs2 = new char[buf_size];
 
     ushort * name_ucs2 = new ushort[buf_size];
     for (i = 0; i < buf_size ; i++) {
         //* char*/
         //abr >> name_ucs2[i];
 
         // I will use ushort as that is input to fromUtf16
         abr >>  name_ucs2[i];
     }
     QString name_utf8 = QString::fromUtf16(name_ucs2, buf_size);
     delete [] name_ucs2;
 
     return name_utf8;
 }
 
 
 quint32 KisAbrBrushCollection::abr_brush_load_v6(QDataStream & abr, AbrInfo *abr_hdr, const QString filename, qint32 image_ID, qint32 id)
 {
     Q_UNUSED(image_ID);
     qint32 brush_size = 0;
     qint32 brush_end = 0;
     qint32 next_brush = 0;
 
     qint32 top, left, bottom, right;
     top = left = bottom = right = 0;
     short depth;
     char compression;
 
     qint32 width = 0;
     qint32 height = 0;
     qint32 size = 0;
 
     qint32 layer_ID = -1;
 
     char *buffer;
 
     abr >> brush_size;
     brush_end = brush_size;
     // complement to 4
     while (brush_end % 4 != 0) {
         brush_end++;
     }
 
     next_brush = abr.device()->pos() + brush_end;
 
     // discard key
     abr.device()->seek(abr.device()->pos() + 37);
     if (abr_hdr->subversion == 1)
         // discard short coordinates and unknown short
         abr.device()->seek(abr.device()->pos() + 10);
     else
         // discard unknown bytes
         abr.device()->seek(abr.device()->pos() + 264);
 
     // long
     abr >> top;
     abr >> left;
     abr >> bottom;
     abr >> right;
     // short
     abr >> depth;
     // char
     abr.device()->getChar(&compression);
 
     width = right - left;
     height = bottom - top;
     size = width * (depth >> 3) * height;
 
     // remove .abr and add some id, so something like test.abr -> test_12345
     QString name = abr_v1_brush_name(filename, id);
 
     buffer = (char*)malloc(size);
 
     // data decoding
     if (!compression) {
         // not compressed - read raw bytes as brush data
         //fread (buffer, size, 1, abr);
         abr.readRawData(buffer, size);
     } else {
         rle_decode(abr, buffer, height);
     }
 
     if (width < quint16_MAX && height < quint16_MAX) {
         // filename - filename of the file , e.g. test.abr
         // name - test_number_of_the_brush, e.g test_1, test_2
         KisAbrBrush* abrBrush = 0;
         if (m_abrBrushes.contains(name)) {
             abrBrush = m_abrBrushes[name];
         }
         else {
             abrBrush = new KisAbrBrush(name, this);
             abrBrush->setMD5(md5());
         }
 
         abrBrush->setBrushTipImage(convertToQImage(buffer, width, height));
         // XXX: call extra setters on abrBrush for other options of ABR brushes
         abrBrush->setValid(true);
         abrBrush->setName(name);
         m_abrBrushes[name] = abrBrush;
 
     }
 
     free(buffer);
     abr.device()->seek(next_brush);
 
     layer_ID = id;
     return layer_ID;
 }
 
 
 qint32 KisAbrBrushCollection::abr_brush_load_v12(QDataStream & abr, AbrInfo *abr_hdr, const QString filename, qint32 image_ID, qint32 id)
 {
     Q_UNUSED(image_ID);
     short brush_type;
     qint32 brush_size;
     qint32 next_brush;
 
     qint32 top, left, bottom, right;
     qint16 depth;
     char compression;
     QString name;
 
     qint32 width, height;
     qint32 size;
 
     qint32 layer_ID = -1;
     char   *buffer;
 
     // short
     abr >> brush_type;
     // long
     abr >> brush_size;
     next_brush = abr.device()->pos() + brush_size;
 
     if (brush_type == 1) {
         // computed brush
         // FIXME: support it!
         warnKrita  << "WARNING: computed brush unsupported, skipping.";
         abr.device()->seek(abr.device()->pos() + next_brush);
         // TODO: test also this one abr.skipRawData(next_brush);
     }
     else if (brush_type == 2) {
         // sampled brush
         // discard 4 misc bytes and 2 spacing bytes
         abr.device()->seek(abr.device()->pos() + 6);
 
         if (abr_hdr->version == 2)
             name = abr_read_ucs2_text(abr);
         if (name.isNull()) {
             name = abr_v1_brush_name(filename, id);
         }
 
         // discard 1 byte for antialiasing and 4 x short for short bounds
         abr.device()->seek(abr.device()->pos() + 9);
 
         // long
         abr >> top;
         abr >> left;
         abr >> bottom;
         abr >> right;
         // short
         abr >> depth;
         // char
         abr.device()->getChar(&compression);
 
         width = right - left;
         height = bottom - top;
         size = width * (depth >> 3) * height;
 
         /* FIXME: support wide brushes */
         if (height > 16384) {
             warnKrita << "WARNING: wide brushes not supported";
             abr.device()->seek(next_brush);
         }
         else {
             buffer = (char*)malloc(size);
 
             if (!compression) {
                 // not compressed - read raw bytes as brush data
                 abr.readRawData(buffer, size);
             } else {
                 rle_decode(abr, buffer, height);
             }
 
             KisAbrBrush* abrBrush = 0;
             if (m_abrBrushes.contains(name)) {
                 abrBrush = m_abrBrushes[name];
             }
             else {
                 abrBrush = new KisAbrBrush(name, this);
                 abrBrush->setMD5(md5());
             }
 
             abrBrush->setBrushTipImage(convertToQImage(buffer, width, height));
             // XXX: call extra setters on abrBrush for other options of ABR brushes   free (buffer);
             abrBrush->setValid(true);
             abrBrush->setName(name);
             m_abrBrushes[name] = abrBrush;
             layer_ID = 1;
         }
     }
     else {
         warnKrita << "Unknown ABR brush type, skipping.";
         abr.device()->seek(next_brush);
     }
 
     return layer_ID;
 }
 
 
 qint32 KisAbrBrushCollection::abr_brush_load(QDataStream & abr, AbrInfo *abr_hdr, const QString filename, qint32 image_ID, qint32 id)
 {
     qint32 layer_ID = -1;
     switch (abr_hdr->version) {
     case 1:
         // fall through, version 1 and 2 are compatible
     case 2:
         layer_ID = abr_brush_load_v12(abr, abr_hdr, filename, image_ID, id);
         break;
     case 6:
         layer_ID = abr_brush_load_v6(abr, abr_hdr, filename, image_ID, id);
         break;
     }
 
     return layer_ID;
 }
 
 
 KisAbrBrushCollection::KisAbrBrushCollection(const QString& filename)
     : KisScalingSizeBrush(filename)
 {
 }
 
 KisAbrBrushCollection::KisAbrBrushCollection(const KisAbrBrushCollection& rhs)
     : KisScalingSizeBrush(rhs)
 {
     for (auto it = rhs.m_abrBrushes.begin();
          it != rhs.m_abrBrushes.end();
          ++it) {
 
         m_abrBrushes.insert(it.key(), new KisAbrBrush(*it.value(), this));
     }
 }
 
 KisBrush* KisAbrBrushCollection::clone() const
 {
     return new KisAbrBrushCollection(*this);
 }
 
 bool KisAbrBrushCollection::load()
 {
     QFile file(filename());
     // check if the file is open correctly
     if (!file.open(QIODevice::ReadOnly)) {
         warnKrita << "Can't open file " << filename();
         return false;
     }
 
     bool res = loadFromDevice(&file);
     file.close();
 
     return res;
 
 }
 
 bool KisAbrBrushCollection::loadFromDevice(QIODevice *dev)
 {
     AbrInfo abr_hdr;
     qint32 image_ID;
     int i;
     qint32 layer_ID;
 
     QByteArray ba = dev->readAll();
     QBuffer buf(&ba);
     buf.open(QIODevice::ReadOnly);
     QDataStream abr(&buf);
 
 
     if (!abr_read_content(abr, &abr_hdr)) {
         warnKrita << "Error: cannot parse ABR file: " << filename();
         return false;
     }
 
     if (!abr_supported_content(&abr_hdr)) {
         warnKrita << "ERROR: unable to decode abr format version " << abr_hdr.version << "(subver " << abr_hdr.subversion << ")";
         return false;
     }
 
     if (abr_hdr.count == 0) {
         errKrita << "ERROR: no sample brush found in " << filename();
         return false;
     }
 
     image_ID = 123456;
 
     for (i = 0; i < abr_hdr.count; i++) {
         layer_ID = abr_brush_load(abr, &abr_hdr, shortFilename(), image_ID, i + 1);
         if (layer_ID == -1) {
             warnKrita << "Warning: problem loading brush #" << i << " in " << filename();
         }
     }
 
     return true;
 
 }
 
 bool KisAbrBrushCollection::save()
 {
     return false;
 }
 
 bool KisAbrBrushCollection::saveToDevice(QIODevice */*dev*/) const
 {
     return false;
 }
 
 QImage KisAbrBrushCollection::image() const
 {
     return QImage();
 }
 
 void KisAbrBrushCollection::toXML(QDomDocument& d, QDomElement& e) const
 {
     Q_UNUSED(d);
     Q_UNUSED(e);
     // Do nothing...
 }
 
 QString KisAbrBrushCollection::defaultFileExtension() const
 {
     return QString(".abr");
 }
diff --git a/libs/flake/KoFlake.cpp b/libs/flake/KoFlake.cpp
index 3e30fb0a6e..ad46c89c67 100644
--- a/libs/flake/KoFlake.cpp
+++ b/libs/flake/KoFlake.cpp
@@ -1,347 +1,346 @@
 /* This file is part of the KDE project
  * Copyright (C) 2009 Jos van den Oever <jos@vandenoever.info>
  * Copyright (C) 2009 Thomas Zander <zander@kde.org>
  * Copyright (C) 2008 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2010 Thorsten Zachmann <zachmann@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoFlake.h"
 #include "KoShape.h"
 
 #include <QGradient>
 #include <math.h>
 #include "kis_global.h"
 
 QGradient *KoFlake::cloneGradient(const QGradient *gradient)
 {
     if (! gradient)
         return 0;
 
     QGradient *clone = 0;
 
     switch (gradient->type()) {
     case QGradient::LinearGradient:
     {
         const QLinearGradient *lg = static_cast<const QLinearGradient*>(gradient);
         clone = new QLinearGradient(lg->start(), lg->finalStop());
         break;
     }
     case QGradient::RadialGradient:
     {
         const QRadialGradient *rg = static_cast<const QRadialGradient*>(gradient);
         clone = new QRadialGradient(rg->center(), rg->radius(), rg->focalPoint());
         break;
     }
     case QGradient::ConicalGradient:
     {
         const QConicalGradient *cg = static_cast<const QConicalGradient*>(gradient);
         clone = new QConicalGradient(cg->center(), cg->angle());
         break;
     }
     default:
         return 0;
     }
 
     clone->setCoordinateMode(gradient->coordinateMode());
     clone->setSpread(gradient->spread());
     clone->setStops(gradient->stops());
 
     return clone;
 }
 
 QGradient *KoFlake::mergeGradient(const QGradient *coordsSource, const QGradient *fillSource)
 {
     QPointF start;
     QPointF end;
     QPointF focalPoint;
 
     switch (coordsSource->type()) {
     case QGradient::LinearGradient: {
         const QLinearGradient *lg = static_cast<const QLinearGradient*>(coordsSource);
         start = lg->start();
         focalPoint = start;
         end = lg->finalStop();
         break;
     }
     case QGradient::RadialGradient: {
         const QRadialGradient *rg = static_cast<const QRadialGradient*>(coordsSource);
         start = rg->center();
         end = start + QPointF(rg->radius(), 0);
         focalPoint = rg->focalPoint();
         break;
     }
     case QGradient::ConicalGradient: {
         const QConicalGradient *cg = static_cast<const QConicalGradient*>(coordsSource);
 
         start = cg->center();
         focalPoint = start;
 
         QLineF l (start, start + QPointF(1.0, 0));
         l.setAngle(cg->angle());
         end = l.p2();
         break;
     }
     default:
         return 0;
     }
 
     QGradient *clone = 0;
 
     switch (fillSource->type()) {
     case QGradient::LinearGradient:
         clone = new QLinearGradient(start, end);
         break;
     case QGradient::RadialGradient:
         clone = new QRadialGradient(start, kisDistance(start, end), focalPoint);
         break;
     case QGradient::ConicalGradient: {
         QLineF l(start, end);
         clone = new QConicalGradient(l.p1(), l.angle());
         break;
     }
     default:
         return 0;
     }
 
     clone->setCoordinateMode(fillSource->coordinateMode());
     clone->setSpread(fillSource->spread());
     clone->setStops(fillSource->stops());
 
     return clone;
 }
 
 QPointF KoFlake::toRelative(const QPointF &absolute, const QSizeF &size)
 {
     return QPointF(size.width() == 0 ? 0: absolute.x() / size.width(),
                    size.height() == 0 ? 0: absolute.y() / size.height());
 }
 
 QPointF KoFlake::toAbsolute(const QPointF &relative, const QSizeF &size)
 {
     return QPointF(relative.x() * size.width(), relative.y() * size.height());
 }
 
-#include <KoShape.h>
 #include <QTransform>
 #include "kis_debug.h"
 #include "kis_algebra_2d.h"
 
 namespace {
 
 qreal getScaleByPointsPair(qreal x1, qreal x2, qreal expX1, qreal expX2)
 {
     static const qreal eps = 1e-10;
 
     const qreal diff = x2 - x1;
     const qreal expDiff = expX2 - expX1;
 
     return qAbs(diff) > eps ? expDiff / diff : 1.0;
 }
 
 void findMinMaxPoints(const QPolygonF &poly, int *minPoint, int *maxPoint, std::function<qreal(const QPointF&)> dimension)
 {
     KIS_ASSERT_RECOVER_RETURN(minPoint);
     KIS_ASSERT_RECOVER_RETURN(maxPoint);
 
     qreal minValue = dimension(poly[*minPoint]);
     qreal maxValue = dimension(poly[*maxPoint]);
 
     for (int i = 0; i < poly.size(); i++) {
         const qreal value = dimension(poly[i]);
 
         if (value < minValue) {
             *minPoint = i;
             minValue = value;
         }
 
         if (value > maxValue) {
             *maxPoint = i;
             maxValue = value;
         }
     }
 }
 
 }
 
 
 Qt::Orientation KoFlake::significantScaleOrientation(qreal scaleX, qreal scaleY)
 {
     const qreal scaleXDeviation = qAbs(1.0 - scaleX);
     const qreal scaleYDeviation = qAbs(1.0 - scaleY);
 
     return scaleXDeviation > scaleYDeviation ? Qt::Horizontal : Qt::Vertical;
 }
 
 void KoFlake::resizeShape(KoShape *shape, qreal scaleX, qreal scaleY,
                           const QPointF &absoluteStillPoint,
                           bool useGlobalMode,
                           bool usePostScaling, const QTransform &postScalingCoveringTransform)
 {
     QPointF localStillPoint = shape->absoluteTransformation(0).inverted().map(absoluteStillPoint);
 
     QPointF relativeStillPoint = KisAlgebra2D::absoluteToRelative(localStillPoint, shape->outlineRect());
     QPointF parentalStillPointBefore = shape->transformation().map(localStillPoint);
 
     if (usePostScaling) {
         const QTransform scale = QTransform::fromScale(scaleX, scaleY);
 
         if (!useGlobalMode) {
             shape->setTransformation(shape->transformation() *
                                      postScalingCoveringTransform.inverted() *
                                      scale * postScalingCoveringTransform);
         } else {
             const QTransform uniformGlobalTransform =
                     shape->absoluteTransformation(0) *
                     scale *
                     shape->absoluteTransformation(0).inverted() *
                     shape->transformation();
 
             shape->setTransformation(uniformGlobalTransform);
         }
     } else {
         using namespace KisAlgebra2D;
 
         if (useGlobalMode) {
             const QTransform scale = QTransform::fromScale(scaleX, scaleY);
             const QTransform uniformGlobalTransform =
                     shape->absoluteTransformation(0) *
                     scale *
                     shape->absoluteTransformation(0).inverted();
 
             const QRectF rect = shape->outlineRect();
 
             /**
              * The basic idea of such global scaling:
              *
              * 1) We choose two the most distant points of the original outline rect
              * 2) Calculate their expected position if transformed using `uniformGlobalTransform`
              * 3) NOTE1: we do not transform the entire shape using `uniformGlobalTransform`,
              *           because it will cause massive shearing. We transform only two points
              *           and adjust other points using dumb scaling.
              * 4) NOTE2: given that `scale` transform is much more simpler than
              *           `uniformGlobalTransform`, we cannot guarantee equivalent changes on
              *           both globalScaleX and globalScaleY at the same time. We can guarantee
              *           only one of them. Therefore we select the most "important" axis and
              *           guarantee scael along it. The scale along the other direction is not
              *           controlled.
              * 5) After we have the two most distant points, we can just calculate the scale
              *    by dividing difference between their expected and original positions. This
              *    formula can be derived from equation:
              *
              *    localPoint_i * ScaleMatrix = localPoint_i * UniformGlobalTransform = expectedPoint_i
              */
 
             // choose the most significant scale direction
             Qt::Orientation significantOrientation = significantScaleOrientation(scaleX, scaleY);
 
             std::function<qreal(const QPointF&)> dimension;
 
             if (significantOrientation == Qt::Horizontal) {
                 dimension = [] (const QPointF &pt) {
                     return pt.x();
                 };
 
             } else {
                 dimension = [] (const QPointF &pt) {
                     return pt.y();
                 };
             }
 
             // find min and max points (in absolute coordinates),
             // by default use top-left and bottom-right
             QPolygonF localPoints(rect);
             QPolygonF globalPoints = shape->absoluteTransformation(0).map(localPoints);
 
             int minPointIndex = 0;
             int maxPointIndex = 2;
 
             findMinMaxPoints(globalPoints, &minPointIndex, &maxPointIndex, dimension);
 
             // calculate the scale using the extremum points
             const QPointF minPoint = localPoints[minPointIndex];
             const QPointF maxPoint = localPoints[maxPointIndex];
 
             const QPointF minPointExpected = uniformGlobalTransform.map(minPoint);
             const QPointF maxPointExpected = uniformGlobalTransform.map(maxPoint);
 
             scaleX = getScaleByPointsPair(minPoint.x(), maxPoint.x(),
                                           minPointExpected.x(), maxPointExpected.x());
             scaleY = getScaleByPointsPair(minPoint.y(), maxPoint.y(),
                                           minPointExpected.y(), maxPointExpected.y());
         }
 
         const QSizeF oldSize(shape->size());
         const QSizeF newSize(oldSize.width() * qAbs(scaleX), oldSize.height() * qAbs(scaleY));
 
         const QTransform mirrorTransform = QTransform::fromScale(signPZ(scaleX), signPZ(scaleY));
 
         shape->setSize(newSize);
 
         if (!mirrorTransform.isIdentity()) {
             shape->setTransformation(mirrorTransform * shape->transformation());
         }
 
     }
 
     QPointF newLocalStillPoint = KisAlgebra2D::relativeToAbsolute(relativeStillPoint, shape->outlineRect());
     QPointF parentalStillPointAfter = shape->transformation().map(newLocalStillPoint);
 
     QPointF diff = parentalStillPointBefore - parentalStillPointAfter;
     shape->setTransformation(shape->transformation() * QTransform::fromTranslate(diff.x(), diff.y()));
 }
 
 QPointF KoFlake::anchorToPoint(AnchorPosition anchor, const QRectF rect, bool *valid)
 {
     static QVector<QPointF> anchorTable;
 
     if (anchorTable.isEmpty()) {
         anchorTable << QPointF(0.0,0.0);
         anchorTable << QPointF(0.5,0.0);
         anchorTable << QPointF(1.0,0.0);
 
         anchorTable << QPointF(0.0,0.5);
         anchorTable << QPointF(0.5,0.5);
         anchorTable << QPointF(1.0,0.5);
 
         anchorTable << QPointF(0.0,1.0);
         anchorTable << QPointF(0.5,1.0);
         anchorTable << QPointF(1.0,1.0);
     }
 
     if (valid)
         *valid = false;
 
     switch(anchor)
     {
         case AnchorPosition::TopLeft:
         case AnchorPosition::Top:
         case AnchorPosition::TopRight:
         case AnchorPosition::Left:
         case AnchorPosition::Center:
         case AnchorPosition::Right:
         case AnchorPosition::BottomLeft:
         case AnchorPosition::Bottom:
         case AnchorPosition::BottomRight:
             if (valid)
                 *valid = true;
             return KisAlgebra2D::relativeToAbsolute(anchorTable[int(anchor)], rect);
         default:
             KIS_SAFE_ASSERT_RECOVER_NOOP(anchor >= AnchorPosition::TopLeft && anchor < AnchorPosition::NumAnchorPositions);
             return rect.topLeft();
     }
 }
diff --git a/libs/flake/KoShape.cpp b/libs/flake/KoShape.cpp
index 40f88b3304..f0095ebed3 100644
--- a/libs/flake/KoShape.cpp
+++ b/libs/flake/KoShape.cpp
@@ -1,2546 +1,2545 @@
 /* This file is part of the KDE project
    Copyright (C) 2006 C. Boemann Rasmussen <cbo@boemann.dk>
    Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
    Copyright (C) 2006-2010 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2007-2009,2011 Jan Hambrecht <jaham@gmx.net>
    CopyRight (C) 2010 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 <limits>
 
 #include "KoShape.h"
 #include "KoShape_p.h"
 #include "KoShapeContainer.h"
 #include "KoShapeLayer.h"
 #include "KoShapeContainerModel.h"
 #include "KoSelection.h"
 #include "KoPointerEvent.h"
 #include "KoInsets.h"
 #include "KoShapeStrokeModel.h"
 #include "KoShapeBackground.h"
 #include "KoColorBackground.h"
 #include "KoHatchBackground.h"
 #include "KoGradientBackground.h"
 #include "KoPatternBackground.h"
 #include "KoShapeManager.h"
 #include "KoShapeUserData.h"
 #include "KoShapeApplicationData.h"
 #include "KoShapeSavingContext.h"
 #include "KoShapeLoadingContext.h"
 #include "KoViewConverter.h"
 #include "KoShapeStroke.h"
 #include "KoShapeShadow.h"
 #include "KoClipPath.h"
 #include "KoPathShape.h"
 #include "KoOdfWorkaround.h"
 #include "KoFilterEffectStack.h"
 #include <KoSnapData.h>
 #include <KoElementReference.h>
 
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoXmlNS.h>
 #include <KoGenStyle.h>
 #include <KoGenStyles.h>
 #include <KoUnit.h>
 #include <KoOdfStylesReader.h>
 #include <KoOdfGraphicStyles.h>
 #include <KoOdfLoadingContext.h>
 #include <KoStyleStack.h>
 #include <KoBorder.h>
 
 #include <QPainter>
 #include <QVariant>
 #include <QPainterPath>
 #include <QList>
 #include <QMap>
 #include <QByteArray>
 #include <FlakeDebug.h>
 
 #include "kis_assert.h"
 
-#include <limits>
 #include "KoOdfGradientBackground.h"
 #include <KisHandlePainterHelper.h>
 
 // KoShapePrivate
 
 KoShapePrivate::KoShapePrivate(KoShape *shape)
     : q_ptr(shape),
       size(50, 50),
       parent(0),
       shadow(0),
       border(0),
       filterEffectStack(0),
       transparency(0.0),
       zIndex(0),
       runThrough(0),
       visible(true),
       printable(true),
       geometryProtected(false),
       keepAspect(false),
       selectable(true),
       detectCollision(false),
       protectContent(false),
       textRunAroundSide(KoShape::BiggestRunAroundSide),
       textRunAroundDistanceLeft(0.0),
       textRunAroundDistanceTop(0.0),
       textRunAroundDistanceRight(0.0),
       textRunAroundDistanceBottom(0.0),
       textRunAroundThreshold(0.0),
       textRunAroundContour(KoShape::ContourFull)
 {
     connectors[KoConnectionPoint::TopConnectionPoint] = KoConnectionPoint::defaultConnectionPoint(KoConnectionPoint::TopConnectionPoint);
     connectors[KoConnectionPoint::RightConnectionPoint] = KoConnectionPoint::defaultConnectionPoint(KoConnectionPoint::RightConnectionPoint);
     connectors[KoConnectionPoint::BottomConnectionPoint] = KoConnectionPoint::defaultConnectionPoint(KoConnectionPoint::BottomConnectionPoint);
     connectors[KoConnectionPoint::LeftConnectionPoint] = KoConnectionPoint::defaultConnectionPoint(KoConnectionPoint::LeftConnectionPoint);
     connectors[KoConnectionPoint::FirstCustomConnectionPoint] = KoConnectionPoint(QPointF(0.5, 0.5), KoConnectionPoint::AllDirections, KoConnectionPoint::AlignCenter);
 }
 
 KoShapePrivate::KoShapePrivate(const KoShapePrivate &rhs, KoShape *q)
     : q_ptr(q),
       size(rhs.size),
       shapeId(rhs.shapeId),
       name(rhs.name),
       localMatrix(rhs.localMatrix),
       connectors(rhs.connectors),
       parent(0), // to be initialized later
       shapeManagers(), // to be initialized later
       toolDelegates(), // FIXME: how to initialize them?
       userData(rhs.userData ? rhs.userData->clone() : 0),
       stroke(rhs.stroke),
       fill(rhs.fill),
       inheritBackground(rhs.inheritBackground),
       inheritStroke(rhs.inheritStroke),
       dependees(), // FIXME: how to initialize them?
       shadow(0), // WARNING: not implemented in Krita
       border(0), // WARNING: not implemented in Krita
       clipPath(rhs.clipPath ? rhs.clipPath->clone() : 0),
       clipMask(rhs.clipMask ? rhs.clipMask->clone() : 0),
       additionalAttributes(rhs.additionalAttributes),
       additionalStyleAttributes(rhs.additionalStyleAttributes),
       filterEffectStack(0), // WARNING: not implemented in Krita
       transparency(rhs.transparency),
       hyperLink(rhs.hyperLink),
 
       zIndex(rhs.zIndex),
       runThrough(rhs.runThrough),
       visible(rhs.visible),
       printable(rhs.visible),
       geometryProtected(rhs.geometryProtected),
       keepAspect(rhs.keepAspect),
       selectable(rhs.selectable),
       detectCollision(rhs.detectCollision),
       protectContent(rhs.protectContent),
 
       textRunAroundSide(rhs.textRunAroundSide),
       textRunAroundDistanceLeft(rhs.textRunAroundDistanceLeft),
       textRunAroundDistanceTop(rhs.textRunAroundDistanceTop),
       textRunAroundDistanceRight(rhs.textRunAroundDistanceRight),
       textRunAroundDistanceBottom(rhs.textRunAroundDistanceBottom),
       textRunAroundThreshold(rhs.textRunAroundThreshold),
       textRunAroundContour(rhs.textRunAroundContour)
 {
 }
 
 KoShapePrivate::~KoShapePrivate()
 {
     Q_Q(KoShape);
 
     /**
      * The shape must have already been detached from all the parents and
      * shape managers. Otherwise we migh accidentally request some RTTI
      * information, which is not available anymore (we are in d-tor).
      *
      * TL;DR: fix the code that caused this destruction without unparenting
      *        instead of trying to remove these assert!
      */
     KIS_SAFE_ASSERT_RECOVER (!parent) {
         parent->removeShape(q);
     }
 
     KIS_SAFE_ASSERT_RECOVER (shapeManagers.isEmpty()) {
         Q_FOREACH (KoShapeManager *manager, shapeManagers) {
             manager->shapeInterface()->notifyShapeDestructed(q);
         }
         shapeManagers.clear();
     }
 
     if (shadow && !shadow->deref())
         delete shadow;
     if (filterEffectStack && !filterEffectStack->deref())
         delete filterEffectStack;
 }
 
 void KoShapePrivate::shapeChanged(KoShape::ChangeType type)
 {
     Q_Q(KoShape);
     if (parent)
         parent->model()->childChanged(q, type);
 
     q->shapeChanged(type);
 
     Q_FOREACH (KoShape * shape, dependees) {
         shape->shapeChanged(type, q);
     }
 
     Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners) {
         listener->notifyShapeChangedImpl(type, q);
     }
 }
 
 void KoShapePrivate::addShapeManager(KoShapeManager *manager)
 {
     shapeManagers.insert(manager);
 }
 
 void KoShapePrivate::removeShapeManager(KoShapeManager *manager)
 {
     shapeManagers.remove(manager);
 }
 
 void KoShapePrivate::convertFromShapeCoordinates(KoConnectionPoint &point, const QSizeF &shapeSize) const
 {
     switch(point.alignment) {
     case KoConnectionPoint::AlignNone:
         point.position = KoFlake::toRelative(point.position, shapeSize);
         point.position.rx() = qBound<qreal>(0.0, point.position.x(), 1.0);
         point.position.ry() = qBound<qreal>(0.0, point.position.y(), 1.0);
         break;
     case KoConnectionPoint::AlignRight:
         point.position.rx() -= shapeSize.width();
         break;
     case KoConnectionPoint::AlignLeft:
         point.position.ry() = 0.5*shapeSize.height();
         break;
     case KoConnectionPoint::AlignBottom:
         point.position.ry() -= shapeSize.height();
         break;
     case KoConnectionPoint::AlignTop:
         point.position.rx() = 0.5*shapeSize.width();
         break;
     case KoConnectionPoint::AlignTopLeft:
         // nothing to do here
         break;
     case KoConnectionPoint::AlignTopRight:
         point.position.rx() -= shapeSize.width();
         break;
     case KoConnectionPoint::AlignBottomLeft:
         point.position.ry() -= shapeSize.height();
         break;
     case KoConnectionPoint::AlignBottomRight:
         point.position.rx() -= shapeSize.width();
         point.position.ry() -= shapeSize.height();
         break;
     case KoConnectionPoint::AlignCenter:
         point.position.rx() -= 0.5 * shapeSize.width();
         point.position.ry() -= 0.5 * shapeSize.height();
         break;
     }
 }
 
 void KoShapePrivate::convertToShapeCoordinates(KoConnectionPoint &point, const QSizeF &shapeSize) const
 {
     switch(point.alignment) {
     case KoConnectionPoint::AlignNone:
         point.position = KoFlake::toAbsolute(point.position, shapeSize);
         break;
     case KoConnectionPoint::AlignRight:
         point.position.rx() += shapeSize.width();
         break;
     case KoConnectionPoint::AlignLeft:
         point.position.ry() = 0.5*shapeSize.height();
         break;
     case KoConnectionPoint::AlignBottom:
         point.position.ry() += shapeSize.height();
         break;
     case KoConnectionPoint::AlignTop:
         point.position.rx() = 0.5*shapeSize.width();
         break;
     case KoConnectionPoint::AlignTopLeft:
         // nothing to do here
         break;
     case KoConnectionPoint::AlignTopRight:
         point.position.rx() += shapeSize.width();
         break;
     case KoConnectionPoint::AlignBottomLeft:
         point.position.ry() += shapeSize.height();
         break;
     case KoConnectionPoint::AlignBottomRight:
         point.position.rx() += shapeSize.width();
         point.position.ry() += shapeSize.height();
         break;
     case KoConnectionPoint::AlignCenter:
         point.position.rx() += 0.5 * shapeSize.width();
         point.position.ry() += 0.5 * shapeSize.height();
         break;
     }
 }
 
 // static
 QString KoShapePrivate::getStyleProperty(const char *property, KoShapeLoadingContext &context)
 {
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
     QString value;
 
     if (styleStack.hasProperty(KoXmlNS::draw, property)) {
         value = styleStack.property(KoXmlNS::draw, property);
     }
 
     return value;
 }
 
 
 
 // ======== KoShape
 
 const qint16 KoShape::maxZIndex = std::numeric_limits<qint16>::max();
 const qint16 KoShape::minZIndex = std::numeric_limits<qint16>::min();
 
 KoShape::KoShape()
     : d_ptr(new KoShapePrivate(this))
 {
     notifyChanged();
 }
 
 KoShape::KoShape(KoShapePrivate *dd)
     : d_ptr(dd)
 {
 }
 
 KoShape::~KoShape()
 {
     Q_D(KoShape);
     d->shapeChanged(Deleted);
     d->listeners.clear();
     delete d_ptr;
 }
 
 KoShape *KoShape::cloneShape() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "not implemented!");
     qWarning() << shapeId() << "cannot be cloned";
     return 0;
 }
 
 void KoShape::paintStroke(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintcontext)
 {
     Q_UNUSED(paintcontext);
 
     if (stroke()) {
         stroke()->paint(this, painter, converter);
     }
 }
 
 void KoShape::scale(qreal sx, qreal sy)
 {
     Q_D(KoShape);
     QPointF pos = position();
     QTransform scaleMatrix;
     scaleMatrix.translate(pos.x(), pos.y());
     scaleMatrix.scale(sx, sy);
     scaleMatrix.translate(-pos.x(), -pos.y());
     d->localMatrix = d->localMatrix * scaleMatrix;
 
     notifyChanged();
     d->shapeChanged(ScaleChanged);
 }
 
 void KoShape::rotate(qreal angle)
 {
     Q_D(KoShape);
     QPointF center = d->localMatrix.map(QPointF(0.5 * size().width(), 0.5 * size().height()));
     QTransform rotateMatrix;
     rotateMatrix.translate(center.x(), center.y());
     rotateMatrix.rotate(angle);
     rotateMatrix.translate(-center.x(), -center.y());
     d->localMatrix = d->localMatrix * rotateMatrix;
 
     notifyChanged();
     d->shapeChanged(RotationChanged);
 }
 
 void KoShape::shear(qreal sx, qreal sy)
 {
     Q_D(KoShape);
     QPointF pos = position();
     QTransform shearMatrix;
     shearMatrix.translate(pos.x(), pos.y());
     shearMatrix.shear(sx, sy);
     shearMatrix.translate(-pos.x(), -pos.y());
     d->localMatrix = d->localMatrix * shearMatrix;
 
     notifyChanged();
     d->shapeChanged(ShearChanged);
 }
 
 void KoShape::setSize(const QSizeF &newSize)
 {
     Q_D(KoShape);
     QSizeF oldSize(size());
 
     // always set size, as d->size and size() may vary
     d->size = newSize;
 
     if (oldSize == newSize)
         return;
 
     notifyChanged();
     d->shapeChanged(SizeChanged);
 }
 
 void KoShape::setPosition(const QPointF &newPosition)
 {
     Q_D(KoShape);
     QPointF currentPos = position();
     if (newPosition == currentPos)
         return;
     QTransform translateMatrix;
     translateMatrix.translate(newPosition.x() - currentPos.x(), newPosition.y() - currentPos.y());
     d->localMatrix = d->localMatrix * translateMatrix;
 
     notifyChanged();
     d->shapeChanged(PositionChanged);
 }
 
 bool KoShape::hitTest(const QPointF &position) const
 {
     Q_D(const KoShape);
     if (d->parent && d->parent->isClipped(this) && !d->parent->hitTest(position))
         return false;
 
     QPointF point = absoluteTransformation(0).inverted().map(position);
     QRectF bb = outlineRect();
 
     if (d->stroke) {
         KoInsets insets;
         d->stroke->strokeInsets(this, insets);
         bb.adjust(-insets.left, -insets.top, insets.right, insets.bottom);
     }
     if (bb.contains(point))
         return true;
 
     // if there is no shadow we can as well just leave
     if (! d->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 - d->shadow->offset());
 
     return bb.contains(point);
 }
 
 QRectF KoShape::boundingRect() const
 {
     Q_D(const KoShape);
 
     QTransform transform = absoluteTransformation(0);
     QRectF bb = outlineRect();
     if (d->stroke) {
         KoInsets insets;
         d->stroke->strokeInsets(this, insets);
         bb.adjust(-insets.left, -insets.top, insets.right, insets.bottom);
     }
     bb = transform.mapRect(bb);
     if (d->shadow) {
         KoInsets insets;
         d->shadow->insets(insets);
         bb.adjust(-insets.left, -insets.top, insets.right, insets.bottom);
     }
     if (d->filterEffectStack) {
         QRectF clipRect = d->filterEffectStack->clipRectForBoundingRect(outlineRect());
         bb |= transform.mapRect(clipRect);
     }
 
     return bb;
 }
 
 QRectF KoShape::boundingRect(const QList<KoShape *> &shapes)
 {
     QRectF boundingRect;
     Q_FOREACH (KoShape *shape, shapes) {
         boundingRect |= shape->boundingRect();
     }
     return boundingRect;
 }
 
 QRectF KoShape::absoluteOutlineRect(KoViewConverter *converter) const
 {
     return absoluteTransformation(converter).map(outline()).boundingRect();
 }
 
 QRectF KoShape::absoluteOutlineRect(const QList<KoShape *> &shapes, KoViewConverter *converter)
 {
     QRectF absoluteOutlineRect;
     Q_FOREACH (KoShape *shape, shapes) {
         absoluteOutlineRect |= shape->absoluteOutlineRect(converter);
     }
     return absoluteOutlineRect;
 }
 
 QTransform KoShape::absoluteTransformation(const KoViewConverter *converter) const
 {
     Q_D(const KoShape);
     QTransform matrix;
     // apply parents matrix to inherit any transformations done there.
     KoShapeContainer * container = d->parent;
     if (container) {
         if (container->inheritsTransform(this)) {
             // We do need to pass the converter here, otherwise the parent's
             // translation is not inherited.
             matrix = container->absoluteTransformation(converter);
         } else {
             QSizeF containerSize = container->size();
             QPointF containerPos = container->absolutePosition() - QPointF(0.5 * containerSize.width(), 0.5 * containerSize.height());
             if (converter)
                 containerPos = converter->documentToView(containerPos);
             matrix.translate(containerPos.x(), containerPos.y());
         }
     }
 
     if (converter) {
         QPointF pos = d->localMatrix.map(QPointF());
         QPointF trans = converter->documentToView(pos) - pos;
         matrix.translate(trans.x(), trans.y());
     }
 
     return d->localMatrix * matrix;
 }
 
 void KoShape::applyAbsoluteTransformation(const QTransform &matrix)
 {
     QTransform globalMatrix = absoluteTransformation(0);
     // the transformation is relative to the global coordinate system
     // but we want to change the local matrix, so convert the matrix
     // to be relative to the local coordinate system
     QTransform transformMatrix = globalMatrix * matrix * globalMatrix.inverted();
     applyTransformation(transformMatrix);
 }
 
 void KoShape::applyTransformation(const QTransform &matrix)
 {
     Q_D(KoShape);
     d->localMatrix = matrix * d->localMatrix;
     notifyChanged();
     d->shapeChanged(GenericMatrixChange);
 }
 
 void KoShape::setTransformation(const QTransform &matrix)
 {
     Q_D(KoShape);
     d->localMatrix = matrix;
     notifyChanged();
     d->shapeChanged(GenericMatrixChange);
 }
 
 QTransform KoShape::transformation() const
 {
     Q_D(const KoShape);
     return d->localMatrix;
 }
 
 KoShape::ChildZOrderPolicy KoShape::childZOrderPolicy()
 {
     return ChildZDefault;
 }
 
 bool KoShape::compareShapeZIndex(KoShape *s1, KoShape *s2)
 {
     /**
      * WARNING: Our definition of zIndex is not yet compatible with SVG2's
      *          definition. In SVG stacking context of groups with the same
      *          zIndex are **merged**, while in Krita the contents of groups
      *          is never merged. One group will always below than the other.
      *          Therefore, when zIndex of two groups inside the same parent
      *          coinside, the resulting painting order in Krita is
      *          **UNDEFINED**.
      *
      *          To avoid this trouble we use  KoShapeReorderCommand::mergeInShape()
      *          inside KoShapeCreateCommand.
      */
 
     /**
      * The algorithm below doesn't correctly handle the case when the two pointers actually
      * point to the same shape. So just check it in advance to guarantee strict weak ordering
      * relation requirement
      */
     if (s1 == s2) return false;
 
 
     // First sort according to runThrough which is sort of a master level
     KoShape *parentShapeS1 = s1->parent();
     KoShape *parentShapeS2 = s2->parent();
     int runThrough1 = s1->runThrough();
     int runThrough2 = s2->runThrough();
     while (parentShapeS1) {
         if (parentShapeS1->childZOrderPolicy() == KoShape::ChildZParentChild) {
             runThrough1 = parentShapeS1->runThrough();
         } else {
             runThrough1 = runThrough1 + parentShapeS1->runThrough();
         }
         parentShapeS1 = parentShapeS1->parent();
     }
 
     while (parentShapeS2) {
         if (parentShapeS2->childZOrderPolicy() == KoShape::ChildZParentChild) {
             runThrough2 = parentShapeS2->runThrough();
         } else {
             runThrough2 = runThrough2 + parentShapeS2->runThrough();
         }
         parentShapeS2 = parentShapeS2->parent();
     }
 
     if (runThrough1 > runThrough2) {
         return false;
     }
     if (runThrough1 < runThrough2) {
         return true;
     }
 
     // If on the same runThrough level then the zIndex is all that matters.
     //
     // We basically walk up through the parents until we find a common base parent
     // To do that we need two loops where the inner loop walks up through the parents
     // of s2 every time we step up one parent level on s1
     //
     // We don't update the index value until after we have seen that it's not a common base
     // That way we ensure that two children of a common base are sorted according to their respective
     // z value
     bool foundCommonParent = false;
     int index1 = s1->zIndex();
     int index2 = s2->zIndex();
     parentShapeS1 = s1;
     parentShapeS2 = s2;
     while (parentShapeS1 && !foundCommonParent) {
         parentShapeS2 = s2;
         index2 = parentShapeS2->zIndex();
         while (parentShapeS2) {
             if (parentShapeS2 == parentShapeS1) {
                 foundCommonParent = true;
                 break;
             }
             if (parentShapeS2->childZOrderPolicy() == KoShape::ChildZParentChild) {
                 index2 = parentShapeS2->zIndex();
             }
             parentShapeS2 = parentShapeS2->parent();
         }
 
         if (!foundCommonParent) {
             if (parentShapeS1->childZOrderPolicy() == KoShape::ChildZParentChild) {
                 index1 = parentShapeS1->zIndex();
             }
             parentShapeS1 = parentShapeS1->parent();
         }
     }
 
     // If the one shape is a parent/child of the other then sort so.
     if (s1 == parentShapeS2) {
         return true;
     }
     if (s2 == parentShapeS1) {
         return false;
     }
 
     // If we went that far then the z-Index is used for sorting.
     return index1 < index2;
 }
 
 void KoShape::setParent(KoShapeContainer *parent)
 {
     Q_D(KoShape);
 
     if (d->parent == parent) {
         return;
     }
 
     KoShapeContainer *oldParent = d->parent;
     d->parent = 0; // avoids recursive removing
 
     if (oldParent) {
         oldParent->shapeInterface()->removeShape(this);
     }
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(parent != this);
 
     if (parent && parent != this) {
         d->parent = parent;
         parent->shapeInterface()->addShape(this);
     }
 
     notifyChanged();
     d->shapeChanged(ParentChanged);
 }
 
 bool KoShape::inheritsTransformFromAny(const QList<KoShape *> ancestorsInQuestion) const
 {
     bool result = false;
 
     KoShape *shape = const_cast<KoShape*>(this);
     while (shape) {
         KoShapeContainer *parent = shape->parent();
         if (parent && !parent->inheritsTransform(shape)) {
             break;
         }
 
         if (ancestorsInQuestion.contains(shape)) {
             result = true;
             break;
         }
 
         shape = parent;
     }
 
     return result;
 }
 
 bool KoShape::hasCommonParent(const KoShape *shape) const
 {
     const KoShape *thisShape = this;
     while (thisShape) {
 
         const KoShape *otherShape = shape;
         while (otherShape) {
             if (thisShape == otherShape) {
                 return true;
             }
             otherShape = otherShape->parent();
         }
 
         thisShape = thisShape->parent();
     }
 
     return false;
 }
 
 qint16 KoShape::zIndex() const
 {
     Q_D(const KoShape);
     return d->zIndex;
 }
 
 void KoShape::update() const
 {
     Q_D(const KoShape);
 
     if (!d->shapeManagers.empty()) {
         QRectF rect(boundingRect());
         Q_FOREACH (KoShapeManager * manager, d->shapeManagers) {
             manager->update(rect, this, true);
         }
     }
 }
 
 void KoShape::updateAbsolute(const QRectF &rect) const
 {
 
     if (rect.isEmpty() && !rect.isNull()) {
         return;
     }
 
     Q_D(const KoShape);
 
     if (!d->shapeManagers.empty() && isVisible()) {
         Q_FOREACH (KoShapeManager * manager, d->shapeManagers) {
             manager->update(rect);
         }
     }
 }
 
 QPainterPath KoShape::outline() const
 {
     QPainterPath path;
     path.addRect(outlineRect());
     return path;
 }
 
 QRectF KoShape::outlineRect() const
 {
     const QSizeF s = size();
     return QRectF(QPointF(0, 0), QSizeF(qMax(s.width(),  qreal(0.0001)),
                                         qMax(s.height(), qreal(0.0001))));
 }
 
 QPainterPath KoShape::shadowOutline() const
 {
     Q_D(const KoShape);
     if (background()) {
         return outline();
     }
 
     return QPainterPath();
 }
 
 QPointF KoShape::absolutePosition(KoFlake::AnchorPosition anchor) const
 {
     const QRectF rc = outlineRect();
 
     QPointF point = rc.topLeft();
 
     bool valid = false;
     QPointF anchoredPoint = KoFlake::anchorToPoint(anchor, rc, &valid);
     if (valid) {
         point = anchoredPoint;
     }
 
     return absoluteTransformation(0).map(point);
 }
 
 void KoShape::setAbsolutePosition(const QPointF &newPosition, KoFlake::AnchorPosition anchor)
 {
     Q_D(KoShape);
     QPointF currentAbsPosition = absolutePosition(anchor);
     QPointF translate = newPosition - currentAbsPosition;
     QTransform translateMatrix;
     translateMatrix.translate(translate.x(), translate.y());
     applyAbsoluteTransformation(translateMatrix);
     notifyChanged();
     d->shapeChanged(PositionChanged);
 }
 
 void KoShape::copySettings(const KoShape *shape)
 {
     Q_D(KoShape);
     d->size = shape->size();
     d->connectors.clear();
     Q_FOREACH (const KoConnectionPoint &point, shape->connectionPoints())
         addConnectionPoint(point);
     d->zIndex = shape->zIndex();
     d->visible = shape->isVisible(false);
 
     // Ensure printable is true by default
     if (!d->visible)
         d->printable = true;
     else
         d->printable = shape->isPrintable();
 
     d->geometryProtected = shape->isGeometryProtected();
     d->protectContent = shape->isContentProtected();
     d->selectable = shape->isSelectable();
     d->keepAspect = shape->keepAspectRatio();
     d->localMatrix = shape->d_ptr->localMatrix;
 }
 
 void KoShape::notifyChanged()
 {
     Q_D(KoShape);
     Q_FOREACH (KoShapeManager * manager, d->shapeManagers) {
         manager->notifyShapeChanged(this);
     }
 }
 
 void KoShape::setUserData(KoShapeUserData *userData)
 {
     Q_D(KoShape);
     d->userData.reset(userData);
 }
 
 KoShapeUserData *KoShape::userData() const
 {
     Q_D(const KoShape);
     return d->userData.data();
 }
 
 bool KoShape::hasTransparency() const
 {
     Q_D(const KoShape);
     QSharedPointer<KoShapeBackground> bg = background();
 
     return !bg || bg->hasTransparency() || d->transparency > 0.0;
 }
 
 void KoShape::setTransparency(qreal transparency)
 {
     Q_D(KoShape);
     d->transparency = qBound<qreal>(0.0, transparency, 1.0);
 
     d->shapeChanged(TransparencyChanged);
     notifyChanged();
 }
 
 qreal KoShape::transparency(bool recursive) const
 {
     Q_D(const KoShape);
     if (!recursive || !parent()) {
         return d->transparency;
     } else {
         const qreal parentOpacity = 1.0-parent()->transparency(recursive);
         const qreal childOpacity = 1.0-d->transparency;
         return 1.0-(parentOpacity*childOpacity);
     }
 }
 
 KoInsets KoShape::strokeInsets() const
 {
     Q_D(const KoShape);
     KoInsets answer;
     if (d->stroke)
         d->stroke->strokeInsets(this, answer);
     return answer;
 }
 
 qreal KoShape::rotation() const
 {
     Q_D(const KoShape);
     // try to extract the rotation angle out of the local matrix
     // if it is a pure rotation matrix
 
     // check if the matrix has shearing mixed in
     if (fabs(fabs(d->localMatrix.m12()) - fabs(d->localMatrix.m21())) > 1e-10)
         return std::numeric_limits<qreal>::quiet_NaN();
     // check if the matrix has scaling mixed in
     if (fabs(d->localMatrix.m11() - d->localMatrix.m22()) > 1e-10)
         return std::numeric_limits<qreal>::quiet_NaN();
 
     // calculate the angle from the matrix elements
     qreal angle = atan2(-d->localMatrix.m21(), d->localMatrix.m11()) * 180.0 / M_PI;
     if (angle < 0.0)
         angle += 360.0;
 
     return angle;
 }
 
 QSizeF KoShape::size() const
 {
     Q_D(const KoShape);
     return d->size;
 }
 
 QPointF KoShape::position() const
 {
     Q_D(const KoShape);
     QPointF center = outlineRect().center();
     return d->localMatrix.map(center) - center;
 }
 
 int KoShape::addConnectionPoint(const KoConnectionPoint &point)
 {
     Q_D(KoShape);
 
     // get next glue point id
     int nextConnectionPointId = KoConnectionPoint::FirstCustomConnectionPoint;
     if (d->connectors.size())
         nextConnectionPointId = qMax(nextConnectionPointId, (--d->connectors.end()).key()+1);
 
     KoConnectionPoint p = point;
     d->convertFromShapeCoordinates(p, size());
     d->connectors[nextConnectionPointId] = p;
 
     return nextConnectionPointId;
 }
 
 bool KoShape::setConnectionPoint(int connectionPointId, const KoConnectionPoint &point)
 {
     Q_D(KoShape);
     if (connectionPointId < 0)
         return false;
 
     const bool insertPoint = !hasConnectionPoint(connectionPointId);
 
     switch(connectionPointId) {
     case KoConnectionPoint::TopConnectionPoint:
     case KoConnectionPoint::RightConnectionPoint:
     case KoConnectionPoint::BottomConnectionPoint:
     case KoConnectionPoint::LeftConnectionPoint:
     {
         KoConnectionPoint::PointId id = static_cast<KoConnectionPoint::PointId>(connectionPointId);
         d->connectors[id] = KoConnectionPoint::defaultConnectionPoint(id);
         break;
     }
     default:
     {
         KoConnectionPoint p = point;
         d->convertFromShapeCoordinates(p, size());
         d->connectors[connectionPointId] = p;
         break;
     }
     }
 
     if(!insertPoint)
         d->shapeChanged(ConnectionPointChanged);
 
     return true;
 }
 
 bool KoShape::hasConnectionPoint(int connectionPointId) const
 {
     Q_D(const KoShape);
     return d->connectors.contains(connectionPointId);
 }
 
 KoConnectionPoint KoShape::connectionPoint(int connectionPointId) const
 {
     Q_D(const KoShape);
     KoConnectionPoint p = d->connectors.value(connectionPointId, KoConnectionPoint());
     // convert glue point to shape coordinates
     d->convertToShapeCoordinates(p, size());
     return p;
 }
 
 KoConnectionPoints KoShape::connectionPoints() const
 {
     Q_D(const KoShape);
     QSizeF s = size();
     KoConnectionPoints points = d->connectors;
     KoConnectionPoints::iterator point = points.begin();
     KoConnectionPoints::iterator lastPoint = points.end();
     // convert glue points to shape coordinates
     for(; point != lastPoint; ++point) {
         d->convertToShapeCoordinates(point.value(), s);
     }
 
     return points;
 }
 
 void KoShape::removeConnectionPoint(int connectionPointId)
 {
     Q_D(KoShape);
     d->connectors.remove(connectionPointId);
     d->shapeChanged(ConnectionPointChanged);
 }
 
 void KoShape::clearConnectionPoints()
 {
     Q_D(KoShape);
     d->connectors.clear();
 }
 
 KoShape::TextRunAroundSide KoShape::textRunAroundSide() const
 {
     Q_D(const KoShape);
     return d->textRunAroundSide;
 }
 
 void KoShape::setTextRunAroundSide(TextRunAroundSide side, RunThroughLevel runThrought)
 {
     Q_D(KoShape);
 
     if (side == RunThrough) {
         if (runThrought == Background) {
             setRunThrough(-1);
         } else {
             setRunThrough(1);
         }
     } else {
         setRunThrough(0);
     }
 
     if ( d->textRunAroundSide == side) {
         return;
     }
 
     d->textRunAroundSide = side;
     notifyChanged();
     d->shapeChanged(TextRunAroundChanged);
 }
 
 qreal KoShape::textRunAroundDistanceTop() const
 {
     Q_D(const KoShape);
     return d->textRunAroundDistanceTop;
 }
 
 void KoShape::setTextRunAroundDistanceTop(qreal distance)
 {
     Q_D(KoShape);
     d->textRunAroundDistanceTop = distance;
 }
 
 qreal KoShape::textRunAroundDistanceLeft() const
 {
     Q_D(const KoShape);
     return d->textRunAroundDistanceLeft;
 }
 
 void KoShape::setTextRunAroundDistanceLeft(qreal distance)
 {
     Q_D(KoShape);
     d->textRunAroundDistanceLeft = distance;
 }
 
 qreal KoShape::textRunAroundDistanceRight() const
 {
     Q_D(const KoShape);
     return d->textRunAroundDistanceRight;
 }
 
 void KoShape::setTextRunAroundDistanceRight(qreal distance)
 {
     Q_D(KoShape);
     d->textRunAroundDistanceRight = distance;
 }
 
 qreal KoShape::textRunAroundDistanceBottom() const
 {
     Q_D(const KoShape);
     return d->textRunAroundDistanceBottom;
 }
 
 void KoShape::setTextRunAroundDistanceBottom(qreal distance)
 {
     Q_D(KoShape);
     d->textRunAroundDistanceBottom = distance;
 }
 
 qreal KoShape::textRunAroundThreshold() const
 {
     Q_D(const KoShape);
     return d->textRunAroundThreshold;
 }
 
 void KoShape::setTextRunAroundThreshold(qreal threshold)
 {
     Q_D(KoShape);
     d->textRunAroundThreshold = threshold;
 }
 
 KoShape::TextRunAroundContour KoShape::textRunAroundContour() const
 {
     Q_D(const KoShape);
     return d->textRunAroundContour;
 }
 
 void KoShape::setTextRunAroundContour(KoShape::TextRunAroundContour contour)
 {
     Q_D(KoShape);
     d->textRunAroundContour = contour;
 }
 
 void KoShape::setBackground(QSharedPointer<KoShapeBackground> fill)
 {
     Q_D(KoShape);
     d->inheritBackground = false;
     d->fill = fill;
     d->shapeChanged(BackgroundChanged);
     notifyChanged();
 }
 
 QSharedPointer<KoShapeBackground> KoShape::background() const
 {
     Q_D(const KoShape);
 
     QSharedPointer<KoShapeBackground> bg;
 
     if (!d->inheritBackground) {
         bg = d->fill;
     } else if (parent()) {
         bg = parent()->background();
     }
 
     return bg;
 }
 
 void KoShape::setInheritBackground(bool value)
 {
     Q_D(KoShape);
 
     d->inheritBackground = value;
     if (d->inheritBackground) {
         d->fill.clear();
     }
 }
 
 bool KoShape::inheritBackground() const
 {
     Q_D(const KoShape);
     return d->inheritBackground;
 }
 
 void KoShape::setZIndex(qint16 zIndex)
 {
     Q_D(KoShape);
     if (d->zIndex == zIndex)
         return;
     d->zIndex = zIndex;
     notifyChanged();
 }
 
 int KoShape::runThrough()
 {
     Q_D(const KoShape);
     return d->runThrough;
 }
 
 void KoShape::setRunThrough(short int runThrough)
 {
     Q_D(KoShape);
     d->runThrough = runThrough;
 }
 
 void KoShape::setVisible(bool on)
 {
     Q_D(KoShape);
     int _on = (on ? 1 : 0);
     if (d->visible == _on) return;
     d->visible = _on;
 }
 
 bool KoShape::isVisible(bool recursive) const
 {
     Q_D(const KoShape);
     if (!recursive)
         return d->visible;
 
     if (!d->visible)
         return false;
 
     KoShapeContainer * parentShape = parent();
 
     if (parentShape) {
         return parentShape->isVisible(true);
     }
 
     return true;
 }
 
 void KoShape::setPrintable(bool on)
 {
     Q_D(KoShape);
     d->printable = on;
 }
 
 bool KoShape::isPrintable() const
 {
     Q_D(const KoShape);
     if (d->visible)
         return d->printable;
     else
         return false;
 }
 
 void KoShape::setSelectable(bool selectable)
 {
     Q_D(KoShape);
     d->selectable = selectable;
 }
 
 bool KoShape::isSelectable() const
 {
     Q_D(const KoShape);
     return d->selectable;
 }
 
 void KoShape::setGeometryProtected(bool on)
 {
     Q_D(KoShape);
     d->geometryProtected = on;
 }
 
 bool KoShape::isGeometryProtected() const
 {
     Q_D(const KoShape);
     return d->geometryProtected;
 }
 
 void KoShape::setContentProtected(bool protect)
 {
     Q_D(KoShape);
     d->protectContent = protect;
 }
 
 bool KoShape::isContentProtected() const
 {
     Q_D(const KoShape);
     return d->protectContent;
 }
 
 KoShapeContainer *KoShape::parent() const
 {
     Q_D(const KoShape);
     return d->parent;
 }
 
 void KoShape::setKeepAspectRatio(bool keepAspect)
 {
     Q_D(KoShape);
     d->keepAspect = keepAspect;
 
     d->shapeChanged(KeepAspectRatioChange);
     notifyChanged();
 }
 
 bool KoShape::keepAspectRatio() const
 {
     Q_D(const KoShape);
     return d->keepAspect;
 }
 
 QString KoShape::shapeId() const
 {
     Q_D(const KoShape);
     return d->shapeId;
 }
 
 void KoShape::setShapeId(const QString &id)
 {
     Q_D(KoShape);
     d->shapeId = id;
 }
 
 void KoShape::setCollisionDetection(bool detect)
 {
     Q_D(KoShape);
     d->detectCollision = detect;
 }
 
 bool KoShape::collisionDetection()
 {
     Q_D(KoShape);
     return d->detectCollision;
 }
 
 KoShapeStrokeModelSP KoShape::stroke() const
 {
     Q_D(const KoShape);
 
     KoShapeStrokeModelSP stroke;
 
     if (!d->inheritStroke) {
         stroke = d->stroke;
     } else if (parent()) {
         stroke = parent()->stroke();
     }
 
     return stroke;
 }
 
 void KoShape::setStroke(KoShapeStrokeModelSP stroke)
 {
     Q_D(KoShape);
 
     d->inheritStroke = false;
     d->stroke = stroke;
     d->shapeChanged(StrokeChanged);
     notifyChanged();
 }
 
 void KoShape::setInheritStroke(bool value)
 {
     Q_D(KoShape);
     d->inheritStroke = value;
     if (d->inheritStroke) {
         d->stroke.clear();
     }
 }
 
 bool KoShape::inheritStroke() const
 {
     Q_D(const KoShape);
     return d->inheritStroke;
 }
 
 void KoShape::setShadow(KoShapeShadow *shadow)
 {
     Q_D(KoShape);
     if (d->shadow)
         d->shadow->deref();
     d->shadow = shadow;
     if (d->shadow) {
         d->shadow->ref();
         // TODO update changed area
     }
     d->shapeChanged(ShadowChanged);
     notifyChanged();
 }
 
 KoShapeShadow *KoShape::shadow() const
 {
     Q_D(const KoShape);
     return d->shadow;
 }
 
 void KoShape::setBorder(KoBorder *border)
 {
     Q_D(KoShape);
     if (d->border) {
         // The shape owns the border.
         delete d->border;
     }
     d->border = border;
     d->shapeChanged(BorderChanged);
     notifyChanged();
 }
 
 KoBorder *KoShape::border() const
 {
     Q_D(const KoShape);
     return d->border;
 }
 
 void KoShape::setClipPath(KoClipPath *clipPath)
 {
     Q_D(KoShape);
     d->clipPath.reset(clipPath);
     d->shapeChanged(ClipPathChanged);
     notifyChanged();
 }
 
 KoClipPath * KoShape::clipPath() const
 {
     Q_D(const KoShape);
     return d->clipPath.data();
 }
 
 void KoShape::setClipMask(KoClipMask *clipMask)
 {
     Q_D(KoShape);
     d->clipMask.reset(clipMask);
 }
 
 KoClipMask* KoShape::clipMask() const
 {
     Q_D(const KoShape);
     return d->clipMask.data();
 }
 
 QTransform KoShape::transform() const
 {
     Q_D(const KoShape);
     return d->localMatrix;
 }
 
 QString KoShape::name() const
 {
     Q_D(const KoShape);
     return d->name;
 }
 
 void KoShape::setName(const QString &name)
 {
     Q_D(KoShape);
     d->name = name;
 }
 
 void KoShape::waitUntilReady(const KoViewConverter &converter, bool asynchronous) const
 {
     Q_UNUSED(converter);
     Q_UNUSED(asynchronous);
 }
 
 bool KoShape::isShapeEditable(bool recursive) const
 {
     Q_D(const KoShape);
     if (!d->visible || d->geometryProtected)
         return false;
 
     if (recursive && d->parent) {
         return d->parent->isShapeEditable(true);
     }
 
     return true;
 }
 
 // painting
 void KoShape::paintBorder(QPainter &painter, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
     KoBorder *bd = border();
     if (!bd) {
         return;
     }
 
     QRectF borderRect = QRectF(QPointF(0, 0), size());
     // Paint the border.
     bd->paint(painter, borderRect, KoBorder::PaintInsideLine);
 }
 
 
 // loading & saving methods
 QString KoShape::saveStyle(KoGenStyle &style, KoShapeSavingContext &context) const
 {
     Q_D(const KoShape);
     // and fill the style
     KoShapeStrokeModelSP sm = stroke();
     if (sm) {
         sm->fillStyle(style, context);
     }
     else {
         style.addProperty("draw:stroke", "none", KoGenStyle::GraphicType);
     }
     KoShapeShadow *s = shadow();
     if (s)
         s->fillStyle(style, context);
 
     QSharedPointer<KoShapeBackground> bg = background();
     if (bg) {
         bg->fillStyle(style, context);
     }
     else {
         style.addProperty("draw:fill", "none", KoGenStyle::GraphicType);
     }
 
     KoBorder *b = border();
     if (b) {
         b->saveOdf(style);
     }
 
     if (context.isSet(KoShapeSavingContext::AutoStyleInStyleXml)) {
         style.setAutoStyleInStylesDotXml(true);
     }
 
     QString value;
     if (isGeometryProtected()) {
         value = "position size";
     }
     if (isContentProtected()) {
         if (! value.isEmpty())
             value += ' ';
         value += "content";
     }
     if (!value.isEmpty()) {
         style.addProperty("style:protect", value, KoGenStyle::GraphicType);
     }
 
     QMap<QByteArray, QString>::const_iterator it(d->additionalStyleAttributes.constBegin());
     for (; it != d->additionalStyleAttributes.constEnd(); ++it) {
         style.addProperty(it.key(), it.value());
     }
 
     if (parent() && parent()->isClipped(this)) {
         /*
          * In Calligra clipping is done using a parent shape which can be rotated, sheared etc
          * and even non-square.  So the ODF interoperability version we write here is really
          * just a very simple version of that...
          */
         qreal top = -position().y();
         qreal left = -position().x();
         qreal right = parent()->size().width() - size().width() - left;
         qreal bottom = parent()->size().height() - size().height() - top;
 
         style.addProperty("fo:clip", QString("rect(%1pt, %2pt, %3pt, %4pt)")
                           .arg(top, 10, 'f').arg(right, 10, 'f')
                           .arg(bottom, 10, 'f').arg(left, 10, 'f'), KoGenStyle::GraphicType);
 
     }
 
     QString wrap;
     switch (textRunAroundSide()) {
     case BiggestRunAroundSide:
         wrap = "biggest";
         break;
     case LeftRunAroundSide:
         wrap = "left";
         break;
     case RightRunAroundSide:
         wrap = "right";
         break;
     case EnoughRunAroundSide:
         wrap = "dynamic";
         break;
     case BothRunAroundSide:
         wrap = "parallel";
         break;
     case NoRunAround:
         wrap = "none";
         break;
     case RunThrough:
         wrap = "run-through";
         break;
     }
     style.addProperty("style:wrap", wrap, KoGenStyle::GraphicType);
     switch (textRunAroundContour()) {
     case ContourBox:
         style.addProperty("style:wrap-contour", "false", KoGenStyle::GraphicType);
         break;
     case ContourFull:
         style.addProperty("style:wrap-contour", "true", KoGenStyle::GraphicType);
         style.addProperty("style:wrap-contour-mode", "full", KoGenStyle::GraphicType);
         break;
     case ContourOutside:
         style.addProperty("style:wrap-contour", "true", KoGenStyle::GraphicType);
         style.addProperty("style:wrap-contour-mode", "outside", KoGenStyle::GraphicType);
         break;
     }
     style.addPropertyPt("style:wrap-dynamic-threshold", textRunAroundThreshold(), KoGenStyle::GraphicType);
     if ((textRunAroundDistanceLeft() == textRunAroundDistanceRight())
             && (textRunAroundDistanceTop() == textRunAroundDistanceBottom())
             && (textRunAroundDistanceLeft() == textRunAroundDistanceTop())) {
         style.addPropertyPt("fo:margin", textRunAroundDistanceLeft(), KoGenStyle::GraphicType);
     } else {
         style.addPropertyPt("fo:margin-left", textRunAroundDistanceLeft(), KoGenStyle::GraphicType);
         style.addPropertyPt("fo:margin-top", textRunAroundDistanceTop(), KoGenStyle::GraphicType);
         style.addPropertyPt("fo:margin-right", textRunAroundDistanceRight(), KoGenStyle::GraphicType);
         style.addPropertyPt("fo:margin-bottom", textRunAroundDistanceBottom(), KoGenStyle::GraphicType);
     }
 
     return context.mainStyles().insert(style, context.isSet(KoShapeSavingContext::PresentationShape) ? "pr" : "gr");
 }
 
 void KoShape::loadStyle(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     Q_D(KoShape);
 
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
     styleStack.setTypeProperties("graphic");
 
     d->fill.clear();
     d->stroke.clear();
 
     if (d->shadow && !d->shadow->deref()) {
         delete d->shadow;
         d->shadow = 0;
     }
     setBackground(loadOdfFill(context));
     setStroke(loadOdfStroke(element, context));
     setShadow(d->loadOdfShadow(context));
     setBorder(d->loadOdfBorder(context));
 
     QString protect(styleStack.property(KoXmlNS::style, "protect"));
     setGeometryProtected(protect.contains("position") || protect.contains("size"));
     setContentProtected(protect.contains("content"));
 
     QString margin = styleStack.property(KoXmlNS::fo, "margin");
     if (!margin.isEmpty()) {
         setTextRunAroundDistanceLeft(KoUnit::parseValue(margin));
         setTextRunAroundDistanceTop(KoUnit::parseValue(margin));
         setTextRunAroundDistanceRight(KoUnit::parseValue(margin));
         setTextRunAroundDistanceBottom(KoUnit::parseValue(margin));
     }
     margin = styleStack.property(KoXmlNS::fo, "margin-left");
     if (!margin.isEmpty()) {
         setTextRunAroundDistanceLeft(KoUnit::parseValue(margin));
     }
 
     margin = styleStack.property(KoXmlNS::fo, "margin-top");
     if (!margin.isEmpty()) {
         setTextRunAroundDistanceTop(KoUnit::parseValue(margin));
     }
     margin = styleStack.property(KoXmlNS::fo, "margin-right");
     if (!margin.isEmpty()) {
         setTextRunAroundDistanceRight(KoUnit::parseValue(margin));
     }
     margin = styleStack.property(KoXmlNS::fo, "margin-bottom");
     if (!margin.isEmpty()) {
         setTextRunAroundDistanceBottom(KoUnit::parseValue(margin));
     }
 
     QString wrap;
     if (styleStack.hasProperty(KoXmlNS::style, "wrap")) {
         wrap = styleStack.property(KoXmlNS::style, "wrap");
     } else {
         // no value given in the file, but guess biggest
         wrap = "biggest";
     }
     if (wrap == "none") {
         setTextRunAroundSide(KoShape::NoRunAround);
     } else if (wrap == "run-through") {
         QString runTrought = styleStack.property(KoXmlNS::style, "run-through", "background");
         if (runTrought == "background") {
             setTextRunAroundSide(KoShape::RunThrough, KoShape::Background);
         } else {
             setTextRunAroundSide(KoShape::RunThrough, KoShape::Foreground);
         }
     } else {
         if (wrap == "biggest")
             setTextRunAroundSide(KoShape::BiggestRunAroundSide);
         else if (wrap == "left")
             setTextRunAroundSide(KoShape::LeftRunAroundSide);
         else if (wrap == "right")
             setTextRunAroundSide(KoShape::RightRunAroundSide);
         else if (wrap == "dynamic")
             setTextRunAroundSide(KoShape::EnoughRunAroundSide);
         else if (wrap == "parallel")
             setTextRunAroundSide(KoShape::BothRunAroundSide);
     }
 
     if (styleStack.hasProperty(KoXmlNS::style, "wrap-dynamic-threshold")) {
         QString wrapThreshold = styleStack.property(KoXmlNS::style, "wrap-dynamic-threshold");
         if (!wrapThreshold.isEmpty()) {
             setTextRunAroundThreshold(KoUnit::parseValue(wrapThreshold));
         }
     }
     if (styleStack.property(KoXmlNS::style, "wrap-contour", "false") == "true") {
         if (styleStack.property(KoXmlNS::style, "wrap-contour-mode", "full") == "full") {
             setTextRunAroundContour(KoShape::ContourFull);
         } else {
             setTextRunAroundContour(KoShape::ContourOutside);
         }
     } else {
         setTextRunAroundContour(KoShape::ContourBox);
     }
 }
 
 bool KoShape::loadOdfAttributes(const KoXmlElement &element, KoShapeLoadingContext &context, int attributes)
 {
     if (attributes & OdfPosition) {
         QPointF pos(position());
         if (element.hasAttributeNS(KoXmlNS::svg, "x"))
             pos.setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x", QString())));
         if (element.hasAttributeNS(KoXmlNS::svg, "y"))
             pos.setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y", QString())));
         setPosition(pos);
     }
 
     if (attributes & OdfSize) {
         QSizeF s(size());
         if (element.hasAttributeNS(KoXmlNS::svg, "width"))
             s.setWidth(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "width", QString())));
         if (element.hasAttributeNS(KoXmlNS::svg, "height"))
             s.setHeight(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "height", QString())));
         setSize(s);
     }
 
     if (attributes & OdfLayer) {
         if (element.hasAttributeNS(KoXmlNS::draw, "layer")) {
             KoShapeLayer *layer = context.layer(element.attributeNS(KoXmlNS::draw, "layer"));
             if (layer) {
                 setParent(layer);
             }
         }
     }
 
     if (attributes & OdfId) {
         KoElementReference ref;
         ref.loadOdf(element);
         if (ref.isValid()) {
             context.addShapeId(this, ref.toString());
         }
     }
 
     if (attributes & OdfZIndex) {
         if (element.hasAttributeNS(KoXmlNS::draw, "z-index")) {
             setZIndex(element.attributeNS(KoXmlNS::draw, "z-index").toInt());
         } else {
             setZIndex(context.zIndex());
         }
     }
 
     if (attributes & OdfName) {
         if (element.hasAttributeNS(KoXmlNS::draw, "name")) {
             setName(element.attributeNS(KoXmlNS::draw, "name"));
         }
     }
 
     if (attributes & OdfStyle) {
         KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
         styleStack.save();
         if (element.hasAttributeNS(KoXmlNS::draw, "style-name")) {
             context.odfLoadingContext().fillStyleStack(element, KoXmlNS::draw, "style-name", "graphic");
         }
         if (element.hasAttributeNS(KoXmlNS::presentation, "style-name")) {
             context.odfLoadingContext().fillStyleStack(element, KoXmlNS::presentation, "style-name", "presentation");
         }
         loadStyle(element, context);
 
         styleStack.restore();
     }
 
     if (attributes & OdfTransformation) {
         QString transform = element.attributeNS(KoXmlNS::draw, "transform", QString());
         if (! transform.isEmpty())
             applyAbsoluteTransformation(parseOdfTransform(transform));
     }
 
     if (attributes & OdfAdditionalAttributes) {
         QSet<KoShapeLoadingContext::AdditionalAttributeData> additionalAttributeData = KoShapeLoadingContext::additionalAttributeData();
         Q_FOREACH (const KoShapeLoadingContext::AdditionalAttributeData &attributeData, additionalAttributeData) {
             if (element.hasAttributeNS(attributeData.ns, attributeData.tag)) {
                 QString value = element.attributeNS(attributeData.ns, attributeData.tag);
                 //debugFlake << "load additional attribute" << attributeData.tag << value;
                 setAdditionalAttribute(attributeData.name, value);
             }
         }
     }
 
     if (attributes & OdfCommonChildElements) {
         // load glue points (connection points)
         loadOdfGluePoints(element, context);
     }
 
     return true;
 }
 
 QSharedPointer<KoShapeBackground> KoShape::loadOdfFill(KoShapeLoadingContext &context) const
 {
     QString fill = KoShapePrivate::getStyleProperty("fill", context);
     QSharedPointer<KoShapeBackground> bg;
     if (fill == "solid") {
         bg = QSharedPointer<KoShapeBackground>(new KoColorBackground());
     }
     else if (fill == "hatch") {
         bg = QSharedPointer<KoShapeBackground>(new KoHatchBackground());
     }
     else if (fill == "gradient") {
         QString styleName = KoShapePrivate::getStyleProperty("fill-gradient-name", context);
         KoXmlElement *e = context.odfLoadingContext().stylesReader().drawStyles("gradient")[styleName];
         QString style;
         if (e) {
             style = e->attributeNS(KoXmlNS::draw, "style", QString());
         }
         if ((style == "rectangular") || (style == "square")) {
             bg = QSharedPointer<KoShapeBackground>(new KoOdfGradientBackground());
         } else {
             QGradient *gradient = new QLinearGradient();
             gradient->setCoordinateMode(QGradient::ObjectBoundingMode);
             bg = QSharedPointer<KoShapeBackground>(new KoGradientBackground(gradient));
         }
     } else if (fill == "bitmap") {
         bg = QSharedPointer<KoShapeBackground>(new KoPatternBackground(context.imageCollection()));
 #ifndef NWORKAROUND_ODF_BUGS
     } else if (fill.isEmpty()) {
         bg = QSharedPointer<KoShapeBackground>(KoOdfWorkaround::fixBackgroundColor(this, context));
         return bg;
 #endif
     } else {
         return QSharedPointer<KoShapeBackground>(0);
     }
 
     if (!bg->loadStyle(context.odfLoadingContext(), size())) {
         return QSharedPointer<KoShapeBackground>(0);
     }
 
     return bg;
 }
 
 KoShapeStrokeModelSP KoShape::loadOdfStroke(const KoXmlElement &element, KoShapeLoadingContext &context) const
 {
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
     KoOdfStylesReader &stylesReader = context.odfLoadingContext().stylesReader();
 
     QString stroke = KoShapePrivate::getStyleProperty("stroke", context);
     if (stroke == "solid" || stroke == "dash") {
         QPen pen = KoOdfGraphicStyles::loadOdfStrokeStyle(styleStack, stroke, stylesReader);
 
         QSharedPointer<KoShapeStroke> stroke(new KoShapeStroke());
 
         if (styleStack.hasProperty(KoXmlNS::calligra, "stroke-gradient")) {
             QString gradientName = styleStack.property(KoXmlNS::calligra, "stroke-gradient");
             QBrush brush = KoOdfGraphicStyles::loadOdfGradientStyleByName(stylesReader, gradientName, size());
             stroke->setLineBrush(brush);
         } else {
             stroke->setColor(pen.color());
         }
 
 #ifndef NWORKAROUND_ODF_BUGS
         KoOdfWorkaround::fixPenWidth(pen, context);
 #endif
         stroke->setLineWidth(pen.widthF());
         stroke->setJoinStyle(pen.joinStyle());
         stroke->setLineStyle(pen.style(), pen.dashPattern());
         stroke->setCapStyle(pen.capStyle());
 
         return stroke;
 #ifndef NWORKAROUND_ODF_BUGS
     } else if (stroke.isEmpty()) {
         QPen pen = KoOdfGraphicStyles::loadOdfStrokeStyle(styleStack, "solid", stylesReader);
         if (KoOdfWorkaround::fixMissingStroke(pen, element, context, this)) {
             QSharedPointer<KoShapeStroke> stroke(new KoShapeStroke());
 
 #ifndef NWORKAROUND_ODF_BUGS
             KoOdfWorkaround::fixPenWidth(pen, context);
 #endif
             stroke->setLineWidth(pen.widthF());
             stroke->setJoinStyle(pen.joinStyle());
             stroke->setLineStyle(pen.style(), pen.dashPattern());
             stroke->setCapStyle(pen.capStyle());
             stroke->setColor(pen.color());
 
             return stroke;
         }
 #endif
     }
 
     return KoShapeStrokeModelSP();
 }
 
 KoShapeShadow *KoShapePrivate::loadOdfShadow(KoShapeLoadingContext &context) const
 {
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
     QString shadowStyle = KoShapePrivate::getStyleProperty("shadow", context);
     if (shadowStyle == "visible" || shadowStyle == "hidden") {
         KoShapeShadow *shadow = new KoShapeShadow();
         QColor shadowColor(styleStack.property(KoXmlNS::draw, "shadow-color"));
         qreal offsetX = KoUnit::parseValue(styleStack.property(KoXmlNS::draw, "shadow-offset-x"));
         qreal offsetY = KoUnit::parseValue(styleStack.property(KoXmlNS::draw, "shadow-offset-y"));
         shadow->setOffset(QPointF(offsetX, offsetY));
         qreal blur = KoUnit::parseValue(styleStack.property(KoXmlNS::calligra, "shadow-blur-radius"));
         shadow->setBlur(blur);
 
         QString opacity = styleStack.property(KoXmlNS::draw, "shadow-opacity");
         if (! opacity.isEmpty() && opacity.right(1) == "%")
             shadowColor.setAlphaF(opacity.left(opacity.length() - 1).toFloat() / 100.0);
         shadow->setColor(shadowColor);
         shadow->setVisible(shadowStyle == "visible");
 
         return shadow;
     }
     return 0;
 }
 
 KoBorder *KoShapePrivate::loadOdfBorder(KoShapeLoadingContext &context) const
 {
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
 
     KoBorder *border = new KoBorder();
     if (border->loadOdf(styleStack)) {
         return border;
     }
     delete border;
     return 0;
 }
 
 
 void KoShape::loadOdfGluePoints(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     Q_D(KoShape);
 
     KoXmlElement child;
     bool hasCenterGluePoint = false;
     forEachElement(child, element) {
         if (child.namespaceURI() != KoXmlNS::draw)
             continue;
         if (child.localName() != "glue-point")
             continue;
 
         // NOTE: this uses draw:id, but apparently while ODF 1.2 has deprecated
         // all use of draw:id for xml:id, it didn't specify that here, so it
         // doesn't support xml:id (and so, maybe, shouldn't use KoElementReference.
         const QString id = child.attributeNS(KoXmlNS::draw, "id", QString());
         const int index = id.toInt();
         // connection point in center should be default but odf doesn't support,
         // in new shape, first custom point is in center, it's okay to replace that point
         // with point from xml now, we'll add it back later
         if(id.isEmpty() || index < KoConnectionPoint::FirstCustomConnectionPoint ||
                 (index != KoConnectionPoint::FirstCustomConnectionPoint && d->connectors.contains(index))) {
             warnFlake << "glue-point with no or invalid id";
             continue;
         }
         QString xStr = child.attributeNS(KoXmlNS::svg, "x", QString()).simplified();
         QString yStr = child.attributeNS(KoXmlNS::svg, "y", QString()).simplified();
         if(xStr.isEmpty() || yStr.isEmpty()) {
             warnFlake << "glue-point with invald position";
             continue;
         }
 
         KoConnectionPoint connector;
 
         const QString align = child.attributeNS(KoXmlNS::draw, "align", QString());
         if (align.isEmpty()) {
 #ifndef NWORKAROUND_ODF_BUGS
             KoOdfWorkaround::fixGluePointPosition(xStr, context);
             KoOdfWorkaround::fixGluePointPosition(yStr, context);
 #endif
             if(!xStr.endsWith('%') || !yStr.endsWith('%')) {
                 warnFlake << "glue-point with invald position";
                 continue;
             }
             // x and y are relative to drawing object center
             connector.position.setX(xStr.remove('%').toDouble()/100.0);
             connector.position.setY(yStr.remove('%').toDouble()/100.0);
             // convert position to be relative to top-left corner
             connector.position += QPointF(0.5, 0.5);
             connector.position.rx() = qBound<qreal>(0.0, connector.position.x(), 1.0);
             connector.position.ry() = qBound<qreal>(0.0, connector.position.y(), 1.0);
         } else {
             // absolute distances to the edge specified by align
             connector.position.setX(KoUnit::parseValue(xStr));
             connector.position.setY(KoUnit::parseValue(yStr));
             if (align == "top-left") {
                 connector.alignment = KoConnectionPoint::AlignTopLeft;
             } else if (align == "top") {
                 connector.alignment = KoConnectionPoint::AlignTop;
             } else if (align == "top-right") {
                 connector.alignment = KoConnectionPoint::AlignTopRight;
             } else if (align == "left") {
                 connector.alignment = KoConnectionPoint::AlignLeft;
             } else if (align == "center") {
                 connector.alignment = KoConnectionPoint::AlignCenter;
             } else if (align == "right") {
                 connector.alignment = KoConnectionPoint::AlignRight;
             } else if (align == "bottom-left") {
                 connector.alignment = KoConnectionPoint::AlignBottomLeft;
             } else if (align == "bottom") {
                 connector.alignment = KoConnectionPoint::AlignBottom;
             } else if (align == "bottom-right") {
                 connector.alignment = KoConnectionPoint::AlignBottomRight;
             }
             debugFlake << "using alignment" << align;
         }
         const QString escape = child.attributeNS(KoXmlNS::draw, "escape-direction", QString());
         if (!escape.isEmpty()) {
             if (escape == "horizontal") {
                 connector.escapeDirection = KoConnectionPoint::HorizontalDirections;
             } else if (escape == "vertical") {
                 connector.escapeDirection = KoConnectionPoint::VerticalDirections;
             } else if (escape == "left") {
                 connector.escapeDirection = KoConnectionPoint::LeftDirection;
             } else if (escape == "right") {
                 connector.escapeDirection = KoConnectionPoint::RightDirection;
             } else if (escape == "up") {
                 connector.escapeDirection = KoConnectionPoint::UpDirection;
             } else if (escape == "down") {
                 connector.escapeDirection = KoConnectionPoint::DownDirection;
             }
             debugFlake << "using escape direction" << escape;
         }
         d->connectors[index] = connector;
         debugFlake << "loaded glue-point" << index << "at position" << connector.position;
         if (d->connectors[index].position == QPointF(0.5, 0.5)) {
             hasCenterGluePoint = true;
             debugFlake << "center glue-point found at id " << index;
         }
     }
     if (!hasCenterGluePoint) {
         d->connectors[d->connectors.count()] = KoConnectionPoint(QPointF(0.5, 0.5),
                                                                  KoConnectionPoint::AllDirections, KoConnectionPoint::AlignCenter);
     }
     debugFlake << "shape has now" << d->connectors.count() << "glue-points";
 }
 
 void KoShape::loadOdfClipContour(const KoXmlElement &element, KoShapeLoadingContext &context, const QSizeF &scaleFactor)
 {
     Q_D(KoShape);
 
     KoXmlElement child;
     forEachElement(child, element) {
         if (child.namespaceURI() != KoXmlNS::draw)
             continue;
         if (child.localName() != "contour-polygon")
             continue;
 
         debugFlake << "shape loads contour-polygon";
         KoPathShape *ps = new KoPathShape();
         ps->loadContourOdf(child, context, scaleFactor);
         ps->setTransformation(transformation());
 
         KoClipPath *clipPath = new KoClipPath({ps}, KoFlake::UserSpaceOnUse);
         d->clipPath.reset(clipPath);
     }
 }
 
 QTransform KoShape::parseOdfTransform(const QString &transform)
 {
     QTransform matrix;
 
     // Split string for handling 1 transform statement at a time
     QStringList subtransforms = transform.split(')', QString::SkipEmptyParts);
     QStringList::ConstIterator it = subtransforms.constBegin();
     QStringList::ConstIterator end = subtransforms.constEnd();
     for (; it != end; ++it) {
         QStringList subtransform = (*it).split('(', QString::SkipEmptyParts);
 
         subtransform[0] = subtransform[0].trimmed().toLower();
         subtransform[1] = subtransform[1].simplified();
         QRegExp reg("[,( ]");
         QStringList params = subtransform[1].split(reg, QString::SkipEmptyParts);
 
         if (subtransform[0].startsWith(';') || subtransform[0].startsWith(','))
             subtransform[0] = subtransform[0].right(subtransform[0].length() - 1);
 
         QString cmd = subtransform[0].toLower();
 
         if (cmd == "rotate") {
             QTransform rotMatrix;
             if (params.count() == 3) {
                 qreal x = KoUnit::parseValue(params[1]);
                 qreal y = KoUnit::parseValue(params[2]);
 
                 rotMatrix.translate(x, y);
                 // oo2 rotates by radians
                 rotMatrix.rotate(-params[0].toDouble()*180.0 / M_PI);
                 rotMatrix.translate(-x, -y);
             } else {
                 // oo2 rotates by radians
                 rotMatrix.rotate(-params[0].toDouble()*180.0 / M_PI);
             }
             matrix = matrix * rotMatrix;
         } else if (cmd == "translate") {
             QTransform moveMatrix;
             if (params.count() == 2) {
                 qreal x = KoUnit::parseValue(params[0]);
                 qreal y = KoUnit::parseValue(params[1]);
                 moveMatrix.translate(x, y);
             } else   // Spec : if only one param given, assume 2nd param to be 0
                 moveMatrix.translate(KoUnit::parseValue(params[0]) , 0);
             matrix = matrix * moveMatrix;
         } else if (cmd == "scale") {
             QTransform scaleMatrix;
             if (params.count() == 2)
                 scaleMatrix.scale(params[0].toDouble(), params[1].toDouble());
             else    // Spec : if only one param given, assume uniform scaling
                 scaleMatrix.scale(params[0].toDouble(), params[0].toDouble());
             matrix = matrix * scaleMatrix;
         } else if (cmd == "skewx") {
             QPointF p = absolutePosition(KoFlake::TopLeft);
             QTransform shearMatrix;
             shearMatrix.translate(p.x(), p.y());
             shearMatrix.shear(tan(-params[0].toDouble()), 0.0F);
             shearMatrix.translate(-p.x(), -p.y());
             matrix = matrix * shearMatrix;
         } else if (cmd == "skewy") {
             QPointF p = absolutePosition(KoFlake::TopLeft);
             QTransform shearMatrix;
             shearMatrix.translate(p.x(), p.y());
             shearMatrix.shear(0.0F, tan(-params[0].toDouble()));
             shearMatrix.translate(-p.x(), -p.y());
             matrix = matrix * shearMatrix;
         } else if (cmd == "matrix") {
             QTransform m;
             if (params.count() >= 6) {
                 m.setMatrix(params[0].toDouble(), params[1].toDouble(), 0,
                         params[2].toDouble(), params[3].toDouble(), 0,
                         KoUnit::parseValue(params[4]), KoUnit::parseValue(params[5]), 1);
             }
             matrix = matrix * m;
         }
     }
 
     return matrix;
 }
 
 void KoShape::saveOdfAttributes(KoShapeSavingContext &context, int attributes) const
 {
     Q_D(const KoShape);
     if (attributes & OdfStyle) {
         KoGenStyle style;
         // all items that should be written to 'draw:frame' and any other 'draw:' object that inherits this shape
         if (context.isSet(KoShapeSavingContext::PresentationShape)) {
             style = KoGenStyle(KoGenStyle::PresentationAutoStyle, "presentation");
             context.xmlWriter().addAttribute("presentation:style-name", saveStyle(style, context));
         } else {
             style = KoGenStyle(KoGenStyle::GraphicAutoStyle, "graphic");
             context.xmlWriter().addAttribute("draw:style-name", saveStyle(style, context));
         }
     }
 
     if (attributes & OdfId)  {
         if (context.isSet(KoShapeSavingContext::DrawId)) {
             KoElementReference ref = context.xmlid(this, "shape", KoElementReference::Counter);
             ref.saveOdf(&context.xmlWriter(), KoElementReference::DrawId);
         }
     }
 
     if (attributes & OdfName) {
         if (! name().isEmpty())
             context.xmlWriter().addAttribute("draw:name", name());
     }
 
     if (attributes & OdfLayer) {
         KoShape *parent = d->parent;
         while (parent) {
             if (dynamic_cast<KoShapeLayer*>(parent)) {
                 context.xmlWriter().addAttribute("draw:layer", parent->name());
                 break;
             }
             parent = parent->parent();
         }
     }
 
     if (attributes & OdfZIndex && context.isSet(KoShapeSavingContext::ZIndex)) {
         context.xmlWriter().addAttribute("draw:z-index", zIndex());
     }
 
     if (attributes & OdfSize) {
         QSizeF s(size());
         if (parent() && parent()->isClipped(this)) { // being clipped shrinks our visible size
             // clipping in ODF is done using a combination of visual size and content cliprect.
             // A picture of 10cm x 10cm displayed in a box of 2cm x 4cm will be scaled (out
             // of proportion in this case).  If we then add a fo:clip like;
             // fo:clip="rect(2cm, 3cm, 4cm, 5cm)" (top, right, bottom, left)
             // our original 10x10 is clipped to 2cm x 4cm  and *then* fitted in that box.
 
             // TODO do this properly by subtracting rects
             s = parent()->size();
         }
         context.xmlWriter().addAttribute("svg:width", s.width());
         context.xmlWriter().addAttribute("svg:height", s.height());
     }
 
     // The position is implicitly stored in the transformation matrix
     // if the transformation is saved as well
     if ((attributes & OdfPosition) && !(attributes & OdfTransformation)) {
         const QPointF p(position() * context.shapeOffset(this));
         context.xmlWriter().addAttribute("svg:x", p.x());
         context.xmlWriter().addAttribute("svg:y", p.y());
     }
 
     if (attributes & OdfTransformation) {
         QTransform matrix = absoluteTransformation(0) * context.shapeOffset(this);
         if (! matrix.isIdentity()) {
             if (qAbs(matrix.m11() - 1) < 1E-5           // 1
                     && qAbs(matrix.m12()) < 1E-5        // 0
                     && qAbs(matrix.m21()) < 1E-5        // 0
                     && qAbs(matrix.m22() - 1) < 1E-5) { // 1
                 context.xmlWriter().addAttribute("svg:x", matrix.dx());
                 context.xmlWriter().addAttribute("svg:y", matrix.dy());
             } else {
                 QString m = QString("matrix(%1 %2 %3 %4 %5pt %6pt)")
                         .arg(matrix.m11(), 0, 'f', 11)
                         .arg(matrix.m12(), 0, 'f', 11)
                         .arg(matrix.m21(), 0, 'f', 11)
                         .arg(matrix.m22(), 0, 'f', 11)
                         .arg(matrix.dx(), 0, 'f', 11)
                         .arg(matrix.dy(), 0, 'f', 11);
                 context.xmlWriter().addAttribute("draw:transform", m);
             }
         }
     }
 
     if (attributes & OdfViewbox) {
         const QSizeF s(size());
         QString viewBox = QString("0 0 %1 %2").arg(qRound(s.width())).arg(qRound(s.height()));
         context.xmlWriter().addAttribute("svg:viewBox", viewBox);
     }
 
     if (attributes & OdfAdditionalAttributes) {
         QMap<QString, QString>::const_iterator it(d->additionalAttributes.constBegin());
         for (; it != d->additionalAttributes.constEnd(); ++it) {
             context.xmlWriter().addAttribute(it.key().toUtf8(), it.value());
         }
     }
 }
 
 void KoShape::saveOdfCommonChildElements(KoShapeSavingContext &context) const
 {
     Q_D(const KoShape);
     // save glue points see ODF 9.2.19 Glue Points
     if(d->connectors.count()) {
         KoConnectionPoints::const_iterator cp = d->connectors.constBegin();
         KoConnectionPoints::const_iterator lastCp = d->connectors.constEnd();
         for(; cp != lastCp; ++cp) {
             // do not save default glue points
             if(cp.key() < 4)
                 continue;
             context.xmlWriter().startElement("draw:glue-point");
             context.xmlWriter().addAttribute("draw:id", QString("%1").arg(cp.key()));
             if (cp.value().alignment == KoConnectionPoint::AlignNone) {
                 // convert to percent from center
                 const qreal x = cp.value().position.x() * 100.0 - 50.0;
                 const qreal y = cp.value().position.y() * 100.0 - 50.0;
                 context.xmlWriter().addAttribute("svg:x", QString("%1%").arg(x));
                 context.xmlWriter().addAttribute("svg:y", QString("%1%").arg(y));
             } else {
                 context.xmlWriter().addAttribute("svg:x", cp.value().position.x());
                 context.xmlWriter().addAttribute("svg:y", cp.value().position.y());
             }
             QString escapeDirection;
             switch(cp.value().escapeDirection) {
             case KoConnectionPoint::HorizontalDirections:
                 escapeDirection = "horizontal";
                 break;
             case KoConnectionPoint::VerticalDirections:
                 escapeDirection = "vertical";
                 break;
             case KoConnectionPoint::LeftDirection:
                 escapeDirection = "left";
                 break;
             case KoConnectionPoint::RightDirection:
                 escapeDirection = "right";
                 break;
             case KoConnectionPoint::UpDirection:
                 escapeDirection = "up";
                 break;
             case KoConnectionPoint::DownDirection:
                 escapeDirection = "down";
                 break;
             default:
                 // fall through
                 break;
             }
             if(!escapeDirection.isEmpty()) {
                 context.xmlWriter().addAttribute("draw:escape-direction", escapeDirection);
             }
             QString alignment;
             switch(cp.value().alignment) {
             case KoConnectionPoint::AlignTopLeft:
                 alignment = "top-left";
                 break;
             case KoConnectionPoint::AlignTop:
                 alignment = "top";
                 break;
             case KoConnectionPoint::AlignTopRight:
                 alignment = "top-right";
                 break;
             case KoConnectionPoint::AlignLeft:
                 alignment = "left";
                 break;
             case KoConnectionPoint::AlignCenter:
                 alignment = "center";
                 break;
             case KoConnectionPoint::AlignRight:
                 alignment = "right";
                 break;
             case KoConnectionPoint::AlignBottomLeft:
                 alignment = "bottom-left";
                 break;
             case KoConnectionPoint::AlignBottom:
                 alignment = "bottom";
                 break;
             case KoConnectionPoint::AlignBottomRight:
                 alignment = "bottom-right";
                 break;
             default:
                 // fall through
                 break;
             }
             if(!alignment.isEmpty()) {
                 context.xmlWriter().addAttribute("draw:align", alignment);
             }
             context.xmlWriter().endElement();
         }
     }
 }
 
 void KoShape::saveOdfClipContour(KoShapeSavingContext &context, const QSizeF &originalSize) const
 {
     Q_D(const KoShape);
 
     debugFlake << "shape saves contour-polygon";
     if (d->clipPath && !d->clipPath->clipPathShapes().isEmpty()) {
         // This will loose data as odf can only save one set of contour whereas
         // svg loading and at least karbon editing can produce more than one
         // TODO, FIXME see if we can save more than one clipshape to odf
         d->clipPath->clipPathShapes().first()->saveContourOdf(context, originalSize);
     }
 }
 
 // end loading & saving methods
 
 // static
 void KoShape::applyConversion(QPainter &painter, const KoViewConverter &converter)
 {
     qreal zoomX, zoomY;
     converter.zoom(&zoomX, &zoomY);
     painter.scale(zoomX, zoomY);
 }
 
 KisHandlePainterHelper KoShape::createHandlePainterHelper(QPainter *painter, KoShape *shape, const KoViewConverter &converter, qreal handleRadius)
 {
     const QTransform originalPainterTransform = painter->transform();
 
     painter->setTransform(shape->absoluteTransformation(&converter) * painter->transform());
     KoShape::applyConversion(*painter, converter);
 
     // move c-tor
     return KisHandlePainterHelper(painter, originalPainterTransform, handleRadius);
 }
 
 QPointF KoShape::shapeToDocument(const QPointF &point) const
 {
     return absoluteTransformation(0).map(point);
 }
 
 QRectF KoShape::shapeToDocument(const QRectF &rect) const
 {
     return absoluteTransformation(0).mapRect(rect);
 }
 
 QPointF KoShape::documentToShape(const QPointF &point) const
 {
     return absoluteTransformation(0).inverted().map(point);
 }
 
 QRectF KoShape::documentToShape(const QRectF &rect) const
 {
     return absoluteTransformation(0).inverted().mapRect(rect);
 }
 
 bool KoShape::addDependee(KoShape *shape)
 {
     Q_D(KoShape);
     if (! shape)
         return false;
 
     // refuse to establish a circular dependency
     if (shape->hasDependee(this))
         return false;
 
     if (! d->dependees.contains(shape))
         d->dependees.append(shape);
 
     return true;
 }
 
 void KoShape::removeDependee(KoShape *shape)
 {
     Q_D(KoShape);
     int index = d->dependees.indexOf(shape);
     if (index >= 0)
         d->dependees.removeAt(index);
 }
 
 bool KoShape::hasDependee(KoShape *shape) const
 {
     Q_D(const KoShape);
     return d->dependees.contains(shape);
 }
 
 QList<KoShape*> KoShape::dependees() const
 {
     Q_D(const KoShape);
     return d->dependees;
 }
 
 void KoShape::shapeChanged(ChangeType type, KoShape *shape)
 {
     Q_UNUSED(type);
     Q_UNUSED(shape);
 }
 
 KoSnapData KoShape::snapData() const
 {
     return KoSnapData();
 }
 
 void KoShape::setAdditionalAttribute(const QString &name, const QString &value)
 {
     Q_D(KoShape);
     d->additionalAttributes.insert(name, value);
 }
 
 void KoShape::removeAdditionalAttribute(const QString &name)
 {
     Q_D(KoShape);
     d->additionalAttributes.remove(name);
 }
 
 bool KoShape::hasAdditionalAttribute(const QString &name) const
 {
     Q_D(const KoShape);
     return d->additionalAttributes.contains(name);
 }
 
 QString KoShape::additionalAttribute(const QString &name) const
 {
     Q_D(const KoShape);
     return d->additionalAttributes.value(name);
 }
 
 void KoShape::setAdditionalStyleAttribute(const char *name, const QString &value)
 {
     Q_D(KoShape);
     d->additionalStyleAttributes.insert(name, value);
 }
 
 void KoShape::removeAdditionalStyleAttribute(const char *name)
 {
     Q_D(KoShape);
     d->additionalStyleAttributes.remove(name);
 }
 
 KoFilterEffectStack *KoShape::filterEffectStack() const
 {
     Q_D(const KoShape);
     return d->filterEffectStack;
 }
 
 void KoShape::setFilterEffectStack(KoFilterEffectStack *filterEffectStack)
 {
     Q_D(KoShape);
     if (d->filterEffectStack)
         d->filterEffectStack->deref();
     d->filterEffectStack = filterEffectStack;
     if (d->filterEffectStack) {
         d->filterEffectStack->ref();
     }
     notifyChanged();
 }
 
 QSet<KoShape*> KoShape::toolDelegates() const
 {
     Q_D(const KoShape);
     return d->toolDelegates;
 }
 
 void KoShape::setToolDelegates(const QSet<KoShape*> &delegates)
 {
     Q_D(KoShape);
     d->toolDelegates = delegates;
 }
 
 QString KoShape::hyperLink () const
 {
     Q_D(const KoShape);
     return d->hyperLink;
 }
 
 void KoShape::setHyperLink(const QString &hyperLink)
 {
     Q_D(KoShape);
     d->hyperLink = hyperLink;
 }
 
 KoShapePrivate *KoShape::priv()
 {
     Q_D(KoShape);
     return d;
 }
 
 KoShape::ShapeChangeListener::~ShapeChangeListener()
 {
     Q_FOREACH(KoShape *shape, m_registeredShapes) {
         shape->removeShapeChangeListener(this);
     }
 }
 
 void KoShape::ShapeChangeListener::registerShape(KoShape *shape)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!m_registeredShapes.contains(shape));
     m_registeredShapes.append(shape);
 }
 
 void KoShape::ShapeChangeListener::unregisterShape(KoShape *shape)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_registeredShapes.contains(shape));
     m_registeredShapes.removeAll(shape);
 }
 
 void KoShape::ShapeChangeListener::notifyShapeChangedImpl(KoShape::ChangeType type, KoShape *shape)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_registeredShapes.contains(shape));
 
     notifyShapeChanged(type, shape);
 
     if (type == KoShape::Deleted) {
         unregisterShape(shape);
     }
 }
 
 void KoShape::addShapeChangeListener(KoShape::ShapeChangeListener *listener)
 {
     Q_D(KoShape);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->listeners.contains(listener));
     listener->registerShape(this);
     d->listeners.append(listener);
 }
 
 void KoShape::removeShapeChangeListener(KoShape::ShapeChangeListener *listener)
 {
     Q_D(KoShape);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->listeners.contains(listener));
     d->listeners.removeAll(listener);
     listener->unregisterShape(this);
 }
 
 QList<KoShape *> KoShape::linearizeSubtree(const QList<KoShape *> &shapes)
 {
     QList<KoShape *> result;
 
     Q_FOREACH (KoShape *shape, shapes) {
         result << shape;
 
         KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
         if (container) {
             result << linearizeSubtree(container->shapes());
         }
     }
 
     return result;
 }
diff --git a/libs/flake/resources/KoSvgSymbolCollectionResource.h b/libs/flake/resources/KoSvgSymbolCollectionResource.h
index 9fff3c05d7..91ab13cd75 100644
--- a/libs/flake/resources/KoSvgSymbolCollectionResource.h
+++ b/libs/flake/resources/KoSvgSymbolCollectionResource.h
@@ -1,106 +1,105 @@
 /*  This file is part of the KDE project
     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; 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 KOSVGSYMBOLCOLLECTIONRESOURCE
 #define KOSVGSYMBOLCOLLECTIONRESOURCE
 
 #include <QObject>
 #include <QColor>
 #include <QVector>
 #include <QScopedPointer>
 #include <QImage>
-#include <QImage>
 #include <QPainter>
 
 #include <resources/KoResource.h>
 
 #include <KoShape.h>
 #include <KoShapeGroup.h>
 #include <KoShapeManager.h>
 #include <KoViewConverter.h>
 #include <KoShapePaintingContext.h>
 
 #include "kritaflake_export.h"
 
 struct KRITAFLAKE_EXPORT KoSvgSymbol {
     KoSvgSymbol() {}
     KoSvgSymbol(const QString &_title)
         : title(_title) {}
 
     ~KoSvgSymbol()
     {
         delete shape;
     }
 
     QString id;
     QString title;
     KoShape *shape;
     QImage icon();
 
     bool operator==(const KoSvgSymbol& rhs) const {
         return title == rhs.title;
     }
 };
 
 /**
  * Loads an svg file that contains "symbol" objects and creates a collection of those objects.
  */
 class KRITAFLAKE_EXPORT KoSvgSymbolCollectionResource : public QObject, public KoResource
 {
     Q_OBJECT
 public:
 
     /**
      */
     explicit KoSvgSymbolCollectionResource(const QString &filename);
 
     /// Create an empty color set
     KoSvgSymbolCollectionResource();
 
     /// Explicit copy constructor (KoResource copy constructor is private)
     KoSvgSymbolCollectionResource(const KoSvgSymbolCollectionResource& rhs);
 
     ~KoSvgSymbolCollectionResource() override;
 
     bool load() override;
     bool loadFromDevice(QIODevice *dev) override;
     bool save() override;
     bool saveToDevice(QIODevice* dev) const override;
 
     QString defaultFileExtension() const override;
 
     QString title() const;
     QString description() const;
     QString creator() const;
     QString rights() const;
     QString language() const;
     QStringList subjects() const;
     QString license() const;
     QStringList permits() const;
 
     QVector<KoSvgSymbol *> symbols() const;
 
 
 private:
 
     struct Private;
     const QScopedPointer<Private> d;
 
 };
 #endif // KoSvgSymbolCollectionResource
 
diff --git a/libs/flake/tests/TestPointMergeCommand.cpp b/libs/flake/tests/TestPointMergeCommand.cpp
index 077e307b06..ee6c6477bb 100644
--- a/libs/flake/tests/TestPointMergeCommand.cpp
+++ b/libs/flake/tests/TestPointMergeCommand.cpp
@@ -1,578 +1,577 @@
 /* This file is part of the KDE project
  * Copyright (C) 2009 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "TestPointMergeCommand.h"
 #include "KoPathPointMergeCommand.h"
 #include "KoPathShape.h"
 #include "KoPathPoint.h"
 #include "KoPathPointData.h"
 #include <sdk/tests/kistest.h>
 #include <QTest>
 #include <FlakeDebug.h>
 
 void TestPointMergeCommand::closeSingleLinePath()
 {
     KoPathShape path1;
     path1.moveTo(QPointF(40, 0));
     path1.lineTo(QPointF(60, 0));
     path1.lineTo(QPointF(60, 30));
     path1.lineTo(QPointF(0, 30));
     path1.lineTo(QPointF(0, 0));
     path1.lineTo(QPointF(20, 0));
 
     KoPathPointIndex index1(0,0);
     KoPathPointIndex index2(0,5);
 
     KoPathPointData pd1(&path1, index1);
     KoPathPointData pd2(&path1, index2);
 
     KoPathPoint * p1 = path1.pointByIndex(index1);
     KoPathPoint * p2 = path1.pointByIndex(index2);
 
     QVERIFY(!path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 6);
     QCOMPARE(p1->point(), QPointF(40,0));
     QCOMPARE(p2->point(), QPointF(20,0));
 
     KoPathPointMergeCommand cmd1(pd1,pd2);
     cmd1.redo();
 
     QVERIFY(path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 5);
     QCOMPARE(p2->point(), QPointF(20,0));
 
     cmd1.undo();
 
     QVERIFY(!path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 6);
     QCOMPARE(p1->point(), QPointF(40,0));
     QCOMPARE(p2->point(), QPointF(20,0));
 
     KoPathPointMergeCommand cmd2(pd2,pd1);
     cmd2.redo();
 
     QVERIFY(path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 5);
     QCOMPARE(p2->point(), QPointF(20,0));
 
     cmd2.undo();
 
     QVERIFY(!path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 6);
     QCOMPARE(p1->point(), QPointF(40,0));
     QCOMPARE(p2->point(), QPointF(20,0));
 }
 
 void TestPointMergeCommand::closeSingleCurvePath()
 {
     KoPathShape path1;
     path1.moveTo(QPointF(40, 0));
     path1.curveTo(QPointF(60, 0), QPointF(60,0), QPointF(60,60));
     path1.lineTo(QPointF(0, 60));
     path1.curveTo(QPointF(0, 0), QPointF(0,0), QPointF(20,0));
 
     KoPathPointIndex index1(0,0);
     KoPathPointIndex index2(0,3);
 
     KoPathPointData pd1(&path1, index1);
     KoPathPointData pd2(&path1, index2);
 
     KoPathPoint * p1 = path1.pointByIndex(index1);
     KoPathPoint * p2 = path1.pointByIndex(index2);
 
     QVERIFY(!path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 4);
     QCOMPARE(p1->point(), QPointF(40,0));
     QVERIFY(!p1->activeControlPoint1());
     QCOMPARE(p2->point(), QPointF(20,0));
     QVERIFY(!p2->activeControlPoint2());
 
     KoPathPointMergeCommand cmd1(pd1,pd2);
     cmd1.redo();
 
     QVERIFY(path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 3);
     QCOMPARE(p2->point(), QPointF(20,0));
     QVERIFY(p2->activeControlPoint1());
     QVERIFY(!p2->activeControlPoint2());
 
     cmd1.undo();
 
     QVERIFY(!path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 4);
     QCOMPARE(p1->point(), QPointF(40,0));
     QVERIFY(!p1->activeControlPoint1());
     QCOMPARE(p2->point(), QPointF(20,0));
     QVERIFY(!p2->activeControlPoint2());
 
     KoPathPointMergeCommand cmd2(pd2,pd1);
     cmd2.redo();
 
     QVERIFY(path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 3);
     QCOMPARE(p2->point(), QPointF(20,0));
     QVERIFY(p2->activeControlPoint1());
     QVERIFY(!p2->activeControlPoint2());
 
     cmd2.undo();
 
     QVERIFY(!path1.isClosedSubpath(0));
     QCOMPARE(path1.subpathPointCount(0), 4);
     QCOMPARE(p1->point(), QPointF(40,0));
     QVERIFY(!p1->activeControlPoint1());
     QCOMPARE(p2->point(), QPointF(20,0));
     QVERIFY(!p2->activeControlPoint2());
 }
 
 void TestPointMergeCommand::connectLineSubpaths()
 {
     KoPathShape path1;
     path1.moveTo(QPointF(0,0));
     path1.lineTo(QPointF(10,0));
     path1.moveTo(QPointF(20,0));
     path1.lineTo(QPointF(30,0));
 
     KoPathPointIndex index1(0,1);
     KoPathPointIndex index2(1,0);
 
     KoPathPointData pd1(&path1, index1);
     KoPathPointData pd2(&path1, index2);
 
     QCOMPARE(path1.subpathCount(), 2);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(10,0));
     QCOMPARE(path1.pointByIndex(index2)->point(), QPointF(20,0));
 
     KoPathPointMergeCommand cmd1(pd1, pd2);
     cmd1.redo();
 
     QCOMPARE(path1.subpathCount(), 1);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(15,0));
 
     cmd1.undo();
 
     QCOMPARE(path1.subpathCount(), 2);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(10,0));
     QCOMPARE(path1.pointByIndex(index2)->point(), QPointF(20,0));
 
     KoPathPointMergeCommand cmd2(pd2, pd1);
     cmd2.redo();
 
     QCOMPARE(path1.subpathCount(), 1);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(15,0));
 
     cmd2.undo();
 
     QCOMPARE(path1.subpathCount(), 2);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(10,0));
     QCOMPARE(path1.pointByIndex(index2)->point(), QPointF(20,0));
 }
 
 void TestPointMergeCommand::connectCurveSubpaths()
 {
     KoPathShape path1;
     path1.moveTo(QPointF(0,0));
     path1.curveTo(QPointF(20,0),QPointF(0,20),QPointF(20,20));
     path1.moveTo(QPointF(50,0));
     path1.curveTo(QPointF(30,0), QPointF(50,20), QPointF(30,20));
 
     KoPathPointIndex index1(0,1);
     KoPathPointIndex index2(1,1);
 
     KoPathPointData pd1(&path1, index1);
     KoPathPointData pd2(&path1, index2);
 
     QCOMPARE(path1.subpathCount(), 2);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(20,20));
     QCOMPARE(path1.pointByIndex(index1)->controlPoint1(), QPointF(0,20));
     QCOMPARE(path1.pointByIndex(index2)->point(), QPointF(30,20));
     QCOMPARE(path1.pointByIndex(index2)->controlPoint1(), QPointF(50,20));
     QVERIFY(path1.pointByIndex(index1)->activeControlPoint1());
     QVERIFY(!path1.pointByIndex(index1)->activeControlPoint2());
 
     KoPathPointMergeCommand cmd1(pd1, pd2);
     cmd1.redo();
 
     QCOMPARE(path1.subpathCount(), 1);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(25,20));
     QCOMPARE(path1.pointByIndex(index1)->controlPoint1(), QPointF(5,20));
     QCOMPARE(path1.pointByIndex(index1)->controlPoint2(), QPointF(45,20));
     QVERIFY(path1.pointByIndex(index1)->activeControlPoint1());
     QVERIFY(path1.pointByIndex(index1)->activeControlPoint2());
 
     cmd1.undo();
 
     QCOMPARE(path1.subpathCount(), 2);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(20,20));
     QCOMPARE(path1.pointByIndex(index1)->controlPoint1(), QPointF(0,20));
     QCOMPARE(path1.pointByIndex(index2)->point(), QPointF(30,20));
     QCOMPARE(path1.pointByIndex(index2)->controlPoint1(), QPointF(50,20));
     QVERIFY(path1.pointByIndex(index1)->activeControlPoint1());
     QVERIFY(!path1.pointByIndex(index1)->activeControlPoint2());
 
     KoPathPointMergeCommand cmd2(pd2, pd1);
     cmd2.redo();
 
     QCOMPARE(path1.subpathCount(), 1);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(25,20));
     QCOMPARE(path1.pointByIndex(index1)->controlPoint1(), QPointF(5,20));
     QCOMPARE(path1.pointByIndex(index1)->controlPoint2(), QPointF(45,20));
     QVERIFY(path1.pointByIndex(index1)->activeControlPoint1());
     QVERIFY(path1.pointByIndex(index1)->activeControlPoint2());
 
     cmd2.undo();
 
     QCOMPARE(path1.subpathCount(), 2);
     QCOMPARE(path1.pointByIndex(index1)->point(), QPointF(20,20));
     QCOMPARE(path1.pointByIndex(index1)->controlPoint1(), QPointF(0,20));
     QCOMPARE(path1.pointByIndex(index2)->point(), QPointF(30,20));
     QCOMPARE(path1.pointByIndex(index2)->controlPoint1(), QPointF(50,20));
     QVERIFY(path1.pointByIndex(index1)->activeControlPoint1());
     QVERIFY(!path1.pointByIndex(index1)->activeControlPoint2());
 }
 
 #include <MockShapes.h>
 #include <commands/KoPathCombineCommand.h>
 #include "kis_debug.h"
-#include <KoPathPointData.h>
 
 void TestPointMergeCommand::testCombineShapes()
 {
     MockShapeController mockController;
     MockCanvas canvas(&mockController);
 
     QList<KoPathShape*> shapesToCombine;
 
     for (int i = 0; i < 3; i++) {
         const QPointF step(15,15);
         const QRectF rect = QRectF(5,5,10,10).translated(step * i);
 
         QPainterPath p;
         p.addRect(rect);
 
         KoPathShape *shape = KoPathShape::createShapeFromPainterPath(p);
         QCOMPARE(shape->absoluteOutlineRect(), rect);
 
         shapesToCombine << shape;
         mockController.addShape(shape);
     }
 
     KoPathCombineCommand cmd(&mockController, shapesToCombine);
     cmd.redo();
 
     QCOMPARE(canvas.shapeManager()->shapes().size(), 1);
 
     KoPathShape *combinedShape = dynamic_cast<KoPathShape*>(canvas.shapeManager()->shapes().first());
     QCOMPARE(combinedShape, cmd.combinedPath());
     QCOMPARE(combinedShape->subpathCount(), 3);
     QCOMPARE(combinedShape->absoluteOutlineRect(), QRectF(5,5,40,40));
 
     QList<KoPathPointData> tstPoints;
     QList<KoPathPointData> expPoints;
 
     tstPoints << KoPathPointData(shapesToCombine[0], KoPathPointIndex(0,1));
     expPoints << KoPathPointData(combinedShape, KoPathPointIndex(0,1));
 
     tstPoints << KoPathPointData(shapesToCombine[1], KoPathPointIndex(0,2));
     expPoints << KoPathPointData(combinedShape, KoPathPointIndex(1,2));
 
     tstPoints << KoPathPointData(shapesToCombine[2], KoPathPointIndex(0,3));
     expPoints << KoPathPointData(combinedShape, KoPathPointIndex(2,3));
 
     for (int i = 0; i < tstPoints.size(); i++) {
         KoPathPointData convertedPoint = cmd.originalToCombined(tstPoints[i]);
         QCOMPARE(convertedPoint, expPoints[i]);
     }
 
     Q_FOREACH (KoShape *shape, canvas.shapeManager()->shapes()) {
         mockController.removeShape(shape);
         shape->setParent(0);
         delete shape;
     }
 
     // 'shapesToCombine' will be deleted by KoPathCombineCommand
 }
 
 #include <commands/KoMultiPathPointMergeCommand.h>
 #include <commands/KoMultiPathPointJoinCommand.h>
 #include <KoSelection.h>
 #include "kis_algebra_2d.h"
 
 inline QPointF fetchPoint(KoPathShape *shape, int subpath, int pointIndex) {
     return shape->absoluteTransformation(0).map(
         shape->pointByIndex(KoPathPointIndex(subpath, pointIndex))->point());
 }
 
 void dumpShape(KoPathShape *shape, const QString &fileName)
 {
     QImage tmp(50,50, QImage::Format_ARGB32);
     tmp.fill(0);
     QPainter p(&tmp);
     p.drawPath(shape->absoluteTransformation(0).map(shape->outline()));
     tmp.save(fileName);
 }
 
 template <class MergeCommand = KoMultiPathPointMergeCommand>
 void testMultipathMergeShapesImpl(const int srcPointIndex1,
                                   const int srcPointIndex2,
                                   const QList<QPointF> &expectedResultPoints,
                                   bool singleShape = false)
 {
     MockShapeController mockController;
     MockCanvas canvas(&mockController);
 
     QList<KoPathShape*> shapes;
 
     for (int i = 0; i < 3; i++) {
         const QPointF step(15,15);
         const QRectF rect = QRectF(5,5,10,10).translated(step * i);
 
         QPainterPath p;
         p.moveTo(rect.topLeft());
         p.lineTo(rect.bottomRight());
         p.lineTo(rect.topRight());
 
         KoPathShape *shape = KoPathShape::createShapeFromPainterPath(p);
         QCOMPARE(shape->absoluteOutlineRect(), rect);
 
         shapes << shape;
         mockController.addShape(shape);
     }
 
 
     {
         KoPathPointData pd1(shapes[0], KoPathPointIndex(0,srcPointIndex1));
         KoPathPointData pd2(shapes[singleShape ? 0 : 1], KoPathPointIndex(0,srcPointIndex2));
 
         MergeCommand cmd(pd1, pd2, &mockController, canvas.shapeManager()->selection());
 
         cmd.redo();
 
         const int expectedShapesCount = singleShape ? 3 : 2;
         QCOMPARE(canvas.shapeManager()->shapes().size(), expectedShapesCount);
 
         KoPathShape *combinedShape = 0;
 
         if (!singleShape) {
             combinedShape = dynamic_cast<KoPathShape*>(canvas.shapeManager()->shapes()[1]);
             QCOMPARE(combinedShape, cmd.testingCombinedPath());
         } else {
             combinedShape = dynamic_cast<KoPathShape*>(canvas.shapeManager()->shapes()[0]);
             QCOMPARE(combinedShape, shapes[0]);
         }
 
         QCOMPARE(combinedShape->subpathCount(), 1);
 
         QRectF expectedOutlineRect;
         KisAlgebra2D::accumulateBounds(expectedResultPoints, &expectedOutlineRect);
         QVERIFY(KisAlgebra2D::fuzzyCompareRects(combinedShape->absoluteOutlineRect(), expectedOutlineRect, 0.01));
 
         if (singleShape) {
             QCOMPARE(combinedShape->isClosedSubpath(0), true);
         }
 
         QCOMPARE(combinedShape->subpathPointCount(0), expectedResultPoints.size());
         for (int i = 0; i < expectedResultPoints.size(); i++) {
             if (fetchPoint(combinedShape, 0, i) != expectedResultPoints[i]) {
                 qDebug() << ppVar(i);
                 qDebug() << ppVar(fetchPoint(combinedShape, 0, i));
                 qDebug() << ppVar(expectedResultPoints[i]);
 
                 QFAIL("Resulting shape points are different!");
             }
         }
 
         QList<KoShape*> shapes = canvas.shapeManager()->selection()->selectedEditableShapes();
         QCOMPARE(shapes.size(), 1);
         QCOMPARE(shapes.first(), combinedShape);
 
         //dumpShape(combinedShape, "tmp_0_seq.png");
         cmd.undo();
 
         QCOMPARE(canvas.shapeManager()->shapes().size(), 3);
     }
 
     Q_FOREACH (KoShape *shape, canvas.shapeManager()->shapes()) {
         mockController.removeShape(shape);
         shape->setParent(0);
         delete shape;
     }
 
     // combined shapes will be deleted by the corresponding commands
 }
 
 
 void TestPointMergeCommand::testMultipathMergeShapesBothSequential()
 {
     // both sequential
     testMultipathMergeShapesImpl(2, 0,
                                  {
                                      QPointF(5,5),
                                      QPointF(15,15),
                                      QPointF(17.5,12.5), // merged by melding the points!
                                      QPointF(30,30),
                                      QPointF(30,20)
                                  });
 }
 
 void TestPointMergeCommand::testMultipathMergeShapesFirstReversed()
 {
     // first reversed
     testMultipathMergeShapesImpl(0, 0,
                                  {
                                      QPointF(15,5),
                                      QPointF(15,15),
                                      QPointF(12.5,12.5), // merged by melding the points!
                                      QPointF(30,30),
                                      QPointF(30,20)
                                  });
 }
 
 void TestPointMergeCommand::testMultipathMergeShapesSecondReversed()
 {
     // second reversed
     testMultipathMergeShapesImpl(2, 2,
                                  {
                                      QPointF(5,5),
                                      QPointF(15,15),
                                      QPointF(22.5,12.5), // merged by melding the points!
                                      QPointF(30,30),
                                      QPointF(20,20)
                                  });
 }
 
 void TestPointMergeCommand::testMultipathMergeShapesBothReversed()
 {
     // both reversed
     testMultipathMergeShapesImpl(0, 2,
                                  {
                                      QPointF(15,5),
                                      QPointF(15,15),
                                      QPointF(17.5,12.5), // merged by melding the points!
                                      QPointF(30,30),
                                      QPointF(20,20)
                                  });
 }
 
 void TestPointMergeCommand::testMultipathMergeShapesSingleShapeEndToStart()
 {
     // close end->start
     testMultipathMergeShapesImpl(2, 0,
                                  {
                                      QPointF(10,5),
                                      QPointF(15,15)
                                  }, true);
 }
 
 void TestPointMergeCommand::testMultipathMergeShapesSingleShapeStartToEnd()
 {
     // close start->end
     testMultipathMergeShapesImpl(0, 2,
                                  {
                                      QPointF(10,5),
                                      QPointF(15,15)
                                  }, true);
 }
 
 void TestPointMergeCommand::testMultipathJoinShapesBothSequential()
 {
     // both sequential
     testMultipathMergeShapesImpl<KoMultiPathPointJoinCommand>
             (2, 0,
              {
                  QPointF(5,5),
                  QPointF(15,15),
                  QPointF(15,5),
                  QPointF(20,20),
                  QPointF(30,30),
                  QPointF(30,20)
              });
 }
 
 void TestPointMergeCommand::testMultipathJoinShapesFirstReversed()
 {
     // first reversed
     testMultipathMergeShapesImpl<KoMultiPathPointJoinCommand>
             (0, 0,
              {
                  QPointF(15,5),
                  QPointF(15,15),
                  QPointF(5,5),
                  QPointF(20,20),
                  QPointF(30,30),
                  QPointF(30,20)
              });
 }
 
 void TestPointMergeCommand::testMultipathJoinShapesSecondReversed()
 {
     // second reversed
     testMultipathMergeShapesImpl<KoMultiPathPointJoinCommand>
             (2, 2,
              {
                  QPointF(5,5),
                  QPointF(15,15),
                  QPointF(15,5),
                  QPointF(30,20),
                  QPointF(30,30),
                  QPointF(20,20)
              });
 }
 
 void TestPointMergeCommand::testMultipathJoinShapesBothReversed()
 {
     // both reversed
     testMultipathMergeShapesImpl<KoMultiPathPointJoinCommand>
             (0, 2,
              {
                  QPointF(15,5),
                  QPointF(15,15),
                  QPointF(5,5),
                  QPointF(30,20),
                  QPointF(30,30),
                  QPointF(20,20)
              });
 }
 
 void TestPointMergeCommand::testMultipathJoinShapesSingleShapeEndToStart()
 {
     // close end->start
     testMultipathMergeShapesImpl<KoMultiPathPointJoinCommand>
             (2, 0,
              {
                  QPointF(5,5),
                  QPointF(15,15),
                  QPointF(15,5)
              }, true);
 }
 
 void TestPointMergeCommand::testMultipathJoinShapesSingleShapeStartToEnd()
 {
     // close start->end
     testMultipathMergeShapesImpl<KoMultiPathPointJoinCommand>
             (0, 2,
              {
                  QPointF(5,5),
                  QPointF(15,15),
                  QPointF(15,5)
              }, true);
 }
 
 
 
 KISTEST_MAIN(TestPointMergeCommand)
diff --git a/libs/flake/tests/TestSvgText.cpp b/libs/flake/tests/TestSvgText.cpp
index 559549e901..c1d69f320d 100644
--- a/libs/flake/tests/TestSvgText.cpp
+++ b/libs/flake/tests/TestSvgText.cpp
@@ -1,1229 +1,1228 @@
 /*
  *  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 "TestSvgText.h"
 
 #include <QTest>
 
 #include "SvgParserTestingUtils.h"
 #include <text/KoSvgText.h>
 #include <text/KoSvgTextProperties.h>
 #include "KoSvgTextShapeMarkupConverter.h"
 
 #include <SvgLoadingContext.h>
 #include <SvgGraphicContext.h>
 #include <QFont>
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              int newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).toInt() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
 }
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              KoSvgText::AutoValue newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).value<KoSvgText::AutoValue>() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
     QCOMPARE(props.property(id), QVariant::fromValue(newValue));
 }
 
 void addProp(SvgLoadingContext &context,
              KoSvgTextProperties &props,
              const QString &attribute,
              const QString &value,
              KoSvgTextProperties::PropertyId id,
              qreal newValue)
 {
     props.parseSvgTextAttribute(context, attribute, value);
     if (props.property(id).toReal() != newValue) {
         qDebug() << "Failed to load the property:";
         qDebug() << ppVar(attribute) << ppVar(value);
         qDebug() << ppVar(newValue);
         qDebug() << ppVar(props.property(id));
         QFAIL("Fail :(");
     }
 }
 
 
 void TestSvgText::testTextProperties()
 {
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     KoSvgTextProperties props;
 
     addProp(context, props, "writing-mode", "tb-rl", KoSvgTextProperties::WritingModeId, KoSvgText::TopToBottom);
     addProp(context, props, "writing-mode", "rl", KoSvgTextProperties::WritingModeId, KoSvgText::RightToLeft);
 
     addProp(context, props, "glyph-orientation-vertical", "auto", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue());
     addProp(context, props, "glyph-orientation-vertical", "0", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(0));
     addProp(context, props, "glyph-orientation-vertical", "90", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "95", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "175", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI));
     addProp(context, props, "glyph-orientation-vertical", "280", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(3 * M_PI_2));
     addProp(context, props, "glyph-orientation-vertical", "350", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(0));
     addProp(context, props, "glyph-orientation-vertical", "105", KoSvgTextProperties::GlyphOrientationVerticalId, KoSvgText::AutoValue(M_PI_2));
 
     addProp(context, props, "glyph-orientation-horizontal", "0", KoSvgTextProperties::GlyphOrientationHorizontalId, 0.0);
     addProp(context, props, "glyph-orientation-horizontal", "90", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI_2);
     addProp(context, props, "glyph-orientation-horizontal", "95", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI_2);
     addProp(context, props, "glyph-orientation-horizontal", "175", KoSvgTextProperties::GlyphOrientationHorizontalId, M_PI);
     addProp(context, props, "glyph-orientation-horizontal", "280", KoSvgTextProperties::GlyphOrientationHorizontalId, 3 * M_PI_2);
 
     addProp(context, props, "direction", "rtl", KoSvgTextProperties::WritingModeId, KoSvgText::DirectionRightToLeft);
     addProp(context, props, "unicode-bidi", "embed", KoSvgTextProperties::UnicodeBidiId, KoSvgText::BidiEmbed);
     addProp(context, props, "unicode-bidi", "bidi-override", KoSvgTextProperties::UnicodeBidiId, KoSvgText::BidiOverride);
 
 
     addProp(context, props, "text-anchor", "middle", KoSvgTextProperties::TextAnchorId, KoSvgText::AnchorMiddle);
     addProp(context, props, "dominant-baseline", "ideographic", KoSvgTextProperties::DominantBaselineId, KoSvgText::DominantBaselineIdeographic);
     addProp(context, props, "alignment-baseline", "alphabetic", KoSvgTextProperties::AlignmentBaselineId, KoSvgText::AlignmentBaselineAlphabetic);
     addProp(context, props, "baseline-shift", "sub", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftSub);
     addProp(context, props, "baseline-shift", "super", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftSuper);
     addProp(context, props, "baseline-shift", "baseline", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftNone);
 
     addProp(context, props, "baseline-shift", "10%", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftPercentage);
     QCOMPARE(props.property(KoSvgTextProperties::BaselineShiftValueId).toDouble(), 0.1);
 
     context.currentGC()->font.setPointSizeF(180);
 
     addProp(context, props, "baseline-shift", "36", KoSvgTextProperties::BaselineShiftModeId, KoSvgText::ShiftPercentage);
     QCOMPARE(props.property(KoSvgTextProperties::BaselineShiftValueId).toDouble(), 0.2);
 
     addProp(context, props, "kerning", "auto", KoSvgTextProperties::KerningId, KoSvgText::AutoValue());
     addProp(context, props, "kerning", "20", KoSvgTextProperties::KerningId, KoSvgText::AutoValue(20.0));
 
     addProp(context, props, "letter-spacing", "normal", KoSvgTextProperties::LetterSpacingId, KoSvgText::AutoValue());
     addProp(context, props, "letter-spacing", "20", KoSvgTextProperties::LetterSpacingId, KoSvgText::AutoValue(20.0));
 
     addProp(context, props, "word-spacing", "normal", KoSvgTextProperties::WordSpacingId, KoSvgText::AutoValue());
     addProp(context, props, "word-spacing", "20", KoSvgTextProperties::WordSpacingId, KoSvgText::AutoValue(20.0));
 }
 
 void TestSvgText::testDefaultTextProperties()
 {
     KoSvgTextProperties props;
 
     QVERIFY(props.isEmpty());
     QVERIFY(!props.hasProperty(KoSvgTextProperties::UnicodeBidiId));
 
     QVERIFY(KoSvgTextProperties::defaultProperties().hasProperty(KoSvgTextProperties::UnicodeBidiId));
     QCOMPARE(KoSvgTextProperties::defaultProperties().property(KoSvgTextProperties::UnicodeBidiId).toInt(), int(KoSvgText::BidiNormal));
 
     props = KoSvgTextProperties::defaultProperties();
 
     QVERIFY(props.hasProperty(KoSvgTextProperties::UnicodeBidiId));
     QCOMPARE(props.property(KoSvgTextProperties::UnicodeBidiId).toInt(), int(KoSvgText::BidiNormal));
 }
 
 void TestSvgText::testTextPropertiesDifference()
 {
     using namespace KoSvgText;
 
     KoSvgTextProperties props;
 
     props.setProperty(KoSvgTextProperties::WritingModeId, RightToLeft);
     props.setProperty(KoSvgTextProperties::DirectionId, DirectionRightToLeft);
     props.setProperty(KoSvgTextProperties::UnicodeBidiId, BidiEmbed);
     props.setProperty(KoSvgTextProperties::TextAnchorId, AnchorEnd);
     props.setProperty(KoSvgTextProperties::DominantBaselineId, DominantBaselineNoChange);
     props.setProperty(KoSvgTextProperties::AlignmentBaselineId, AlignmentBaselineIdeographic);
     props.setProperty(KoSvgTextProperties::BaselineShiftModeId, ShiftPercentage);
     props.setProperty(KoSvgTextProperties::BaselineShiftValueId, 0.5);
     props.setProperty(KoSvgTextProperties::KerningId, fromAutoValue(AutoValue(10)));
     props.setProperty(KoSvgTextProperties::GlyphOrientationVerticalId, fromAutoValue(AutoValue(90)));
     props.setProperty(KoSvgTextProperties::GlyphOrientationHorizontalId, fromAutoValue(AutoValue(180)));
     props.setProperty(KoSvgTextProperties::LetterSpacingId, fromAutoValue(AutoValue(20)));
     props.setProperty(KoSvgTextProperties::WordSpacingId, fromAutoValue(AutoValue(30)));
 
     KoSvgTextProperties newProps = props;
 
     newProps.setProperty(KoSvgTextProperties::KerningId, fromAutoValue(AutoValue(11)));
     newProps.setProperty(KoSvgTextProperties::LetterSpacingId, fromAutoValue(AutoValue(21)));
 
     KoSvgTextProperties diff = newProps.ownProperties(props);
 
     QVERIFY(diff.hasProperty(KoSvgTextProperties::KerningId));
     QVERIFY(diff.hasProperty(KoSvgTextProperties::LetterSpacingId));
 
     QVERIFY(!diff.hasProperty(KoSvgTextProperties::WritingModeId));
     QVERIFY(!diff.hasProperty(KoSvgTextProperties::DirectionId));
 
 
 }
 
 void TestSvgText::testParseFontStyles()
 {
     const QString data =
             "<text x=\"7\" y=\"7\""
             "    font-family=\"Verdana , \'Times New Roman\', serif\" font-size=\"15\" font-style=\"oblique\" fill=\"blue\""
             "    font-stretch=\"extra-condensed\""
             "    font-size-adjust=\"0.56\"" //// not implemented! should issue a warning!
             "    font=\"bold italic large Palatino, serif\"" //// not implemented! should issue a warning!
             "    font-variant=\"small-caps\" font-weight=\"600\" >"
             "    Hello, out there"
             "</text>";
 
     KoXmlDocument doc;
     QVERIFY(doc.setContent(data.toLatin1()));
     KoXmlElement root = doc.documentElement();
 
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     SvgStyles styles = context.styleParser().collectStyles(root);
     context.styleParser().parseFont(styles);
 
     //QCOMPARE(styles.size(), 3);
 
     // TODO: multiple fonts!
     QCOMPARE(context.currentGC()->font.family(), QString("Verdana"));
 
     {
         QStringList expectedFonts = {"Verdana", "Times New Roman", "serif"};
         QCOMPARE(context.currentGC()->fontFamiliesList, expectedFonts);
     }
 
     QCOMPARE(context.currentGC()->font.pointSizeF(), 15.0);
     QCOMPARE(context.currentGC()->font.style(), QFont::StyleOblique);
     QCOMPARE(context.currentGC()->font.capitalization(), QFont::SmallCaps);
     QCOMPARE(context.currentGC()->font.weight(), 66);
 
     {
         SvgStyles fontModifier;
         fontModifier["font-weight"] = "bolder";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.weight(), 75);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["font-weight"] = "lighter";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.weight(), 66);
     }
 
     QCOMPARE(context.currentGC()->font.stretch(), int(QFont::ExtraCondensed));
 
     {
         SvgStyles fontModifier;
         fontModifier["font-stretch"] = "narrower";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.stretch(), int(QFont::UltraCondensed));
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["font-stretch"] = "wider";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.stretch(), int(QFont::ExtraCondensed));
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "underline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.underline(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "overline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.overline(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = "line-through";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.strikeOut(), true);
     }
 
     {
         SvgStyles fontModifier;
         fontModifier["text-decoration"] = " line-through overline";
         context.styleParser().parseFont(fontModifier);
         QCOMPARE(context.currentGC()->font.underline(), false);
         QCOMPARE(context.currentGC()->font.strikeOut(), true);
         QCOMPARE(context.currentGC()->font.overline(), true);
     }
 
 }
 
 void TestSvgText::testParseTextStyles()
 {
     const QString data =
             "<text x=\"7\" y=\"7\""
             "    font-family=\"Verdana\" font-size=\"15\" font-style=\"oblique\" fill=\"blue\""
             "    writing-mode=\"tb-rl\" "
             "    glyph-orientation-vertical=\"90\" >"
             "    Hello, out there"
             "</text>";
 
     KoXmlDocument doc;
     QVERIFY(doc.setContent(data.toLatin1()));
     KoXmlElement root = doc.documentElement();
 
     KoDocumentResourceManager resourceManager;
     SvgLoadingContext context(&resourceManager);
     context.pushGraphicsContext();
 
     SvgStyles styles = context.styleParser().collectStyles(root);
     context.styleParser().parseFont(styles);
 
     QCOMPARE(context.currentGC()->font.family(), QString("Verdana"));
 
     KoSvgTextProperties &props = context.currentGC()->textProperties;
 
     QCOMPARE(props.property(KoSvgTextProperties::WritingModeId).toInt(), int(KoSvgText::TopToBottom));
     QCOMPARE(props.property(KoSvgTextProperties::GlyphOrientationVerticalId).value<KoSvgText::AutoValue>(), KoSvgText::AutoValue(M_PI_2));
 
 }
 
 #include <text/KoSvgTextShape.h>
 #include <text/KoSvgTextChunkShape.h>
 #include <text/KoSvgTextChunkShapeLayoutInterface.h>
 
 void TestSvgText::testSimpleText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        Hello, out there!"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     QFont testFont("DejaVu Sans");
     if (!QFontInfo(testFont).exactMatch()) {
         QEXPECT_FAIL(0, "DejaVu Sans is *not* found! Text rendering might be broken!", Continue);
     }
 
     SvgRenderTester t (data);
     t.test_standard("text_simple", QSize(175, 40), 72.0);
 
     KoShape *shape = t.findShape("testRect");
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     QVERIFY(chunkShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(shape));
 
     QCOMPARE(chunkShape->shapeCount(), 0);
     QCOMPARE(chunkShape->layoutInterface()->isTextNode(), true);
 
     QCOMPARE(chunkShape->layoutInterface()->numChars(), 17);
     QCOMPARE(chunkShape->layoutInterface()->nodeText(), QString("Hello, out there!"));
 
     QVector<KoSvgText::CharTransformation> transform = chunkShape->layoutInterface()->localCharTransformations();
     QCOMPARE(transform.size(), 1);
     QVERIFY(bool(transform[0].xPos));
     QVERIFY(bool(transform[0].yPos));
     QVERIFY(!transform[0].dxPos);
     QVERIFY(!transform[0].dyPos);
     QVERIFY(!transform[0].rotate);
 
     QCOMPARE(*transform[0].xPos, 7.0);
     QCOMPARE(*transform[0].yPos, 27.0);
 
     QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
             chunkShape->layoutInterface()->collectSubChunks();
 
     QCOMPARE(subChunks.size(), 1);
     QCOMPARE(subChunks[0].text.size(), 17);
     //qDebug() << ppVar(subChunks[0].text);
     //qDebug() << ppVar(subChunks[0].transformation);
     //qDebug() << ppVar(subChunks[0].format);
 
 }
 
 inline KoSvgTextChunkShape* toChunkShape(KoShape *shape) {
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     KIS_ASSERT(chunkShape);
     return chunkShape;
 }
 
 void TestSvgText::testComplexText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\" dx=\"0,1,2,3,4,5,6,7,8\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        Hello, <tspan fill=\"red\" x=\"20\" y=\"46\" text-anchor=\"start\">ou"
             "t</tspan> there <![CDATA[cool cdata --> nice work]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_complex", QSize(385, 56), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
     QCOMPARE(baseShape->shapeCount(), 4);
     QCOMPARE(baseShape->layoutInterface()->isTextNode(), false);
     QCOMPARE(baseShape->layoutInterface()->numChars(), 41);
 
     {   // chunk 0: "Hello, "
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[0]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 7);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("Hello, "));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 7);
         QVERIFY(bool(transform[0].xPos));
         QVERIFY(!bool(transform[1].xPos));
 
         for (int i = 0; i < 7; i++) {
             QVERIFY(!i || bool(transform[i].dxPos));
 
             if (i) {
                 QCOMPARE(*transform[i].dxPos, qreal(i));
             }
         }
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 7);
         QCOMPARE(subChunks[0].text.size(), 1);
         QCOMPARE(*subChunks[0].transformation.xPos, 7.0);
         QVERIFY(!subChunks[1].transformation.xPos);
     }
 
     {   // chunk 1: "out"
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[1]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 3);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("out"));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 2);
         QVERIFY(bool(transform[0].xPos));
         QVERIFY(!bool(transform[1].xPos));
 
         for (int i = 0; i < 2; i++) {
             QVERIFY(bool(transform[i].dxPos));
             QCOMPARE(*transform[i].dxPos, qreal(i + 7));
         }
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 2);
         QCOMPARE(subChunks[0].text.size(), 1);
         QCOMPARE(subChunks[1].text.size(), 2);
     }
 
     {   // chunk 2: " there "
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[2]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 7);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString(" there "));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 0);
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 1);
         QCOMPARE(subChunks[0].text.size(), 7);
     }
 
     {   // chunk 3: "cool cdata --> nice work"
         KoSvgTextChunkShape *chunk = toChunkShape(baseShape->shapes()[3]);
 
         QCOMPARE(chunk->shapeCount(), 0);
         QCOMPARE(chunk->layoutInterface()->isTextNode(), true);
 
         QCOMPARE(chunk->layoutInterface()->numChars(), 24);
         QCOMPARE(chunk->layoutInterface()->nodeText(), QString("cool cdata --> nice work"));
 
         QVector<KoSvgText::CharTransformation> transform = chunk->layoutInterface()->localCharTransformations();
         QCOMPARE(transform.size(), 0);
 
         QVector<KoSvgTextChunkShapeLayoutInterface::SubChunk> subChunks =
                 chunk->layoutInterface()->collectSubChunks();
 
         QCOMPARE(subChunks.size(), 1);
         QCOMPARE(subChunks[0].text.size(), 24);
     }
 }
 
 void TestSvgText::testHindiText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"24\""
             "        font-family=\"FreeSans\" font-size=\"15\" fill=\"blue\" >"
             "मौखिक रूप से हिंदी के काफी सामान"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     QFont testFont("FreeSans");
     if (!QFontInfo(testFont).exactMatch()) {
 #ifdef USE_ROUND_TRIP
             return;
 #else
             QEXPECT_FAIL(0, "FreeSans found is *not* found! Hindi rendering might be broken!", Continue);
 #endif
     }
 
     t.test_standard("text_hindi", QSize(260, 30), 72);
 }
 
 void TestSvgText::testTextBaselineShift()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"29\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan>text<tspan baseline-shift=\"super\">super </tspan>normal<tspan baseline-shift=\"sub\">sub</tspan></tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     t.test_standard("text_baseline_shift", QSize(180, 40), 72);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testTextSpacing()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"5\" y=\"24\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan x=\"5\" dy=\"0.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" letter-spacing=\"4.0\">Lorem ipsum (ls=4)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" letter-spacing=\"-2.0\">Lorem ipsum (ls=-2)</tspan>"
 
             "        <tspan x=\"5\" dy=\"2.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" word-spacing=\"4.0\">Lorem ipsum (ws=4)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" word-spacing=\"-2.0\">Lorem ipsum (ws=-2)</tspan>"
 
             "        <tspan x=\"5\" dy=\"2.0em\">Lorem ipsum</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"0.0\">Lorem ipsum (k=0)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"2.0\">Lorem ipsum (k=2)</tspan>"
             "        <tspan x=\"5\" dy=\"1.5em\" kerning=\"2.0\" letter-spacing=\"2.0\">Lorem ipsum (k=2,ls=2)</tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_letter_word_spacing", QSize(340, 250), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testTextDecorations()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"4\" y=\"24\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
 
             "        <tspan x=\"20\" dy=\"0.0em\" text-decoration=\"underline\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.5em\" text-decoration=\"overline\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.0em\" text-decoration=\"line-through\">Lorem ipsum</tspan>"
             "        <tspan x=\"20\" dy=\"2.0em\" text-decoration=\"underline\">Lorem <tspan fill=\"red\">ipsum</tspan> (WRONG!!!)</tspan>"
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_decorations", QSize(290, 135), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 void TestSvgText::testRightToLeft()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"5\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"20\" y=\"34\" "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" text-anchor=\"end\">"
 
             "        <tspan x=\"250\" dy=\"0.0em\" text-anchor=\"middle\" direction=\"rtl\">aa bb cc dd</tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"rtl\">حادثتا السفينتين «بسين Bassein» و«فايبر Viper»</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"150\" dy=\"2.0em\" text-anchor=\"start\" direction=\"ltr\">aa bb حادثتا السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"350\" dy=\"2.0em\" text-anchor=\"start\" direction=\"rtl\">aa bb حادثتا السفينتين بسين cc dd </tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"150\" dy=\"2.0em\" text-anchor=\"start\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
             "        <tspan x=\"350\" dy=\"2.0em\" text-anchor=\"end\" direction=\"ltr\">aa bb <tspan text-decoration=\"underline\">حادثتا</tspan> السفينتين بسين cc dd </tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">الناطقون: 295 مليون - 422 مليون</tspan>"
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">Spoken: <tspan direction=\"rtl\" unicode-bidi=\"embed\">295 مليون - 422 مليون </tspan></tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\">*</tspan>"
 
             "        <tspan x=\"250\" dy=\"2.0em\" text-anchor=\"middle\" direction=\"ltr\">aa bb <tspan direction=\"rtl\" unicode-bidi=\"bidi-override\">c1 c2 c3 c4</tspan> dd ee</tspan>"
 
 
 
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_right_to_left", QSize(500,450), 72.0);
 
     KoSvgTextChunkShape *baseShape = toChunkShape(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     // root shape is not just a chunk!
     QVERIFY(dynamic_cast<KoSvgTextShape*>(baseShape));
 
 }
 
 #include <QTextLayout>
 #include <QPainter>
 
 void TestSvgText::testQtBidi()
 {
     // Arabic text sample from Wikipedia:
     // https://ar.wikipedia.org/wiki/%D8%A5%D9%85%D8%A7%D8%B1%D8%A7%D8%AA_%D8%A7%D9%84%D8%B3%D8%A7%D8%AD%D9%84_%D8%A7%D9%84%D9%85%D8%AA%D8%B5%D8%A7%D9%84%D8%AD
 
     QStringList ltrText;
     ltrText << "aa bb cc dd";
     ltrText << "aa bb حادثتا السفينتين بسين cc dd";
     ltrText << "aa bb \u202ec1c2 d3d4\u202C ee ff";
 
     QStringList rtlText;
     rtlText << "حادثتا السفينتين «بسين Bassein» و«فايبر Viper»";
     rtlText << "حادثتا السفينتين «بسين aa bb cc dd» و«فايبر Viper»";
 
 
     QImage canvas(500,500,QImage::Format_ARGB32);
     QPainter gc(&canvas);
     QPointF pos(15,15);
 
 
     QVector<QStringList> textSamples;
     textSamples << ltrText;
     textSamples << rtlText;
 
     QVector<Qt::LayoutDirection> textDirections;
     textDirections << Qt::LeftToRight;
     textDirections << Qt::RightToLeft;
 
     for (int i = 0; i < textSamples.size(); i++) {
         Q_FOREACH (const QString str, textSamples[i]) {
             QTextOption option;
             option.setTextDirection(textDirections[i]);
             option.setUseDesignMetrics(true);
 
             QTextLayout layout;
 
             layout.setText(str);
             layout.setFont(QFont("serif", 15.0));
             layout.setCacheEnabled(true);
             layout.beginLayout();
 
             QTextLine line = layout.createLine();
             line.setPosition(pos);
             pos.ry() += 25;
             layout.endLayout();
             layout.draw(&gc, QPointF());
         }
     }
 
     canvas.save("test_bidi.png");
 }
 
 void TestSvgText::testQtDxDy()
 {
     QImage canvas(500,500,QImage::Format_ARGB32);
     QPainter gc(&canvas);
     QPointF pos(15,15);
 
     QTextOption option;
     option.setTextDirection(Qt::LeftToRight);
     option.setUseDesignMetrics(true);
     option.setWrapMode(QTextOption::WrapAnywhere);
 
     QTextLayout layout;
 
     layout.setText("aa bb cc dd ee ff");
     layout.setFont(QFont("serif", 15.0));
     layout.setCacheEnabled(true);
     layout.beginLayout();
     layout.setTextOption(option);
 
     {
         QTextLine line = layout.createLine();
         line.setPosition(pos);
         line.setNumColumns(4);
     }
     pos.ry() += 25;
     pos.rx() += 30;
     {
         QTextLine line = layout.createLine();
         line.setPosition(pos);
     }
 
     layout.endLayout();
     layout.draw(&gc, QPointF());
 
 
     canvas.save("test_dxdy.png");
 }
 
 
 void TestSvgText::testTextOutlineSolid()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
             "        SA"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_outline_solid", QSize(30, 30), 72.0);
 }
 
 void TestSvgText::testNbspHandling()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" stroke=\"red\" stroke-width=\"1\">"
             "        S\u00A0A"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_nbsp", QSize(30, 30), 72.0);
 }
 
 void TestSvgText::testMulticolorText()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_multicolor", QSize(30, 30), 72.0);
 }
 
-#include <KoSvgTextShapeMarkupConverter.h>
 #include <KoColorBackground.h>
 
 void TestSvgText::testConvertToStrippedSvg()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text transform=\"translate(2)\" id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan><![CDATA[some stuff<><><<<>]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 
     KoSvgTextShape *baseShape = dynamic_cast<KoSvgTextShape*>(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     {
         KoColorBackground *bg = dynamic_cast<KoColorBackground*>(baseShape->background().data());
         QVERIFY(bg);
         QCOMPARE(bg->color(), QColor(Qt::blue));
     }
 
     KoSvgTextShapeMarkupConverter converter(baseShape);
 
     QString svgText;
     QString stylesText;
     QVERIFY(converter.convertToSvg(&svgText, &stylesText));
 
     QCOMPARE(stylesText, QString("<defs/>"));
     QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"DejaVu Sans\" font-size=\"15\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
 
     // test loading
 
     svgText = "<text fill=\"#00ff00\" font-family=\"DejaVu Sans\" font-size=\"19\"><tspan x=\"2\" y=\"24\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>";
 
     QVERIFY(converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
 
     {
         KoColorBackground *bg = dynamic_cast<KoColorBackground*>(baseShape->background().data());
         QVERIFY(bg);
         QCOMPARE(bg->color(), QColor(Qt::green));
     }
 
     {
         KoSvgTextProperties props = baseShape->textProperties();
         QVERIFY(props.hasProperty(KoSvgTextProperties::FontSizeId));
 
         const qreal fontSize = props.property(KoSvgTextProperties::FontSizeId).toReal();
         QCOMPARE(fontSize, 19.0);
     }
 
     QCOMPARE(baseShape->shapeCount(), 3);
 }
 
 void TestSvgText::testConvertToStrippedSvgNullOrigin()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text transform=\"translate(2)\" id=\"testRect\" x=\"0\" y=\"0\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        S<tspan fill=\"red\">A</tspan><![CDATA[some stuff<><><<<>]]>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 
     KoSvgTextShape *baseShape = dynamic_cast<KoSvgTextShape*>(t.findShape("testRect"));
     QVERIFY(baseShape);
 
     KoSvgTextShapeMarkupConverter converter(baseShape);
 
     QString svgText;
     QString stylesText;
     QVERIFY(converter.convertToSvg(&svgText, &stylesText));
 
     QCOMPARE(stylesText, QString("<defs/>"));
     QCOMPARE(svgText, QString("<text fill=\"#0000ff\" font-family=\"DejaVu Sans\" font-size=\"15\"><tspan x=\"0\" y=\"0\">S</tspan><tspan fill=\"#ff0000\">A</tspan><tspan>some stuff&lt;&gt;&lt;&gt;&lt;&lt;&lt;&gt;</tspan></text>"));
 }
 
 void TestSvgText::testConvertFromIncorrectStrippedSvg()
 {
     QScopedPointer<KoSvgTextShape> baseShape(new KoSvgTextShape());
 
     KoSvgTextShapeMarkupConverter converter(baseShape.data());
 
     QString svgText;
     QString stylesText;
 
     svgText = "<text>blah text</text>";
     QVERIFY(converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     QCOMPARE(converter.errors().size(), 0);
 
     svgText = "<text>>><<><blah text</text>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 
     svgText = "<notext>blah text</notext>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 
     svgText = "<defs/>";
     QVERIFY(!converter.convertFromSvg(svgText, stylesText, QRectF(0,0,30,30), 72.0));
     qDebug() << ppVar(converter.errors());
     QCOMPARE(converter.errors().size(), 1);
 }
 
 void TestSvgText::testEmptyTextChunk()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"2\" y=\"24\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        " // no actual text! should not crash!
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     // it just shouldn't assert or fail when seeing an empty text block
     t.parser.setResolution(QRectF(QPointF(), QSizeF(30,30)) /* px */, 72.0/* ppi */);
     t.run();
 }
 
 void TestSvgText::testConvertHtmlToSvg()
 {
     const QString html =
             "<?xml version=\"1.0\"?>"
             "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">"
             "<html>"
               "<head>"
                 "<meta name=\"qrichtext\" content=\"1\"/>"
                 "<style type=\"text/css\">p, li { white-space: pre-wrap; }</style>"
               "</head>"
               "<body style=\" font-family:'Droid Sans'; font-size:9pt; font-weight:400; font-style:normal;\">"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">"
                 "  <span style=\" font-family:'Times'; font-size:20pt;\">Lorem ipsum dolor</span>"
                 "</p>"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">sit am"
                 "<span style=\" font-weight:600;\">et, consectetur adipis</span>cing </p>"
                 "<p style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">"
                 "  <span style=\" font-style:italic;\">elit. </span>"
                 "</p>"
               "</body>"
             "</html>";
 
     KoSvgTextShape shape;
     KoSvgTextShapeMarkupConverter converter(&shape);
 
     QString svg;
     QString defs;
 
     converter.convertFromHtml(html, &svg, &defs);
 
 
     bool r = converter.convertToSvg(&svg, &defs);
 
     qDebug() << r << svg << defs;
 
 }
 
 void TestSvgText::testTextWithMultipleRelativeOffsets()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        dy=\"0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0\">"
             "        Lorem ipsum dolor sit amet"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_multiple_relative_offsets", QSize(300, 80), 72.0);
 }
 
 void TestSvgText::testTextWithMultipleAbsoluteOffsetsArabic()
 {
     /**
      * According to the standard, each **absolute** offset defines a
      * new text chunk, therefore, the arabic text must become
      * ltr reordered
      */
 
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        y=\"40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 40 45 50 55 50 45 40 35 30 25 30 35 \">"
             "        Lo rem اللغة العربية المعيارية الحديثة ip sum"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
     t.test_standard("text_multiple_absolute_offsets_arabic", QSize(530, 70), 72.0);
 }
 
 void TestSvgText::testTextWithMultipleRelativeOffsetsArabic()
 {
     /**
      * According to the standard, **relative** offsets must not define a new
      * text chunk, therefore, the arabic text must be written in native rtl order,
      * even though the individual letters are split.
      */
 
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
             "    <text id=\"testRect\" x=\"10\" y=\"40\""
             "        font-family=\"DejaVu Sans\" font-size=\"15\" "
             "        dy=\"0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0 -3 -3 -3 -3 3 3 3 3 0\">"
             "        Lo rem اللغة العربية المعيارية الحديثة ip sum"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     SvgRenderTester t (data);
 
     // we cannot expect more than one failure
 #ifndef USE_ROUND_TRIP
     QEXPECT_FAIL("", "WARNING: in Krita relative offsets also define a new text chunk, that doesn't comply with SVG standard and must be fixed", Continue);
     t.test_standard("text_multiple_relative_offsets_arabic", QSize(530, 70), 72.0);
 #endif
 }
 
 void TestSvgText::testTextOutline()
 {
     const QString data =
             "<svg width=\"100px\" height=\"30px\""
             "    xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">"
 
             "<g id=\"test\">"
 
             "    <rect id=\"boundingRect\" x=\"4\" y=\"5\" width=\"89\" height=\"19\""
             "        fill=\"none\" stroke=\"red\"/>"
 
             "    <text id=\"testRect\" x=\"7\" y=\"27\""
             " "
             "        font-family=\"DejaVu Sans\" font-size=\"15\" fill=\"blue\" >"
             "        normal "
             "        <tspan text-decoration=\"line-through\">strikethrough</tspan>"
             "        <tspan text-decoration=\"overline\">overline</tspan>"
             "        <tspan text-decoration=\"underline\">underline</tspan>"
             "    </text>"
 
             "</g>"
 
             "</svg>";
 
     QRect renderRect(0, 0, 450, 40);
 
     SvgRenderTester t (data);
     t.setFuzzyThreshold(5);
     t.test_standard("text_outline", renderRect.size(), 72.0);
 
     KoShape *shape = t.findShape("testRect");
     KoSvgTextChunkShape *chunkShape = dynamic_cast<KoSvgTextChunkShape*>(shape);
     QVERIFY(chunkShape);
 
     KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
 
     QImage canvas(renderRect.size(), QImage::Format_ARGB32);
     canvas.fill(0);
     QPainter gc(&canvas);
     gc.setPen(Qt::NoPen);
     gc.setBrush(Qt::black);
     gc.setRenderHint(QPainter::Antialiasing, true);
     gc.drawPath(textShape->textOutline());
 
     QVERIFY(TestUtil::checkQImage(canvas, "svg_render", "load_text_outline", "converted_to_path", 3, 5));
 }
 
 
 
 
 QTEST_MAIN(TestSvgText)
diff --git a/libs/global/kis_global.h b/libs/global/kis_global.h
index 37777ba1f5..0df49fc58b 100644
--- a/libs/global/kis_global.h
+++ b/libs/global/kis_global.h
@@ -1,272 +1,271 @@
 /*
  *  Copyright (c) 2000 Matthias Elter <elter@kde.org>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KISGLOBAL_H_
 #define KISGLOBAL_H_
 
 #include <limits.h>
 
 #include <KoConfig.h>
 #include "kis_assert.h"
 
 #include <QPoint>
 #include <QPointF>
 
 const quint8 quint8_MAX = UCHAR_MAX;
 const quint16 quint16_MAX = 65535;
 
 const qint32 qint32_MAX = (2147483647);
 const qint32 qint32_MIN = (-2147483647 - 1);
 
 const quint8 MAX_SELECTED = UCHAR_MAX;
 const quint8 MIN_SELECTED = 0;
 const quint8 SELECTION_THRESHOLD = 1;
 
 enum OutlineStyle {
     OUTLINE_NONE = 0,
     OUTLINE_CIRCLE,
     OUTLINE_FULL,
     OUTLINE_TILT,
 
     N_OUTLINE_STYLE_SIZE
 };
 
 enum CursorStyle {
     CURSOR_STYLE_NO_CURSOR = 0,
     CURSOR_STYLE_TOOLICON,
     CURSOR_STYLE_POINTER,
     CURSOR_STYLE_SMALL_ROUND,
     CURSOR_STYLE_CROSSHAIR,
     CURSOR_STYLE_TRIANGLE_RIGHTHANDED,
     CURSOR_STYLE_TRIANGLE_LEFTHANDED,
     CURSOR_STYLE_BLACK_PIXEL,
     CURSOR_STYLE_WHITE_PIXEL,
 
     N_CURSOR_STYLE_SIZE
 };
 
 enum OldCursorStyle {
     OLD_CURSOR_STYLE_TOOLICON = 0,
     OLD_CURSOR_STYLE_CROSSHAIR = 1,
     OLD_CURSOR_STYLE_POINTER = 2,
 
     OLD_CURSOR_STYLE_OUTLINE = 3,
 
     OLD_CURSOR_STYLE_NO_CURSOR = 4,
     OLD_CURSOR_STYLE_SMALL_ROUND = 5,
 
     OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT = 6,
     OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS = 7,
 
     OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED = 8,
     OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED = 9,
 
     OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED = 10,
     OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED = 11
 };
 
 /*
  * Most wacom pads have 512 levels of pressure; Qt only supports 256, and even
  * this is downscaled to 127 levels because the line would be too jittery, and
  * the amount of masks take too much memory otherwise.
  */
 const qint32 PRESSURE_LEVELS = 127;
 const double PRESSURE_MIN = 0.0;
 const double PRESSURE_MAX = 1.0;
 const double PRESSURE_DEFAULT = PRESSURE_MAX;
 const double PRESSURE_THRESHOLD = 5.0 / 255.0;
 
 // copy of lcms.h
 #define INTENT_PERCEPTUAL                 0
 #define INTENT_RELATIVE_COLORIMETRIC      1
 #define INTENT_SATURATION                 2
 #define INTENT_ABSOLUTE_COLORIMETRIC      3
 
 #include <cmath>
-#include <QPointF>
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 
 
 // converts \p a to [0, 2 * M_PI) range
 inline qreal normalizeAngle(qreal a) {
     if (a < 0.0) {
         a = 2 * M_PI + fmod(a, 2 * M_PI);
     }
 
     return a >= 2 * M_PI ? fmod(a, 2 * M_PI) : a;
 }
 
 // converts \p a to [0, 360.0) range
 inline qreal normalizeAngleDegrees(qreal a) {
     if (a < 0.0) {
         a = 360.0 + fmod(a, 360.0);
     }
 
     return a >= 360.0 ? fmod(a, 360.0) : a;
 }
 
 inline qreal shortestAngularDistance(qreal a, qreal b) {
     qreal dist = fmod(qAbs(a - b), 2 * M_PI);
     if (dist > M_PI) dist = 2 * M_PI - dist;
 
     return dist;
 }
 
 inline qreal incrementInDirection(qreal a, qreal inc, qreal direction) {
     qreal b1 = a + inc;
     qreal b2 = a - inc;
 
     qreal d1 = shortestAngularDistance(b1, direction);
     qreal d2 = shortestAngularDistance(b2, direction);
 
     return d1 < d2 ? b1 : b2;
 }
 
 inline qreal bisectorAngle(qreal a, qreal b) {
     const qreal diff = shortestAngularDistance(a, b);
     return incrementInDirection(a, 0.5 * diff, b);
 }
 
 template<typename PointType>
 inline PointType snapToClosestAxis(PointType P) {
     if (qAbs(P.x()) < qAbs(P.y())) {
         P.setX(0);
     } else {
         P.setY(0);
     }
     return P;
 }
 
 template<typename T>
 inline T pow2(const T& x) {
     return x * x;
 }
 
 template<typename T>
 inline T kisDegreesToRadians(T degrees) {
     return degrees * M_PI / 180.0;
 }
 
 template<typename T>
 inline T kisRadiansToDegrees(T radians) {
     return radians * 180.0 / M_PI;
 }
 
 template<class T, typename U>
 inline T kisGrowRect(const T &rect, U offset) {
     return rect.adjusted(-offset, -offset, offset, offset);
 }
 
 inline qreal kisDistance(const QPointF &pt1, const QPointF &pt2) {
     return std::sqrt(pow2(pt1.x() - pt2.x()) + pow2(pt1.y() - pt2.y()));
 }
 
 inline qreal kisSquareDistance(const QPointF &pt1, const QPointF &pt2) {
     return pow2(pt1.x() - pt2.x()) + pow2(pt1.y() - pt2.y());
 }
 
 #include <QLineF>
 
 inline qreal kisDistanceToLine(const QPointF &m, const QLineF &line)
 {
     const QPointF &p1 = line.p1();
     const QPointF &p2 = line.p2();
 
     qreal distance = 0;
 
     if (qFuzzyCompare(p1.x(), p2.x())) {
         distance = qAbs(m.x() - p2.x());
     } else if (qFuzzyCompare(p1.y(), p2.y())) {
         distance = qAbs(m.y() - p2.y());
     } else {
         qreal A = 1;
         qreal B = - (p1.x() - p2.x()) / (p1.y() - p2.y());
         qreal C = - p1.x() - B * p1.y();
 
         distance = qAbs(A * m.x() + B * m.y() + C) / std::sqrt(pow2(A) + pow2(B));
     }
 
     return distance;
 }
 
 inline QPointF kisProjectOnVector(const QPointF &base, const QPointF &v)
 {
     const qreal prod = base.x() * v.x() + base.y() * v.y();
     const qreal lengthSq = pow2(base.x()) + pow2(base.y());
     qreal coeff = prod / lengthSq;
 
     return coeff * base;
 }
 
 #include <QRect>
 
 inline QRect kisEnsureInRect(QRect rc, const QRect &bounds)
 {
     if(rc.right() > bounds.right()) {
         rc.translate(bounds.right() - rc.right(), 0);
     }
 
     if(rc.left() < bounds.left()) {
         rc.translate(bounds.left() - rc.left(), 0);
     }
 
     if(rc.bottom() > bounds.bottom()) {
         rc.translate(0, bounds.bottom() - rc.bottom());
     }
 
     if(rc.top() < bounds.top()) {
         rc.translate(0, bounds.top() - rc.top());
     }
 
     return rc;
 }
 
 #include "kis_pointer_utils.h"
 
 /**
  * A special wrapper object that converts Qt-style mutexes and locks
  * into an object that supports Std's (and Boost's) "Lockable"
  * concept. Basically, it converts tryLock() into try_lock() to comply
  * with the syntax.
  */
 
 template <class T>
 struct StdLockableWrapper {
     StdLockableWrapper(T *lock) : m_lock(lock) {}
 
     void lock() {
         m_lock->lock();
     }
 
     bool try_lock() {
         return m_lock->tryLock();
     }
 
     void unlock() {
         m_lock->unlock();
     }
 
 private:
     T *m_lock;
 };
 
 #endif // KISGLOBAL_H_
 
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index 1e64bb7577..fbea2059cd 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,1841 +1,1840 @@
 /*
  *  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_change_profile_visitor.h"
 #include "kis_colorspace_convert_visitor.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 "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_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 "kis_image_barrier_locker.h"
 
 #include <QtCore>
 
 #include <functional>
 
 #include "kis_time_range.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;
     KisProjectionUpdatesFilterSP projectionUpdatesFilter;
     KisImageSignalRouter signalRouter;
     KisImageAnimationInterface *animationInterface;
     KisUpdateScheduler scheduler;
     QAtomicInt disableDirtyRequests;
 
 
     KisCompositeProgressProxy compositeProgressProxy;
 
     bool blockLevelOfDetail = false;
 
     QPointF axesCenter;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc);
 };
 
 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
 }
 
 KisImage *KisImage::clone(bool exactCopy)
 {
     return new KisImage(*this, 0, exactCopy);
 }
 
 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()));
 
     setObjectName(rhs.objectName());
 
     m_d->xres = rhs.m_d->xres;
     m_d->yres = rhs.m_d->yres;
 
 
     if (rhs.m_d->proofingConfig) {
         m_d->proofingConfig = toQShared(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
     }
 
     KisNodeSP newRoot = rhs.root()->clone();
     newRoot->setGraphListener(this);
     newRoot->setImage(this);
     m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
     setRoot(newRoot);
 
     if (exactCopy || rhs.m_d->isolatedRootNode) {
         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;
                 }
             });
     }
 
     Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
         m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
     }
 
     rhs.m_d->nserver = KisNameServer(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);
     }
 }
 
 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);
 
     KisNodeSP newNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(newNode.data())) {
         emit sigInternalStopIsolatedModeRequested();
     }
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data())) {
         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")),
               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, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(scaleX, scaleY,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           bool resizeImage,
                           double radians)
 {
     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(bounds());
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(rootNode->exactBounds()).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != width() || newSize.height() != height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), 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");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
 
     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(), true, radians);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians)
 {
     if (node->inherits("KisMask")) {
         rotateImpl(kundo2_i18n("Rotate Mask"), node, false, radians);
     } else {
         rotateImpl(kundo2_i18n("Rotate Layer"), node, false, radians);
     }
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          const QPointF &origin)
 {
     //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(bounds());
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(bounds(), 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");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY)
 {
     QPointF shearOrigin = QRectF(bounds()).center();
 
     if (node->inherits("KisMask")) {
         shearImpl(kundo2_i18n("Shear Mask"), node, false,
                   angleX, angleY, shearOrigin);
     } else {
         shearImpl(kundo2_i18n("Shear Layer"), node, false,
                   angleX, angleY, shearOrigin);
     }
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, QPointF());
 }
 
 void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!dstColorSpace) return;
 
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Image Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
 
     KisColorSpaceConvertVisitor visitor(this, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     m_d->rootLayer->accept(visitor);
 
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     const KoColorSpace *srcCs = colorSpace();
 
     if (!dstCs) return false;
 
     m_d->colorSpace = dstCs;
 
     KisChangeProfileVisitor visitor(srcCs, dstCs);
     bool retval = m_d->rootLayer->accept(visitor);
     m_d->signalRouter.emitNotification(ProfileChangedSignal);
     return retval;
 
 }
 
 void KisImage::convertProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     if (*m_d->colorSpace == *dstColorSpace) return;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Projection Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
     m_d->rootLayer->resetCache();
     m_d->signalRouter.emitNotification(ColorSpaceChangedSignal);
 }
 
 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()
 {
     KisLayerUtils::flattenImage(this);
 }
 
 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;
 }
 
 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);
 
     KisPaintDeviceSP newOriginal = m_d->rootLayer->original();
     newOriginal->setDefaultPixel(defaultProjectionColor);
 
     setRoot(m_d->rootLayer.data());
 }
 
 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)
 {
     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;
 
             QtConcurrent::run(std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
     struct StartIsolatedModeStroke : public KisSimpleStrokeStrategy {
         StartIsolatedModeStroke(KisNodeSP node, KisImageSP image)
             : KisSimpleStrokeStrategy("start-isolated-mode", kundo2_noi18n("start-isolated-mode")),
               m_node(node),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             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
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
 
             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 KisSimpleStrokeStrategy {
         StopIsolatedModeStroke(KisImageSP image)
             : KisSimpleStrokeStrategy("stop-isolated-mode", kundo2_noi18n("stop-isolated-mode")),
               m_image(image)
         {
             this->enableJob(JOB_INIT);
             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();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
             m_image->invalidateAllFrames();
 
             // 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);
 }
 
 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::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
 }
 
 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);
     }
 }
 
 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 asynchromously, 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::notifyNodeCollpasedChanged()
 {
     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;
 }
diff --git a/libs/image/kis_image_config.cpp b/libs/image/kis_image_config.cpp
index 6144437fb0..0c2afa7727 100644
--- a/libs/image/kis_image_config.cpp
+++ b/libs/image/kis_image_config.cpp
@@ -1,602 +1,600 @@
 /*
  *  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_image_config.h"
 
 #include <ksharedconfig.h>
 
 #include <KoConfig.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 
 #include "kis_debug.h"
 
 #include <QThread>
 #include <QApplication>
 #include <QColor>
 #include <QDir>
 
 #include "kis_global.h"
 #include <cmath>
 
 #ifdef Q_OS_OSX
 #include <errno.h>
 #endif
 
 KisImageConfig::KisImageConfig(bool readOnly)
     : m_config(KSharedConfig::openConfig()->group(QString()))
     , m_readOnly(readOnly)
 {
     if (!readOnly) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
     }
 #ifdef Q_OS_OSX
     // clear /var/folders/ swap path set by old broken Krita swap implementation in order to use new default swap dir.
     QString swap = m_config.readEntry("swaplocation", "");
     if (swap.startsWith("/var/folders/")) {
         m_config.deleteEntry("swaplocation");
     }
 #endif
 }
 
 KisImageConfig::~KisImageConfig()
 {
     if (m_readOnly) return;
 
     if (qApp->thread() != QThread::currentThread()) {
         dbgKrita << "KisImageConfig: requested config synchronization from nonGUI thread! Called from" << kisBacktrace();
         return;
     }
 
     m_config.sync();
 }
 
 bool KisImageConfig::enableProgressReporting(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enableProgressReporting", true) : true;
 }
 
 void KisImageConfig::setEnableProgressReporting(bool value)
 {
     m_config.writeEntry("enableProgressReporting", value);
 }
 
 bool KisImageConfig::enablePerfLog(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enablePerfLog", false) :false;
 }
 
 void KisImageConfig::setEnablePerfLog(bool value)
 {
     m_config.writeEntry("enablePerfLog", value);
 }
 
 qreal KisImageConfig::transformMaskOffBoundsReadArea() const
 {
     return m_config.readEntry("transformMaskOffBoundsReadArea", 0.5);
 }
 
 int KisImageConfig::updatePatchHeight() const
 {
     return m_config.readEntry("updatePatchHeight", 512);
 }
 
 void KisImageConfig::setUpdatePatchHeight(int value)
 {
     m_config.writeEntry("updatePatchHeight", value);
 }
 
 int KisImageConfig::updatePatchWidth() const
 {
     return m_config.readEntry("updatePatchWidth", 512);
 }
 
 void KisImageConfig::setUpdatePatchWidth(int value)
 {
     m_config.writeEntry("updatePatchWidth", value);
 }
 
 qreal KisImageConfig::maxCollectAlpha() const
 {
     return m_config.readEntry("maxCollectAlpha", 2.5);
 }
 
 qreal KisImageConfig::maxMergeAlpha() const
 {
     return m_config.readEntry("maxMergeAlpha", 1.);
 }
 
 qreal KisImageConfig::maxMergeCollectAlpha() const
 {
     return m_config.readEntry("maxMergeCollectAlpha", 1.5);
 }
 
 qreal KisImageConfig::schedulerBalancingRatio() const
 {
     /**
      * updates-queue-size / strokes-queue-size
      */
     return m_config.readEntry("schedulerBalancingRatio", 100.);
 }
 
 void KisImageConfig::setSchedulerBalancingRatio(qreal value)
 {
     m_config.writeEntry("schedulerBalancingRatio", value);
 }
 
 int KisImageConfig::maxSwapSize(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("maxSwapSize", 4096) : 4096; // in MiB
 }
 
 void KisImageConfig::setMaxSwapSize(int value)
 {
     m_config.writeEntry("maxSwapSize", value);
 }
 
 int KisImageConfig::swapSlabSize() const
 {
     return m_config.readEntry("swapSlabSize", 64); // in MiB
 }
 
 void KisImageConfig::setSwapSlabSize(int value)
 {
     m_config.writeEntry("swapSlabSize", value);
 }
 
 int KisImageConfig::swapWindowSize() const
 {
     return m_config.readEntry("swapWindowSize", 16); // in MiB
 }
 
 void KisImageConfig::setSwapWindowSize(int value)
 {
     m_config.writeEntry("swapWindowSize", value);
 }
 
 int KisImageConfig::tilesHardLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * (1 - pp);
 }
 
 int KisImageConfig::tilesSoftLimit() const
 {
     qreal sp = qreal(memorySoftLimitPercent()) / 100.0;
 
     return tilesHardLimit() * sp;
 }
 
 int KisImageConfig::poolLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * pp;
 }
 
 qreal KisImageConfig::memoryHardLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryHardLimitPercent", 50.) : 50.;
 }
 
 void KisImageConfig::setMemoryHardLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryHardLimitPercent", value);
 }
 
 qreal KisImageConfig::memorySoftLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memorySoftLimitPercent", 2.) : 2.;
 }
 
 void KisImageConfig::setMemorySoftLimitPercent(qreal value)
 {
     m_config.writeEntry("memorySoftLimitPercent", value);
 }
 
 qreal KisImageConfig::memoryPoolLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryPoolLimitPercent", 0.0) : 0.0;
 }
 
 void KisImageConfig::setMemoryPoolLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryPoolLimitPercent", value);
 }
 
 QString KisImageConfig::safelyGetWritableTempLocation(const QString &suffix, const QString &configKey, bool requestDefault) const
 {
 #ifdef Q_OS_OSX
     // On OSX, QDir::tempPath() gives us a folder we cannot reply upon (usually
     // something like /var/folders/.../...) and that will have vanished when we
     // try to create the tmp file in KisMemoryWindow::KisMemoryWindow using
     // swapFileTemplate. thus, we just pick the home folder if swapDir does not
     // tell us otherwise.
 
     // the other option here would be to use a "garbled name" temp file (i.e. no name
     // KRITA_SWAP_FILE_XXXXXX) in an obscure /var/folders place, which is not
     // nice to the user. having a clearly named swap file in the home folder is
     // much nicer to Krita's users.
 
     // furthermore, this is just a default and swapDir can always be configured
     // to another location.
 
     QString swap = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QDir::separator() + suffix;
 #else
     Q_UNUSED(suffix);
     QString swap = QDir::tempPath();
 #endif
     if (requestDefault) {
        return swap;
     }
     const QString configuredSwap = m_config.readEntry(configKey, swap);
     if (!configuredSwap.isEmpty()) {
         swap = configuredSwap;
     }
     return swap;
 }
 
 
 QString KisImageConfig::swapDir(bool requestDefault)
 {
     return safelyGetWritableTempLocation("swap", "swaplocation", requestDefault);
 }
 
 void KisImageConfig::setSwapDir(const QString &swapDir)
 {
     m_config.writeEntry("swaplocation", swapDir);
 }
 
 int KisImageConfig::numberOfOnionSkins() const
 {
     return m_config.readEntry("numberOfOnionSkins", 10);
 }
 
 void KisImageConfig::setNumberOfOnionSkins(int value)
 {
     m_config.writeEntry("numberOfOnionSkins", value);
 }
 
 int KisImageConfig::onionSkinTintFactor() const
 {
     return m_config.readEntry("onionSkinTintFactor", 192);
 }
 
 void KisImageConfig::setOnionSkinTintFactor(int value)
 {
     m_config.writeEntry("onionSkinTintFactor", value);
 }
 
 int KisImageConfig::onionSkinOpacity(int offset) const
 {
     int value = m_config.readEntry("onionSkinOpacity_" + QString::number(offset), -1);
 
     if (value < 0) {
         const int num = numberOfOnionSkins();
         const qreal dx = qreal(qAbs(offset)) / num;
         value = 0.7 * exp(-pow2(dx) / 0.5) * 255;
     }
 
     return value;
 }
 
 void KisImageConfig::setOnionSkinOpacity(int offset, int value)
 {
     m_config.writeEntry("onionSkinOpacity_" + QString::number(offset), value);
 }
 
 bool KisImageConfig::onionSkinState(int offset) const
 {
     bool enableByDefault = (qAbs(offset) <= 2);
     return m_config.readEntry("onionSkinState_" + QString::number(offset), enableByDefault);
 }
 
 void KisImageConfig::setOnionSkinState(int offset, bool value)
 {
     m_config.writeEntry("onionSkinState_" + QString::number(offset), value);
 }
 
 QColor KisImageConfig::onionSkinTintColorBackward() const
 {
     return m_config.readEntry("onionSkinTintColorBackward", QColor(Qt::red));
 }
 
 void KisImageConfig::setOnionSkinTintColorBackward(const QColor &value)
 {
     m_config.writeEntry("onionSkinTintColorBackward", value);
 }
 
 QColor KisImageConfig::onionSkinTintColorForward() const
 {
     return m_config.readEntry("oninSkinTintColorForward", QColor(Qt::green));
 }
 
 void KisImageConfig::setOnionSkinTintColorForward(const QColor &value)
 {
     m_config.writeEntry("oninSkinTintColorForward", value);
 }
 
 bool KisImageConfig::lazyFrameCreationEnabled(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("lazyFrameCreationEnabled", true) : true;
 }
 
 void KisImageConfig::setLazyFrameCreationEnabled(bool value)
 {
     m_config.writeEntry("lazyFrameCreationEnabled", value);
 }
 
 
 #if defined Q_OS_LINUX
 #include <sys/sysinfo.h>
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
 #include <sys/sysctl.h>
 #elif defined Q_OS_WIN
 #include <windows.h>
 #elif defined Q_OS_OSX
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #endif
 
-#include <kis_debug.h>
-
 int KisImageConfig::totalRAM()
 {
     // let's think that default memory size is 1000MiB
     int totalMemory = 1000; // MiB
     int error = 1;
 
 #if defined Q_OS_LINUX
     struct sysinfo info;
 
     error = sysinfo(&info);
     if(!error) {
         totalMemory = info.totalram * info.mem_unit / (1UL << 20);
     }
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
     u_long physmem;
 #   if defined HW_PHYSMEM64 // NetBSD only
     int mib[] = {CTL_HW, HW_PHYSMEM64};
 #   else
     int mib[] = {CTL_HW, HW_PHYSMEM};
 #   endif
     size_t len = sizeof(physmem);
 
     error = sysctl(mib, 2, &physmem, &len, 0, 0);
     if(!error) {
         totalMemory = physmem >> 20;
     }
 #elif defined Q_OS_WIN
     MEMORYSTATUSEX status;
     status.dwLength = sizeof(status);
     error  = !GlobalMemoryStatusEx(&status);
 
     if (!error) {
         totalMemory = status.ullTotalPhys >> 20;
     }
 
     // For 32 bit windows, the total memory available is at max the 2GB per process memory limit.
 #   if defined ENV32BIT
     totalMemory = qMin(totalMemory, 2000);
 #   endif
 #elif defined Q_OS_OSX
     int mib[2] = { CTL_HW, HW_MEMSIZE };
     u_int namelen = sizeof(mib) / sizeof(mib[0]);
     uint64_t size;
     size_t len = sizeof(size);
 
     errno = 0;
     if (sysctl(mib, namelen, &size, &len, 0, 0) >= 0) {
         totalMemory = size >> 20;
         error = 0;
     }
     else {
         dbgKrita << "sysctl(\"hw.memsize\") raised error" << strerror(errno);
     }
 #endif
 
     if (error) {
         warnKrita << "Cannot get the size of your RAM. Using 1 GiB by default.";
     }
 
     return totalMemory;
 }
 
 bool KisImageConfig::showAdditionalOnionSkinsSettings(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("showAdditionalOnionSkinsSettings", true) : true;
 }
 
 void KisImageConfig::setShowAdditionalOnionSkinsSettings(bool value)
 {
     m_config.writeEntry("showAdditionalOnionSkinsSettings", value);
 }
 
 int KisImageConfig::defaultFrameColorLabel() const
 {
     return m_config.readEntry("defaultFrameColorLabel", 0);
 }
 
 void KisImageConfig::setDefaultFrameColorLabel(int label)
 {
     m_config.writeEntry("defaultFrameColorLabel", label);
 }
 
 KisProofingConfigurationSP KisImageConfig::defaultProofingconfiguration()
 {
     KisProofingConfiguration *proofingConfig= new KisProofingConfiguration();
     proofingConfig->proofingProfile = m_config.readEntry("defaultProofingProfileName", "Chemical proof");
     proofingConfig->proofingModel = m_config.readEntry("defaultProofingProfileModel", "CMYKA");
     proofingConfig->proofingDepth = m_config.readEntry("defaultProofingProfileDepth", "U8");
     proofingConfig->intent = (KoColorConversionTransformation::Intent)m_config.readEntry("defaultProofingProfileIntent", 3);
     if (m_config.readEntry("defaultProofingBlackpointCompensation", true)) {
         proofingConfig->conversionFlags  |= KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     } else {
         proofingConfig->conversionFlags  = proofingConfig->conversionFlags & ~KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     }
     QColor def(Qt::green);
     m_config.readEntry("defaultProofingGamutwarning", def);
     KoColor col(KoColorSpaceRegistry::instance()->rgb8());
     col.fromQColor(def);
     col.setOpacity(1.0);
     proofingConfig->warningColor = col;
     proofingConfig->adaptationState = (double)m_config.readEntry("defaultProofingAdaptationState", 1.0);
     return toQShared(proofingConfig);
 }
 
 void KisImageConfig::setDefaultProofingConfig(const KoColorSpace *proofingSpace, int proofingIntent, bool blackPointCompensation, KoColor warningColor, double adaptationState)
 {
     m_config.writeEntry("defaultProofingProfileName", proofingSpace->profile()->name());
     m_config.writeEntry("defaultProofingProfileModel", proofingSpace->colorModelId().id());
     m_config.writeEntry("defaultProofingProfileDepth", proofingSpace->colorDepthId().id());
     m_config.writeEntry("defaultProofingProfileIntent", proofingIntent);
     m_config.writeEntry("defaultProofingBlackpointCompensation", blackPointCompensation);
     QColor c;
     c = warningColor.toQColor();
     m_config.writeEntry("defaultProofingGamutwarning", c);
     m_config.writeEntry("defaultProofingAdaptationState",adaptationState);
 }
 
 bool KisImageConfig::useLodForColorizeMask(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("useLodForColorizeMask", false) : false;
 }
 
 void KisImageConfig::setUseLodForColorizeMask(bool value)
 {
     m_config.writeEntry("useLodForColorizeMask", value);
 }
 
 int KisImageConfig::maxNumberOfThreads(bool defaultValue) const
 {
     return (defaultValue ? QThread::idealThreadCount() : m_config.readEntry("maxNumberOfThreads", QThread::idealThreadCount()));
 }
 
 void KisImageConfig::setMaxNumberOfThreads(int value)
 {
     if (value == QThread::idealThreadCount()) {
         m_config.deleteEntry("maxNumberOfThreads");
     } else {
         m_config.writeEntry("maxNumberOfThreads", value);
     }
 }
 
 int KisImageConfig::frameRenderingClones(bool defaultValue) const
 {
     const int defaultClonesCount = qMax(1, maxNumberOfThreads(defaultValue) / 2);
     return defaultValue ? defaultClonesCount : m_config.readEntry("frameRenderingClones", defaultClonesCount);
 }
 
 void KisImageConfig::setFrameRenderingClones(int value)
 {
     m_config.writeEntry("frameRenderingClones", value);
 }
 
 int KisImageConfig::fpsLimit(bool defaultValue) const
 {
     return defaultValue ? 100 : m_config.readEntry("fpsLimit", 100);
 }
 
 void KisImageConfig::setFpsLimit(int value)
 {
     m_config.writeEntry("fpsLimit", value);
 }
 
 bool KisImageConfig::useOnDiskAnimationCacheSwapping(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useOnDiskAnimationCacheSwapping", true);
 }
 
 void KisImageConfig::setUseOnDiskAnimationCacheSwapping(bool value)
 {
     m_config.writeEntry("useOnDiskAnimationCacheSwapping", value);
 }
 
 QString KisImageConfig::animationCacheDir(bool defaultValue) const
 {
     return safelyGetWritableTempLocation("animation_cache", "animationCacheDir", defaultValue);
 }
 
 void KisImageConfig::setAnimationCacheDir(const QString &value)
 {
     m_config.writeEntry("animationCacheDir", value);
 }
 
 bool KisImageConfig::useAnimationCacheFrameSizeLimit(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useAnimationCacheFrameSizeLimit", true);
 }
 
 void KisImageConfig::setUseAnimationCacheFrameSizeLimit(bool value)
 {
     m_config.writeEntry("useAnimationCacheFrameSizeLimit", value);
 }
 
 int KisImageConfig::animationCacheFrameSizeLimit(bool defaultValue) const
 {
     return defaultValue ? 2500 : m_config.readEntry("animationCacheFrameSizeLimit", 2500);
 }
 
 void KisImageConfig::setAnimationCacheFrameSizeLimit(int value)
 {
     m_config.writeEntry("animationCacheFrameSizeLimit", value);
 }
 
 bool KisImageConfig::useAnimationCacheRegionOfInterest(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useAnimationCacheRegionOfInterest", true);
 }
 
 void KisImageConfig::setUseAnimationCacheRegionOfInterest(bool value)
 {
     m_config.writeEntry("useAnimationCacheRegionOfInterest", value);
 }
 
 qreal KisImageConfig::animationCacheRegionOfInterestMargin(bool defaultValue) const
 {
     return defaultValue ? 0.25 : m_config.readEntry("animationCacheRegionOfInterestMargin", 0.25);
 }
 
 void KisImageConfig::setAnimationCacheRegionOfInterestMargin(qreal value)
 {
     m_config.writeEntry("animationCacheRegionOfInterestMargin", value);
 }
 
 QColor KisImageConfig::selectionOverlayMaskColor(bool defaultValue) const
 {
     QColor def(255, 0, 0, 220);
     return (defaultValue ? def : m_config.readEntry("selectionOverlayMaskColor", def));
 }
 
 void KisImageConfig::setSelectionOverlayMaskColor(const QColor &color)
 {
     m_config.writeEntry("selectionOverlayMaskColor", color);
 }
diff --git a/libs/image/kis_layer_utils.cpp b/libs/image/kis_layer_utils.cpp
index 362078252e..e3eeeefba8 100644
--- a/libs/image/kis_layer_utils.cpp
+++ b/libs/image/kis_layer_utils.cpp
@@ -1,1459 +1,1458 @@
 /*
  *  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_layer_utils.h"
 
 #include <algorithm>
 
 #include <QUuid>
 #include <KoColorSpaceConstants.h>
 #include <KoProperties.h>
 
 #include "kis_painter.h"
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_clone_layer.h"
 #include "kis_group_layer.h"
 #include "kis_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_meta_data_merge_strategy.h"
 #include <kundo2command.h>
 #include "commands/kis_image_layer_add_command.h"
 #include "commands/kis_image_layer_remove_command.h"
 #include "commands/kis_image_layer_move_command.h"
 #include "commands/kis_image_change_layers_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "commands/kis_image_change_visibility_command.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_processing_applicator.h"
 #include "kis_image_animation_interface.h"
 #include "kis_keyframe_channel.h"
 #include "kis_command_utils.h"
-#include "kis_processing_applicator.h"
 #include "commands_new/kis_change_projection_color_command.h"
 #include "kis_layer_properties_icons.h"
 #include "lazybrush/kis_colorize_mask.h"
 #include "commands/kis_node_property_list_command.h"
 #include "commands/kis_node_compositeop_command.h"
 #include <KisDelayedUpdateNodeInterface.h>
 #include "krita_utils.h"
 
 
 namespace KisLayerUtils {
 
     void fetchSelectionMasks(KisNodeList mergedNodes, QVector<KisSelectionMaskSP> &selectionMasks)
     {
         foreach (KisNodeSP node, mergedNodes) {
             KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
 
             KisSelectionMaskSP mask;
 
             if (layer && (mask = layer->selectionMask())) {
                 selectionMasks.append(mask);
             }
         }
     }
 
     struct MergeDownInfoBase {
         MergeDownInfoBase(KisImageSP _image)
             : image(_image),
               storage(new SwitchFrameCommand::SharedStorage())
         {
         }
         virtual ~MergeDownInfoBase() {}
 
         KisImageWSP image;
 
         QVector<KisSelectionMaskSP> selectionMasks;
 
         KisNodeSP dstNode;
 
         SwitchFrameCommand::SharedStorageSP storage;
         QSet<int> frames;
         bool useInTimeline = false;
         bool enableOnionSkins = false;
 
         virtual KisNodeList allSrcNodes() = 0;
 
         KisLayerSP dstLayer() {
             return qobject_cast<KisLayer*>(dstNode.data());
         }
     };
 
     struct MergeDownInfo : public MergeDownInfoBase {
         MergeDownInfo(KisImageSP _image,
                       KisLayerSP _prevLayer,
                       KisLayerSP _currLayer)
             : MergeDownInfoBase(_image),
               prevLayer(_prevLayer),
               currLayer(_currLayer)
         {
             frames =
                 fetchLayerFramesRecursive(prevLayer) |
                 fetchLayerFramesRecursive(currLayer);
 
             useInTimeline = prevLayer->useInTimeline() || currLayer->useInTimeline();
 
             const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(currLayer.data());
             if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
 
             paintLayer = qobject_cast<KisPaintLayer*>(prevLayer.data());
             if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
         }
 
         KisLayerSP prevLayer;
         KisLayerSP currLayer;
 
         KisNodeList allSrcNodes() override {
             KisNodeList mergedNodes;
             mergedNodes << currLayer;
             mergedNodes << prevLayer;
             return mergedNodes;
         }
     };
 
     struct MergeMultipleInfo : public MergeDownInfoBase {
         MergeMultipleInfo(KisImageSP _image,
                           KisNodeList _mergedNodes)
             : MergeDownInfoBase(_image),
               mergedNodes(_mergedNodes)
         {
             foreach (KisNodeSP node, mergedNodes) {
                 frames |= fetchLayerFramesRecursive(node);
                 useInTimeline |= node->useInTimeline();
 
                 const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(node.data());
                 if (paintLayer) {
                     enableOnionSkins |= paintLayer->onionSkinEnabled();
                 }
             }
         }
 
         KisNodeList mergedNodes;
         bool nodesCompositingVaries = false;
 
         KisNodeList allSrcNodes() override {
             return mergedNodes;
         }
     };
 
     typedef QSharedPointer<MergeDownInfoBase> MergeDownInfoBaseSP;
     typedef QSharedPointer<MergeDownInfo> MergeDownInfoSP;
     typedef QSharedPointer<MergeMultipleInfo> MergeMultipleInfoSP;
 
     struct FillSelectionMasks : public KUndo2Command {
         FillSelectionMasks(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             fetchSelectionMasks(m_info->allSrcNodes(), m_info->selectionMasks);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableColorizeKeyStrokes : public KisCommandUtils::AggregateCommand {
         DisableColorizeKeyStrokes(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 recursiveApplyNodes(node,
                                     [this] (KisNodeSP node) {
                                         if (dynamic_cast<KisColorizeMask*>(node.data()) &&
                                             KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool()) {
 
                                             KisBaseNode::PropertyList props = node->sectionModelProperties();
                                             KisLayerPropertiesIcons::setNodeProperty(&props,
                                                                                      KisLayerPropertiesIcons::colorizeEditKeyStrokes,
                                                                                      false);
 
                                             addCommand(new KisNodePropertyListCommand(node, props));
                                         }
                                     });
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableOnionSkins : public KisCommandUtils::AggregateCommand {
         DisableOnionSkins(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 recursiveApplyNodes(node,
                                     [this] (KisNodeSP node) {
                                         if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::onionSkins, false).toBool()) {
 
                                             KisBaseNode::PropertyList props = node->sectionModelProperties();
                                             KisLayerPropertiesIcons::setNodeProperty(&props,
                                                                                      KisLayerPropertiesIcons::onionSkins,
                                                                                      false);
 
                                             addCommand(new KisNodePropertyListCommand(node, props));
                                         }
                                     });
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableExtraCompositing : public KisCommandUtils::AggregateCommand {
         DisableExtraCompositing(MergeMultipleInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             /**
              * We disable extra compositing only in case all the layers have
              * the same compositing properties, therefore, we can just sum them using
              * Normal blend mode
              */
             if (m_info->nodesCompositingVaries) return;
 
             // we should disable dirty requests on **redo only**, otherwise
             // the state of the layers will not be recovered on undo
             m_info->image->disableDirtyRequests();
 
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 if (node->compositeOpId() != COMPOSITE_OVER) {
                     addCommand(new KisNodeCompositeOpCommand(node, node->compositeOpId(), COMPOSITE_OVER));
                 }
 
                 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::inheritAlpha, false).toBool()) {
 
                     KisBaseNode::PropertyList props = node->sectionModelProperties();
                     KisLayerPropertiesIcons::setNodeProperty(&props,
                                                              KisLayerPropertiesIcons::inheritAlpha,
                                                              false);
 
                     addCommand(new KisNodePropertyListCommand(node, props));
                 }
             }
 
             m_info->image->enableDirtyRequests();
         }
 
     private:
         MergeMultipleInfoSP m_info;
     };
 
     struct DisablePassThroughForHeadsOnly : public KisCommandUtils::AggregateCommand {
         DisablePassThroughForHeadsOnly(MergeDownInfoBaseSP info, bool skipIfDstIsGroup = false)
             : m_info(info),
               m_skipIfDstIsGroup(skipIfDstIsGroup)
         {
         }
 
         void populateChildCommands() override {
             if (m_skipIfDstIsGroup &&
                 m_info->dstLayer() &&
                 m_info->dstLayer()->inherits("KisGroupLayer")) {
 
                 return;
             }
 
 
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::passThrough, false).toBool()) {
 
                     KisBaseNode::PropertyList props = node->sectionModelProperties();
                     KisLayerPropertiesIcons::setNodeProperty(&props,
                                                              KisLayerPropertiesIcons::passThrough,
                                                              false);
 
                     addCommand(new KisNodePropertyListCommand(node, props));
                 }
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         bool m_skipIfDstIsGroup;
     };
 
     struct RefreshHiddenAreas : public KUndo2Command {
         RefreshHiddenAreas(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             KisImageAnimationInterface *interface = m_info->image->animationInterface();
             const QRect preparedRect = !interface->externalFrameActive() ?
                 m_info->image->bounds() : QRect();
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 refreshHiddenAreaAsync(node, preparedRect);
             }
         }
 
     private:
         QRect realNodeExactBounds(KisNodeSP rootNode, QRect currentRect = QRect()) {
             KisNodeSP node = rootNode->firstChild();
 
             while(node) {
                 currentRect |= realNodeExactBounds(node, currentRect);
                 node = node->nextSibling();
             }
 
             // TODO: it would be better to count up changeRect inside
             // node's extent() method
             currentRect |= rootNode->projectionPlane()->changeRect(rootNode->exactBounds());
 
             return currentRect;
         }
 
         void refreshHiddenAreaAsync(KisNodeSP rootNode, const QRect &preparedArea) {
             QRect realNodeRect = realNodeExactBounds(rootNode);
             if (!preparedArea.contains(realNodeRect)) {
 
                 QRegion dirtyRegion = realNodeRect;
                 dirtyRegion -= preparedArea;
 
                 foreach(const QRect &rc, dirtyRegion.rects()) {
                     m_info->image->refreshGraphAsync(rootNode, rc, realNodeRect);
                 }
             }
         }
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct RefreshDelayedUpdateLayers : public KUndo2Command {
         RefreshDelayedUpdateLayers(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 forceAllDelayedNodesUpdate(node);
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct KeepMergedNodesSelected : public KisCommandUtils::AggregateCommand {
         KeepMergedNodesSelected(MergeDownInfoSP info, bool finalizing)
             : m_singleInfo(info),
               m_finalizing(finalizing) {}
 
         KeepMergedNodesSelected(MergeMultipleInfoSP info, KisNodeSP putAfter, bool finalizing)
             : m_multipleInfo(info),
               m_finalizing(finalizing),
               m_putAfter(putAfter) {}
 
         void populateChildCommands() override {
             KisNodeSP prevNode;
             KisNodeSP nextNode;
             KisNodeList prevSelection;
             KisNodeList nextSelection;
             KisImageSP image;
 
             if (m_singleInfo) {
                 prevNode = m_singleInfo->currLayer;
                 nextNode = m_singleInfo->dstNode;
                 image = m_singleInfo->image;
             } else if (m_multipleInfo) {
                 prevNode = m_putAfter;
                 nextNode = m_multipleInfo->dstNode;
                 prevSelection = m_multipleInfo->allSrcNodes();
                 image = m_multipleInfo->image;
             }
 
             if (!m_finalizing) {
                 addCommand(new KeepNodesSelectedCommand(prevSelection, KisNodeList(),
                                                         prevNode, KisNodeSP(),
                                                         image, false));
             } else {
                 addCommand(new KeepNodesSelectedCommand(KisNodeList(), nextSelection,
                                                         KisNodeSP(), nextNode,
                                                         image, true));
             }
         }
 
     private:
         MergeDownInfoSP m_singleInfo;
         MergeMultipleInfoSP m_multipleInfo;
         bool m_finalizing;
         KisNodeSP m_putAfter;
     };
 
     struct CreateMergedLayer : public KisCommandUtils::AggregateCommand {
         CreateMergedLayer(MergeDownInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
             m_info->dstNode = m_info->currLayer->createMergedLayerTemplate(m_info->prevLayer);
 
             if (m_info->frames.size() > 0) {
                 m_info->dstNode->enableAnimation();
                 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             }
 
             m_info->dstNode->setUseInTimeline(m_info->useInTimeline);
 
             KisPaintLayer *dstPaintLayer = qobject_cast<KisPaintLayer*>(m_info->dstNode.data());
             if (dstPaintLayer) {
                 dstPaintLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
             }
         }
 
     private:
         MergeDownInfoSP m_info;
     };
 
     struct CreateMergedLayerMultiple : public KisCommandUtils::AggregateCommand {
         CreateMergedLayerMultiple(MergeMultipleInfoSP info, const QString name = QString() )
             : m_info(info),
               m_name(name) {}
 
         void populateChildCommands() override {
             QString mergedLayerName;
 
             if (m_name.isEmpty()){
                 const QString mergedLayerSuffix = i18n("Merged");
                 mergedLayerName = m_info->mergedNodes.first()->name();
 
                 if (!mergedLayerName.endsWith(mergedLayerSuffix)) {
                     mergedLayerName = QString("%1 %2")
                         .arg(mergedLayerName).arg(mergedLayerSuffix);
                 }
             } else {
                 mergedLayerName = m_name;
             }
 
             KisPaintLayer *dstPaintLayer = new KisPaintLayer(m_info->image, mergedLayerName, OPACITY_OPAQUE_U8);
             m_info->dstNode = dstPaintLayer;
 
             if (m_info->frames.size() > 0) {
                 m_info->dstNode->enableAnimation();
                 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             }
 
 
             auto channelFlagsLazy = [](KisNodeSP node) {
                 KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
                 return layer ? layer->channelFlags() : QBitArray();
             };
 
             QString compositeOpId;
             QBitArray channelFlags;
             bool compositionVaries = false;
             bool isFirstCycle = true;
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 if (isFirstCycle) {
                     compositeOpId = node->compositeOpId();
                     channelFlags = channelFlagsLazy(node);
                     isFirstCycle = false;
                 } else if (compositeOpId != node->compositeOpId() ||
                            channelFlags != channelFlagsLazy(node)) {
                     compositionVaries = true;
                     break;
                 }
 
                 KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
                 if (layer && layer->layerStyle()) {
                     compositionVaries = true;
                     break;
                 }
             }
 
             if (!compositionVaries) {
                 if (!compositeOpId.isEmpty()) {
                     m_info->dstNode->setCompositeOpId(compositeOpId);
                 }
                 if (m_info->dstLayer() && !channelFlags.isEmpty()) {
                     m_info->dstLayer()->setChannelFlags(channelFlags);
                 }
             }
 
             m_info->nodesCompositingVaries = compositionVaries;
 
             m_info->dstNode->setUseInTimeline(m_info->useInTimeline);
             dstPaintLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
         }
 
     private:
         MergeMultipleInfoSP m_info;
         QString m_name;
     };
 
     struct MergeLayers : public KisCommandUtils::AggregateCommand {
         MergeLayers(MergeDownInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
             m_info->currLayer->fillMergedLayerTemplate(m_info->dstLayer(), m_info->prevLayer);
         }
 
     private:
         MergeDownInfoSP m_info;
     };
 
     struct MergeLayersMultiple : public KisCommandUtils::AggregateCommand {
         MergeLayersMultiple(MergeMultipleInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             KisPainter gc(m_info->dstNode->paintDevice());
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 QRect rc = node->exactBounds() | m_info->image->bounds();
                 node->projectionPlane()->apply(&gc, rc);
             }
         }
 
     private:
         MergeMultipleInfoSP m_info;
     };
 
     struct MergeMetaData : public KUndo2Command {
         MergeMetaData(MergeDownInfoSP info, const KisMetaData::MergeStrategy* strategy)
             : m_info(info),
               m_strategy(strategy) {}
 
         void redo() override {
             QRect layerProjectionExtent = m_info->currLayer->projection()->extent();
             QRect prevLayerProjectionExtent = m_info->prevLayer->projection()->extent();
             int prevLayerArea = prevLayerProjectionExtent.width() * prevLayerProjectionExtent.height();
             int layerArea = layerProjectionExtent.width() * layerProjectionExtent.height();
 
             QList<double> scores;
             double norm = qMax(prevLayerArea, layerArea);
             scores.append(prevLayerArea / norm);
             scores.append(layerArea / norm);
 
             QList<const KisMetaData::Store*> srcs;
             srcs.append(m_info->prevLayer->metaData());
             srcs.append(m_info->currLayer->metaData());
             m_strategy->merge(m_info->dstLayer()->metaData(), srcs, scores);
         }
 
     private:
         MergeDownInfoSP m_info;
         const KisMetaData::MergeStrategy *m_strategy;
     };
 
     KeepNodesSelectedCommand::KeepNodesSelectedCommand(const KisNodeList &selectedBefore,
                                                        const KisNodeList &selectedAfter,
                                                        KisNodeSP activeBefore,
                                                        KisNodeSP activeAfter,
                                                        KisImageSP image,
                                                        bool finalize, KUndo2Command *parent)
         : FlipFlopCommand(finalize, parent),
           m_selectedBefore(selectedBefore),
           m_selectedAfter(selectedAfter),
           m_activeBefore(activeBefore),
           m_activeAfter(activeAfter),
           m_image(image)
     {
     }
 
     void KeepNodesSelectedCommand::end() {
         KisImageSignalType type;
         if (isFinalizing()) {
             type = ComplexNodeReselectionSignal(m_activeAfter, m_selectedAfter);
         } else {
             type = ComplexNodeReselectionSignal(m_activeBefore, m_selectedBefore);
         }
         m_image->signalRouter()->emitNotification(type);
     }
 
     KisLayerSP constructDefaultLayer(KisImageSP image) {
         return new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
     }
 
     RemoveNodeHelper::~RemoveNodeHelper()
     {
     }
 
     /**
      * The removal of two nodes in one go may be a bit tricky, because one
      * of them may be the clone of another. If we remove the source of a
      * clone layer, it will reincarnate into a paint layer. In this case
      * the pointer to the second layer will be lost.
      *
      * That's why we need to care about the order of the nodes removal:
      * the clone --- first, the source --- last.
      */
     void RemoveNodeHelper::safeRemoveMultipleNodes(KisNodeList nodes, KisImageSP image) {
         const bool lastLayer = scanForLastLayer(image, nodes);
 
         while (!nodes.isEmpty()) {
             KisNodeList::iterator it = nodes.begin();
 
             while (it != nodes.end()) {
                 if (!checkIsSourceForClone(*it, nodes)) {
                     KisNodeSP node = *it;
                     addCommandImpl(new KisImageLayerRemoveCommand(image, node, false, true));
                     it = nodes.erase(it);
                 } else {
                     ++it;
                 }
             }
         }
 
         if (lastLayer) {
             KisLayerSP newLayer = constructDefaultLayer(image);
             addCommandImpl(new KisImageLayerAddCommand(image, newLayer,
                                                        image->root(),
                                                        KisNodeSP(),
                                                        false, false));
         }
     }
 
     bool RemoveNodeHelper::checkIsSourceForClone(KisNodeSP src, const KisNodeList &nodes) {
         foreach (KisNodeSP node, nodes) {
             if (node == src) continue;
 
             KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
 
             if (clone && KisNodeSP(clone->copyFrom()) == src) {
                 return true;
             }
         }
 
         return false;
     }
 
     bool RemoveNodeHelper::scanForLastLayer(KisImageWSP image, KisNodeList nodesToRemove) {
         bool removeLayers = false;
         Q_FOREACH(KisNodeSP nodeToRemove, nodesToRemove) {
             if (qobject_cast<KisLayer*>(nodeToRemove.data())) {
                 removeLayers = true;
                 break;
             }
         }
         if (!removeLayers) return false;
 
         bool lastLayer = true;
         KisNodeSP node = image->root()->firstChild();
         while (node) {
             if (!nodesToRemove.contains(node) &&
                 qobject_cast<KisLayer*>(node.data())) {
 
                 lastLayer = false;
                 break;
             }
             node = node->nextSibling();
         }
 
         return lastLayer;
     }
 
     SimpleRemoveLayers::SimpleRemoveLayers(const KisNodeList &nodes,
                                            KisImageSP image)
         : m_nodes(nodes),
           m_image(image)
     {
     }
 
     void SimpleRemoveLayers::populateChildCommands() {
         if (m_nodes.isEmpty()) return;
         safeRemoveMultipleNodes(m_nodes, m_image);
     }
 
     void SimpleRemoveLayers::addCommandImpl(KUndo2Command *cmd) {
         addCommand(cmd);
     }
 
     struct InsertNode : public KisCommandUtils::AggregateCommand {
         InsertNode(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info), m_putAfter(putAfter) {}
 
         void populateChildCommands() override {
             addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            m_putAfter->parent(),
                                                            m_putAfter,
                                                            true, false));
 
         }
 
     private:
         virtual void addCommandImpl(KUndo2Command *cmd) {
             addCommand(cmd);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
 
     struct CleanUpNodes : private RemoveNodeHelper, public KisCommandUtils::AggregateCommand {
         CleanUpNodes(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info), m_putAfter(putAfter) {}
 
         static void findPerfectParent(KisNodeList nodesToDelete, KisNodeSP &putAfter, KisNodeSP &parent) {
             if (!putAfter) {
                 putAfter = nodesToDelete.last();
             }
 
             // Add the new merged node on top of the active node -- checking
             // whether the parent is going to be deleted
             parent = putAfter->parent();
             while (parent && nodesToDelete.contains(parent)) {
                 parent = parent->parent();
             }
         }
 
         void populateChildCommands() override {
             KisNodeList nodesToDelete = m_info->allSrcNodes();
 
             KisNodeSP parent;
             findPerfectParent(nodesToDelete, m_putAfter, parent);
 
             if (!parent) {
                 KisNodeSP oldRoot = m_info->image->root();
                 KisNodeSP newRoot(new KisGroupLayer(m_info->image, "root", OPACITY_OPAQUE_U8));
 
                 addCommand(new KisImageLayerAddCommand(m_info->image,
                                                        m_info->dstNode,
                                                        newRoot,
                                                        KisNodeSP(),
                                                        true, false));
                 addCommand(new KisImageChangeLayersCommand(m_info->image, oldRoot, newRoot));
 
             }
             else {
                 if (parent == m_putAfter->parent()) {
                     addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            parent,
                                                            m_putAfter,
                                                            true, false));
                 }
                 else {
                     addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            parent,
                                                            parent->lastChild(),
                                                            true, false));
                 }
 
                 /**
                  * We can merge selection masks, in this case dstLayer is not defined!
                  */
                 if (m_info->dstLayer()) {
                     reparentSelectionMasks(m_info->image,
                                            m_info->dstLayer(),
                                            m_info->selectionMasks);
                 }
 
                 KisNodeList safeNodesToDelete = m_info->allSrcNodes();
                 for (KisNodeList::iterator it = safeNodesToDelete.begin(); it != safeNodesToDelete.end(); ++it) {
                     KisNodeSP node = *it;
                     if (node->userLocked() && node->visible()) {
                         addCommand(new KisImageChangeVisibilityCommand(false, node));
                     }
                 }
 
                 KritaUtils::filterContainer<KisNodeList>(safeNodesToDelete, [this](KisNodeSP node) {
                   return !node->userLocked();
                 });
                 safeRemoveMultipleNodes(safeNodesToDelete, m_info->image);
             }
 
 
         }
 
     private:
         void addCommandImpl(KUndo2Command *cmd) override {
             addCommand(cmd);
         }
 
         void reparentSelectionMasks(KisImageSP image,
                                     KisLayerSP newLayer,
                                     const QVector<KisSelectionMaskSP> &selectionMasks) {
 
             KIS_SAFE_ASSERT_RECOVER_RETURN(newLayer);
 
             foreach (KisSelectionMaskSP mask, selectionMasks) {
                 addCommand(new KisImageLayerMoveCommand(image, mask, newLayer, newLayer->lastChild()));
                 addCommand(new KisActivateSelectionMaskCommand(mask, false));
             }
         }
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
     SwitchFrameCommand::SharedStorage::~SharedStorage() {
     }
 
     SwitchFrameCommand::SwitchFrameCommand(KisImageSP image, int time, bool finalize, SharedStorageSP storage)
         : FlipFlopCommand(finalize),
           m_image(image),
           m_newTime(time),
           m_storage(storage) {}
 
     SwitchFrameCommand::~SwitchFrameCommand() {}
 
     void SwitchFrameCommand::init() {
         KisImageAnimationInterface *interface = m_image->animationInterface();
         const int currentTime = interface->currentTime();
         if (currentTime == m_newTime) {
             m_storage->value = m_newTime;
             return;
         }
 
         interface->image()->disableUIUpdates();
         interface->saveAndResetCurrentTime(m_newTime, &m_storage->value);
     }
 
     void SwitchFrameCommand::end() {
         KisImageAnimationInterface *interface = m_image->animationInterface();
         const int currentTime = interface->currentTime();
         if (currentTime == m_storage->value) {
             return;
         }
 
         interface->restoreCurrentTime(&m_storage->value);
         interface->image()->enableUIUpdates();
     }
 
     struct AddNewFrame : public KisCommandUtils::AggregateCommand {
         AddNewFrame(MergeDownInfoBaseSP info, int frame) : m_info(info), m_frame(frame) {}
 
         void populateChildCommands() override {
             KUndo2Command *cmd = new KisCommandUtils::SkipFirstRedoWrapper();
             KisKeyframeChannel *channel = m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id());
             KisKeyframeSP keyframe = channel->addKeyframe(m_frame, cmd);
 
             applyKeyframeColorLabel(keyframe);
 
             addCommand(cmd);
         }
 
         void applyKeyframeColorLabel(KisKeyframeSP dstKeyframe) {
             Q_FOREACH(KisNodeSP srcNode, m_info->allSrcNodes()) {
                 Q_FOREACH(KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
                     KisKeyframeSP keyframe = channel->keyframeAt(m_frame);
                     if (!keyframe.isNull() && keyframe->colorLabel() != 0) {
                         dstKeyframe->setColorLabel(keyframe->colorLabel());
                         return;
                     }
                 }
             }
 
             dstKeyframe->setColorLabel(0);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         int m_frame;
     };
 
     QSet<int> fetchLayerFrames(KisNodeSP node) {
         KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!channel) return QSet<int>();
 
         return channel->allKeyframeIds();
     }
 
     QSet<int> fetchLayerFramesRecursive(KisNodeSP rootNode) {
         QSet<int> frames = fetchLayerFrames(rootNode);
 
         KisNodeSP node = rootNode->firstChild();
         while(node) {
             frames |= fetchLayerFramesRecursive(node);
             node = node->nextSibling();
         }
 
         return frames;
     }
 
     void updateFrameJobs(FrameJobs *jobs, KisNodeSP node) {
         QSet<int> frames = fetchLayerFrames(node);
 
         if (frames.isEmpty()) {
             (*jobs)[0].insert(node);
         } else {
             foreach (int frame, frames) {
                 (*jobs)[frame].insert(node);
             }
         }
     }
 
     void updateFrameJobsRecursive(FrameJobs *jobs, KisNodeSP rootNode) {
         updateFrameJobs(jobs, rootNode);
 
         KisNodeSP node = rootNode->firstChild();
         while(node) {
             updateFrameJobsRecursive(jobs, node);
             node = node->nextSibling();
         }
     }
 
     void mergeDown(KisImageSP image, KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
     {
         if (!layer->prevSibling()) return;
 
         // XXX: this breaks if we allow free mixing of masks and layers
         KisLayerSP prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
         if (!prevLayer) return;
 
         if (!layer->visible() && !prevLayer->visible()) {
             return;
         }
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            kundo2_i18n("Merge Down"));
 
         if (layer->visible() && prevLayer->visible()) {
             MergeDownInfoSP info(new MergeDownInfo(image, prevLayer, layer));
 
             // disable key strokes on all colorize masks, all onion skins on
             // paint layers and wait until update is finished with a barrier
             applicator.applyCommand(new DisableColorizeKeyStrokes(info));
             applicator.applyCommand(new DisableOnionSkins(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             applicator.applyCommand(new KeepMergedNodesSelected(info, false));
             applicator.applyCommand(new FillSelectionMasks(info));
             applicator.applyCommand(new CreateMergedLayer(info), KisStrokeJobData::BARRIER);
 
             // NOTE: shape layer may have emitted spontaneous jobs during layer creation,
             //       wait for them to complete!
             applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             // in two-layer mode we disable pass trhough only when the destination layer
             // is not a group layer
             applicator.applyCommand(new DisablePassThroughForHeadsOnly(info, true));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             if (info->frames.size() > 0) {
                 foreach (int frame, info->frames) {
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                     applicator.applyCommand(new AddNewFrame(info, frame));
                     applicator.applyCommand(new RefreshHiddenAreas(info));
                     applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                     applicator.applyCommand(new MergeLayers(info), KisStrokeJobData::BARRIER);
 
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
                 }
             } else {
                 applicator.applyCommand(new RefreshHiddenAreas(info));
                 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                 applicator.applyCommand(new MergeLayers(info), KisStrokeJobData::BARRIER);
             }
 
             applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new CleanUpNodes(info, layer),
                                     KisStrokeJobData::SEQUENTIAL,
                                     KisStrokeJobData::EXCLUSIVE);
             applicator.applyCommand(new KeepMergedNodesSelected(info, true));
         } else if (layer->visible()) {
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  layer, KisNodeSP(),
                                                                  image, false));
 
             applicator.applyCommand(
                 new SimpleRemoveLayers(KisNodeList() << prevLayer,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
 
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  KisNodeSP(), layer,
                                                                  image, true));
         } else if (prevLayer->visible()) {
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  layer, KisNodeSP(),
                                                                  image, false));
 
             applicator.applyCommand(
                 new SimpleRemoveLayers(KisNodeList() << layer,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
 
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  KisNodeSP(), prevLayer,
                                                                  image, true));
         }
 
         applicator.end();
     }
 
     bool checkIsChildOf(KisNodeSP node, const KisNodeList &parents)
     {
         KisNodeList nodeParents;
 
         KisNodeSP parent = node->parent();
         while (parent) {
             nodeParents << parent;
             parent = parent->parent();
         }
 
         foreach(KisNodeSP perspectiveParent, parents) {
             if (nodeParents.contains(perspectiveParent)) {
                 return true;
             }
         }
 
         return false;
     }
 
     bool checkIsCloneOf(KisNodeSP node, const KisNodeList &nodes)
     {
         bool result = false;
 
         KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
         if (clone) {
             KisNodeSP cloneSource = KisNodeSP(clone->copyFrom());
 
             Q_FOREACH(KisNodeSP subtree, nodes) {
                 result =
                     recursiveFindNode(subtree,
                                       [cloneSource](KisNodeSP node) -> bool
                                       {
                                           return node == cloneSource;
                                       });
 
                 if (!result) {
                     result = checkIsCloneOf(cloneSource, nodes);
                 }
 
                 if (result) {
                     break;
                 }
             }
         }
 
         return result;
     }
 
     void filterMergableNodes(KisNodeList &nodes, bool allowMasks)
     {
         KisNodeList::iterator it = nodes.begin();
 
         while (it != nodes.end()) {
             if ((!allowMasks && !qobject_cast<KisLayer*>(it->data())) ||
                 checkIsChildOf(*it, nodes)) {
                 //dbgImage << "Skipping node" << ppVar((*it)->name());
                 it = nodes.erase(it);
             } else {
                 ++it;
             }
         }
     }
 
     void sortMergableNodes(KisNodeSP root, KisNodeList &inputNodes, KisNodeList &outputNodes)
     {
         KisNodeList::iterator it = std::find(inputNodes.begin(), inputNodes.end(), root);
 
         if (it != inputNodes.end()) {
             outputNodes << *it;
             inputNodes.erase(it);
         }
 
         if (inputNodes.isEmpty()) {
             return;
         }
 
         KisNodeSP child = root->firstChild();
         while (child) {
             sortMergableNodes(child, inputNodes, outputNodes);
             child = child->nextSibling();
         }
 
         /**
          * By the end of recursion \p inputNodes must be empty
          */
         KIS_ASSERT_RECOVER_NOOP(root->parent() || inputNodes.isEmpty());
     }
 
     KisNodeList sortMergableNodes(KisNodeSP root, KisNodeList nodes)
     {
         KisNodeList result;
         sortMergableNodes(root, nodes, result);
         return result;
     }
 
     KisNodeList sortAndFilterMergableInternalNodes(KisNodeList nodes, bool allowMasks)
     {
         KIS_ASSERT_RECOVER(!nodes.isEmpty()) { return nodes; }
 
         KisNodeSP root;
         Q_FOREACH(KisNodeSP node, nodes) {
             KisNodeSP localRoot = node;
             while (localRoot->parent()) {
                 localRoot = localRoot->parent();
             }
 
             if (!root) {
                 root = localRoot;
             }
             KIS_ASSERT_RECOVER(root == localRoot) { return nodes; }
         }
 
         KisNodeList result;
         sortMergableNodes(root, nodes, result);
         filterMergableNodes(result, allowMasks);
         return result;
     }
 
     void addCopyOfNameTag(KisNodeSP node)
     {
         const QString prefix = i18n("Copy of");
         QString newName = node->name();
         if (!newName.startsWith(prefix)) {
             newName = QString("%1 %2").arg(prefix).arg(newName);
             node->setName(newName);
         }
     }
 
     KisNodeList findNodesWithProps(KisNodeSP root, const KoProperties &props, bool excludeRoot)
     {
         KisNodeList nodes;
 
         if ((!excludeRoot || root->parent()) && root->check(props)) {
             nodes << root;
         }
 
         KisNodeSP node = root->firstChild();
         while (node) {
             nodes += findNodesWithProps(node, props, excludeRoot);
             node = node->nextSibling();
         }
 
         return nodes;
     }
 
     KisNodeList filterInvisibleNodes(const KisNodeList &nodes, KisNodeList *invisibleNodes, KisNodeSP *putAfter)
     {
         KIS_ASSERT_RECOVER(invisibleNodes) { return nodes; }
         KIS_ASSERT_RECOVER(putAfter) { return nodes; }
 
         KisNodeList visibleNodes;
         int putAfterIndex = -1;
 
         Q_FOREACH(KisNodeSP node, nodes) {
             if (node->visible() || node->userLocked()) {
                 visibleNodes << node;
             } else {
                 *invisibleNodes << node;
 
                 if (node == *putAfter) {
                     putAfterIndex = visibleNodes.size() - 1;
                 }
             }
         }
 
         if (!visibleNodes.isEmpty() && putAfterIndex >= 0) {
             putAfterIndex = qBound(0, putAfterIndex, visibleNodes.size() - 1);
             *putAfter = visibleNodes[putAfterIndex];
         }
 
         return visibleNodes;
     }
 
     void changeImageDefaultProjectionColor(KisImageSP image, const KoColor &color)
     {
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image,
                                            image->root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            emitSignals,
                                            kundo2_i18n("Change projection color"),
                                            0,
                                            142857 + 1);
         applicator.applyCommand(new KisChangeProjectionColorCommand(image, color), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
     void mergeMultipleLayersImpl(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter,
                                            bool flattenSingleLayer, const KUndo2MagicString &actionName,
                                            bool cleanupNodes = true, const QString layerName = QString())
     {
         if (!putAfter) {
             putAfter = mergedNodes.first();
         }
 
         filterMergableNodes(mergedNodes);
         {
             KisNodeList tempNodes;
             std::swap(mergedNodes, tempNodes);
             sortMergableNodes(image->root(), tempNodes, mergedNodes);
         }
 
         if (mergedNodes.size() <= 1 &&
             (!flattenSingleLayer && mergedNodes.size() == 1)) return;
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
         emitSignals << ComplexNodeReselectionSignal(KisNodeSP(), KisNodeList(), KisNodeSP(), mergedNodes);
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            actionName);
 
 
         KisNodeList originalNodes = mergedNodes;
         KisNodeList invisibleNodes;
         mergedNodes = filterInvisibleNodes(originalNodes, &invisibleNodes, &putAfter);
 
         if (!invisibleNodes.isEmpty()) {
             applicator.applyCommand(
                 new SimpleRemoveLayers(invisibleNodes,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
         }
 
         if (mergedNodes.size() > 1 || invisibleNodes.isEmpty()) {
             MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes));
 
             // disable key strokes on all colorize masks, all onion skins on
             // paint layers and wait until update is finished with a barrier
             applicator.applyCommand(new DisableColorizeKeyStrokes(info));
             applicator.applyCommand(new DisableOnionSkins(info));
             applicator.applyCommand(new DisablePassThroughForHeadsOnly(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, false));
             applicator.applyCommand(new FillSelectionMasks(info));
             applicator.applyCommand(new CreateMergedLayerMultiple(info, layerName), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new DisableExtraCompositing(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             if (info->frames.size() > 0) {
                 foreach (int frame, info->frames) {
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                     applicator.applyCommand(new AddNewFrame(info, frame));
                     applicator.applyCommand(new RefreshHiddenAreas(info));
                     applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                     applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
 
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
                 }
             } else {
                 applicator.applyCommand(new RefreshHiddenAreas(info));
                 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                 applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
             }
 
             //applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
             if (cleanupNodes){
                 applicator.applyCommand(new CleanUpNodes(info, putAfter),
                                             KisStrokeJobData::SEQUENTIAL,
                                         KisStrokeJobData::EXCLUSIVE);
             } else {
                 applicator.applyCommand(new InsertNode(info, putAfter),
                                             KisStrokeJobData::SEQUENTIAL,
                                         KisStrokeJobData::EXCLUSIVE);
             }
             applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, true));
         }
 
         applicator.end();
 
     }
 
     void mergeMultipleLayers(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
     {
         mergeMultipleLayersImpl(image, mergedNodes, putAfter, false, kundo2_i18n("Merge Selected Nodes"));
     }
 
     void newLayerFromVisible(KisImageSP image, KisNodeSP putAfter)
     {
         KisNodeList mergedNodes;
         mergedNodes << image->root();
 
         mergeMultipleLayersImpl(image, mergedNodes, putAfter, true, kundo2_i18n("New From Visible"), false, i18nc("New layer created from all the visible layers", "Visible"));
     }
 
     struct MergeSelectionMasks : public KisCommandUtils::AggregateCommand {
         MergeSelectionMasks(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info),
               m_putAfter(putAfter){}
 
         void populateChildCommands() override {
             KisNodeSP parent;
             CleanUpNodes::findPerfectParent(m_info->allSrcNodes(), m_putAfter, parent);
 
             KisLayerSP parentLayer;
             do {
                 parentLayer = qobject_cast<KisLayer*>(parent.data());
 
                 parent = parent->parent();
             } while(!parentLayer && parent);
 
             KisSelectionSP selection = new KisSelection();
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 KisMaskSP mask = dynamic_cast<KisMask*>(node.data());
                 if (!mask) continue;
 
                 selection->pixelSelection()->applySelection(
                     mask->selection()->pixelSelection(), SELECTION_ADD);
             }
 
             KisSelectionMaskSP mergedMask = new KisSelectionMask(m_info->image);
             mergedMask->initSelection(parentLayer);
             mergedMask->setSelection(selection);
 
             m_info->dstNode = mergedMask;
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
     struct ActivateSelectionMask : public KisCommandUtils::AggregateCommand {
         ActivateSelectionMask(MergeDownInfoBaseSP info)
             : m_info(info) {}
 
         void populateChildCommands() override {
             KisSelectionMaskSP mergedMask = dynamic_cast<KisSelectionMask*>(m_info->dstNode.data());
             addCommand(new KisActivateSelectionMaskCommand(mergedMask, true));
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     bool tryMergeSelectionMasks(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
     {
         QList<KisSelectionMaskSP> selectionMasks;
 
         for (auto it = mergedNodes.begin(); it != mergedNodes.end(); /*noop*/) {
             KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(it->data());
             if (!mask) {
                 it = mergedNodes.erase(it);
             } else {
                 selectionMasks.append(mask);
                 ++it;
             }
         }
 
         if (mergedNodes.isEmpty()) return false;
 
         KisLayerSP parentLayer = qobject_cast<KisLayer*>(selectionMasks.first()->parent().data());
         KIS_ASSERT_RECOVER(parentLayer) { return 0; }
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            kundo2_i18n("Merge Selection Masks"));
 
         MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes));
 
 
         applicator.applyCommand(new MergeSelectionMasks(info, putAfter));
         applicator.applyCommand(new CleanUpNodes(info, putAfter),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new ActivateSelectionMask(info));
         applicator.end();
 
         return true;
     }
 
     void flattenLayer(KisImageSP image, KisLayerSP layer)
     {
         if (!layer->childCount() && !layer->layerStyle())
             return;
 
         KisNodeList mergedNodes;
         mergedNodes << layer;
 
         mergeMultipleLayersImpl(image, mergedNodes, layer, true, kundo2_i18n("Flatten Layer"));
     }
 
     void flattenImage(KisImageSP image)
     {
         KisNodeList mergedNodes;
         mergedNodes << image->root();
 
         mergeMultipleLayersImpl(image, mergedNodes, 0, true, kundo2_i18n("Flatten Image"));
     }
 
     KisSimpleUpdateCommand::KisSimpleUpdateCommand(KisNodeList nodes, bool finalize, KUndo2Command *parent)
         : FlipFlopCommand(finalize, parent),
           m_nodes(nodes)
     {
     }
     void KisSimpleUpdateCommand::end()
     {
         updateNodes(m_nodes);
     }
     void KisSimpleUpdateCommand::updateNodes(const KisNodeList &nodes)
     {
         Q_FOREACH(KisNodeSP node, nodes) {
             node->setDirty(node->extent());
         }
     }
 
     KisNodeSP recursiveFindNode(KisNodeSP node, std::function<bool(KisNodeSP)> func)
     {
         if (func(node)) {
             return node;
         }
 
         node = node->firstChild();
         while (node) {
             KisNodeSP resultNode = recursiveFindNode(node, func);
             if (resultNode) {
                 return resultNode;
             }
             node = node->nextSibling();
         }
 
         return 0;
     }
 
     KisNodeSP findNodeByUuid(KisNodeSP root, const QUuid &uuid)
     {
         return recursiveFindNode(root,
             [uuid] (KisNodeSP node) {
                 return node->uuid() == uuid;
         });
     }
 
     void forceAllDelayedNodesUpdate(KisNodeSP root)
     {
         KisLayerUtils::recursiveApplyNodes(root,
         [] (KisNodeSP node) {
             KisDelayedUpdateNodeInterface *delayedUpdate =
                     dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
             if (delayedUpdate) {
                 delayedUpdate->forceUpdateTimedNode();
             }
         });
     }
 
 }
diff --git a/libs/image/layerstyles/kis_layer_style_filter_environment.cpp b/libs/image/layerstyles/kis_layer_style_filter_environment.cpp
index f1e7438a56..a8cf6e834e 100644
--- a/libs/image/layerstyles/kis_layer_style_filter_environment.cpp
+++ b/libs/image/layerstyles/kis_layer_style_filter_environment.cpp
@@ -1,134 +1,133 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer_style_filter_environment.h"
 
 #include <QBitArray>
 
 #include "kis_layer.h"
 #include "kis_ls_utils.h"
 
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "kis_painter.h"
 #include "kis_image.h"
 
 #include "krita_utils.h"
 
 #include <boost/random/mersenne_twister.hpp>
 #include "kis_random_accessor_ng.h"
 #include "kis_iterator_ng.h"
-#include "kis_pixel_selection.h"
 
 
 struct Q_DECL_HIDDEN KisLayerStyleFilterEnvironment::Private
 {
     KisLayer *sourceLayer;
     KisPixelSelectionSP cachedRandomSelection;
 
     static KisPixelSelectionSP generateRandomSelection(const QRect &rc);
 };
 
 
 KisPixelSelectionSP
 KisLayerStyleFilterEnvironment::Private::
 generateRandomSelection(const QRect &rc)
 {
     KisPixelSelectionSP selection = new KisPixelSelection();
     KisSequentialIterator dstIt(selection, rc);
 
     boost::mt11213b uniformSource;
 
     if (uniformSource.max() >= 0x00FFFFFF) {
         while (dstIt.nextPixel()) {
             int randValue = uniformSource();
             *dstIt.rawData() = (quint8) randValue;
 
             if (!dstIt.nextPixel()) break;
             randValue >>= 8;
             *dstIt.rawData() = (quint8) randValue;
 
             if (!dstIt.nextPixel()) break;
             randValue >>= 8;
             *dstIt.rawData() = (quint8) randValue;
         }
 
     } else {
         while (dstIt.nextPixel()) {
             *dstIt.rawData() = (quint8) uniformSource();
         }
     }
 
     return selection;
 }
 
 KisLayerStyleFilterEnvironment::KisLayerStyleFilterEnvironment(KisLayer *sourceLayer)
     : m_d(new Private)
 {
     Q_ASSERT(sourceLayer);
     m_d->sourceLayer = sourceLayer;
 }
 
 KisLayerStyleFilterEnvironment::~KisLayerStyleFilterEnvironment()
 {
 }
 
 QRect KisLayerStyleFilterEnvironment::layerBounds() const
 {
     return m_d->sourceLayer ? m_d->sourceLayer->projection()->exactBounds() : QRect();
 }
 
 QRect KisLayerStyleFilterEnvironment::defaultBounds() const
 {
     return m_d->sourceLayer ?
         m_d->sourceLayer->original()->defaultBounds()->bounds() : QRect();
 }
 
 int KisLayerStyleFilterEnvironment::currentLevelOfDetail() const
 {
     return m_d->sourceLayer ?
         m_d->sourceLayer->original()->defaultBounds()->currentLevelOfDetail() : 0;
 }
 
 void KisLayerStyleFilterEnvironment::setupFinalPainter(KisPainter *gc,
                                                        quint8 opacity,
                                                        const QBitArray &channelFlags) const
 {
     Q_ASSERT(m_d->sourceLayer);
     gc->setOpacity(KritaUtils::mergeOpacity(opacity, m_d->sourceLayer->opacity()));
     gc->setChannelFlags(KritaUtils::mergeChannelFlags(channelFlags, m_d->sourceLayer->channelFlags()));
 
 }
 
 KisPixelSelectionSP KisLayerStyleFilterEnvironment::cachedRandomSelection(const QRect &requestedRect) const
 {
     KisPixelSelectionSP selection = m_d->cachedRandomSelection;
 
     QRect existingRect;
 
     if (selection) {
         existingRect = selection->selectedExactRect();
     }
 
     if (!existingRect.contains(requestedRect)) {
         m_d->cachedRandomSelection =
             Private::generateRandomSelection(requestedRect | existingRect);
     }
 
     return m_d->cachedRandomSelection;
 }
diff --git a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
index af55114d3a..ba301df874 100644
--- a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
+++ b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
@@ -1,283 +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 "krita_utils.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")),
       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/lazybrush/kis_lazy_fill_tools.cpp b/libs/image/lazybrush/kis_lazy_fill_tools.cpp
index bdc365ed82..0f04238e1f 100644
--- a/libs/image/lazybrush/kis_lazy_fill_tools.cpp
+++ b/libs/image/lazybrush/kis_lazy_fill_tools.cpp
@@ -1,218 +1,216 @@
 /*
  *  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.
  */
 
 #define BOOST_DISABLE_ASSERTS 1
 
 #include "kis_lazy_fill_tools.h"
 
 #include <numeric>
 #include <boost/limits.hpp>
 
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>
 #include <boost/iterator/counting_iterator.hpp>
 #include <boost/iterator/transform_iterator.hpp>
 
-#include <boost/graph/properties.hpp>
-
 // we use a forked version of the algorithm
 //#include <boost/graph/boykov_kolmogorov_max_flow.hpp>
 #include "patched_boykov_kolmogorov_max_flow.hpp"
 
 #include <boost/graph/iteration_macros.hpp>
 
 #include "lazybrush/kis_lazy_fill_graph.h"
 #include "lazybrush/kis_lazy_fill_capacity_map.h"
 
 #include "kis_sequential_iterator.h"
 #include <floodfill/kis_scanline_fill.h>
 
 #include "krita_utils.h"
 
 namespace KisLazyFillTools {
 
 void normalizeAndInvertAlpha8Device(KisPaintDeviceSP dev, const QRect &rect)
 {
     quint8 maxPixel = std::numeric_limits<quint8>::min();
     quint8 minPixel = std::numeric_limits<quint8>::max();
     KritaUtils::applyToAlpha8Device(dev, rect,
                                     [&minPixel, &maxPixel](quint8 pixel) {
                                         if (pixel > maxPixel) {
                                             maxPixel = pixel;
                                         }
                                         if (pixel < minPixel) {
                                             minPixel = pixel;
                                         }
                                     });
 
     const qreal scale = 255.0 / (maxPixel - minPixel);
     KritaUtils::filterAlpha8Device(dev, rect,
                                    [minPixel, scale](quint8 pixel) {
                                        return pow2(255 - quint8((pixel - minPixel) * scale)) / 255;
                                    });
 }
 
 void normalizeAlpha8Device(KisPaintDeviceSP dev, const QRect &rect)
 {
     quint8 maxPixel = std::numeric_limits<quint8>::min();
     quint8 minPixel = std::numeric_limits<quint8>::max();
     KritaUtils::applyToAlpha8Device(dev, rect,
                                     [&minPixel, &maxPixel](quint8 pixel) {
                                         if (pixel > maxPixel) {
                                             maxPixel = pixel;
                                         }
                                         if (pixel < minPixel) {
                                             minPixel = pixel;
                                         }
                                     });
 
     const qreal scale = 255.0 / (maxPixel - minPixel);
     KritaUtils::filterAlpha8Device(dev, rect,
                                    [minPixel, scale](quint8 pixel) {
                                        return (quint8((pixel - minPixel) * scale));
                                    });
 }
 
 void cutOneWay(const KoColor &color,
                KisPaintDeviceSP src,
                KisPaintDeviceSP colorScribble,
                KisPaintDeviceSP backgroundScribble,
                KisPaintDeviceSP resultDevice,
                KisPaintDeviceSP maskDevice,
                const QRect &boundingRect)
 {
     using namespace boost;
 
     KIS_ASSERT_RECOVER_RETURN(src->pixelSize() == 1);
     KIS_ASSERT_RECOVER_RETURN(colorScribble->pixelSize() == 1);
     KIS_ASSERT_RECOVER_RETURN(backgroundScribble->pixelSize() == 1);
     KIS_ASSERT_RECOVER_RETURN(maskDevice->pixelSize() == 1);
     KIS_ASSERT_RECOVER_RETURN(*resultDevice->colorSpace() == *color.colorSpace());
 
     KisLazyFillCapacityMap capacityMap(src, colorScribble, backgroundScribble, maskDevice, boundingRect);
     KisLazyFillGraph &graph = capacityMap.graph();
 
     std::vector<default_color_type> groups(num_vertices(graph));
     std::vector<int> residual_capacity(num_edges(graph), 0);
 
     std::vector<typename graph_traits<KisLazyFillGraph>::vertices_size_type> distance_vec(num_vertices(graph), 0);
     std::vector<typename graph_traits<KisLazyFillGraph>::edge_descriptor> predecessor_vec(num_vertices(graph));
 
     auto vertexIndexMap = get(boost::vertex_index, graph);
 
     typedef KisLazyFillGraph::vertex_descriptor Vertex;
 
     Vertex s(Vertex::LABEL_A);
     Vertex t(Vertex::LABEL_B);
 
     float maxFlow =
         boykov_kolmogorov_max_flow(graph,
                                    capacityMap,
                                    make_iterator_property_map(&residual_capacity[0], get(boost::edge_index, graph)),
                                    get(boost::edge_reverse, graph),
                                    make_iterator_property_map(&predecessor_vec[0], vertexIndexMap),
                                    make_iterator_property_map(&groups[0], vertexIndexMap),
                                    make_iterator_property_map(&distance_vec[0], vertexIndexMap),
                                    vertexIndexMap,
                                    s,
                                    t);
     Q_UNUSED(maxFlow);
 
     KisSequentialIterator dstIt(resultDevice, graph.rect());
     KisSequentialIterator mskIt(maskDevice, graph.rect());
 
     const int pixelSize = resultDevice->pixelSize();
 
     while (dstIt.nextPixel() && mskIt.nextPixel()) {
         KisLazyFillGraph::vertex_descriptor v(dstIt.x(), dstIt.y());
         long vertex_idx = get(boost::vertex_index, graph, v);
         default_color_type label = groups[vertex_idx];
 
         if (label == black_color) {
             memcpy(dstIt.rawData(), color.data(), pixelSize);
             *mskIt.rawData() = 10 + (int(label) << 4);
         }
     }
 }
 
 QVector<QPoint> splitIntoConnectedComponents(KisPaintDeviceSP dev,
                                              const QRect &boundingRect)
 {
     QVector<QPoint> points;
     const KoColorSpace *cs = dev->colorSpace();
 
     const QRect rect = dev->exactBounds() & boundingRect;
     if (rect.isEmpty()) return points;
 
     /**
      * Please note that since we modify the device inside
      * clearNonZeroComponent() call, we must use a *writable*
      * iterator, for not ending up with a lazy copied old version of a
      * device.
      */
     KisSequentialIterator dstIt(dev, rect);
 
     while (dstIt.nextPixel()) {
         if (cs->opacityU8(dstIt.rawData()) > 0) {
             const QPoint pt(dstIt.x(), dstIt.y());
             points << pt;
 
             KisScanlineFill fill(dev, pt, rect);
             fill.clearNonZeroComponent();
         }
     }
 
     return points;
 }
 
 
 KeyStroke::KeyStroke()
     : isTransparent(false)
 {
 }
 
 KeyStroke::KeyStroke(KisPaintDeviceSP _dev, const KoColor &_color, bool _isTransparent)
     : dev(_dev), color(_color), isTransparent(_isTransparent)
 {
 }
 
 bool operator==(const KeyStroke& t1, const KeyStroke&t2)
 {
     return
         t1.dev == t2.dev &&
         t1.color == t2.color &&
         t1.isTransparent == t2.isTransparent;
 }
 
 FilteringOptions::FilteringOptions(bool _useEdgeDetection, qreal _edgeDetectionSize, qreal _fuzzyRadius, qreal _cleanUpAmount)
     : useEdgeDetection(_useEdgeDetection),
       edgeDetectionSize(_edgeDetectionSize),
       fuzzyRadius(_fuzzyRadius),
       cleanUpAmount(_cleanUpAmount)
 {
 }
 
 bool operator==(const FilteringOptions &t1, const FilteringOptions &t2)
 {
     return t1.useEdgeDetection == t2.useEdgeDetection &&
            qFuzzyCompare(t1.edgeDetectionSize, t2.edgeDetectionSize) &&
            qFuzzyCompare(t1.fuzzyRadius, t2.fuzzyRadius) &&
            qFuzzyCompare(t1.cleanUpAmount, t2.cleanUpAmount);
 }
 
 }
diff --git a/libs/image/tests/kis_gradient_painter_test.cpp b/libs/image/tests/kis_gradient_painter_test.cpp
index 547e8e6ed9..cd2a2fa0ae 100644
--- a/libs/image/tests/kis_gradient_painter_test.cpp
+++ b/libs/image/tests/kis_gradient_painter_test.cpp
@@ -1,337 +1,334 @@
 /*
  *  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_gradient_painter_test.h"
 
 #include <QTest>
 #include "kis_gradient_painter.h"
 
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoCompositeOpRegistry.h>
 
 #include <resources/KoStopGradient.h>
 
 #include "krita_utils.h"
 #include "testutil.h"
 
 
 void KisGradientPainterTest::testSimplifyPath()
 {
     QPolygonF selectionPolygon;
     selectionPolygon << QPointF(100, 100);
     selectionPolygon << QPointF(200, 100);
     selectionPolygon << QPointF(202, 100);
     selectionPolygon << QPointF(200, 200);
     selectionPolygon << QPointF(100, 200);
     selectionPolygon << QPointF(100, 102);
 
     QPainterPath path;
     path.addPolygon(selectionPolygon);
 
     QPainterPath simplifiedPath;
     simplifiedPath = KritaUtils::trySimplifyPath(path, 10.0);
 
     QPainterPath ref;
     ref.moveTo(100,100);
     ref.lineTo(200,100);
     ref.lineTo(200,200);
     ref.lineTo(100,200);
 
     QCOMPARE(simplifiedPath, ref);
 }
 
 void testShapedGradientPainterImpl(const QPolygonF &selectionPolygon,
                                    const QString &testName,
                                    const QPolygonF &selectionErasePolygon = QPolygonF())
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QRect imageRect(0,0,300,300);
 
     KisSelectionSP selection = new KisSelection();
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
 
     KisPainter selPainter(pixelSelection);
     selPainter.setFillStyle(KisPainter::FillStyleForegroundColor);
     selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace()));
     selPainter.paintPolygon(selectionPolygon);
 
     if (!selectionErasePolygon.isEmpty()) {
         selPainter.setCompositeOp(COMPOSITE_ERASE);
         selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace()));
         selPainter.paintPolygon(selectionErasePolygon);
     }
 
     selPainter.end();
 
     pixelSelection->invalidateOutlineCache();
 
     pixelSelection->convertToQImage(0, imageRect).save("sgt_selection.png");
 
     QLinearGradient testGradient;
     testGradient.setColorAt(0.0, Qt::white);
     testGradient.setColorAt(0.5, Qt::green);
     testGradient.setColorAt(1.0, Qt::black);
     testGradient.setSpread(QGradient::ReflectSpread);
     QScopedPointer<KoStopGradient> gradient(
         KoStopGradient::fromQGradient(&testGradient));
 
     KisGradientPainter gc(dev, selection);
     gc.setGradient(gradient.data());
     gc.setGradientShape(KisGradientPainter::GradientShapePolygonal);
 
     gc.paintGradient(selectionPolygon.boundingRect().topLeft(),
                      selectionPolygon.boundingRect().bottomRight(),
                      KisGradientPainter::GradientRepeatNone,
                      0,
                      false,
                      imageRect.x(),
                      imageRect.y(),
                      imageRect.width(),
                      imageRect.height());
 
     QVERIFY(TestUtil::checkQImageExternal(dev->convertToQImage(0, imageRect),
                                           "shaped_gradient",
                                           "fill",
                                           testName, 1, 1, 0));
 }
 
 void KisGradientPainterTest::testShapedGradientPainterRect()
 {
     QPolygonF selectionPolygon;
 
     selectionPolygon << QPointF(100, 100);
     selectionPolygon << QPointF(200, 100);
     selectionPolygon << QPointF(202, 100);
     selectionPolygon << QPointF(200, 200);
     selectionPolygon << QPointF(100, 200);
 
     testShapedGradientPainterImpl(selectionPolygon, "rect_shape");
 }
 
 void KisGradientPainterTest::testShapedGradientPainterRectPierced()
 {
     QPolygonF selectionPolygon;
 
     selectionPolygon << QPointF(100, 100);
     selectionPolygon << QPointF(200, 100);
     selectionPolygon << QPointF(200, 200);
     selectionPolygon << QPointF(100, 200);
 
     QPolygonF selectionErasePolygon;
     selectionErasePolygon << QPointF(150, 150);
     selectionErasePolygon << QPointF(155, 150);
     selectionErasePolygon << QPointF(155, 155);
     selectionErasePolygon << QPointF(150, 155);
 
     testShapedGradientPainterImpl(selectionPolygon, "rect_shape_pierced", selectionErasePolygon);
 }
 
 void KisGradientPainterTest::testShapedGradientPainterNonRegular()
 {
     QPolygonF selectionPolygon;
     selectionPolygon << QPointF(100, 100);
     selectionPolygon << QPointF(200, 120);
     selectionPolygon << QPointF(170, 140);
     selectionPolygon << QPointF(200, 180);
     selectionPolygon << QPointF(30, 220);
 
     testShapedGradientPainterImpl(selectionPolygon, "nonregular_shape");
 }
 
 void KisGradientPainterTest::testShapedGradientPainterNonRegularPierced()
 {
     QPolygonF selectionPolygon;
     selectionPolygon << QPointF(100, 100);
     selectionPolygon << QPointF(200, 120);
     selectionPolygon << QPointF(170, 140);
     selectionPolygon << QPointF(200, 180);
     selectionPolygon << QPointF(30, 220);
 
     QPolygonF selectionErasePolygon;
     selectionErasePolygon << QPointF(150, 150);
     selectionErasePolygon << QPointF(155, 150);
     selectionErasePolygon << QPointF(155, 155);
     selectionErasePolygon << QPointF(150, 155);
 
     testShapedGradientPainterImpl(selectionPolygon, "nonregular_shape_pierced", selectionErasePolygon);
 }
 
 #include "kis_polygonal_gradient_shape_strategy.h"
 
 void KisGradientPainterTest::testFindShapedExtremums()
 {
     QPolygonF selectionPolygon;
     selectionPolygon << QPointF(100, 100);
     selectionPolygon << QPointF(200, 120);
     selectionPolygon << QPointF(170, 140);
     selectionPolygon << QPointF(200, 180);
     selectionPolygon << QPointF(30, 220);
 
     QPolygonF selectionErasePolygon;
     selectionErasePolygon << QPointF(101, 101);
     selectionErasePolygon << QPointF(190, 120);
     selectionErasePolygon << QPointF(160, 140);
     selectionErasePolygon << QPointF(200, 180);
     selectionErasePolygon << QPointF(30, 220);
 
     QPainterPath path;
     path.addPolygon(selectionPolygon);
     path.closeSubpath();
     path.addPolygon(selectionErasePolygon);
     path.closeSubpath();
 
     QPointF center =
         KisPolygonalGradientShapeStrategy::testingCalculatePathCenter(
             4, path, 2.0, true);
 
     dbgKrita << ppVar(center);
 
     QVERIFY(path.contains(center));
 }
 
-#include "krita_utils.h"
-
 void KisGradientPainterTest::testSplitDisjointPaths()
 {
     QPainterPath path;
 
     // small bug: the smaller rect is also merged
     path.addRect(QRectF(323, 123, 4, 4));
     path.addRect(QRectF(300, 100, 50, 50));
     path.addRect(QRectF(320, 120, 10, 10));
 
     path.addRect(QRectF(200, 100, 50, 50));
     path.addRect(QRectF(240, 120, 70, 10));
 
     path.addRect(QRectF(100, 100, 50, 50));
     path.addRect(QRectF(120, 120, 10, 10));
 
     path = path.simplified();
 
     {
         QImage srcImage(450, 250, QImage::Format_ARGB32);
         srcImage.fill(0);
         QPainter gc(&srcImage);
         gc.fillPath(path, Qt::red);
         //srcImage.save("src_disjoint_paths.png");
     }
 
     QList<QPainterPath> result = KritaUtils::splitDisjointPaths(path);
 
     {
         QImage dstImage(450, 250, QImage::Format_ARGB32);
         dstImage.fill(0);
         QPainter gc(&dstImage);
 
         QVector<QBrush> brushes;
         brushes << Qt::red;
         brushes << Qt::green;
         brushes << Qt::blue;
         brushes << Qt::cyan;
         brushes << Qt::magenta;
         brushes << Qt::yellow;
         brushes << Qt::black;
         brushes << Qt::white;
 
         int index = 0;
         Q_FOREACH (const QPainterPath &p, result) {
             gc.fillPath(p, brushes[index]);
             index = (index + 1) % brushes.size();
         }
 
 
         TestUtil::checkQImageExternal(dstImage,
                                       "shaped_gradient",
                                       "test",
                                       "disjoint_paths");
     }
 }
 
-#include "kis_polygonal_gradient_shape_strategy.h"
 #include "kis_cached_gradient_shape_strategy.h"
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/variance.hpp>
 #include <boost/accumulators/statistics/min.hpp>
 #include <boost/accumulators/statistics/max.hpp>
 
 using namespace boost::accumulators;
 
 void KisGradientPainterTest::testCachedStrategy()
 {
     QPolygonF selectionPolygon;
     selectionPolygon << QPointF(100, 100);
     selectionPolygon << QPointF(200, 120);
     selectionPolygon << QPointF(170, 140);
     selectionPolygon << QPointF(200, 180);
     selectionPolygon << QPointF(30, 220);
 
     QPainterPath selectionPath;
     selectionPath.addPolygon(selectionPolygon);
 
     QRect rc = selectionPolygon.boundingRect().toAlignedRect();
 
     KisGradientShapeStrategy *strategy =
         new KisPolygonalGradientShapeStrategy(selectionPath, 2.0);
 
     KisCachedGradientShapeStrategy cached(rc, 4, 4, strategy);
 
     accumulator_set<qreal, stats<tag::variance, tag::max, tag::min> > accum;
     const qreal maxRelError = 5.0 / 256;
 
 
     for (int y = rc.y(); y <= rc.bottom(); y++) {
         for (int x = rc.x(); x <= rc.right(); x++) {
             if (!selectionPolygon.containsPoint(QPointF(x, y), Qt::OddEvenFill)) continue;
 
             qreal ref = strategy->valueAt(x, y);
             qreal value = cached.valueAt(x, y);
 
             if (ref == 0.0) continue;
 
             qreal relError = (ref - value)/* / ref*/;
             accum(relError);
 
             if (relError > maxRelError) {
                 //dbgKrita << ppVar(x) << ppVar(y) << ppVar(value) << ppVar(ref) << ppVar(relError);
             }
         }
     }
 
     dbgKrita << ppVar(count(accum));
     dbgKrita << ppVar(mean(accum));
     dbgKrita << ppVar(variance(accum));
     dbgKrita << ppVar((min)(accum));
     dbgKrita << ppVar((max)(accum));
 
     qreal varError = variance(accum);
     QVERIFY(varError < maxRelError);
 
     qreal maxError = qMax(qAbs((min)(accum)), qAbs((max)(accum)));
     QVERIFY(maxError < 2 * maxRelError);
 }
 
 QTEST_MAIN(KisGradientPainterTest)
diff --git a/libs/image/tests/kis_image_test.cpp b/libs/image/tests/kis_image_test.cpp
index e91907eafd..8546bcf63e 100644
--- a/libs/image/tests/kis_image_test.cpp
+++ b/libs/image/tests/kis_image_test.cpp
@@ -1,1209 +1,1207 @@
 /*
  *  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* 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->lock();
     image->convertImageColorSpace(cs16,
                                   KoColorConversionTransformation::internalRenderingIntent(),
                                   KoColorConversionTransformation::internalConversionFlags());
     image->unlock();
 
     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::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 "testutil.h"
-#include "kis_group_layer.h"
 #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 <metadata/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)
 {
     QRect refRect;
     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()
 {
     QRect refRect;
     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);
         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(), p.image));
 
     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");
 
     p.image->setOverlaySelectionMask(0);
     p.image->waitForDone();
 
     KIS_DUMP_DEVICE_2(p.image->projection(), refRect, "02_deactivated", "dd");
 
 
 
 }
 
 
 
 QTEST_MAIN(KisImageTest)
diff --git a/libs/image/tests/kis_paint_information_test.cpp b/libs/image/tests/kis_paint_information_test.cpp
index 392cbb01b0..ebf3a68761 100644
--- a/libs/image/tests/kis_paint_information_test.cpp
+++ b/libs/image/tests/kis_paint_information_test.cpp
@@ -1,81 +1,79 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt boud@valdyas.org
  *  Copyright (c) 2008 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_paint_information_test.h"
 
 #include <QTest>
 #include <brushengine/kis_paint_information.h>
 #include "kis_debug.h"
 
 
 #include <QDomDocument>
 #include <Eigen/Core>
 
-#include <kis_debug.h>
-
 void KisPaintInformationTest::testCreation()
 {
     KisPaintInformation test;
 }
 
 void KisPaintInformationTest::testSerialisation()
 {
     KisPaintInformation test(QPointF(double(rand()) / RAND_MAX, double(rand()) / RAND_MAX), double(rand()) / RAND_MAX, double(rand()) / RAND_MAX, double(rand()) / RAND_MAX, double(rand()) / RAND_MAX, double(rand()) / RAND_MAX, double(rand()) / RAND_MAX, double(rand()) / RAND_MAX, double(rand()) / RAND_MAX);
 
     QDomDocument doc = QDomDocument("pi");
     QDomElement root = doc.createElement("pi");
     doc.appendChild(root);
     test.toXML(doc, root);
     KisPaintInformation testUnS = KisPaintInformation::fromXML(root);
     QCOMPARE(test.pos().x() , testUnS.pos().x());
     QCOMPARE(test.pos().y() , testUnS.pos().y());
     QCOMPARE(test.pressure() , testUnS.pressure());
     QCOMPARE(test.xTilt() , testUnS.xTilt());
     QCOMPARE(test.yTilt() , testUnS.yTilt());
     QCOMPARE(test.rotation() , testUnS.rotation());
     QCOMPARE(test.tangentialPressure() , testUnS.tangentialPressure());
     /**
      * drawingAngle(), velocity() and distance() are calculated basing
      * on the KisDistanceInformation data and are not available without
      * it
      */
 }
 
 #include <boost/random/taus88.hpp>
 #include <boost/random/uniform_smallint.hpp>
 
 void KisPaintInformationTest::benchmarkTausRandomGeneration()
 {
     boost::taus88 rnd;
 
     QBENCHMARK {
         // make a copy
         boost::taus88 rnd2(rnd);
 
         // use smallint shaper
         boost::uniform_smallint<int> smallint(0,10);
 
         // generate
         int value = smallint(rnd2);
         Q_UNUSED(value);
     }
 }
 
 
 QTEST_MAIN(KisPaintInformationTest)
diff --git a/libs/image/tests/kis_walkers_test.h b/libs/image/tests/kis_walkers_test.h
index e39f36b84c..0e66f0ef35 100644
--- a/libs/image/tests/kis_walkers_test.h
+++ b/libs/image/tests/kis_walkers_test.h
@@ -1,269 +1,268 @@
 /*
  *  Copyright (c) 2009 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_WALKERS_TEST_H
 #define KIS_WALKERS_TEST_H
 
 #include <QtTest>
 
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_types.h"
 #include "kis_node_visitor.h"
 #include "kis_default_bounds.h"
 #include "kis_paint_device.h"
 #include "kis_merge_walker.h"
-#include "kis_image.h"
 
 class TestLayer : public KisLayer
 {
 
     Q_OBJECT
 
 public:
 
     TestLayer(KisImageWSP image, const QString & name, quint8 opacity)
             : KisLayer(image, name, opacity) {
     }
 
     KisNodeSP clone() {
         return new TestLayer(*this);
     }
     bool allowAsChild(KisNodeSP) const override {
         return true;
     }
 
     virtual QString nodeType() {
         return "TEST";
     }
 
     KisPaintDeviceSP original() const override {
         // This test doesn't use updateProjection so just return 0
         return 0;
     }
 
     KisPaintDeviceSP paintDevice() const override {
         return 0;
     }
 
     QIcon icon() const override {
         return QIcon();
     }
 
     KisNodeSP clone() const override {
         return new TestLayer(image(), name(), opacity());
     }
 
     qint32 x() const override {
         return 0;
     }
 
     void setX(qint32) override {
     }
 
     qint32 y() const override {
         return 0;
     }
 
     void setY(qint32) override {
     }
 
     QRect extent() const override {
         return QRect();
     }
 
     QRect exactBounds() const override {
         return QRect();
     }
 
     using KisLayer::accept;
 
     bool accept(KisNodeVisitor& v) override {
         return v.visit(this);
     }
 };
 
 class ComplexRectsLayer : public KisLayer
 {
 
     Q_OBJECT
 
 public:
 
     ComplexRectsLayer(KisImageWSP image, const QString & name, quint8 opacity)
             : KisLayer(image, name, opacity) {
 
         m_device = new KisPaintDevice(this, image->colorSpace(), new KisDefaultBounds(image), "test device");
     }
 
     KisNodeSP clone() {
         return new ComplexRectsLayer(*this);
     }
     bool allowAsChild(KisNodeSP) const override {
         return true;
     }
 
     virtual QString nodeType() {
         return "TEST";
     }
 
     KisPaintDeviceSP original() const override {
         return m_device;
     }
 
     KisPaintDeviceSP paintDevice() const override {
         return m_device;
     }
 
     QIcon icon() const override {
         return QIcon();
     }
 
     KisNodeSP clone() const override {
         return new ComplexRectsLayer(image(), name(), opacity());
     }
 
     qint32 x() const override {
         return 0;
     }
 
     void setX(qint32) override {
     }
 
     qint32 y() const override {
         return 0;
     }
 
     void setY(qint32) override {
     }
 
     QRect extent() const override {
         return QRect();
     }
 
     QRect exactBounds() const override {
         return QRect();
     }
 
     using KisLayer::accept;
 
     bool accept(KisNodeVisitor& v) override {
         return v.visit(this);
     }
 
     QRect changeRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override {
         Q_UNUSED(pos);
         const qint32 delta = 3;
         return rect.adjusted(-delta, -delta, delta, delta);
     }
 
     QRect needRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override {
         Q_UNUSED(pos);
         const qint32 delta = 7;
         return rect.adjusted(-delta, -delta, delta, delta);
     }
 private:
     KisPaintDeviceSP m_device;
 };
 
 class CacheLayer : public ComplexRectsLayer
 {
 
     Q_OBJECT
 
 public:
     CacheLayer(KisImageWSP image, const QString & name, quint8 opacity)
             : ComplexRectsLayer(image, name, opacity) {
     }
 
 
     QRect needRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override {
         QRect retval;
 
         if(pos != KisNode::N_BELOW_FILTHY && pos != N_FILTHY_PROJECTION) {
             const qint32 delta = 7;
             retval = rect.adjusted(-delta, -delta, delta, delta);
         }
         return retval;
     }
 };
 
 class ComplexAccessLayer : public ComplexRectsLayer
 {
 
     Q_OBJECT
 
 public:
     ComplexAccessLayer(KisImageWSP image, const QString & name, quint8 opacity)
             : ComplexRectsLayer(image, name, opacity) {
     }
 
 
     QRect accessRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override {
         Q_UNUSED(pos);
 
         const qint32 delta = 70;
         return rect.translated(delta, 0);
     }
 
     QRect needRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override {
         Q_UNUSED(pos);
         return rect;
     }
 
     QRect changeRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override {
         Q_UNUSED(pos);
         return rect;
     }
 };
 
 class KisBaseRectsWalker;
 
 class KisWalkersTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void testUsualVisiting();
     void testVisitingWithTopmostMask();
     void testMergeVisiting();
     void testComplexGroupVisiting();
     void testComplexAccessVisiting();
     void testCloneNotificationsVisiting();
     void testRefreshSubtreeVisiting();
     void testFullRefreshVisiting();
     void testCachedVisiting();
     void testMasksVisiting();
     void testMasksVisitingNoFilthy();
     void testMasksOverlapping();
     void testRectsChecksum();
     void testGraphStructureChecksum();
 
 private:
     void verifyResult(KisBaseRectsWalker &walker, QStringList reference,
                       QRect accessRect, bool changeRectVaries,
                       bool needRectVaries);
     void verifyResult(KisBaseRectsWalker &walker, struct UpdateTestJob &job);
 
     void checkNotification(const KisMergeWalker::CloneNotification &notification,
                            const QString &name,
                            const QRect &rect);
 };
 
 #endif
 
diff --git a/libs/libkis/Document.cpp b/libs/libkis/Document.cpp
index 6b2a706793..48ebdf39db 100644
--- a/libs/libkis/Document.cpp
+++ b/libs/libkis/Document.cpp
@@ -1,827 +1,826 @@
 /*
  *  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 Lesser 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 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 "Document.h"
 #include <QPointer>
 #include <QUrl>
 #include <QDomDocument>
 
 #include <KoColorSpaceConstants.h>
 #include <KoXmlReader.h>
 #include <KisDocument.h>
 #include <kis_colorspace_convert_visitor.h>
 #include <kis_image.h>
 #include <KisPart.h>
 #include <kis_paint_device.h>
 #include <KisMainWindow.h>
 #include <kis_node_manager.h>
 #include <kis_node_selection_adapter.h>
 #include <KisViewManager.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <kis_effect_mask.h>
 #include <kis_paint_layer.h>
 #include <kis_generator_layer.h>
 #include <kis_generator_registry.h>
 #include <kis_shape_layer.h>
 #include <kis_filter_configuration.h>
 #include <kis_filter_registry.h>
 #include <kis_selection.h>
 #include <KisMimeDatabase.h>
 #include <kis_filter_strategy.h>
 #include <kis_guides_config.h>
 #include <kis_coordinates_converter.h>
 
-#include <KisMimeDatabase.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 #include <KoDocumentInfo.h>
 
 #include <InfoObject.h>
 #include <Node.h>
 #include <Selection.h>
 #include <LibKisUtils.h>
 
 struct Document::Private {
     Private() {}
     QPointer<KisDocument> document;
 };
 
 Document::Document(KisDocument *document, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->document = document;
 }
 
 Document::~Document()
 {
     delete d;
 }
 
 bool Document::operator==(const Document &other) const
 {
     return (d->document == other.d->document);
 }
 
 bool Document::operator!=(const Document &other) const
 {
     return !(operator==(other));
 }
 
 bool Document::batchmode() const
 {
     if (!d->document) return false;
     return d->document->fileBatchMode();
 }
 
 void Document::setBatchmode(bool value)
 {
     if (!d->document) return;
     d->document->setFileBatchMode(value);
 }
 
 Node *Document::activeNode() const
 {
     QList<KisNodeSP> activeNodes;
     Q_FOREACH(QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->document() == d->document) {
             activeNodes << view->currentNode();
         }
     }
     if (activeNodes.size() > 0) {
         QList<Node*> nodes = LibKisUtils::createNodeList(activeNodes, d->document->image());
         return nodes.first();
     }
     return 0;
 }
 
 void Document::setActiveNode(Node* value)
 {
     if (!value->node()) return;
     KisMainWindow *mainWin = KisPart::instance()->currentMainwindow();
     if (!mainWin) return;
     KisViewManager *viewManager = mainWin->viewManager();
     if (!viewManager) return;
     if (viewManager->document() != d->document) return;
     KisNodeManager *nodeManager = viewManager->nodeManager();
     if (!nodeManager) return;
     KisNodeSelectionAdapter *selectionAdapter = nodeManager->nodeSelectionAdapter();
     if (!selectionAdapter) return;
     selectionAdapter->setActiveNode(value->node());
 
 }
 
 QList<Node *> Document::topLevelNodes() const
 {
     if (!d->document) return QList<Node *>();
     Node n(d->document->image(), d->document->image()->rootLayer());
     return n.childNodes();
 }
 
 
 Node *Document::nodeByName(const QString &name) const
 {
     if (!d->document) return 0;
     KisNodeSP node = d->document->image()->rootLayer()->findChildByName(name);
     return new Node(d->document->image(), node);
 }
 
 
 QString Document::colorDepth() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorDepthId().id();
 }
 
 QString Document::colorModel() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorModelId().id();
 }
 
 QString Document::colorProfile() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->profile()->name();
 }
 
 bool Document::setColorProfile(const QString &value)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(value);
     if (!profile) return false;
     bool retval = d->document->image()->assignImageProfile(profile);
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
     return retval;
 }
 
 bool Document::setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, colorProfile);
     if (!colorSpace) return false;
 
     d->document->image()->convertImageColorSpace(colorSpace,
                                                  KoColorConversionTransformation::IntentPerceptual,
                                                  KoColorConversionTransformation::HighQuality | KoColorConversionTransformation::NoOptimization);
 
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
     return true;
 }
 
 QColor Document::backgroundColor()
 {
     if (!d->document) return QColor();
     if (!d->document->image()) return QColor();
 
     const KoColor color = d->document->image()->defaultProjectionColor();
     return color.toQColor();
 }
 
 bool Document::setBackgroundColor(const QColor &color)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     KoColor background = KoColor(color, d->document->image()->colorSpace());
     d->document->image()->setDefaultProjectionColor(background);
 
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
 
     return true;
 }
 
 QString Document::documentInfo() const
 {
     QDomDocument doc = KisDocument::createDomDocument("document-info"
                                                       /*DTD name*/, "document-info" /*tag name*/, "1.1");
     doc = d->document->documentInfo()->save(doc);
     return doc.toString();
 }
 
 void Document::setDocumentInfo(const QString &document)
 {
     KoXmlDocument doc;
     QString errorMsg;
     int errorLine, errorColumn;
     doc.setContent(document, &errorMsg, &errorLine, &errorColumn);
     d->document->documentInfo()->load(doc);
 }
 
 
 QString Document::fileName() const
 {
     if (!d->document) return QString();
     return d->document->url().toLocalFile();
 }
 
 void Document::setFileName(QString value)
 {
     if (!d->document) return;
     QString mimeType = KisMimeDatabase::mimeTypeForFile(value, false);
     d->document->setMimeType(mimeType.toLatin1());
     d->document->setUrl(QUrl::fromLocalFile(value));
 }
 
 int Document::height() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->height();
 }
 
 void Document::setHeight(int value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 d->document->image()->bounds().y(),
                 d->document->image()->width(),
                 value);
 }
 
 
 QString Document::name() const
 {
     if (!d->document) return "";
     return d->document->documentInfo()->aboutInfo("title");
 }
 
 void Document::setName(QString value)
 {
     if (!d->document) return;
     d->document->documentInfo()->setAboutInfo("title", value);
 }
 
 
 int Document::resolution() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return qRound(d->document->image()->xRes() * 72);
 }
 
 void Document::setResolution(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
 
     d->document->image()->setResolution(value / 72.0, value / 72.0);
 }
 
 
 Node *Document::rootNode() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return new Node(image, image->root());
 }
 
 Selection *Document::selection() const
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     if (!d->document->image()->globalSelection()) return 0;
     return new Selection(d->document->image()->globalSelection());
 }
 
 void Document::setSelection(Selection* value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     if (value) {
         d->document->image()->setGlobalSelection(value->selection());
     }
     else {
         d->document->image()->setGlobalSelection(0);
     }
 }
 
 
 int Document::width() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->width();
 }
 
 void Document::setWidth(int value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 d->document->image()->bounds().y(),
                 value,
                 d->document->image()->height());
 }
 
 
 int Document::xOffset() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->bounds().x();
 }
 
 void Document::setXOffset(int x)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(x,
                 d->document->image()->bounds().y(),
                 d->document->image()->width(),
                 d->document->image()->height());
 }
 
 
 int Document::yOffset() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->bounds().y();
 }
 
 void Document::setYOffset(int y)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 y,
                 d->document->image()->width(),
                 d->document->image()->height());
 }
 
 
 double Document::xRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->xRes()*72.0;
 }
 
 void Document::setXRes(double xRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(xRes/72.0, d->document->image()->yRes());
 }
 
 double Document::yRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->yRes()*72.0;
 }
 
 void Document::setYRes(double yRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(d->document->image()->xRes(), yRes/72.0);
 }
 
 
 QByteArray Document::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->document) return ba;
     KisImageSP image = d->document->image();
     if (!image) return ba;
 
     KisPaintDeviceSP dev = image->projection();
     ba.resize(w * h * dev->pixelSize());
     dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
     return ba;
 }
 
 bool Document::close()
 {
     bool retval = d->document->closeUrl(false);
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         if (view->document() == d->document) {
             view->close();
             view->closeView();
             view->deleteLater();
         }
     }
 
     KisPart::instance()->removeDocument(d->document);
     d->document = 0;
     return retval;
 }
 
 void Document::crop(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc(x, y, w, h);
     image->cropImage(rc);
 }
 
 bool Document::exportImage(const QString &filename, const InfoObject &exportConfiguration)
 {
     if (!d->document) return false;
 
     const QString outputFormatString = KisMimeDatabase::mimeTypeForFile(filename, false);
     const QByteArray outputFormat = outputFormatString.toLatin1();
 
     return d->document->exportDocumentSync(QUrl::fromLocalFile(filename), outputFormat, exportConfiguration.configuration());
 }
 
 void Document::flatten()
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->flatten();
 }
 
 void Document::resizeImage(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc;
     rc.setX(x);
     rc.setY(y);
     rc.setWidth(w);
     rc.setHeight(h);
 
     image->resizeImage(rc);
 }
 
 void Document::scaleImage(int w, int h, int xres, int yres, QString strategy)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setWidth(w);
     rc.setHeight(h);
 
     KisFilterStrategy *actualStrategy = KisFilterStrategyRegistry::instance()->get(strategy);
     if (!actualStrategy) actualStrategy = KisFilterStrategyRegistry::instance()->get("Bicubic");
 
     image->scaleImage(rc.size(), xres/72, yres/72, actualStrategy);
 }
 
 void Document::rotateImage(double radians)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     image->rotateImage(radians);
 }
 
 void Document::shearImage(double angleX, double angleY)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     image->shear(angleX, angleY);
 }
 
 bool Document::save()
 {
     if (!d->document) return false;
     if (d->document->url().isEmpty()) return false;
 
     bool retval = d->document->save(true, 0);
     d->document->waitForSavingToComplete();
 
     return retval;
 }
 
 bool Document::saveAs(const QString &filename)
 {
     if (!d->document) return false;
 
     const QString outputFormatString = KisMimeDatabase::mimeTypeForFile(filename, false);
     const QByteArray outputFormat = outputFormatString.toLatin1();
     QUrl oldUrl = d->document->url();
     d->document->setUrl(QUrl::fromLocalFile(filename));
     bool retval = d->document->saveAs(QUrl::fromLocalFile(filename), outputFormat, true);
     d->document->waitForSavingToComplete();
     d->document->setUrl(oldUrl);
 
     return retval;
 }
 
 Node* Document::createNode(const QString &name, const QString &nodeType)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     Node *node = 0;
 
     if (nodeType.toLower()== "paintlayer") {
         node = new Node(image, new KisPaintLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "grouplayer") {
         node = new Node(image, new KisGroupLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "filelayer") {
         node = new Node(image, new KisFileLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "filterlayer") {
         node = new Node(image, new KisAdjustmentLayer(image, name, 0, 0));
     }
     else if (nodeType.toLower()  == "filllayer") {
         node = new Node(image, new KisGeneratorLayer(image, name, 0, 0));
     }
     else if (nodeType.toLower()  == "clonelayer") {
         node = new Node(image, new KisCloneLayer(0, image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "vectorlayer") {
         node = new Node(image, new KisShapeLayer(d->document->shapeController(), image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "transparencymask") {
         node = new Node(image, new KisTransparencyMask());
     }
     else if (nodeType.toLower()  == "filtermask") {
         node = new Node(image, new KisFilterMask());
     }
     else if (nodeType.toLower()  == "transformmask") {
         node = new Node(image, new KisTransformMask());
     }
     else if (nodeType.toLower()  == "selectionmask") {
         node = new Node(image, new KisSelectionMask(image));
     }
     return node;
 }
 
 GroupLayer *Document::createGroupLayer(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new GroupLayer(image, name);
 }
 
 FileLayer *Document::createFileLayer(const QString &name, const QString fileName, const QString scalingMethod)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FileLayer(image, name, this->fileName(), fileName, scalingMethod);
 }
 
 FilterLayer *Document::createFilterLayer(const QString &name, Filter &filter, Selection &selection)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FilterLayer(image, name, filter, selection);
 }
 
 FillLayer *Document::createFillLayer(const QString &name, const QString generatorName, InfoObject &configuration, Selection &selection)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorName);
     if (generator) {
 
         KisFilterConfigurationSP config = generator->defaultConfiguration();
         Q_FOREACH(const QString property, configuration.properties().keys()) {
             config->setProperty(property, configuration.property(property));
         }
 
         return new FillLayer(image, name, config, selection);
     }
     return 0;
 }
 
 CloneLayer *Document::createCloneLayer(const QString &name, const Node *source)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
     KisLayerSP layer = qobject_cast<KisLayer*>(source->node().data());
 
     return new CloneLayer(image, name, layer);
 }
 
 VectorLayer *Document::createVectorLayer(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new VectorLayer(d->document->shapeController(), image, name);
 }
 
 FilterMask *Document::createFilterMask(const QString &name, Filter &filter)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FilterMask(image, name, filter);
 }
 
 SelectionMask *Document::createSelectionMask(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new SelectionMask(image, name);
 }
 
 
 QImage Document::projection(int x, int y, int w, int h) const
 {
     if (!d->document || !d->document->image()) return QImage();
     return d->document->image()->convertToQImage(x, y, w, h, 0);
 }
 
 QImage Document::thumbnail(int w, int h) const
 {
     if (!d->document || !d->document->image()) return QImage();
     return d->document->generatePreview(QSize(w, h)).toImage();
 }
 
 
 void Document::lock()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->barrierLock();
 }
 
 void Document::unlock()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->unlock();
 }
 
 void Document::waitForDone()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->waitForDone();
 }
 
 bool Document::tryBarrierLock()
 {
     if (!d->document || !d->document->image()) return false;
     return d->document->image()->tryBarrierLock();
 }
 
 bool Document::isIdle()
 {
     if (!d->document || !d->document->image()) return false;
     return d->document->image()->isIdle();
 }
 
 void Document::refreshProjection()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->refreshGraph();
 }
 
 QList<qreal> Document::horizontalGuides() const
 {
     QList<qreal> lines;
     if (!d->document || !d->document->image()) return lines;
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform().inverted();
     QList<qreal> untransformedLines = d->document->guidesConfig().horizontalGuideLines();
     for (int i = 0; i< untransformedLines.size(); i++) {
         qreal line = untransformedLines[i];
         lines.append(transform.map(QPointF(line, line)).x());
     }
     return lines;
 }
 
 QList<qreal> Document::verticalGuides() const
 {
     QList<qreal> lines;
     if (!d->document || !d->document->image()) return lines;
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform().inverted();
     QList<qreal> untransformedLines = d->document->guidesConfig().verticalGuideLines();
     for (int i = 0; i< untransformedLines.size(); i++) {
         qreal line = untransformedLines[i];
         lines.append(transform.map(QPointF(line, line)).y());
     }
     return lines;
 }
 
 bool Document::guidesVisible() const
 {
     return d->document->guidesConfig().lockGuides();
 }
 
 bool Document::guidesLocked() const
 {
     return d->document->guidesConfig().showGuides();
 }
 
 Document *Document::clone() const
 {
     if (!d->document) return 0;
     QPointer<KisDocument> clone = d->document->clone();
     Document * d = new Document(clone);
     clone->setParent(d); // It's owned by the document, not KisPart
     return d;
 }
 
 void Document::setHorizontalGuides(const QList<qreal> &lines)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform();
     QList<qreal> transformedLines;
     for (int i = 0; i< lines.size(); i++) {
         qreal line = lines[i];
         transformedLines.append(transform.map(QPointF(line, line)).x());
     }
     config.setHorizontalGuideLines(transformedLines);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setVerticalGuides(const QList<qreal> &lines)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform();
     QList<qreal> transformedLines;
     for (int i = 0; i< lines.size(); i++) {
         qreal line = lines[i];
         transformedLines.append(transform.map(QPointF(line, line)).y());
     }
     config.setVerticalGuideLines(transformedLines);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setGuidesVisible(bool visible)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     config.setShowGuides(visible);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setGuidesLocked(bool locked)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     config.setLockGuides(locked);
     d->document->setGuidesConfig(config);
 }
 
 QPointer<KisDocument> Document::document() const
 {
     return d->document;
 }
diff --git a/libs/libkis/Filter.cpp b/libs/libkis/Filter.cpp
index 48ec4ff903..56d6c7c3a2 100644
--- a/libs/libkis/Filter.cpp
+++ b/libs/libkis/Filter.cpp
@@ -1,174 +1,173 @@
 /*
  *  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 Lesser 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 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 "Filter.h"
 
 #include <KoCanvasResourceManager.h>
 
 #include <kis_canvas_resource_provider.h>
 #include <kis_filter.h>
-#include <kis_filter.h>
 #include <kis_properties_configuration.h>
 #include <kis_filter_configuration.h>
 #include <kis_filter_manager.h>
 #include <kis_filter_registry.h>
 #include <KisPart.h>
 #include <KisView.h>
 
 #include <strokes/kis_filter_stroke_strategy.h>
 #include <krita_utils.h>
 
 #include "Krita.h"
 #include "Document.h"
 #include "InfoObject.h"
 #include "Node.h"
 
 struct Filter::Private {
     Private() {}
     QString name;
     InfoObject *configuration {0};
 };
 
 Filter::Filter()
     : QObject(0)
     , d(new Private)
 {
 }
 
 Filter::~Filter()
 {
     delete d->configuration;
     delete d;
 }
 
 bool Filter::operator==(const Filter &other) const
 {
     return (d->name == other.d->name
             && d->configuration == other.d->configuration);
 }
 
 bool Filter::operator!=(const Filter &other) const
 {
     return !(operator==(other));
 }
 
 
 QString Filter::name() const
 {
     return d->name;
 }
 
 void Filter::setName(const QString &name)
 {
     d->name = name;
     delete d->configuration;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     d->configuration = new InfoObject(filter->defaultConfiguration());
 }
 
 InfoObject* Filter::configuration() const
 {
     return d->configuration;
 }
 
 void Filter::setConfiguration(InfoObject* value)
 {
     d->configuration = value;
 }
 
 bool Filter::apply(Node *node, int x, int y, int w, int h)
 {
     if (node->locked()) return false;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     if (!filter) return false;
 
     KisPaintDeviceSP dev = node->paintDevice();
     if (!dev) return false;
 
     QRect applyRect = QRect(x, y, w, h);
     KisFilterConfigurationSP config = static_cast<KisFilterConfiguration*>(d->configuration->configuration().data());
     filter->process(dev, applyRect, config);
     return true;
 }
 
 bool Filter::startFilter(Node *node, int x, int y, int w, int h)
 {
     if (node->locked()) return false;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     if (!filter) return false;
 
     KisImageWSP image = node->image();
     if (!image) return false;
 
     KisFilterConfigurationSP filterConfig = static_cast<KisFilterConfiguration*>(d->configuration->configuration().data());
 
     image->waitForDone();
     QRect initialApplyRect = QRect(x, y, w, h);
 
     QRect applyRect = initialApplyRect;
 
     KisPaintDeviceSP paintDevice = node->paintDevice();
     if (paintDevice && filter->needsTransparentPixels(filterConfig.data(), paintDevice->colorSpace())) {
         applyRect |= image->bounds();
     }
 
     KisResourcesSnapshotSP resources = new KisResourcesSnapshot(image, node->node());
 
     Document *document = Krita::instance()->activeDocument();
     if (document && KisPart::instance()->viewCount(document->document()) > 0) {
         Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
             if (view && view->document() == document->document()) {
                 resources = new KisResourcesSnapshot(image, node->node(), view->resourceProvider()->resourceManager());
                 break;
             }
         }
     }
     delete document;
 
     KisStrokeId currentStrokeId = image->startStroke(new KisFilterStrokeStrategy(filter,
                                                                                  KisFilterConfigurationSP(filterConfig),
                                                                                  resources));
 
     QRect processRect = filter->changedRect(applyRect, filterConfig.data(), 0);
     processRect &= image->bounds();
 
     if (filter->supportsThreading()) {
         QSize size = KritaUtils::optimalPatchSize();
         QVector<QRect> rects = KritaUtils::splitRectIntoPatches(processRect, size);
         Q_FOREACH (const QRect &rc, rects) {
             image->addJob(currentStrokeId, new KisFilterStrokeStrategy::Data(rc, true));
         }
     } else {
         image->addJob(currentStrokeId, new KisFilterStrokeStrategy::Data(processRect, false));
     }
 
     image->endStroke(currentStrokeId);
 
     return true;
 }
 
 KisFilterConfigurationSP Filter::filterConfig()
 {
     KisFilterConfigurationSP config = KisFilterRegistry::instance()->get(d->name)->defaultConfiguration();
     Q_FOREACH(const QString property, d->configuration->properties().keys()) {
         config->setProperty(property, d->configuration->property(property));
     }
     return config;
 }
diff --git a/libs/libkis/Krita.cpp b/libs/libkis/Krita.cpp
index c11b9ccf45..b331891f20 100644
--- a/libs/libkis/Krita.cpp
+++ b/libs/libkis/Krita.cpp
@@ -1,424 +1,423 @@
 /*
  *  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 Lesser 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 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 "Krita.h"
 
 #include <QPointer>
 #include <QVariant>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 #include <klocalizedstring.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoDockRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorModelStandardIds.h>
 #include <KoID.h>
 
 #include <kis_filter_strategy.h>
 #include <kactioncollection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_action.h>
 #include <KisViewManager.h>
 #include <KritaVersionWrapper.h>
 #include <kis_filter_registry.h>
 #include <kis_filter.h>
 #include <kis_filter_configuration.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <KisResourceServerProvider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 #include <KoResourceServerProvider.h>
 #include <kis_action_registry.h>
 #include <kis_icon_utils.h>
-#include <KisPart.h>
 
 #include "View.h"
 #include "Document.h"
 #include "Window.h"
 #include "Extension.h"
 #include "DockWidgetFactoryBase.h"
 #include "Filter.h"
 #include "InfoObject.h"
 #include "Resource.h"
 
 Krita* Krita::s_instance = 0;
 
 struct Krita::Private {
     Private() {}
     QList<Extension*> extensions;
     bool batchMode {false};
     Notifier *notifier{new Notifier()};
 };
 
 Krita::Krita(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     qRegisterMetaType<Notifier*>();
     connect(KisPart::instance(), SIGNAL(sigWindowAdded(KisMainWindow*)), SLOT(mainWindowAdded(KisMainWindow*)));
 }
 
 Krita::~Krita()
 {
     qDeleteAll(d->extensions);
     delete d->notifier;
     delete d;
 }
 
 QList<QAction *> Krita::actions() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return QList<QAction*>();
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     return actionCollection->actions();
 }
 
 QAction *Krita::action(const QString &name) const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     QAction *action = actionCollection->action(name);
     return action;
 }
 
 Document* Krita::activeDocument() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KisView *view = mainWindow->activeView();
     if (!view) {
         return 0;
     }
     KisDocument *document = view->document();
     return new Document(document);
 }
 
 void Krita::setActiveDocument(Document* value)
 {
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         if (view->document() == value->document().data()) {
             view->activateWindow();
             break;
         }
     }
 }
 
 bool Krita::batchmode() const
 {
     return d->batchMode;
 }
 
 void Krita::setBatchmode(bool value)
 {
     d->batchMode = value;
 }
 
 
 QList<Document *> Krita::documents() const
 {
     QList<Document *> ret;
     foreach(QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         ret << new Document(doc);
     }
     return ret;
 }
 
 QStringList Krita::filters() const
 {
     QStringList ls = KisFilterRegistry::instance()->keys();
     std::sort(ls.begin(), ls.end());
     return ls;
 }
 
 Filter *Krita::filter(const QString &name) const
 {
     if (!filters().contains(name)) return 0;
 
     Filter *filter = new Filter();
     filter->setName(name);
     KisFilterSP f = KisFilterRegistry::instance()->value(name);
     KisFilterConfigurationSP fc = f->defaultConfiguration();
     InfoObject *info = new InfoObject(fc);
     filter->setConfiguration(info);
     return filter;
 }
 
 QStringList Krita::colorModels() const
 {
     QSet<QString> colorModelsIds;
     QList<KoID> ids = KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(KoID id, ids) {
         colorModelsIds << id.id();
     }
     return colorModelsIds.toList();
 }
 
 QStringList Krita::colorDepths(const QString &colorModel) const
 {
     QSet<QString> colorDepthsIds;
     QList<KoID> ids = KoColorSpaceRegistry::instance()->colorDepthList(colorModel, KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(KoID id, ids) {
         colorDepthsIds << id.id();
     }
     return colorDepthsIds.toList();
 }
 
 QStringList Krita::filterStrategies() const
 {
     return KisFilterStrategyRegistry::instance()->keys();
 }
 
 QStringList Krita::profiles(const QString &colorModel, const QString &colorDepth) const
 {
     QSet<QString> profileNames;
     QString id = KoColorSpaceRegistry::instance()->colorSpaceId(colorModel, colorDepth);
     QList<const KoColorProfile *> profiles = KoColorSpaceRegistry::instance()->profilesFor(id);
     Q_FOREACH(const KoColorProfile *profile, profiles) {
         profileNames << profile->name();
     }
     return profileNames.toList();
 }
 
 bool Krita::addProfile(const QString &profilePath)
 {
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     return iccEngine->addProfile(profilePath);
 }
 
 Notifier* Krita::notifier() const
 {
     return d->notifier;
 }
 
 QString Krita::version() const
 {
     return KritaVersionWrapper::versionString(true);
 }
 
 QList<View *> Krita::views() const
 {
     QList<View *> ret;
     foreach(QPointer<KisView> view, KisPart::instance()->views()) {
         ret << new View(view);
     }
     return ret;
 }
 
 Window *Krita::activeWindow() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     return new Window(mainWindow);
 }
 
 QList<Window*>  Krita::windows() const
 {
     QList<Window*> ret;
     foreach(QPointer<KisMainWindow> mainWin, KisPart::instance()->mainWindows()) {
         ret << new Window(mainWin);
     }
     return ret;
 }
 
 QMap<QString, Resource *> Krita::resources(const QString &type) const
 {
     QMap<QString, Resource *> resources = QMap<QString, Resource *> ();
 
     if (type.toLower() == "pattern") {
         KoResourceServer<KoPattern>* server = KoResourceServerProvider::instance()->patternServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "gradient") {
         KoResourceServer<KoAbstractGradient>* server = KoResourceServerProvider::instance()->gradientServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "brush") {
         KisBrushResourceServer* server = KisBrushServer::instance()->brushServer();
         Q_FOREACH (KisBrushSP res, server->resources()) {
             resources[res->name()] = new Resource(res.data());
         }
     }
     else if (type.toLower() == "preset") {
         KisPaintOpPresetResourceServer* server = KisResourceServerProvider::instance()->paintOpPresetServer();
         Q_FOREACH (KisPaintOpPresetSP res, server->resources()) {
             resources[res->name()] = new Resource(res.data());
         }
     }
     else if (type.toLower() == "palette") {
         KoResourceServer<KoColorSet>* server = KoResourceServerProvider::instance()->paletteServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "workspace") {
         KoResourceServer< KisWorkspaceResource >* server = KisResourceServerProvider::instance()->workspaceServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     return resources;
 }
 
 QStringList Krita::recentDocuments() const
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(QString("RecentFiles"));
     QStringList keys = grp.keyList();
     QStringList recentDocuments;
 
     for(int i = 0; i <= keys.filter("File").count(); i++)
         recentDocuments << grp.readEntry(QString("File%1").arg(i), QString(""));
 
     return recentDocuments;
 }
 
 Document* Krita::createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile, double resolution)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(document);
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, profile);
     Q_ASSERT(cs);
 
     QColor qc(Qt::white);
     qc.setAlpha(0);
     KoColor bgColor(qc, cs);
 
     if (!document->newImage(name, width, height, cs, bgColor, true, 1, "", double(resolution / 72) )) {
         qDebug() << "Could not create a new image";
         return 0;
     }
 
     Q_ASSERT(document->image());
     qDebug() << document->image()->objectName();
 
     return new Document(document);
 }
 
 Document* Krita::openDocument(const QString &filename)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     document->setFileBatchMode(this->batchmode());
     KisPart::instance()->addDocument(document);
     document->openUrl(QUrl::fromLocalFile(filename), KisDocument::DontAddToRecent);
     document->setFileBatchMode(false);
     return new Document(document);
 }
 
 Window* Krita::openWindow()
 {
     KisMainWindow *mw = KisPart::instance()->createMainWindow();
     return new Window(mw);
 }
 
 void Krita::addExtension(Extension* extension)
 {
     d->extensions.append(extension);
 }
 
 QList< Extension* > Krita::extensions()
 {
     return d->extensions;
 }
 
 void Krita::writeSetting(const QString &group, const QString &name, const QString &value)
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(group);
     grp.writeEntry(name, value);
 }
 
 QString Krita::readSetting(const QString &group, const QString &name, const QString &defaultValue)
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(group);
     return grp.readEntry(name, defaultValue);
 }
 
 QIcon Krita::icon(QString &iconName) const
 {
     return KisIconUtils::loadIcon(iconName);
 }
 
 void Krita::addDockWidgetFactory(DockWidgetFactoryBase* factory)
 {
     KoDockRegistry::instance()->add(factory);
 }
 
 Krita* Krita::instance()
 {
     if (!s_instance)
     {
         s_instance = new Krita;
     }
     return s_instance;
 }
 
 /**
  * Scripter.fromVariant(variant)
  * variant is a QVariant
  * returns instance of QObject-subclass
  *
  * This is a helper method for PyQt because PyQt cannot cast a variant to a QObject or QWidget
  */
 QObject *Krita::fromVariant(const QVariant& v)
 {
 
     if (v.canConvert< QWidget* >())
     {
         QObject* obj = qvariant_cast< QWidget* >(v);
         return obj;
     }
     else if (v.canConvert< QObject* >())
     {
         QObject* obj = qvariant_cast< QObject* >(v);
         return obj;
     }
     else
         return 0;
 }
 
 QString Krita::krita_i18n(const QString &text)
 {
     return i18n(text.toUtf8().constData());
 }
 
 void Krita::mainWindowAdded(KisMainWindow *kisWindow)
 {
     Q_FOREACH(Extension *extension, d->extensions) {
         Window window(kisWindow);
         extension->createActions(&window);
     }
 }
diff --git a/libs/libkis/Selection.cpp b/libs/libkis/Selection.cpp
index 9f6b1bed00..28783df6c9 100644
--- a/libs/libkis/Selection.cpp
+++ b/libs/libkis/Selection.cpp
@@ -1,323 +1,322 @@
 /*
  *  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 Lesser 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 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 "Selection.h"
 
 #include <KoColorSpace.h>
 #include "kis_iterator_ng.h"
 #include <kis_selection.h>
 #include <kis_pixel_selection.h>
 #include <kis_paint_device.h>
 #include <kis_selection_filters.h>
 #include <kis_painter.h>
 #include <kis_clipboard.h>
-#include <kis_painter.h>
 #include <QByteArray>
 
 #include <Node.h>
 
 struct Selection::Private {
     Private() {}
     KisSelectionSP selection;
 };
 
 Selection::Selection(KisSelectionSP selection, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->selection = selection;
 }
 
 
 Selection::Selection(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->selection = new KisSelection();
 }
 
 Selection::~Selection()
 {
     delete d;
 }
 
 bool Selection::operator==(const Selection &other) const
 {
     return (d->selection == other.d->selection);
 }
 
 bool Selection::operator!=(const Selection &other) const
 {
     return !(operator==(other));
 }
 
 int Selection::width() const
 {
     if (!d->selection) return 0;
     return d->selection->selectedExactRect().width();
 }
 
 int Selection::height() const
 {
     if (!d->selection) return 0;
     return d->selection->selectedExactRect().height();
 }
 
 int Selection::x() const
 {
     if (!d->selection) return 0;
     int xPos = d->selection->x();
     if (d->selection->hasPixelSelection()) {
         xPos = d->selection->selectedExactRect().x();
     }
     return xPos;
 }
 
 int Selection::y() const
 {
     if (!d->selection) return 0;
     int yPos = d->selection->y();
     if (d->selection->hasPixelSelection()) {
         yPos = d->selection->selectedExactRect().y();
     }
     return yPos;
 }
 
 void Selection::move(int x, int y)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->moveTo(QPoint(x, y));
 }
 
 
 void Selection::clear()
 {
     if (!d->selection) return;
     d->selection->clear();
 }
 
 void Selection::contract(int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x(), y(), width() - value, height() - value));
 }
 
 void Selection::copy(Node *node)
 {
     if (!node) return;
     if (!d->selection) return;
     if (node->node()->exactBounds().isEmpty()) return;
     if (!node->node()->hasEditablePaintDevice()) return;
 
     KisPaintDeviceSP dev = node->node()->paintDevice();
     KisPaintDeviceSP clip = new KisPaintDevice(dev->colorSpace());
     KisPaintDeviceSP selectionProjection = d->selection->projection();
 
     const KoColorSpace *cs = clip->colorSpace();
     const KoColorSpace *selCs = d->selection->projection()->colorSpace();
 
     QRect rc = d->selection->selectedExactRect();
 
     KisPainter::copyAreaOptimized(QPoint(), dev, clip, rc);
 
     KisHLineIteratorSP layerIt = clip->createHLineIteratorNG(0, 0, rc.width());
     KisHLineConstIteratorSP selectionIt = selectionProjection->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 
     for (qint32 y = 0; y < rc.height(); y++) {
         for (qint32 x = 0; x < rc.width(); x++) {
 
             qreal dstAlpha = cs->opacityF(layerIt->rawData());
             qreal sel = selCs->opacityF(selectionIt->oldRawData());
             qreal newAlpha = sel * dstAlpha / (1.0 - dstAlpha + sel * dstAlpha);
             float mask = newAlpha / dstAlpha;
 
             cs->applyAlphaNormedFloatMask(layerIt->rawData(), &mask, 1);
 
             layerIt->nextPixel();
             selectionIt->nextPixel();
         }
         layerIt->nextRow();
         selectionIt->nextRow();
     }
 
     KisClipboard::instance()->setClip(clip, rc.topLeft());
 }
 
 void Selection::cut(Node* node)
 {
     if (!node) return;
     if (!d->selection) return;
     if (node->node()->exactBounds().isEmpty()) return;
     if (!node->node()->hasEditablePaintDevice()) return;
     KisPaintDeviceSP dev = node->node()->paintDevice();
     copy(node);
     dev->clearSelection(d->selection);
     node->node()->setDirty(d->selection->selectedExactRect());
 }
 
 void Selection::paste(Node *destination, int x, int y)
 {
     if (!destination) return;
     if (!d->selection) return;
     if (!KisClipboard::instance()->hasClip()) return;
 
     KisPaintDeviceSP src = KisClipboard::instance()->clip(QRect(), false);
     KisPaintDeviceSP dst = destination->node()->paintDevice();
     if (!dst) return;
     KisPainter::copyAreaOptimized(QPoint(x, y),
                                   src,
                                   dst,
                                   src->exactBounds(),
                                   d->selection);
     destination->node()->setDirty();
 }
 
 void Selection::erode()
 {
     if (!d->selection) return;
     KisErodeSelectionFilter esf;
     QRect rc = esf.changeRect(d->selection->selectedExactRect());
     esf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::dilate()
 {
     if (!d->selection) return;
     KisDilateSelectionFilter dsf;
     QRect rc = dsf.changeRect(d->selection->selectedExactRect());
     dsf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::border(int xRadius, int yRadius)
 {
     if (!d->selection) return;
     KisBorderSelectionFilter sf(xRadius, yRadius);
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::feather(int radius)
 {
     if (!d->selection) return;
     KisFeatherSelectionFilter fsf(radius);
     QRect rc = fsf.changeRect(d->selection->selectedExactRect());
     fsf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::grow(int xradius, int yradius)
 {
     if (!d->selection) return;
     KisGrowSelectionFilter gsf(xradius, yradius);
     QRect rc = gsf.changeRect(d->selection->selectedExactRect());
     gsf.process(d->selection->pixelSelection(), rc);
 }
 
 
 void Selection::shrink(int xRadius, int yRadius, bool edgeLock)
 {
     if (!d->selection) return;
     KisShrinkSelectionFilter sf(xRadius, yRadius, edgeLock);
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::smooth()
 {
     if (!d->selection) return;
     KisSmoothSelectionFilter sf;
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 
 void Selection::invert()
 {
     if (!d->selection) return;
     KisInvertSelectionFilter sf;
     QRect rc = sf.changeRect(d->selection->selectedExactRect());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::resize(int w, int h)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x(), y(), w, h));
 }
 
 void Selection::select(int x, int y, int w, int h, int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x, y, w, h), value);
 }
 
 void Selection::selectAll(Node *node, int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(node->node()->exactBounds(), value);
 }
 
 void Selection::replace(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_REPLACE);
 }
 
 void Selection::add(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_ADD);
 }
 
 void Selection::subtract(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_SUBTRACT);
 }
 
 void Selection::intersect(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_INTERSECT);
 }
 
 
 QByteArray Selection::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
     if (!d->selection) return ba;
     KisPaintDeviceSP dev = d->selection->projection();
     quint8 *data = new quint8[w * h];
     dev->readBytes(data, x, y, w, h);
     ba = QByteArray((const char*)data, (int)(w * h));
     delete[] data;
     return ba;
 }
 
 void Selection::setPixelData(QByteArray value, int x, int y, int w, int h)
 {
     if (!d->selection) return;
     KisPixelSelectionSP dev = d->selection->pixelSelection();
     if (!dev) return;
     dev->writeBytes((const quint8*)value.constData(), x, y, w, h);
 }
 
 KisSelectionSP Selection::selection() const
 {
     return d->selection;
 }
 
 
diff --git a/libs/libkis/tests/TestDocument.cpp b/libs/libkis/tests/TestDocument.cpp
index d6736dc250..be6779cfc4 100644
--- a/libs/libkis/tests/TestDocument.cpp
+++ b/libs/libkis/tests/TestDocument.cpp
@@ -1,221 +1,219 @@
 /* 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 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 "TestDocument.h"
 #include <QTest>
 
 #include <KritaVersionWrapper.h>
-#include <QTest>
 #include <QColor>
 #include <QDataStream>
 #include <QDir>
 
-#include <KritaVersionWrapper.h>
 #include <Node.h>
 #include <Krita.h>
 #include <Document.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_fill_painter.h>
 #include <kis_paint_layer.h>
 #include <KisPart.h>
 
 #include <sdk/tests/kistest.h>
 
 void TestDocument::testSetColorSpace()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb8(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     image->addNode(layer);
     kisdoc->setCurrentImage(image);
 
     Document d(kisdoc);
     QStringList profiles = Krita().profiles("GRAYA", "U16");
     d.setColorSpace("GRAYA", "U16", profiles.first());
 
     QVERIFY(layer->colorSpace()->colorModelId().id() == "GRAYA");
     QVERIFY(layer->colorSpace()->colorDepthId().id() == "U16");
     QVERIFY(layer->colorSpace()->profile()->name() == "gray built-in");
 
     KisPart::instance()->removeDocument(kisdoc);
 }
 
 void TestDocument::testSetColorProfile()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb8(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     image->addNode(layer);
     kisdoc->setCurrentImage(image);
 
     Document d(kisdoc);
 
     QStringList profiles = Krita().profiles("RGBA", "U8");
     Q_FOREACH(const QString &profile, profiles) {
         d.setColorProfile(profile);
         QVERIFY(image->colorSpace()->profile()->name() == profile);
     }
     KisPart::instance()->removeDocument(kisdoc);
 }
 
 void TestDocument::testPixelData()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb8(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::red, layer->colorSpace()));
     image->addNode(layer);
     kisdoc->setCurrentImage(image);
 
     Document d(kisdoc);
     d.refreshProjection();
 
     QByteArray ba = d.pixelData(0, 0, 100, 100);
     QDataStream ds(ba);
     do {
         quint8 channelvalue;
         ds >> channelvalue;
         QVERIFY(channelvalue == 0);
         ds >> channelvalue;
         QVERIFY(channelvalue == 0);
         ds >> channelvalue;
         QVERIFY(channelvalue == 255);
         ds >> channelvalue;
         QVERIFY(channelvalue == 255);
     } while (!ds.atEnd());
 
     KisPart::instance()->removeDocument(kisdoc);
 }
 
 void TestDocument::testThumbnail()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb8(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::red, layer->colorSpace()));
     image->addNode(layer);
     kisdoc->setCurrentImage(image);
 
     Document d(kisdoc);
     d.refreshProjection();
 
     QImage thumb = d.thumbnail(10, 10);
     thumb.save("thumb.png");
     QVERIFY(thumb.width() == 10);
     QVERIFY(thumb.height() == 10);
     // Our thumbnail calculator in KisPaintDevice cannot make a filled 10x10 thumbnail from a 100x100 device,
     // it makes it 10x10 empty, then puts 8x8 pixels in there... Not a bug in the Node class
     for (int i = 0; i < 8; ++i) {
         for (int j = 0; j < 8; ++j) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
             QVERIFY(thumb.pixelColor(i, j) == QColor(Qt::red));
 #else
             QVERIFY(QColor(thumb.pixel(i, j)) == QColor(Qt::red));
 #endif
         }
     }
     KisPart::instance()->removeDocument(kisdoc);
 
 }
 
 void TestDocument::testCreateAndSave()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 5000, 5000, KoColorSpaceRegistry::instance()->rgb16(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 128);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(100, 100, 4000, 4000, KoColor(Qt::red, layer->colorSpace()));
     image->addNode(layer);
     for(int i = 0; i < 10; ++i) {
         image->addNode(layer->clone());
     }
     kisdoc->setCurrentImage(image);
 
     Document d(kisdoc);
     d.setBatchmode(true);
     d.refreshProjection();
 
     QString filename = QDir::tempPath() + "/TestDocumentTestCreateAndSave.kra";
 
     d.saveAs(filename);
     QVERIFY2(QFileInfo(filename).exists(), filename.toUtf8());
 
     Document *d2 = Krita::instance()->openDocument(filename);
     Q_ASSERT(d2->colorDepth() == "U16");
 
     KisPart::instance()->removeDocument(kisdoc);
 
 }
 
 void TestDocument::testCreateFillLayer()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 50, 50, KoColorSpaceRegistry::instance()->rgb16(), "test");
     kisdoc->setCurrentImage(image);
     Document d(kisdoc);
 
     const QString pattern("pattern");
     const QString color("color");
     const QString filllayer = "filllayer";
     InfoObject info;
     Selection sel(image->globalSelection());
 
     FillLayer *f = d.createFillLayer("test1", pattern, info, sel);
     QVERIFY(f->generatorName() == pattern);
     QVERIFY(f->type() == filllayer);
     delete f;
     f = d.createFillLayer("test1", color, info, sel);
     QVERIFY(f->generatorName() == color);
     QVERIFY(f->type() == filllayer);
 
     info.setProperty(pattern, "Cross01.pat");
     QVERIFY(f->setGenerator(pattern, &info));
     QVERIFY(f->filterConfig()->property(pattern).toString() == "Cross01.pat");
     QVERIFY(f->generatorName() == pattern);
     QVERIFY(f->type() == filllayer);
 
     info.setProperty(color, QColor(Qt::red));
     QVERIFY(f->setGenerator(color, &info));
     QVariant v = f->filterConfig()->property(color);
     QColor c = v.value<QColor>();
     QVERIFY(c == QColor(Qt::red));
     QVERIFY(f->generatorName() == color);
     QVERIFY(f->type() == filllayer);
 
     bool r = f->setGenerator(QString("xxx"), &info);
     QVERIFY(!r);
 
     delete f;
 
     QVERIFY(d.createFillLayer("test1", "xxx", info, sel) == 0);
 
     KisPart::instance()->removeDocument(kisdoc);
 
 }
 
 
 
 KISTEST_MAIN(TestDocument)
 
diff --git a/libs/libkis/tests/TestFilter.cpp b/libs/libkis/tests/TestFilter.cpp
index d385749aca..8a3b67c735 100644
--- a/libs/libkis/tests/TestFilter.cpp
+++ b/libs/libkis/tests/TestFilter.cpp
@@ -1,104 +1,102 @@
 /* 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 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 "TestFilter.h"
 #include <QTest>
 
 #include <KritaVersionWrapper.h>
-#include <QTest>
 #include <QColor>
 #include <QDataStream>
 
-#include <KritaVersionWrapper.h>
 #include <Node.h>
 #include <Krita.h>
 #include <Document.h>
 #include <Filter.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_fill_painter.h>
 #include <kis_paint_layer.h>
 #include <KisPart.h>
 
 #include  <sdk/tests/kistest.h>
 
 void TestFilter::testApply()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb8(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::black, layer->colorSpace()));
     image->addNode(layer);
     kisdoc->setCurrentImage(image);
     Document d(kisdoc);
     Node node(image, layer);
 
     Filter f;
     f.setName("invert");
     QVERIFY(f.configuration());
 
     d.lock();
     f.apply(&node, 0, 0, 100, 100);
     d.unlock();
     d.refreshProjection();
 
     for (int i = 0; i < 100 ; i++) {
         for (int j = 0; j < 100 ; j++) {
             QColor pixel;
             layer->paintDevice()->pixel(i, j, &pixel);
             QVERIFY(pixel == QColor(Qt::white));
         }
     }
 
 }
 
 void TestFilter::testStartFilter()
 {
     KisDocument *kisdoc = KisPart::instance()->createDocument();
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb8(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::black, layer->colorSpace()));
     image->addNode(layer);
     kisdoc->setCurrentImage(image);
     Document d(kisdoc);
     Node node(image, layer);
 
     Filter f;
     f.setName("invert");
     QVERIFY(f.configuration());
 
     f.startFilter(&node, 0, 0, 100, 100);
     image->waitForDone();
 
     for (int i = 0; i < 100 ; i++) {
         for (int j = 0; j < 100 ; j++) {
             QColor pixel;
             layer->paintDevice()->pixel(i, j, &pixel);
             QVERIFY(pixel == QColor(Qt::white));
         }
     }
 }
 
 KISTEST_MAIN(TestFilter)
 
diff --git a/libs/psd/psd_utils.cpp b/libs/psd/psd_utils.cpp
index 661142d480..38beb2b5e3 100644
--- a/libs/psd/psd_utils.cpp
+++ b/libs/psd/psd_utils.cpp
@@ -1,281 +1,280 @@
 /*
  *  Copyright (c) 2009 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 "psd_utils.h"
 
 #include <QtEndian>
 
 #include <QIODevice>
 #include <QString>
 
-#include <QtEndian>
 #include "psd.h"
 
 bool psdwrite(QIODevice* io, quint8 v)
 {
     int written = io->write((char*)&v, 1);
     return written == 1;
 }
 
 bool psdwrite(QIODevice* io, quint16 v)
 {
     quint16 val = qToBigEndian((quint16)v);
     int written = io->write((char*)&val, 2);
     return written == 2;
 }
 
 bool psdwrite(QIODevice* io, qint16 v)
 {
     qint16 val = qToBigEndian((qint16)v);
     int written = io->write((char*)&val, 2);
     return written == 2;
 }
 
 bool psdwrite(QIODevice* io, quint32 v)
 {
     quint32 val = qToBigEndian((quint32)v);
     int written = io->write((char*)&val, 4);
     return written == 4;
 }
 
 bool psdwrite(QIODevice* io, double val)
 {
     Q_ASSERT(sizeof(double) == sizeof(qint64));
     void *v = &val;
     qint64 i = qToBigEndian<qint64>(*(qint64*)(v));
     quint64 write = io->write((char*)&i, 8);
     if (write != 8) return false;
     return true;
 }
 
 bool psdpad(QIODevice* io, quint32 padding)
 {
     char* pad = new char[padding];
     memset(pad, 0, padding);
     quint32 written = io->write(pad, padding);
     delete [] pad;
     return written == padding;
 }
 
 bool psdwrite(QIODevice* io, const QString &s)
 {
     int l = s.length();
     QByteArray b = s.toLatin1();
     char* str = b.data();
     int written = io->write(str, l);
     return written == l;
 }
 
 bool psdwrite_pascalstring(QIODevice* io, const QString &s)
 {
     Q_ASSERT(s.length() < 256);
     Q_ASSERT(s.length() >= 0);
     if (s.length() < 0 || s.length() > 255) return false;
 
     if (s.isNull()) {
         psdwrite(io, (quint8)0);
         psdwrite(io, (quint8)0);
         return true;
     }
     quint8 length = s.length();
     psdwrite(io, length);
 
     QByteArray b = s.toLatin1();
     char* str = b.data();
     int written = io->write(str, length);
     if (written != length) return false;
 
     if ((length & 0x01) != 0) {
         return psdwrite(io, (quint8)0);
     }
 
     return true;
 }
 
 bool psdwrite_pascalstring(QIODevice* io, const QString &s, int padding)
 {
     Q_ASSERT(s.length() < 256);
     Q_ASSERT(s.length() >= 0);
     if (s.length() < 0 || s.length() > 255) return false;
 
     if (s.isNull()) {
         psdwrite(io, (quint8)0);
         psdwrite(io, (quint8)0);
         return true;
     }
     quint8 length = s.length();
     psdwrite(io, length);
 
     QByteArray b = s.toLatin1();
     char* str = b.data();
     int written = io->write(str, length);
     if (written != length) return false;
 
     // If the total length (length byte + content) is not a multiple of padding, add zeroes to pad
     length++;
     if ((length % padding) != 0) {
         for (int i = 0; i < (padding - (length %padding)); i++) {
             psdwrite(io, (quint8)0);
         }
     }
 
     return true;
 }
 
 
 bool psdread(QIODevice *io, quint8 *v)
 {
     quint64 read = io->read((char*)v, 1);
     if (read != 1) return false;
     return true;
 }
 
 bool psdread(QIODevice* io, quint16* v)
 {
     quint16 val;
     quint64 read = io->read((char*)&val, 2);
     if (read != 2) return false;
     *v = qFromBigEndian(val);
     return true;
 }
 
 bool psdread(QIODevice* io, qint16* v)
 {
     qint16 val;
     quint64 read = io->read((char*)&val, 2);
     if (read != 2) return false;
     *v = qFromBigEndian(val);
     return true;
 }
 
 
 bool psdread(QIODevice* io, quint32* v)
 {
     quint32 val;
     quint64 read = io->read((char*)&val, 4);
     if (read != 4) return false;
     *v = qFromBigEndian(val);
     return true;
 }
 
 
 bool psdread(QIODevice* io, qint32* v)
 {
     qint32 val;
     quint64 read = io->read((char*)&val, 4);
     if (read != 4) return false;
     *v = qFromBigEndian(val);
     return true;
 }
 
 bool psdread(QIODevice* io, quint64* v)
 {
     quint64 val;
     quint64 read = io->read((char*)&val, 8);
     if (read != 8) return false;
 
     *v = qFromBigEndian<qint64>((quint8*)&val);
     return true;
 }
 
 bool psdread(QIODevice* io, double* v)
 {
     Q_ASSERT(sizeof(double) == sizeof(qint64));
 
     qint64 val;
     quint64 read = io->read((char*)&val, 8);
     if (read != 8) return false;
     *(reinterpret_cast<qint64*>(v)) = qFromBigEndian<qint64>(val);
     return true;
 }
 
 bool psdread_pascalstring(QIODevice* io, QString& s, int padding)
 {
     quint8 length;
     if (!psdread(io, &length)) {
         return false;
     }
 
     if (length == 0) {
         // read the padding
         for (int i = 0; i < padding -1; ++i) {
             io->seek(io->pos() + 1);
         }
         return true;
     }
 
     QByteArray chars = io->read(length);
     if (chars.length() != length) {
         return false;
     }
 
     // read padding byte
     quint32 paddedLength = length + 1;
     if (padding > 0) {
         while (paddedLength % padding != 0) {
             if (!io->seek(io->pos() + 1)) {
                 return false;
             }
             paddedLength++;
         }
     }
 
     s.append(QString::fromLatin1(chars));
 
     return true;
 }
 
 
 
 bool psd_read_blendmode(QIODevice *io, QString &blendModeKey)
 {
     QByteArray b;
     b = io->read(4);
     if(b.size() != 4 || QString(b) != "8BIM") {
         return false;
     }
     blendModeKey = QString(io->read(4));
     if (blendModeKey.size() != 4) {
         return false;
     }
     return true;
 }
 
 
 
 
 bool psdread_unicodestring(QIODevice *io, QString &s)
 {
     quint32 stringlen;
     if (!psdread(io, &stringlen)) {
         return false;
     }
 
     for (uint i = 0; i < stringlen; ++i) {
         quint16 ch;
         if (!psdread(io, &ch)) {
             return false;
         }
 
         if (ch != 0) {
             QChar uch(ch);
             s.append(uch);
         }
     }
 
     return true;
 }
diff --git a/libs/ui/KisApplication.cpp b/libs/ui/KisApplication.cpp
index 8bde174da4..f40f64ebd5 100644
--- a/libs/ui/KisApplication.cpp
+++ b/libs/ui/KisApplication.cpp
@@ -1,824 +1,821 @@
 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  * Copyright (C) 2012 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 "KisApplication.h"
 
 #include <stdlib.h>
 #ifdef Q_OS_WIN
 #include <windows.h>
 #include <tchar.h>
 #endif
 
 #ifdef Q_OS_OSX
 #include "osx.h"
 #endif
 
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDir>
 #include <QFile>
 #include <QLocale>
 #include <QMessageBox>
-#include <QMessageBox>
 #include <QProcessEnvironment>
 #include <QSettings>
-#include <QStandardPaths>
 #include <QStringList>
 #include <QStyle>
 #include <QStyleFactory>
 #include <QSysInfo>
 #include <QTimer>
 #include <QWidget>
 
 #include <klocalizedstring.h>
 #include <kdesktopfile.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoShapeRegistry.h>
 #include <KoDpi.h>
 #include "KoConfig.h"
 #include <resources/KoHashGeneratorProvider.h>
 #include <KoResourcePaths.h>
 #include <KisMimeDatabase.h>
 #include "thememanager.h"
 #include "KisPrintJob.h"
 #include "KisDocument.h"
 #include "KisMainWindow.h"
 #include "KisAutoSaveRecoveryDialog.h"
 #include "KisPart.h"
 #include <kis_icon.h>
 #include "kis_md5_generator.h"
 #include "kis_splash_screen.h"
 #include "kis_config.h"
 #include "flake/kis_shape_selection.h"
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_registry.h>
 #include <generator/kis_generator.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include "kisexiv2/kis_exiv2.h"
 #include "KisApplicationArguments.h"
 #include <kis_debug.h>
 #include "kis_action_registry.h"
 #include <kis_brush_server.h>
 #include <KisResourceServerProvider.h>
 #include <KoResourceServerProvider.h>
 #include "kis_image_barrier_locker.h"
 #include "opengl/kis_opengl.h"
 #include "kis_spin_box_unit_manager.h"
 #include "kis_document_aware_spin_box_unit_manager.h"
 #include "KisViewManager.h"
 #include "kis_workspace_resource.h"
-#include <KisAutoSaveRecoveryDialog.h>
 
 #include <KritaVersionWrapper.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "widgets/KisScreenColorPicker.h"
 #include "KisDlgInternalColorSelector.h"
 
 namespace {
 const QTime appStartTime(QTime::currentTime());
 }
 
 class KisApplication::Private
 {
 public:
     Private() {}
     QPointer<KisSplashScreen> splashScreen;
     KisAutoSaveRecoveryDialog *autosaveDialog {0};
     QPointer<KisMainWindow> mainWindow; // The first mainwindow we create on startup
     bool batchRun {false};
 
 };
 
 class KisApplication::ResetStarting
 {
 public:
     ResetStarting(KisSplashScreen *splash, int fileCount)
         : m_splash(splash)
         , m_fileCount(fileCount)
     {
     }
 
     ~ResetStarting()  {
 
         if (m_splash) {
             m_splash->hide();
         }
     }
 
     QPointer<KisSplashScreen> m_splash;
     int m_fileCount;
 };
 
 
 KisApplication::KisApplication(const QString &key, int &argc, char **argv)
     : QtSingleApplication(key, argc, argv)
     , d(new Private)
 {
 #ifdef Q_OS_OSX
     setMouseCoalescingEnabled(false);
 #endif
 
     KisDlgInternalColorSelector::s_screenColorPickerFactory = KisScreenColorPicker::createScreenColorPicker;
 
 
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath());
 
     setApplicationDisplayName("Krita");
     setApplicationName("krita");
     // Note: Qt docs suggest we set this, but if we do, we get resource paths of the form of krita/krita, which is weird.
     //    setOrganizationName("krita");
     setOrganizationDomain("krita.org");
 
     QString version = KritaVersionWrapper::versionString(true);
     setApplicationVersion(version);
     setWindowIcon(KisIconUtils::loadIcon("calligrakrita"));
 
     if (qgetenv("KRITA_NO_STYLE_OVERRIDE").isEmpty()) {
         QStringList styles = QStringList() << "breeze" << "fusion" << "plastique";
         if (!styles.contains(style()->objectName().toLower())) {
             Q_FOREACH (const QString & style, styles) {
                 if (!setStyle(style)) {
                     qDebug() << "No" << style << "available.";
                 }
                 else {
                     qDebug() << "Set style" << style;
                     break;
                 }
             }
         }
     }
     else {
         qDebug() << "Style override disabled, using" << style()->objectName();
     }
 
     KisOpenGL::initialize();
 }
 
 #if defined(Q_OS_WIN) && defined(ENV32BIT)
 typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
 
 LPFN_ISWOW64PROCESS fnIsWow64Process;
 
 BOOL isWow64()
 {
     BOOL bIsWow64 = FALSE;
 
     //IsWow64Process is not available on all supported versions of Windows.
     //Use GetModuleHandle to get a handle to the DLL that contains the function
     //and GetProcAddress to get a pointer to the function if available.
 
     fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
                 GetModuleHandle(TEXT("kernel32")),"IsWow64Process");
 
     if(0 != fnIsWow64Process)
     {
         if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
         {
             //handle error
         }
     }
     return bIsWow64;
 }
 #endif
 
 void KisApplication::initializeGlobals(const KisApplicationArguments &args)
 {
     int dpiX = args.dpiX();
     int dpiY = args.dpiY();
     if (dpiX > 0 && dpiY > 0) {
         KoDpi::setDPI(dpiX, dpiY);
     }
 }
 
 void KisApplication::addResourceTypes()
 {
     //    qDebug() << "addResourceTypes();";
     // All Krita's resource types
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("kis_windowlayouts", "data", "/windowlayouts/");
     KoResourcePaths::addResourceType("kis_sessions", "data", "/sessions/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/", true);
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/", true);
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/", true);
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
     KoResourcePaths::addResourceType("templates", "data", "/templates");
     KoResourcePaths::addResourceType("pythonscripts", "data", "/pykrita");
     KoResourcePaths::addResourceType("symbols", "data", "/symbols");
     KoResourcePaths::addResourceType("preset_icons", "data", "/preset_icons");
 
     //    // Extra directories to look for create resources. (Does anyone actually use that anymore?)
     //    KoResourcePaths::addResourceDir("ko_gradients", "/usr/share/create/gradients/gimp");
     //    KoResourcePaths::addResourceDir("ko_gradients", QDir::homePath() + QString("/.create/gradients/gimp"));
     //    KoResourcePaths::addResourceDir("ko_patterns", "/usr/share/create/patterns/gimp");
     //    KoResourcePaths::addResourceDir("ko_patterns", QDir::homePath() + QString("/.create/patterns/gimp"));
     //    KoResourcePaths::addResourceDir("kis_brushes", "/usr/share/create/brushes/gimp");
     //    KoResourcePaths::addResourceDir("kis_brushes", QDir::homePath() + QString("/.create/brushes/gimp"));
     //    KoResourcePaths::addResourceDir("ko_palettes", "/usr/share/create/swatches");
     //    KoResourcePaths::addResourceDir("ko_palettes", QDir::homePath() + QString("/.create/swatches"));
 
     // Make directories for all resources we can save, and tags
     QDir d;
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/tags/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/asl/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/brushes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/gradients/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/paintoppresets/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/palettes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/patterns/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/taskset/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/workspaces/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/input/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/pykrita/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/symbols/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/color-schemes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/tool_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/emblem_icons/");
 }
 
 void KisApplication::loadResources()
 {
     //    qDebug() << "loadResources();";
 
     setSplashScreenLoadingText(i18n("Loading Resources..."));
     processEvents();
     KoResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brush Presets..."));
     processEvents();
     KisResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brushes..."));
     processEvents();
     KisBrushServer::instance()->brushServer();
 
     setSplashScreenLoadingText(i18n("Loading Bundles..."));
     processEvents();
     KisResourceBundleServerProvider::instance();
 }
 
 void KisApplication::loadResourceTags()
 {
     //    qDebug() << "loadResourceTags()";
 
     KoResourceServerProvider::instance()->patternServer()->loadTags();
     KoResourceServerProvider::instance()->gradientServer()->loadTags();
     KoResourceServerProvider::instance()->paletteServer()->loadTags();
     KoResourceServerProvider::instance()->svgSymbolCollectionServer()->loadTags();
     KisBrushServer::instance()->brushServer()->loadTags();
     KisResourceServerProvider::instance()->workspaceServer()->loadTags();
     KisResourceServerProvider::instance()->layerStyleCollectionServer()->loadTags();
     KisResourceBundleServerProvider::instance()->resourceBundleServer()->loadTags();
     KisResourceServerProvider::instance()->paintOpPresetServer()->loadTags();
 
     KisResourceServerProvider::instance()->paintOpPresetServer()->clearOldSystemTags();
 }
 
 void KisApplication::loadPlugins()
 {
     //    qDebug() << "loadPlugins();";
 
     KoShapeRegistry* r = KoShapeRegistry::instance();
     r->add(new KisShapeSelectionFactory());
 
     KisActionRegistry::instance();
     KisFilterRegistry::instance();
     KisGeneratorRegistry::instance();
     KisPaintOpRegistry::instance();
     KoColorSpaceRegistry::instance();
 }
 
 void KisApplication::loadGuiPlugins()
 {
     //    qDebug() << "loadGuiPlugins();";
     // Load the krita-specific tools
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Tool..."));
     processEvents();
     //    qDebug() << "loading tools";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Tool"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
 
     // Load dockers
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Dock..."));
     processEvents();
     //    qDebug() << "loading dockers";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Dock"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
     // XXX_EXIV: make the exiv io backends real plugins
     setSplashScreenLoadingText(i18n("Loading Plugins Exiv/IO..."));
     processEvents();
     //    qDebug() << "loading exiv2";
     KisExiv2::initialize();
 }
 
 bool KisApplication::start(const KisApplicationArguments &args)
 {
     KisConfig cfg(false);
 
 #if defined(Q_OS_WIN)
 #ifdef ENV32BIT
 
     if (isWow64() && !cfg.readEntry("WarnedAbout32Bits", false)) {
         QMessageBox::information(0,
                                  i18nc("@title:window", "Krita: Warning"),
                                  i18n("You are running a 32 bits build on a 64 bits Windows.\n"
                                       "This is not recommended.\n"
                                       "Please download and install the x64 build instead."));
         cfg.writeEntry("WarnedAbout32Bits", true);
 
     }
 #endif
 #endif
 
     QString opengl = cfg.canvasState();
     if (opengl == "OPENGL_NOT_TRIED" ) {
         cfg.setCanvasState("TRY_OPENGL");
     }
     else if (opengl != "OPENGL_SUCCESS") {
         cfg.setCanvasState("OPENGL_FAILED");
     }
 
     setSplashScreenLoadingText(i18n("Initializing Globals"));
     processEvents();
     initializeGlobals(args);
 
     const bool doNewImage = args.doNewImage();
     const bool doTemplate = args.doTemplate();
     const bool exportAs = args.exportAs();
     const QString exportFileName = args.exportFileName();
 
     d->batchRun = (exportAs || !exportFileName.isEmpty());
     const bool needsMainWindow = !exportAs;
     // only show the mainWindow when no command-line mode option is passed
     bool showmainWindow = !exportAs; // would be !batchRun;
 
     const bool showSplashScreen = !d->batchRun && qEnvironmentVariableIsEmpty("NOSPLASH");
     if (showSplashScreen && d->splashScreen) {
         d->splashScreen->show();
         d->splashScreen->repaint();
         processEvents();
     }
 
     KoHashGeneratorProvider::instance()->setGenerator("MD5", new KisMD5Generator());
 
     KConfigGroup group(KSharedConfig::openConfig(), "theme");
     Digikam::ThemeManager themeManager;
     themeManager.setCurrentTheme(group.readEntry("Theme", "Krita dark"));
 
     ResetStarting resetStarting(d->splashScreen, args.filenames().count()); // remove the splash when done
     Q_UNUSED(resetStarting);
 
     // Make sure we can save resources and tags
     setSplashScreenLoadingText(i18n("Adding resource types"));
     processEvents();
     addResourceTypes();
 
     // Load the plugins
     loadPlugins();
 
     // Load all resources
     loadResources();
 
     // Load all the tags
     loadResourceTags();
 
     // Load the gui plugins
     loadGuiPlugins();
 
     KisPart *kisPart = KisPart::instance();
     if (needsMainWindow) {
         // show a mainWindow asap, if we want that
         setSplashScreenLoadingText(i18n("Loading Main Window..."));
         processEvents();
 
 
         bool sessionNeeded = true;
         auto sessionMode = cfg.sessionOnStartup();
 
         if (!args.session().isEmpty()) {
             sessionNeeded = !kisPart->restoreSession(args.session());
         } else if (sessionMode == KisConfig::SOS_ShowSessionManager) {
             showmainWindow = false;
             sessionNeeded = false;
             kisPart->showSessionManager();
         } else if (sessionMode == KisConfig::SOS_PreviousSession) {
             KConfigGroup sessionCfg = KSharedConfig::openConfig()->group("session");
             const QString &sessionName = sessionCfg.readEntry("previousSession");
 
             sessionNeeded = !kisPart->restoreSession(sessionName);
         }
 
         if (sessionNeeded) {
             kisPart->startBlankSession();
         }
 
         if (!args.windowLayout().isEmpty()) {
             KoResourceServer<KisWindowLayoutResource> * rserver = KisResourceServerProvider::instance()->windowLayoutServer();
             KisWindowLayoutResource* windowLayout = rserver->resourceByName(args.windowLayout());
             if (windowLayout) {
                 windowLayout->applyLayout();
             }
         }
 
         if (showmainWindow) {
             d->mainWindow = kisPart->currentMainwindow();
 
             if (!args.workspace().isEmpty()) {
                 KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
                 KisWorkspaceResource* workspace = rserver->resourceByName(args.workspace());
                 if (workspace) {
                     d->mainWindow->restoreWorkspace(workspace);
                 }
             }
 
             if (args.canvasOnly()) {
                 d->mainWindow->viewManager()->switchCanvasOnly(true);
             }
 
             if (args.fullScreen()) {
                 d->mainWindow->showFullScreen();
             }
         } else {
             d->mainWindow = kisPart->createMainWindow();
         }
     }
     short int numberOfOpenDocuments = 0; // number of documents open
 
     // Check for autosave files that can be restored, if we're not running a batchrun (test)
     if (!d->batchRun) {
         checkAutosaveFiles();
     }
 
     setSplashScreenLoadingText(QString()); // done loading, so clear out label
     processEvents();
 
     //configure the unit manager
     KisSpinBoxUnitManagerFactory::setDefaultUnitManagerBuilder(new KisDocumentAwareSpinBoxUnitManagerBuilder());
     connect(this, &KisApplication::aboutToQuit, &KisSpinBoxUnitManagerFactory::clearUnitManagerBuilder); //ensure the builder is destroyed when the application leave.
     //the new syntax slot syntax allow to connect to a non q_object static method.
 
 
     // Create a new image, if needed
     if (doNewImage) {
         KisDocument *doc = args.image();
         if (doc) {
             kisPart->addDocument(doc);
             d->mainWindow->addViewAndNotifyLoadingCompleted(doc);
         }
     }
 
     // Get the command line arguments which we have to parse
     int argsCount = args.filenames().count();
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; argNumber++) {
             QString fileName = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 // called in mix with batch options? ignore and silently skip
                 if (d->batchRun) {
                     continue;
                 }
                 if (createNewDocFromTemplate(fileName, d->mainWindow)) {
                     ++numberOfOpenDocuments;
                 }
                 // now try to load
             }
             else {
                 if (exportAs) {
                     QString outputMimetype = KisMimeDatabase::mimeTypeForFile(exportFileName, false);
                     if (outputMimetype == "application/octetstream") {
                         dbgKrita << i18n("Mimetype not found, try using the -mimetype option") << endl;
                         return 1;
                     }
 
                     KisDocument *doc = kisPart->createDocument();
                     doc->setFileBatchMode(d->batchRun);
                     doc->openUrl(QUrl::fromLocalFile(fileName));
 
                     qApp->processEvents(); // For vector layers to be updated
 
                     doc->setFileBatchMode(true);
                     if (!doc->exportDocumentSync(QUrl::fromLocalFile(exportFileName), outputMimetype.toLatin1())) {
                         dbgKrita << "Could not export " << fileName << "to" << exportFileName << ":" << doc->errorMessage();
                     }
                     QTimer::singleShot(0, this, SLOT(quit()));
                 }
                 else if (d->mainWindow) {
                     if (fileName.endsWith(".bundle")) {
                         d->mainWindow->installBundle(fileName);
                     }
                     else {
                         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
 
                         if (d->mainWindow->openDocument(QUrl::fromLocalFile(fileName), flags)) {
                             // Normal case, success
                             numberOfOpenDocuments++;
                         }
                     }
                 }
             }
         }
     }
 
     // fixes BUG:369308  - Krita crashing on splash screen when loading.
     // trying to open a file before Krita has loaded can cause it to hang and crash
     if (d->splashScreen) {
         d->splashScreen->displayLinks(true);
         d->splashScreen->displayRecentFiles(true);
     }
 
 
     // not calling this before since the program will quit there.
     return true;
 }
 
 KisApplication::~KisApplication()
 {
 }
 
 void KisApplication::setSplashScreen(QWidget *splashScreen)
 {
     d->splashScreen = qobject_cast<KisSplashScreen*>(splashScreen);
 }
 
 void KisApplication::setSplashScreenLoadingText(QString textToLoad)
 {
     if (d->splashScreen) {
         //d->splashScreen->loadingLabel->setText(textToLoad);
         d->splashScreen->setLoadingText(textToLoad);
         d->splashScreen->repaint();
     }
 }
 
 void KisApplication::hideSplashScreen()
 {
     if (d->splashScreen) {
         // hide the splashscreen to see the dialog
         d->splashScreen->hide();
     }
 }
 
 
 bool KisApplication::notify(QObject *receiver, QEvent *event)
 {
     try {
         return QApplication::notify(receiver, event);
     } catch (std::exception &e) {
         qWarning("Error %s sending event %i to object %s",
                  e.what(), event->type(), qPrintable(receiver->objectName()));
     } catch (...) {
         qWarning("Error <unknown> sending event %i to object %s",
                  event->type(), qPrintable(receiver->objectName()));
     }
     return false;
 }
 
 
 void KisApplication::remoteArguments(QByteArray message, QObject *socket)
 {
     Q_UNUSED(socket);
 
     // check if we have any mainwindow
     KisMainWindow *mw = qobject_cast<KisMainWindow*>(qApp->activeWindow());
     if (!mw) {
         mw = KisPart::instance()->mainWindows().first();
     }
 
     if (!mw) {
         return;
     }
 
     KisApplicationArguments args = KisApplicationArguments::deserialize(message);
     const bool doTemplate = args.doTemplate();
     const int argsCount = args.filenames().count();
 
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; ++argNumber) {
             QString filename = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 createNewDocFromTemplate(filename, mw);
             }
             else if (QFile(filename).exists()) {
                 KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                 mw->openDocument(QUrl::fromLocalFile(filename), flags);
             }
         }
     }
 }
 
 void KisApplication::fileOpenRequested(const QString &url)
 {
     KisMainWindow *mainWindow = KisPart::instance()->mainWindows().first();
     if (mainWindow) {
         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         mainWindow->openDocument(QUrl::fromLocalFile(url), flags);
     }
 }
 
 
 void KisApplication::checkAutosaveFiles()
 {
     if (d->batchRun) return;
 
     // Check for autosave files from a previous run. There can be several, and
     // we want to offer a restore for every one. Including a nice thumbnail!
 
     QStringList filters;
     filters << QString(".krita-*-*-autosave.kra");
 
 #ifdef Q_OS_WIN
     QDir dir = QDir::temp();
 #else
     QDir dir = QDir::home();
 #endif
 
     // all autosave files for our application
     QStringList autosaveFiles = dir.entryList(filters, QDir::Files | QDir::Hidden);
 
     // Allow the user to make their selection
     if (autosaveFiles.size() > 0) {
         if (d->splashScreen) {
             // hide the splashscreen to see the dialog
             d->splashScreen->hide();
         }
         d->autosaveDialog = new KisAutoSaveRecoveryDialog(autosaveFiles, activeWindow());
         QDialog::DialogCode result = (QDialog::DialogCode) d->autosaveDialog->exec();
 
         if (result == QDialog::Accepted) {
             QStringList filesToRecover = d->autosaveDialog->recoverableFiles();
             Q_FOREACH (const QString &autosaveFile, autosaveFiles) {
                 if (!filesToRecover.contains(autosaveFile)) {
                     QFile::remove(dir.absolutePath() + "/" + autosaveFile);
                 }
             }
             autosaveFiles = filesToRecover;
         } else {
             autosaveFiles.clear();
         }
 
         if (autosaveFiles.size() > 0) {
             QList<QUrl> autosaveUrls;
             Q_FOREACH (const QString &autoSaveFile, autosaveFiles) {
                 const QUrl url = QUrl::fromLocalFile(dir.absolutePath() + QLatin1Char('/') + autoSaveFile);
                 autosaveUrls << url;
             }
             if (d->mainWindow) {
                 Q_FOREACH (const QUrl &url, autosaveUrls) {
                     KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                     d->mainWindow->openDocument(url, flags | KisMainWindow::RecoveryFile);
                 }
             }
         }
         // cleanup
         delete d->autosaveDialog;
         d->autosaveDialog = nullptr;
     }
 }
 
 bool KisApplication::createNewDocFromTemplate(const QString &fileName, KisMainWindow *mainWindow)
 {
     QString templatePath;
 
     const QUrl templateUrl = QUrl::fromLocalFile(fileName);
     if (QFile::exists(fileName)) {
         templatePath = templateUrl.toLocalFile();
         dbgUI << "using full path...";
     }
     else {
         QString desktopName(fileName);
         const QString templatesResourcePath =  QStringLiteral("templates/");
 
         QStringList paths = KoResourcePaths::findAllResources("data", templatesResourcePath + "*/" + desktopName);
         if (paths.isEmpty()) {
             paths = KoResourcePaths::findAllResources("data", templatesResourcePath + desktopName);
         }
 
         if (paths.isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("No template found for: %1", desktopName));
         } else if (paths.count() > 1) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Too many templates found for: %1", desktopName));
         } else {
             templatePath = paths.at(0);
         }
     }
 
     if (!templatePath.isEmpty()) {
         QUrl templateBase;
         templateBase.setPath(templatePath);
         KDesktopFile templateInfo(templatePath);
 
         QString templateName = templateInfo.readUrl();
         QUrl templateURL;
         templateURL.setPath(templateBase.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() + '/' + templateName);
 
         KisMainWindow::OpenFlags batchFlags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         if (mainWindow->openDocument(templateURL, KisMainWindow::Import | batchFlags)) {
             dbgUI << "Template loaded...";
             return true;
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Template %1 failed to load.", templateURL.toDisplayString()));
         }
     }
 
     return false;
 }
 
 void KisApplication::clearConfig()
 {
     KIS_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
 
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     // find user settings file
     bool createDir = false;
     QString kritarcPath = KoResourcePaths::locateLocal("config", "kritarc", createDir);
 
     QFile configFile(kritarcPath);
     if (configFile.exists()) {
         // clear file
         if (configFile.open(QFile::WriteOnly)) {
             configFile.close();
         }
         else {
             QMessageBox::warning(0,
                                  i18nc("@title:window", "Krita"),
                                  i18n("Failed to clear %1\n\n"
                                       "Please make sure no other program is using the file and try again.",
                                       kritarcPath),
                                  QMessageBox::Ok, QMessageBox::Ok);
         }
     }
 
     // reload from disk; with the user file settings cleared,
     // this should load any default configuration files shipping with the program
     config->reparseConfiguration();
     config->sync();
 }
 
 void KisApplication::askClearConfig()
 {
     Qt::KeyboardModifiers mods = QApplication::queryKeyboardModifiers();
     bool askClearConfig = (mods & Qt::ControlModifier) && (mods & Qt::ShiftModifier) && (mods & Qt::AltModifier);
 
     if (askClearConfig) {
         bool ok = QMessageBox::question(0,
                                         i18nc("@title:window", "Krita"),
                                         i18n("Do you want to clear the settings file?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::Yes;
         if (ok) {
             clearConfig();
         }
     }
 }
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index 00c5383b04..50e74a92ac 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1820 +1,1817 @@
 /* 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 <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <QTemporaryFile>
 #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_config.h>
 #include <flake/kis_shape_layer.h>
-#include <kis_debug.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_debug.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.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 "KisPart.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"
 
 
 // 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)
         : 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)
         : docInfo(new KoDocumentInfo(*rhs.docInfo, q))
         , unit(rhs.unit)
         , importExportManager(new KisImportExportManager(q))
         , mimeType(rhs.mimeType)
         , outputMimeType(rhs.outputMimeType)
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q))
         , guidesConfig(rhs.guidesConfig)
         , m_bAutoDetectedMime(rhs.m_bAutoDetectedMime)
         , m_url(rhs.m_url)
         , m_file(rhs.m_file)
         , modified(rhs.modified)
         , readwrite(rhs.readwrite)
         , firstMod(rhs.firstMod)
         , lastMod(rhs.lastMod)
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , assistants(rhs.assistants) // WARNING: assistants should not store pointers to the document!
         , globalAssistantsColor(rhs.globalAssistantsColor)
         , gridConfig(rhs.gridConfig)
         , savingLock(&savingMutex)
         , batchMode(rhs.batchMode)
     {
         // TODO: clone assistants
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     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;
 
     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;
 
     KisSharedPtr<KisReferenceImagesLayer> referenceImagesLayer;
 
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportFilter::ConversionStatus> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     class StrippedSafeSavingLocker;
 };
 
 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();
 
             // 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),
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, 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(rhs.objectName());
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 
     // clone the image with keeping the GUIDs of the layers intact
     // NOTE: we expect the image to be locked!
     setCurrentImage(rhs.image()->clone(true), false);
 
     if (rhs.d->preActivatedNode) {
         // since we clone uuid's, we can use them for lacating new
         // nodes. Otherwise we would need to use findSymmetricClone()
         d->preActivatedNode =
                 KisLayerUtils::findNodeByUuid(d->image->root(), rhs.d->preActivatedNode->uuid());
     }
 }
 
 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());
     }
 
     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,
                                    KisImportExportFilter::CreationError,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         return false;
     }
 
     KisConfig cfg(true);
     if (cfg.backupFile() && filePathInfo.exists()) {
         KBackup::backupFile(job.filePath);
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus,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;
     }
 
     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;
 
     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) != KisImportExportFilter::OK) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     if (status == KisImportExportFilter::UserCancelled)
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         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)) {
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 d->undoStack->setClean();
             }
             setRecovered(false);
             removeAutoSaveFiles();
         }
 
         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();
     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);
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return false;
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportFilter::ConversionStatus status =
         d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status == KisImportExportFilter::OK;
 }
 
 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;
     }
 
     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(KisImportExportFilter::ConversionStatus, const QString&)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus, const QString&)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,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(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     KIS_SAFE_ASSERT_RECOVER(!d->savingMutex.tryLock()) {
         d->savingMutex.unlock();
         return;
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveDocument);
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
     d->savingMutex.unlock();
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveJob.isValid());
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     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);
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus, const 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, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         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);
         }
     }
 
     KisImportExportFilter::ConversionStatus initializationStatus;
     d->childSavingFuture =
         d->importExportManager->exportDocumentAsyc(location,
                                                    realLocation,
                                                    mimeType,
                                                    initializationStatus,
                                                    showWarnings,
                                                    exportConfiguration);
 
     if (initializationStatus != KisImportExportFilter::ConversionStatus::OK) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, this->errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportFilter::ConversionStatus> 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(KisImportExportFilter::InternalError, "");
         return;
     }
 
     KisImportExportFilter::ConversionStatus status =
         d->childSavingFuture.result();
     const QString errorMessage = this->errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportFilter::ConversionStatus>();
     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");
     QRegularExpression autosavePattern("^\\..+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern.match(filename).hasMatch()) {
         // 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.%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #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.%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #endif
     } else {
         retval = QString("%1%2.%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension);
     }
 
     //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();
             //dbgUI <<"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 :
                 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 (!(flags & DontAddToRecent)) {
             KisPart::instance()->addRecentURLToAllMainWindows(_url);
         }
 
         if (ret) {
             // 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())) {
         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();
     if (window && window->viewManager()) {
         KoUpdaterPtr updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportFilter::ConversionStatus status;
 
     status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (status != KisImportExportFilter::OK) {
         QString msg = KisImportExportFilter::conversionStatusString(status);
         if (!msg.isEmpty()) {
             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()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 // 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()
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(localFilePath());   // the one in the current dir
     //qDebug() << "\tfilename:" << asf << "exists:" << QFile::exists(asf);
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autosavefile" << asf;
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
     //qDebug() << "Autsavefile in $home" << asf;
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autsavefile 2" << asf;
         QFile::remove(asf);
     }
 }
 
 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);
     d->undoStack->setUndoLimit(cfg.undoStackLimit());
     d->autoSaveDelay = cfg.autoSaveInterval();
     setNormalAutoSaveInterval();
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     d->gridConfig = config;
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 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, bool backgroundAsLayer,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisImageSP image;
     KisPaintLayerSP layer;
 
     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());
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     Q_CHECK_PTR(layer);
 
     if (backgroundAsLayer) {
         image->setDefaultProjectionColor(KoColor(cs));
 
         if (bgColor.opacityU8() == OPACITY_OPAQUE_U8) {
             layer->paintDevice()->setDefaultPixel(bgColor);
         } else {
             // Hack: with a semi-transparent background color, the projection isn't composited right if we just set the default pixel
             KisFillPainter painter;
             painter.begin(layer->paintDevice());
             painter.fillRect(0, 0, width, height, bgColor, bgColor.opacityU8());
         }
     } else {
         image->setDefaultProjectionColor(bgColor);
     }
     layer->setDirty(QRect(0, 0, width, height));
 
     image->addNode(layer.data(), image->rootLayer().data());
     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());
 
     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)
 {
     d->assistants = value;
 }
 
 KisSharedPtr<KisReferenceImagesLayer> KisDocument::referenceImagesLayer() const
 {
     return d->referenceImagesLayer.data();
 }
 
 void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage)
 {
     if (d->referenceImagesLayer) {
         d->referenceImagesLayer->disconnect(this);
     }
 
     if (updateImage) {
         if (layer) {
             d->image->addNode(layer);
         } else {
             d->image->removeNode(d->referenceImagesLayer);
         }
     }
 
     d->referenceImagesLayer = layer;
 
     if (d->referenceImagesLayer) {
         connect(d->referenceImagesLayer, SIGNAL(sigUpdateCanvas(const QRectF&)),
                 this, SIGNAL(sigReferenceImagesChanged()));
     }
 }
 
 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->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
 
     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()
 {
     setModified(true);
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? KisImportExportFilter::conversionStatusString(status) : errorMessage;
 }
 
 void KisDocument::setAssistantsGlobalColor(QColor color)
 {
     d->globalAssistantsColor = color;
 }
 
 QColor KisDocument::assistantsGlobalColor()
 {
     return d->globalAssistantsColor;
 }
 
 QRectF KisDocument::documentBounds() const
 {
     QRectF bounds = d->image->bounds();
 
     if (d->referenceImagesLayer) {
         bounds |= d->referenceImagesLayer->boundingImageRect();
     }
 
     return bounds;
 }
diff --git a/libs/ui/KisImportExportManager.cpp b/libs/ui/KisImportExportManager.cpp
index 510685f1f0..8cb9905d46 100644
--- a/libs/ui/KisImportExportManager.cpp
+++ b/libs/ui/KisImportExportManager.cpp
@@ -1,639 +1,638 @@
 /*
  * 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 <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 <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 <KisMimeDatabase.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<KisImportExportFilter::ConversionStatus> &futureStatus)
         : m_isAsync(true),
           m_futureStatus(futureStatus)
     {
     }
 
     ConversionResult(KisImportExportFilter::ConversionStatus status)
         : m_isAsync(false),
           m_status(status)
     {
     }
 
     bool isAsync() const {
         return m_isAsync;
     }
 
     QFuture<KisImportExportFilter::ConversionStatus> 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 != KisImportExportFilter::OK);
 
         return m_futureStatus;
     }
 
     KisImportExportFilter::ConversionStatus status() const {
         return m_status;
     }
 
     void setStatus(KisImportExportFilter::ConversionStatus value) {
         m_status = value;
     }
 private:
     bool m_isAsync = false;
     QFuture<KisImportExportFilter::ConversionStatus> m_futureStatus;
     KisImportExportFilter::ConversionStatus m_status = KisImportExportFilter::UsageError;
 };
 
 
 KisImportExportManager::KisImportExportManager(KisDocument* document)
     : m_document(document)
     , d(new Private)
 {
 }
 
 KisImportExportManager::~KisImportExportManager()
 {
     delete d;
 }
 
 KisImportExportFilter::ConversionStatus 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(), KisImportExportFilter::UsageError);
 
     return result.status();
 }
 
 KisImportExportFilter::ConversionStatus 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(), KisImportExportFilter::UsageError);
 
     return result.status();
 }
 
 QFuture<KisImportExportFilter::ConversionStatus> KisImportExportManager::exportDocumentAsyc(const QString &location, const QString &realLocation, const QByteArray &mimeType, KisImportExportFilter::ConversionStatus &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() != KisImportExportFilter::OK, QFuture<KisImportExportFilter::ConversionStatus>());
 
     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("@titile: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 KisImportExportFilter::FilterCreationError;
     }
 
     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,
                 KisImportExportFilter::BadConversionGraph);
 
 
 
     ConversionResult result = KisImportExportFilter::OK;
     if (direction == Import) {
         // async importing is not yet supported!
         KIS_SAFE_ASSERT_RECOVER_NOOP(!isAsync);
 
         if (0 && !batchMode()) {
             KisAsyncActionFeedback f(i18n("Opening document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doImport, this, location, filter));
         } else {
             result = doImport(location, filter);
         }
     }
     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 KisImportExportFilter::UserCancelled;
         }
 
         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(KisImportExportFilter::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) {
             KisConfig(false).setExportConfiguration(typeName, exportConfiguration);
         }
     }
     return result;
 }
 
 void KisImportExportManager::fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration)
 {
     // Fill with some meta information about the image
     KisImageSP image = m_document->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);
 }
 
 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);
     }
 
     // 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> 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> 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);
         }
 
         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;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doImport(const QString &location, QSharedPointer<KisImportExportFilter> filter)
 {
     QFile file(location);
     if (!file.exists()) {
         return KisImportExportFilter::FileNotFound;
     }
 
     if (filter->supportsIO() && !file.open(QFile::ReadOnly)) {
         return KisImportExportFilter::FileNotFound;
     }
 
     KisImportExportFilter::ConversionStatus status =
             filter->convert(m_document, &file, KisPropertiesConfigurationSP());
 
     if (file.isOpen()) {
         file.close();
     }
 
     return status;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doExport(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration, bool alsoAsKra)
 {
     KisImportExportFilter::ConversionStatus status =
             doExportImpl(location, filter, exportConfiguration);
 
     if (alsoAsKra && status == KisImportExportFilter::OK) {
         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 = KisImportExportFilter::FilterCreationError;
         }
     }
 
     return status;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doExportImpl(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration)
 {
     QSaveFile file(location);
     file.setDirectWriteFallback(true);
 
     if (filter->supportsIO() && !file.open(QFile::WriteOnly)) {
         m_document->setErrorMessage(file.errorString());
         file.cancelWriting();
         return KisImportExportFilter::CreationError;
     }
 
     KisImportExportFilter::ConversionStatus status =
             filter->convert(m_document, &file, exportConfiguration);
 
     if (filter->supportsIO()) {
         if (status != KisImportExportFilter::OK) {
             file.cancelWriting();
         } else {
             if (!file.commit()) {
                 m_document->setErrorMessage(file.errorString());
                 status = KisImportExportFilter::CreationError;
             }
         }
     }
     return status;
 
 }
 
 #include <KisMimeDatabase.h>
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index 7fb5ea406a..f884f06dd7 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2660 +1,2658 @@
 /* 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 <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 <QSignalMapper>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QTemporaryFile>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 #include <QStackedWidget>
 
 
 #include <kactioncollection.h>
 #include <QAction>
 #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"
 
 #ifdef HAVE_KIO
 #include <krecentdocument.h>
 #endif
 #include <krecentfilesaction.h>
 #include <KoResourcePaths.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 "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>
 
-#include <KisMimeDatabase.h>
 #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.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_icon_utils.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 <mutex>
 
 #ifdef Q_OS_WIN
   #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 
 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 QSignalMapper(parent))
         , documentMapper(new QSignalMapper(parent))
     {
         if (id.isNull()) this->id = QUuid::createUuid();
 
         widgetStack->addWidget(welcomePage);
         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 *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};
 
     KisWelcomePageWidget *welcomePage {0};
 
 
     QStackedWidget *widgetStack {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     QSignalMapper *windowMapper;
     QSignalMapper *documentMapper;
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
 
     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");
 
     setAcceptDrops(true);
     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_OSX
     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);
         }
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     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*)));
 
     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);
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
 
         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!";
         }
     }
     plugActionList("toolbarlist", toolbarList);
     d->toolbarList = toolbarList;
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
 #ifdef Q_OS_WIN
     auto w = qApp->activeWindow();
     if (w) QWindowsWindowFunctions::setHasBorderInFullScreen(w->windowHandle(), true);
 #endif
 
     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));
     }
 }
 
 KisMainWindow::~KisMainWindow()
 {
 //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
 //        QAction *action = qobject_cast<QAction*>(ac);
 //        if (action) {
 //        dbgKrita << "<Action"
 //                 << "name=" << action->objectName()
 //                 << "icon=" << action->icon().name()
 //                 << "text="  << action->text().replace("&", "&amp;")
 //                 << "whatsThis="  << action->whatsThis()
 //                 << "toolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
 //                 << "iconText="  << action->iconText().replace("&", "&amp;")
 //                 << "shortcut="  << action->shortcut(QAction::ActiveShortcut).toString()
 //                 << "defaultShortcut="  << action->shortcut(QAction::DefaultShortcut).toString()
 //                 << "isCheckable="  << QString((action->isChecked() ? "true" : "false"))
 //                 << "statusTip=" << action->statusTip()
 //                 << "/>"   ;
 //        }
 //        else {
 //            dbgKrita << "Got a 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)
 {
     if (d->activeView == view) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view);
     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)
 {
     viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
     if (view->canvasBase() == viewManager()->canvasBase()) {
         viewManager()->setCurrentView(0);
     }
 }
 
 
 void KisMainWindow::showView(KisView *imageView)
 {
     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();
 
         QMdiSubWindow *subwin = d->mdiArea->addSubWindow(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()) {
         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();
             }
 
         }
 
         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);
     }
 
     emit themeChanged();
 }
 
 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
                 }
             }
 #ifdef HAVE_KIO
             if (ok) {
                 KRecentDocument::add(QUrl::fromLocalFile(path));
             }
 #endif
         }
 #ifdef HAVE_KIO
         else {
             KRecentDocument::add(url.adjusted(QUrl::StripTrailingSlash));
         }
 #endif
         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();
 }
 
 
 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") + "] ";
         }
 
 
         // new documents aren't saved yet, so we don't need to say it is modified
         // new files don't have a URL, so we are using that for the check
         if (!doc->url().isEmpty()) {
 
             if ( doc->isModified()) {
                 caption += " [" + i18n("Modified") + "] ";
             }
         }
 
         // 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( ")");
         }
 
 
         d->activeView->setWindowTitle(caption);
         d->activeView->setWindowModified(doc->isModified());
 
         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 mod)
 {
     dbgUI << "KisMainWindow::updateCaption(" << caption << "," << mod << ")";
 #ifdef KRITA_ALPHA
     setCaption(QString("ALPHA %1: %2").arg(KRITA_ALPHA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_BETA
     setCaption(QString("BETA %1: %2").arg(KRITA_BETA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_RC
     setCaption(QString("RELEASE CANDIDATE %1: %2").arg(KRITA_RC).arg(caption), mod);
     return;
 #endif
 
     setCaption(caption, mod);
 }
 
 
 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(const QString &)), this, SLOT(slotLoadCanceled(const 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)
 {
     showWelcomeScreen(false); // see workaround in function header
 
     KisView *view = KisPart::instance()->createView(document, resourceManager(), actionCollection(), this);
     addView(view);
 
     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(const QString &)), this, SLOT(slotLoadCanceled(const 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(const QString &)), this, SLOT(slotLoadCanceled(const 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(const QString &)), this, SLOT(slotSaveCanceled(const 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;
     }
 
     bool reset_url;
 
     if (document->url().isEmpty()) {
         reset_url = true;
         saveas = true;
     }
     else {
         reset_url = false;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     QUrl oldURL = document->url();
     QString oldFile = document->localFilePath();
 
     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()).baseName();
 
         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()) {
 
             // 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()).baseName();
             // 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.baseName());
         }
 
         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()).baseName();
             justChangingFilterOptions = (QFileInfo(newURL.toLocalFile()).absolutePath() == path)
                     && (QFileInfo(newURL.toLocalFile()).baseName() == 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!";
                         document->setUrl(oldURL);
                         document->setLocalFilePath(oldFile);
                     }
                 }
                 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!";
             document->setUrl(oldURL);
             document->setLocalFilePath(oldFile);
         }
     }
 
     if (ret && !isExporting) {
         document->setRecovered(false);
     }
 
     if (!ret && reset_url)
         document->resetURL(); //clean the suggested filename as the save dialog was rejected
 
     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 (!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);
     } 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::dragEnterEvent(QDragEnterEvent *event)
 {
     d->welcomePage->showDropAreaIndicator(true);
 
 
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisMainWindow::dropEvent(QDropEvent *event)
 {
     d->welcomePage->showDropAreaIndicator(false);
 
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             if (url.toLocalFile().endsWith(".bundle")) {
                 bool r = installBundle(url.toLocalFile());
                 qDebug() << "\t" << r;
             }
             else {
                 openDocument(url, None);
             }
         }
     }
 }
 
 void KisMainWindow::dragMoveEvent(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::dragLeaveEvent(QDragLeaveEvent * /*event*/)
 {
         d->welcomePage->showDropAreaIndicator(false);
 
     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";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, 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, item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(const QUrl&)), KisPart::instance(), SLOT(openTemplate(const QUrl&)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
     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";
             }
         }
     }
 }
 
 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();
 }
 
 KoCanvasResourceManager *KisMainWindow::resourceManager() const
 {
     return d->viewManager->resourceProvider()->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()
 {
     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);
         KisImportExportFilter::ConversionStatus status = importer.import(files, firstFrame, step);
 
         if (status != KisImportExportFilter::OK && status != KisImportExportFilter::InternalError) {
             QString msg = KisImportExportFilter::conversionStatusString(status);
 
             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
     }
 }
 
 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_OSX
     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);
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::windowFocused()
 {
     /**
      * Notify selection manager so that it could update selection mask overlay
      */
     viewManager()->selectionManager()->selectionChanged();
 
 
     auto *kisPart = KisPart::instance();
     auto *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();
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = doc->url().toDisplayString();
             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->resourceProvider()->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, child->document()->url().toDisplayString());
             }
             else {
                 text = i18n("%1 %2", i + 1, child->document()->url().toDisplayString());
             }
 
             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 contiue 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();
 
     QBrush brush(cfg.getMDIBackgroundColor());
     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)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     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_OSX
         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.baseName();
     }
 
     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)));
 
     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->createAction("file_close");
     connect(d->close, SIGNAL(triggered()), 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 = QApplication::desktop()->availableGeometry(scnum);
         // if the desktop is virtual then use virtual screen size
         if (QApplication::desktop()->isVirtualDesktop()) {
             desk = QApplication::desktop()->availableGeometry(QApplication::desktop()->screen(scnum));
         }
 
         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 componensate 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::moveEvent(QMoveEvent *e)
 {
     /**
      * For checking if the display number has changed or not we should always use
      * positional overload, not using QWidget overload. Otherwise we might get
      * inconsistency, because screenNumber(widget) can return -1, but screenNumber(pos)
      * will always return the nearest screen.
      */
 
     const int oldScreen = qApp->desktop()->screenNumber(e->oldPos());
     const int newScreen = qApp->desktop()->screenNumber(e->pos());
 
     if (oldScreen != newScreen) {
         KisConfigNotifier::instance()->notifyConfigChanged();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index a74ddc00d1..76707bb382 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,575 +1,568 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@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 "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeControllerBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <kdesktopfile.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
-#include "KisView.h"
-#include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "KisResourceServerProvider.h"
 #include "kis_animation_cache_populator.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
-#include "KisImportExportManager.h"
-#include "KisDocument.h"
-#include "KoToolManager.h"
-#include "KisViewManager.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
-#include "kis_debug.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     KActionCollection *actionCollection{0};
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResource *currentSession = nullptr;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return false;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
                              KoCanvasResourceManager *resourceManager,
                              KActionCollection *actionCollection,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg(false);
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.setUseOpenGL(false);
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.setUseOpenGL(false);
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView *view  = new KisView(document, resourceManager, actionCollection, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
         KisConfig kisCfg(false);
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     //  - Shortcuts called inside of tools
     //  - Perhaps other things?
     KoToolManager::instance()->updateToolShortcuts();
 
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if(action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> * rserver = KisResourceServerProvider::instance()->sessionServer();
     auto *session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     session->restore();
 
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResource *session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/KisResourceBundle.cpp b/libs/ui/KisResourceBundle.cpp
index cb0bdbfe45..5432020dcb 100644
--- a/libs/ui/KisResourceBundle.cpp
+++ b/libs/ui/KisResourceBundle.cpp
@@ -1,1018 +1,1017 @@
 /*
  *  Copyright (c) 2014 Victor Lafon metabolic.ewilan@hotmail.fr
  *
  * 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 "KisResourceBundle.h"
 #include "KisResourceBundleManifest.h"
 
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoStore.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourcePaths.h>
 
 #include <QScopedPointer>
 #include <QProcessEnvironment>
 #include <QDate>
 #include <QDir>
 #include <kis_debug.h>
 #include <QBuffer>
 #include <QCryptographicHash>
 #include <QByteArray>
 #include <QPainter>
 #include <QStringList>
 #include <QMessageBox>
 
 #include <resources/KoHashGeneratorProvider.h>
 #include <resources/KoHashGenerator.h>
 #include <KisResourceServerProvider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
-#include <kis_debug.h>
 
 #include <KritaVersionWrapper.h>
 
 KisResourceBundle::KisResourceBundle(QString const& fileName)
     : KoResource(fileName),
       m_bundleVersion("1")
 {
     setName(QFileInfo(fileName).baseName());
     m_metadata["generator"] = "Krita (" + KritaVersionWrapper::versionString(true) + ")";
 
 }
 
 KisResourceBundle::~KisResourceBundle()
 {
 }
 
 QString KisResourceBundle::defaultFileExtension() const
 {
     return QString(".bundle");
 }
 
 bool KisResourceBundle::load()
 {
     if (filename().isEmpty()) return false;
     QScopedPointer<KoStore> resourceStore(KoStore::createStore(filename(), KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
     if (!resourceStore || resourceStore->bad()) {
         warnKrita << "Could not open store on bundle" << filename();
         m_installed = false;
         setValid(false);
         return false;
 
     } else {
 
         m_metadata.clear();
 
         bool toRecreate = false;
         if (resourceStore->open("META-INF/manifest.xml")) {
             if (!m_manifest.load(resourceStore->device())) {
                 warnKrita << "Could not open manifest for bundle" << filename();
                 return false;
             }
             resourceStore->close();
 
             Q_FOREACH (KisResourceBundleManifest::ResourceReference ref, m_manifest.files()) {
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Bundle is broken. File" << ref.resourcePath << "is missing";
                     toRecreate = true;
                 }
                 else {
                     resourceStore->close();
                 }
             }
 
 
             if(toRecreate) {
                 warnKrita << "Due to missing files and wrong entries in the manifest, " << filename() << " will be recreated.";
             }
 
         } else {
             warnKrita << "Could not load META-INF/manifest.xml";
             return false;
         }
 
         bool versionFound = false;
         if (resourceStore->open("meta.xml")) {
             KoXmlDocument doc;
             if (!doc.setContent(resourceStore->device())) {
                 warnKrita << "Could not parse meta.xml for" << filename();
                 return false;
             }
             // First find the manifest:manifest node.
             KoXmlNode n = doc.firstChild();
             for (; !n.isNull(); n = n.nextSibling()) {
                 if (!n.isElement()) {
                     continue;
                 }
                 if (n.toElement().tagName() == "meta:meta") {
                     break;
                 }
             }
 
             if (n.isNull()) {
                 warnKrita << "Could not find manifest node for bundle" << filename();
                 return false;
             }
 
             const KoXmlElement  metaElement = n.toElement();
             for (n = metaElement.firstChild(); !n.isNull(); n = n.nextSibling()) {
                 if (n.isElement()) {
                     KoXmlElement e = n.toElement();
                     if (e.tagName() == "meta:generator") {
                         m_metadata.insert("generator", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:author") {
                         m_metadata.insert("author", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:title") {
                         m_metadata.insert("title", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:description") {
                         m_metadata.insert("description", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:initial-creator") {
                         m_metadata.insert("author", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:creator") {
                         m_metadata.insert("author", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:creation-date") {
                          m_metadata.insert("created", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:dc-date") {
                         m_metadata.insert("updated", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:meta-userdefined") {
                         if (e.attribute("meta:name") == "tag") {
                             m_bundletags << e.attribute("meta:value");
                         }
                         else {
                             m_metadata.insert(e.attribute("meta:name"), e.attribute("meta:value"));
                         }
                     }
                     else if(e.tagName() == "meta:bundle-version") {
                         m_metadata.insert("bundle-version", e.firstChild().toText().data());
                         versionFound = true;
                     }
                 }
             }
             resourceStore->close();
         }
         else {
             warnKrita << "Could not load meta.xml";
             return false;
         }
 
         if (resourceStore->open("preview.png")) {
             // Workaround for some OS (Debian, Ubuntu), where loading directly from the QIODevice
             // fails with "libpng error: IDAT: CRC error"
             QByteArray data = resourceStore->device()->readAll();
             QBuffer buffer(&data);
             m_thumbnail.load(&buffer, "PNG");
             resourceStore->close();
         }
         else {
             warnKrita << "Could not open preview.png";
         }
 
         /*
          * If no version is found it's an old bundle with md5 hashes to fix, or if some manifest resource entry
          * doesn't not correspond to a file the bundle is "broken", in both cases we need to recreate the bundle.
          */
         if (!versionFound) {
             m_metadata.insert("bundle-version", "1");
             warnKrita << filename() << " has an old version and possibly wrong resources md5, so it will be recreated.";
             toRecreate = true;
         }
 
         if (toRecreate) {
             recreateBundle(resourceStore);
         }
 
 
         m_installed = true;
         setValid(true);
         setImage(m_thumbnail);
     }
 
     return true;
 }
 
 bool KisResourceBundle::loadFromDevice(QIODevice *)
 {
     return false;
 }
 
 bool saveResourceToStore(KoResource *resource, KoStore *store, const QString &resType)
 {
     if (!resource) {
         warnKrita << "No Resource";
         return false;
     }
 
     if (!resource->valid()) {
         warnKrita << "Resource is not valid";
         return false;
     }
     if (!store || store->bad()) {
         warnKrita << "No Store or Store is Bad";
         return false;
     }
 
     QByteArray ba;
     QBuffer buf;
 
     QFileInfo fi(resource->filename());
     if (fi.exists() && fi.isReadable()) {
 
         QFile f(resource->filename());
         if (!f.open(QFile::ReadOnly)) {
             warnKrita << "Could not open resource" << resource->filename();
             return false;
         }
         ba = f.readAll();
         if (ba.size() == 0) {
             warnKrita << "Resource is empty" << resource->filename();
             return false;
         }
         f.close();
         buf.setBuffer(&ba);
     }
     else {
         warnKrita << "Could not find the resource " << resource->filename() << " or it isn't readable";
         return false;
     }
 
     if (!buf.open(QBuffer::ReadOnly)) {
         warnKrita << "Could not open buffer";
         return false;
     }
     Q_ASSERT(!store->hasFile(resType + "/" + resource->shortFilename()));
     if (!store->open(resType + "/" + resource->shortFilename())) {
         warnKrita << "Could not open file in store for resource";
         return false;
     }
 
     bool res = (store->write(buf.data()) == buf.size());
     store->close();
     return res;
 
 }
 
 bool KisResourceBundle::save()
 {
     if (filename().isEmpty()) return false;
 
     addMeta("updated", QDate::currentDate().toString("dd/MM/yyyy"));
 
     QDir bundleDir = KoResourcePaths::saveLocation("data", "bundles");
     bundleDir.cdUp();
 
     QScopedPointer<KoStore> store(KoStore::createStore(filename(), KoStore::Write, "application/x-krita-resourcebundle", KoStore::Zip));
 
     if (!store || store->bad()) return false;
 
     Q_FOREACH (const QString &resType, m_manifest.types()) {
 
         if (resType == "ko_gradients") {
             KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = gradientServer->resourceByMD5(ref.md5sum);
                 if (!res) res = gradientServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "gradients")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "ko_patterns") {
             KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = patternServer->resourceByMD5(ref.md5sum);
                 if (!res) res = patternServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "patterns")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "kis_brushes") {
             KisBrushResourceServer* brushServer = KisBrushServer::instance()->brushServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KisBrushSP brush = brushServer->resourceByMD5(ref.md5sum);
                 if (!brush) brush = brushServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 KoResource *res = brush.data();
                 if (!saveResourceToStore(res, store.data(), "brushes")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "ko_palettes") {
             KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = paletteServer->resourceByMD5(ref.md5sum);
                 if (!res) res = paletteServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "palettes")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "kis_workspaces") {
             KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = workspaceServer->resourceByMD5(ref.md5sum);
                 if (!res) res = workspaceServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "workspaces")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "kis_paintoppresets") {
             KisPaintOpPresetResourceServer* paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KisPaintOpPresetSP res = paintoppresetServer->resourceByMD5(ref.md5sum);
                 if (!res) res = paintoppresetServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res.data(), store.data(), "paintoppresets")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
     }
 
     if (!m_thumbnail.isNull()) {
         QByteArray byteArray;
         QBuffer buffer(&byteArray);
         m_thumbnail.save(&buffer, "PNG");
         if (!store->open("preview.png")) warnKrita << "Could not open preview.png";
         if (store->write(byteArray) != buffer.size()) warnKrita << "Could not write preview.png";
         store->close();
     }
 
     saveManifest(store);
 
     saveMetadata(store);
 
     store->finalize();
 
     return true;
 }
 
 bool KisResourceBundle::saveToDevice(QIODevice */*dev*/) const
 {
     return false;
 }
 
 bool KisResourceBundle::install()
 {
     QStringList md5Mismatch;
     if (filename().isEmpty())  {
         warnKrita << "Cannot install bundle: no file name" << this;
         return false;
     }
     QScopedPointer<KoStore> resourceStore(KoStore::createStore(filename(), KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
     if (!resourceStore || resourceStore->bad()) {
         warnKrita << "Cannot open the resource bundle: invalid zip file?";
         return false;
     }
 
     Q_FOREACH (const QString &resType, m_manifest.types()) {
         dbgResources << "Installing resource type" << resType;
         if (resType == "gradients") {
             KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KoAbstractGradient *res = gradientServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 KoAbstractGradient *res2 = gradientServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     gradientServer->addResource(res, false);//add it!
 
                     if (!m_gradientsMd5Installed.contains(res->md5())) {
                         m_gradientsMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         gradientServer->addTag(res, tag);
                     }
                     //gradientServer->addTag(res, name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
 
             }
         }
         else if (resType  == "patterns") {
             KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KoPattern *res = patternServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 KoPattern *res2 = patternServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     patternServer->addResource(res, false);//add it!
 
                     if (!m_patternsMd5Installed.contains(res->md5())) {
                         m_patternsMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         patternServer->addTag(res, tag);
                     }
                     //patternServer->addTag(res, name());
                 }
 
             }
         }
         else if (resType  == "brushes") {
             KisBrushResourceServer *brushServer = KisBrushServer::instance()->brushServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KisBrushSP res = brushServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 //find the resource on the server
                 KisBrushSP res2 = brushServer->resourceByName(res->name());
                 if (res2) {
                     res->setName(res->name()+"("+res->shortFilename()+")");
                 }
                 // file name is more important than the regular name because the
                 // it is the way how it is called up from the brushpreset settings.
                 // Therefore just adjust the resource name and only refuse to load
                 // when the filename is different.
                 res2 = brushServer->resourceByFilename(res->shortFilename());
                 if (!res2)  {//if it doesn't exist...
                     brushServer->addResource(res, false);//add it!
 
                     if (!m_brushesMd5Installed.contains(res->md5())) {
                         m_brushesMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         brushServer->addTag(res.data(), tag);
                     }
                     //brushServer->addTag(res.data(), name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
             }
         }
         else if (resType  == "palettes") {
             KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KoColorSet *res = paletteServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
 
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 //find the resource on the server
                 KoColorSet *res2 = paletteServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     paletteServer->addResource(res, false);//add it!
 
                     if (!m_palettesMd5Installed.contains(res->md5())) {
                         m_palettesMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         paletteServer->addTag(res, tag);
                     }
                     //paletteServer->addTag(res, name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
             }
         }
         else if (resType  == "workspaces") {
             KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KisWorkspaceResource *res = workspaceServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 //the following tries to find the resource by name.
                 KisWorkspaceResource *res2 = workspaceServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     workspaceServer->addResource(res, false);//add it!
 
                     if (!m_workspacesMd5Installed.contains(res->md5())) {
                         m_workspacesMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         workspaceServer->addTag(res, tag);
                     }
                     //workspaceServer->addTag(res, name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
 
             }
         }
         else if (resType  == "paintoppresets") {
             KisPaintOpPresetResourceServer*  paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KisPaintOpPresetSP res = paintoppresetServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
 
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 // Workaround for some OS (Debian, Ubuntu), where loading directly from the QIODevice
                 // fails with "libpng error: IDAT: CRC error"
                 QByteArray data = resourceStore->device()->readAll();
                 QBuffer buffer(&data);
                 if (!res->loadFromDevice(&buffer)) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name() << "File:" << res->filename();
 
                 //the following tries to find the resource by name.
                 KisPaintOpPresetSP res2 = paintoppresetServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     paintoppresetServer->addResource(res, false);//add it!
                     if (!m_presetsMd5Installed.contains(res->md5())){
                         m_presetsMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         paintoppresetServer->addTag(res.data(), tag);
                     }
                     //paintoppresetServer->addTag(res.data(), name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
 
             }
         }
     }
     m_installed = true;
     if(!md5Mismatch.isEmpty()){
         QString message = i18n("The following resources had mismatching MD5 sums. They may have gotten corrupted, for example, during download.");
         QMessageBox bundleFeedback;
         bundleFeedback.setIcon(QMessageBox::Warning);
         Q_FOREACH (QString name, md5Mismatch) {
             message.append("\n");
             message.append(name);
         }
         bundleFeedback.setText(message);
         bundleFeedback.exec();
     }
     return true;
 }
 
 bool KisResourceBundle::uninstall()
 {
 
     m_installed = false;
     QStringList tags = getTagsList();
     tags << m_manifest.tags();
     //tags << name();
 
     KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("gradients")) {
     Q_FOREACH (const QByteArray md5, m_gradientsMd5Installed) {
         KoAbstractGradient *res = gradientServer->resourceByMD5(md5);
         if (res) {
             gradientServer->removeResourceFromServer(res);
         }
     }
 
     KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("patterns")) {
     Q_FOREACH (const QByteArray md5, m_patternsMd5Installed) {
         KoPattern *res = patternServer->resourceByMD5(md5);
         if (res) {
             patternServer->removeResourceFromServer(res);
         }
     }
 
     KisBrushResourceServer *brushServer = KisBrushServer::instance()->brushServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("brushes")) {
     Q_FOREACH (const QByteArray md5, m_brushesMd5Installed) {
         KisBrushSP res = brushServer->resourceByMD5(md5);
         if (res) {
             brushServer->removeResourceFromServer(res);
         }
     }
 
     KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("palettes")) {
     Q_FOREACH (const QByteArray md5, m_palettesMd5Installed) {
         KoColorSet *res = paletteServer->resourceByMD5(md5);
         if (res) {
             paletteServer->removeResourceFromServer(res);
         }
     }
 
     KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("workspaces")) {
     Q_FOREACH (const QByteArray md5, m_workspacesMd5Installed) {
         KisWorkspaceResource *res = workspaceServer->resourceByMD5(md5);
         if (res) {
             workspaceServer->removeResourceFromServer(res);
         }
     }
     KisPaintOpPresetResourceServer* paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("paintoppresets")) {
     Q_FOREACH (const QByteArray md5, m_presetsMd5Installed) {
         KisPaintOpPresetSP res = paintoppresetServer->resourceByMD5(md5);
         if (res) {
             paintoppresetServer->removeResourceFromServer(res);
         }
     }
 
     Q_FOREACH(const QString &tag, tags) {
         paintoppresetServer->tagCategoryRemoved(tag);
         workspaceServer->tagCategoryRemoved(tag);
         paletteServer->tagCategoryRemoved(tag);
         brushServer->tagCategoryRemoved(tag);
         patternServer->tagCategoryRemoved(tag);
         gradientServer->tagCategoryRemoved(tag);
     }
 
 
     return true;
 }
 
 void KisResourceBundle::addMeta(const QString &type, const QString &value)
 {
     m_metadata.insert(type, value);
 }
 
 const QString KisResourceBundle::getMeta(const QString &type, const QString &defaultValue) const
 {
     if (m_metadata.contains(type)) {
         return m_metadata[type];
     }
     else {
        return defaultValue;
     }
 }
 
 void KisResourceBundle::addResource(QString fileType, QString filePath, QStringList fileTagList, const QByteArray md5sum)
 {
     m_manifest.addResource(fileType, filePath, fileTagList, md5sum);
 }
 
 QList<QString> KisResourceBundle::getTagsList()
 {
     return QList<QString>::fromSet(m_bundletags);
 }
 
 
 bool KisResourceBundle::isInstalled()
 {
     return m_installed;
 }
 
 
 QStringList KisResourceBundle::resourceTypes() const
 {
     return m_manifest.types();
 }
 
 QList<KoResource*> KisResourceBundle::resources(const QString &resType) const
 {
     QList<KisResourceBundleManifest::ResourceReference> references = m_manifest.files(resType);
 
     QList<KoResource*> ret;
     Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, references) {
         if (resType == "gradients") {
             KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
             KoResource *res =  gradientServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "patterns") {
             KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
             KoResource *res =  patternServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "brushes") {
             KisBrushResourceServer *brushServer = KisBrushServer::instance()->brushServer();
             KoResource *res =  brushServer->resourceByMD5(ref.md5sum).data();
             if (res) ret << res;
         }
         else if (resType  == "palettes") {
             KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
             KoResource *res =  paletteServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "workspaces") {
             KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
             KoResource *res =  workspaceServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "paintoppresets") {
             KisPaintOpPresetResourceServer* paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
             KisPaintOpPresetSP res =  paintoppresetServer->resourceByMD5(ref.md5sum);
             if (res) ret << res.data();
         }
     }
     return ret;
 }
 
 void KisResourceBundle::setThumbnail(QString filename)
 {
     if (QFileInfo(filename).exists()) {
         m_thumbnail = QImage(filename);
         m_thumbnail = m_thumbnail.scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
     else {
         m_thumbnail = QImage(256, 256, QImage::Format_ARGB32);
         QPainter gc(&m_thumbnail);
         gc.fillRect(0, 0, 256, 256, Qt::red);
         gc.end();
     }
 
     setImage(m_thumbnail);
 }
 
 void KisResourceBundle::writeMeta(const char *metaTag, const QString &metaKey, KoXmlWriter *writer)
 {
     if (m_metadata.contains(metaKey)) {
         writer->startElement(metaTag);
         writer->addTextNode(m_metadata[metaKey].toUtf8());
         writer->endElement();
     }
 }
 
 void KisResourceBundle::writeUserDefinedMeta(const QString &metaKey, KoXmlWriter *writer)
 {
     if (m_metadata.contains(metaKey)) {
         writer->startElement("meta:meta-userdefined");
         writer->addAttribute("meta:name", metaKey);
         writer->addAttribute("meta:value", m_metadata[metaKey]);
         writer->endElement();
     }
 }
 
 void KisResourceBundle::setInstalled(bool install)
 {
     m_installed = install;
 }
 
 void KisResourceBundle::saveMetadata(QScopedPointer<KoStore> &store)
 {
     QBuffer buf;
 
     store->open("meta.xml");
     buf.open(QBuffer::WriteOnly);
 
     KoXmlWriter metaWriter(&buf);
     metaWriter.startDocument("office:document-meta");
     metaWriter.startElement("meta:meta");
 
     writeMeta("meta:generator", "generator", &metaWriter);
 
     metaWriter.startElement("meta:bundle-version");
     metaWriter.addTextNode(m_bundleVersion.toUtf8());
     metaWriter.endElement();
 
     writeMeta("dc:author", "author", &metaWriter);
     writeMeta("dc:title", "filename", &metaWriter);
     writeMeta("dc:description", "description", &metaWriter);
     writeMeta("meta:initial-creator", "author", &metaWriter);
     writeMeta("dc:creator", "author", &metaWriter);
     writeMeta("meta:creation-date", "created", &metaWriter);
     writeMeta("meta:dc-date", "updated", &metaWriter);
     writeUserDefinedMeta("email", &metaWriter);
     writeUserDefinedMeta("license", &metaWriter);
     writeUserDefinedMeta("website", &metaWriter);
     Q_FOREACH (const QString &tag, m_bundletags) {
         metaWriter.startElement("meta:meta-userdefined");
         metaWriter.addAttribute("meta:name", "tag");
         metaWriter.addAttribute("meta:value", tag);
         metaWriter.endElement();
     }
 
     metaWriter.endElement(); // meta:meta
     metaWriter.endDocument();
 
     buf.close();
     store->write(buf.data());
     store->close();
 }
 
 void KisResourceBundle::saveManifest(QScopedPointer<KoStore> &store)
 {
     store->open("META-INF/manifest.xml");
     QBuffer buf;
     buf.open(QBuffer::WriteOnly);
     m_manifest.save(&buf);
     buf.close();
     store->write(buf.data());
     store->close();
 }
 
 void KisResourceBundle::recreateBundle(QScopedPointer<KoStore> &oldStore)
 {
     // Save a copy of the unmodified bundle, so that if anything goes bad the user doesn't lose it
     QFile file(filename());
     file.copy(filename() + ".old");
 
     QString newStoreName = filename() + ".tmp";
     QScopedPointer<KoStore> store(KoStore::createStore(newStoreName, KoStore::Write, "application/x-krita-resourcebundle", KoStore::Zip));
     KoHashGenerator *generator = KoHashGeneratorProvider::instance()->getGenerator("MD5");
     KisResourceBundleManifest newManifest;
 
     addMeta("updated", QDate::currentDate().toString("dd/MM/yyyy"));
 
     Q_FOREACH (KisResourceBundleManifest::ResourceReference ref, m_manifest.files()) {
         // Wrong manifest entry found, skip it
         if(!oldStore->open(ref.resourcePath))
             continue;
 
         store->open(ref.resourcePath);
 
         QByteArray data = oldStore->device()->readAll();
         oldStore->close();
         store->write(data);
         store->close();
         QByteArray result = generator->generateHash(data);
         newManifest.addResource(ref.fileTypeName, ref.resourcePath, ref.tagList, result);
     }
 
     m_manifest = newManifest;
 
     if (!m_thumbnail.isNull()) {
         QByteArray byteArray;
         QBuffer buffer(&byteArray);
         m_thumbnail.save(&buffer, "PNG");
         if (!store->open("preview.png")) warnKrita << "Could not open preview.png";
         if (store->write(byteArray) != buffer.size()) warnKrita << "Could not write preview.png";
         store->close();
     }
 
     saveManifest(store);
     saveMetadata(store);
 
     store->finalize();
 
     // Remove the current bundle and then move the tmp one to be the correct one
     file.setFileName(filename());
     file.remove();
     file.setFileName(newStoreName);
     file.rename(filename());
 }
 
 
 int KisResourceBundle::resourceCount() const
 {
     return m_manifest.files().count();
 }
diff --git a/libs/ui/KisResourceServerProvider.cpp b/libs/ui/KisResourceServerProvider.cpp
index 7bba63fde6..5360352ce8 100644
--- a/libs/ui/KisResourceServerProvider.cpp
+++ b/libs/ui/KisResourceServerProvider.cpp
@@ -1,121 +1,120 @@
 /*
  *  kis_resourceserver.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Matthias Elter <elter@kde.org>
  *  Copyright (c) 2003 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KisResourceServerProvider.h"
 
 #include <QDir>
 #include <QApplication>
 #include <QGlobalStatic>
 
 #include <kis_debug.h>
 
 #include <KoResourcePaths.h>
 
 #include <resources/KoResource.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerAdapter.h>
 
-#include <kis_debug.h>
 #include <resources/KoPattern.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_workspace_resource.h>
 #include <KisWindowLayoutResource.h>
 #include <KisSessionResource.h>
 
 #include <kis_psd_layer_style_resource.h>
 
 #include <kis_brush_server.h>
 
 Q_GLOBAL_STATIC(KisResourceServerProvider, s_instance)
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisResourceServerProvider::KisResourceServerProvider()
 {
     KisBrushServer *brushServer = KisBrushServer::instance();
 
     m_paintOpPresetServer = new KisPaintOpPresetResourceServer("kis_paintoppresets", "*.kpp");
     m_paintOpPresetServer->loadResources(KoResourceServerProvider::blacklistFileNames(m_paintOpPresetServer->fileNames(), m_paintOpPresetServer->blackListedFiles()));
 
     m_workspaceServer = new KoResourceServerSimpleConstruction<KisWorkspaceResource>("kis_workspaces", "*.kws");
     m_workspaceServer->loadResources(KoResourceServerProvider::blacklistFileNames(m_workspaceServer->fileNames(), m_workspaceServer->blackListedFiles()));
 
     m_windowLayoutServer = new KoResourceServerSimpleConstruction<KisWindowLayoutResource>("kis_windowlayouts", "*.kwl");
     m_windowLayoutServer->loadResources(KoResourceServerProvider::blacklistFileNames(m_windowLayoutServer->fileNames(), m_windowLayoutServer->blackListedFiles()));
 
     m_sessionServer = new KoResourceServerSimpleConstruction<KisSessionResource>("kis_sessions", "*.ksn");
     m_sessionServer->loadResources(KoResourceServerProvider::blacklistFileNames(m_sessionServer->fileNames(), m_sessionServer->blackListedFiles()));
 
     m_layerStyleCollectionServer = new KoResourceServerSimpleConstruction<KisPSDLayerStyleCollectionResource>("psd_layer_style_collections", "*.asl");
     m_layerStyleCollectionServer->loadResources(KoResourceServerProvider::blacklistFileNames(m_layerStyleCollectionServer->fileNames(), m_layerStyleCollectionServer->blackListedFiles()));
 
     connect(this, SIGNAL(notifyBrushBlacklistCleanup()),
             brushServer, SLOT(slotRemoveBlacklistedResources()));
 
 }
 
 KisResourceServerProvider::~KisResourceServerProvider()
 {
     delete m_paintOpPresetServer;
     delete m_workspaceServer;
     delete m_sessionServer;
     delete m_windowLayoutServer;
     delete m_layerStyleCollectionServer;
 }
 
 KisResourceServerProvider* KisResourceServerProvider::instance()
 {
     return s_instance;
 }
 
 
 KisPaintOpPresetResourceServer* KisResourceServerProvider::paintOpPresetServer()
 {
     return m_paintOpPresetServer;
 }
 
 KoResourceServer< KisWorkspaceResource >* KisResourceServerProvider::workspaceServer()
 {
     return m_workspaceServer;
 }
 
 KoResourceServer< KisWindowLayoutResource >* KisResourceServerProvider::windowLayoutServer()
 {
     return m_windowLayoutServer;
 }
 
 KoResourceServer< KisSessionResource >* KisResourceServerProvider::sessionServer()
 {
     return m_sessionServer;
 }
 
 KoResourceServer<KisPSDLayerStyleCollectionResource> *KisResourceServerProvider::layerStyleCollectionServer()
 {
     return m_layerStyleCollectionServer;
 }
 
 void KisResourceServerProvider::brushBlacklistCleanup()
 {
     emit notifyBrushBlacklistCleanup();
 }
diff --git a/libs/ui/KisViewManager.cpp b/libs/ui/KisViewManager.cpp
index ed9d9ba7b9..89139fd21f 100644
--- a/libs/ui/KisViewManager.cpp
+++ b/libs/ui/KisViewManager.cpp
@@ -1,1393 +1,1392 @@
 /*
  *  This file is part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                1999 Carsten Pfeiffer <pfeiffer@kde.org>
  *                2002 Patrick Julien <freak@codepimps.org>
  *                2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *                2004 Clarence Dang <dang@kde.org>
  *                2011 José Luis Vergara <pentalis@gmail.com>
  *                2017 L. E. Segovia <leo.segovia@siggraph.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 <stdio.h>
 
 #include "KisViewManager.h"
 #include <QPrinter>
 
 #include <QAction>
 #include <QApplication>
 #include <QBuffer>
 #include <QByteArray>
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDesktopServices>
 #include <QGridLayout>
 #include <QMainWindow>
 #include <QMenu>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QObject>
 #include <QPoint>
 #include <QPrintDialog>
 #include <QRect>
 #include <QScrollBar>
 #include <QStatusBar>
 #include <QToolBar>
 #include <QUrl>
 #include <QWidget>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 #include <kselectaction.h>
 
 #include <KoCanvasController.h>
 #include <KoCompositeOp.h>
 #include <KoDockRegistry.h>
 #include <KoProperties.h>
 #include <KoResourceItemChooserSync.h>
 #include <KoSelection.h>
 #include <KoStore.h>
 #include <KoToolManager.h>
 #include <KoToolRegistry.h>
 #include <KoViewConverter.h>
 #include <KoZoomHandler.h>
 #include <KoPluginLoader.h>
 #include <KoDocumentInfo.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "input/kis_input_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_canvas_controller.h"
 #include "canvas/kis_grid_manager.h"
 #include "dialogs/kis_dlg_blacklist_cleanup.h"
 #include "input/kis_input_profile_manager.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include "kis_canvas_controls_manager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_composite_progress_proxy.h"
 #include <KoProgressUpdater.h>
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_control_frame.h"
 #include "kis_coordinates_converter.h"
 #include "KisDocument.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_filter_manager.h"
 #include "kis_group_layer.h"
 #include <kis_image.h>
 #include <kis_image_barrier_locker.h>
 #include "kis_image_manager.h"
 #include <kis_layer.h>
 #include "kis_mainwindow_observer.h"
 #include "kis_mask_manager.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node.h"
 #include "kis_node_manager.h"
 #include "KisDecorationsManager.h"
 #include <kis_paint_layer.h>
 #include "kis_paintop_box.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include <KoUpdater.h>
 #include "KisResourceServerProvider.h"
 #include "kis_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_selection_manager.h"
 #include "kis_shape_controller.h"
 #include "kis_shape_layer.h"
 #include <kis_signal_compressor.h>
 #include "kis_statusbar.h"
 #include <KisTemplateCreateDia.h>
 #include <kis_tool_freehand.h>
 #include "kis_tooltip_manager.h"
 #include <kis_undo_adapter.h>
 #include "KisView.h"
 #include "kis_zoom_manager.h"
 #include "widgets/kis_floating_message.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_icon_utils.h"
 #include "kis_guides_manager.h"
 #include "kis_derived_resources.h"
 #include "dialogs/kis_delayed_save_dialog.h"
-#include <kis_image.h>
 #include <KisMainWindow.h>
 #include "kis_signals_blocker.h"
 
 
 class BlockingUserInputEventFilter : public QObject
 {
     bool eventFilter(QObject *watched, QEvent *event) override
     {
         Q_UNUSED(watched);
         if(dynamic_cast<QWheelEvent*>(event)
                 || dynamic_cast<QKeyEvent*>(event)
                 || dynamic_cast<QMouseEvent*>(event)) {
             return true;
         }
         else {
             return false;
         }
     }
 };
 
 class KisViewManager::KisViewManagerPrivate
 {
 
 public:
 
     KisViewManagerPrivate(KisViewManager *_q, KActionCollection *_actionCollection, QWidget *_q_parent)
         : filterManager(_q)
         , createTemplate(0)
         , saveIncremental(0)
         , saveIncrementalBackup(0)
         , openResourcesDirectory(0)
         , rotateCanvasRight(0)
         , rotateCanvasLeft(0)
         , resetCanvasRotation(0)
         , wrapAroundAction(0)
         , levelOfDetailAction(0)
         , showRulersAction(0)
         , rulersTrackMouseAction(0)
         , zoomTo100pct(0)
         , zoomIn(0)
         , zoomOut(0)
         , selectionManager(_q)
         , statusBar(_q)
         , controlFrame(_q, _q_parent)
         , nodeManager(_q)
         , imageManager(_q)
         , gridManager(_q)
         , canvasControlsManager(_q)
         , paintingAssistantsManager(_q)
         , actionManager(_q, _actionCollection)
         , mainWindow(0)
         , showFloatingMessage(true)
         , currentImageView(0)
         , canvasResourceProvider(_q)
         , canvasResourceManager()
         , guiUpdateCompressor(30, KisSignalCompressor::POSTPONE, _q)
         , actionCollection(_actionCollection)
         , mirrorManager(_q)
         , inputManager(_q)
         , actionAuthor(0)
         , showPixelGrid(0)
     {
         KisViewManager::initializeResourceManager(&canvasResourceManager);
     }
 
 public:
     KisFilterManager filterManager;
     KisAction *createTemplate;
     KisAction *createCopy;
     KisAction *saveIncremental;
     KisAction *saveIncrementalBackup;
     KisAction *openResourcesDirectory;
     KisAction *rotateCanvasRight;
     KisAction *rotateCanvasLeft;
     KisAction *resetCanvasRotation;
     KisAction *wrapAroundAction;
     KisAction *levelOfDetailAction;
     KisAction *showRulersAction;
     KisAction *rulersTrackMouseAction;
     KisAction *zoomTo100pct;
     KisAction *zoomIn;
     KisAction *zoomOut;
     KisAction *softProof;
     KisAction *gamutCheck;
 
     KisSelectionManager selectionManager;
     KisGuidesManager guidesManager;
     KisStatusBar statusBar;
     QPointer<KoUpdater> persistentImageProgressUpdater;
 
     QScopedPointer<KoProgressUpdater> persistentUnthreadedProgressUpdaterRouter;
     QPointer<KoUpdater> persistentUnthreadedProgressUpdater;
 
     KisControlFrame controlFrame;
     KisNodeManager nodeManager;
     KisImageManager imageManager;
     KisGridManager gridManager;
     KisCanvasControlsManager canvasControlsManager;
     KisDecorationsManager paintingAssistantsManager;
     BlockingUserInputEventFilter blockingEventFilter;
     KisActionManager actionManager;
     QMainWindow* mainWindow;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     bool showFloatingMessage;
     QPointer<KisView> currentImageView;
     KisCanvasResourceProvider canvasResourceProvider;
     KoCanvasResourceManager canvasResourceManager;
     KisSignalCompressor guiUpdateCompressor;
     KActionCollection *actionCollection;
     KisMirrorManager mirrorManager;
     KisInputManager inputManager;
 
     KisSignalAutoConnectionsStore viewConnections;
     KSelectAction *actionAuthor; // Select action for author profile.
     KisAction *showPixelGrid;
 
     QByteArray canvasState;
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
     QFlags<Qt::WindowState> windowFlags;
 #endif
 
     bool blockUntilOperationsFinishedImpl(KisImageSP image, bool force);
 };
 
 KisViewManager::KisViewManager(QWidget *parent, KActionCollection *_actionCollection)
     : d(new KisViewManagerPrivate(this, _actionCollection, parent))
 {
     d->actionCollection = _actionCollection;
     d->mainWindow = dynamic_cast<QMainWindow*>(parent);
     d->canvasResourceProvider.setResourceManager(&d->canvasResourceManager);
     connect(&d->guiUpdateCompressor, SIGNAL(timeout()), this, SLOT(guiUpdateTimeout()));
 
     createActions();
     setupManagers();
 
     // These initialization functions must wait until KisViewManager ctor is complete.
     d->statusBar.setup();
     d->persistentImageProgressUpdater =
             d->statusBar.progressUpdater()->startSubtask(1, "", true);
     // reset state to "completed"
     d->persistentImageProgressUpdater->setRange(0,100);
     d->persistentImageProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdater =
             d->statusBar.progressUpdater()->startSubtask(1, "", true);
     // reset state to "completed"
     d->persistentUnthreadedProgressUpdater->setRange(0,100);
     d->persistentUnthreadedProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdaterRouter.reset(
                 new KoProgressUpdater(d->persistentUnthreadedProgressUpdater,
                                       KoProgressUpdater::Unthreaded));
     d->persistentUnthreadedProgressUpdaterRouter->setAutoNestNames(true);
 
     d->controlFrame.setup(parent);
 
 
     //Check to draw scrollbars after "Canvas only mode" toggle is created.
     this->showHideScrollbars();
 
     QScopedPointer<KoDummyCanvasController> dummy(new KoDummyCanvasController(actionCollection()));
     KoToolManager::instance()->registerToolActions(actionCollection(), dummy.data());
 
     QTimer::singleShot(0, this, SLOT(initializeStatusBarVisibility()));
 
     connect(KoToolManager::instance(), SIGNAL(inputDeviceChanged(KoInputDevice)),
             d->controlFrame.paintopBox(), SLOT(slotInputDeviceChanged(KoInputDevice)));
 
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
             d->controlFrame.paintopBox(), SLOT(slotToolChanged(KoCanvasController*,int)));
 
     connect(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)),
             resourceProvider(), SLOT(slotNodeActivated(KisNodeSP)));
 
     connect(KisPart::instance(), SIGNAL(sigViewAdded(KisView*)), SLOT(slotViewAdded(KisView*)));
     connect(KisPart::instance(), SIGNAL(sigViewRemoved(KisView*)), SLOT(slotViewRemoved(KisView*)));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotUpdateAuthorProfileActions()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotUpdatePixelGridAction()));
 
     KisInputProfileManager::instance()->loadProfiles();
 
     KisConfig cfg(true);
     d->showFloatingMessage = cfg.showCanvasMessages();
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KoColor foreground(Qt::black, cs);
     d->canvasResourceProvider.setFGColor(cfg.readKoColor("LastForeGroundColor",foreground));
     KoColor background(Qt::white, cs);
     d->canvasResourceProvider.setBGColor(cfg.readKoColor("LastBackGroundColor",background));
 
 
 
 }
 
 
 KisViewManager::~KisViewManager()
 {
     KisConfig cfg(false);
     if (resourceProvider() && resourceProvider()->currentPreset()) {
         cfg.writeEntry("LastPreset", resourceProvider()->currentPreset()->name());
         cfg.writeKoColor("LastForeGroundColor",resourceProvider()->fgColor());
         cfg.writeKoColor("LastBackGroundColor",resourceProvider()->bgColor());
 
     }
 
     cfg.writeEntry("baseLength", KoResourceItemChooserSync::instance()->baseLength());
 
     delete d;
 }
 
 void KisViewManager::initializeResourceManager(KoCanvasResourceManager *resourceManager)
 {
     resourceManager->addDerivedResourceConverter(toQShared(new KisCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEffectiveCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisOpacityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisFlowResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisSizeResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodAvailabilityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdSupportedResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEraserModeResourceConverter));
     resourceManager->addResourceUpdateMediator(toQShared(new KisPresetUpdateMediator));
 }
 
 KActionCollection *KisViewManager::actionCollection() const
 {
     return d->actionCollection;
 }
 
 void KisViewManager::slotViewAdded(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is added!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.showAllStatusBarItems();
     }
 }
 
 void KisViewManager::slotViewRemoved(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is removed!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.hideAllStatusBarItems();
     }
 }
 
 void KisViewManager::setCurrentView(KisView *view)
 {
     bool first = true;
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(false);
 
         d->currentImageView->canvasBase()->setCursor(QCursor(Qt::ArrowCursor));
         first = false;
         KisDocument* doc = d->currentImageView->document();
         if (doc) {
             doc->image()->compositeProgressProxy()->removeProxy(d->persistentImageProgressUpdater);
             doc->disconnect(this);
         }
         d->currentImageView->canvasController()->proxyObject->disconnect(&d->statusBar);
         d->viewConnections.clear();
     }
 
 
     QPointer<KisView> imageView = qobject_cast<KisView*>(view);
     d->currentImageView = imageView;
 
     if (imageView) {
         d->softProof->setChecked(imageView->softProofing());
         d->gamutCheck->setChecked(imageView->gamutCheck());
 
         // Wait for the async image to have loaded
         KisDocument* doc = view->document();
 
         if (KisConfig(true).readEntry<bool>("EnablePositionLabel", false)) {
             connect(d->currentImageView->canvasController()->proxyObject,
                     SIGNAL(documentMousePositionChanged(QPointF)),
                     &d->statusBar,
                     SLOT(documentMousePositionChanged(QPointF)));
         }
 
         // Restore the last used brush preset, color and background color.
         if (first) {
             KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
             QString defaultPresetName = "basic_tip_default";
             bool foundTip = false;
             for (int i=0; i<rserver->resourceCount(); i++) {
                 KisPaintOpPresetSP resource = rserver->resources().at(i);
                 if (resource->name().toLower().contains("basic_tip_default")) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                                  resource->filename().toLower().contains("default"))) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 }
             }
             KisConfig cfg(true);
             QString lastPreset = cfg.readEntry("LastPreset", defaultPresetName);
             KisPaintOpPresetSP preset = rserver->resourceByName(lastPreset);
             if (!preset) {
                 preset = rserver->resourceByName(defaultPresetName);
             }
 
             if (!preset && !rserver->resources().isEmpty()) {
                 preset = rserver->resources().first();
             }
             if (preset) {
                 paintOpBox()->restoreResource(preset.data());
             }
         }
 
         KisCanvasController *canvasController = dynamic_cast<KisCanvasController*>(d->currentImageView->canvasController());
 
         d->viewConnections.addUniqueConnection(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)), doc->image(), SLOT(requestStrokeEndActiveNode()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasRight, SIGNAL(triggered()), canvasController, SLOT(rotateCanvasRight15()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasLeft, SIGNAL(triggered()),canvasController, SLOT(rotateCanvasLeft15()));
         d->viewConnections.addUniqueConnection(d->resetCanvasRotation, SIGNAL(triggered()),canvasController, SLOT(resetCanvasRotation()));
 
         d->viewConnections.addUniqueConnection(d->wrapAroundAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleWrapAroundMode(bool)));
         d->wrapAroundAction->setChecked(canvasController->wrapAroundMode());
 
         d->viewConnections.addUniqueConnection(d->levelOfDetailAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleLevelOfDetailMode(bool)));
         d->levelOfDetailAction->setChecked(canvasController->levelOfDetailMode());
 
         d->viewConnections.addUniqueConnection(d->currentImageView->image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), d->controlFrame.paintopBox(), SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         d->viewConnections.addUniqueConnection(d->showRulersAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setShowRulers(bool)));
         d->viewConnections.addUniqueConnection(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setRulersTrackMouse(bool)));
         d->viewConnections.addUniqueConnection(d->zoomTo100pct, SIGNAL(triggered()), imageView->zoomManager(), SLOT(zoomTo100()));
         d->viewConnections.addUniqueConnection(d->zoomIn, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomIn()));
         d->viewConnections.addUniqueConnection(d->zoomOut, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomOut()));
 
         d->viewConnections.addUniqueConnection(d->softProof, SIGNAL(toggled(bool)), view, SLOT(slotSoftProofing(bool)) );
         d->viewConnections.addUniqueConnection(d->gamutCheck, SIGNAL(toggled(bool)), view, SLOT(slotGamutCheck(bool)) );
 
         // set up progrress reporting
         doc->image()->compositeProgressProxy()->addProxy(d->persistentImageProgressUpdater);
         d->viewConnections.addUniqueConnection(&d->statusBar, SIGNAL(sigCancellationRequested()), doc->image(), SLOT(requestStrokeCancellation()));
 
         d->viewConnections.addUniqueConnection(d->showPixelGrid, SIGNAL(toggled(bool)), canvasController, SLOT(slotTogglePixelGrid(bool)));
 
         imageView->zoomManager()->setShowRulers(d->showRulersAction->isChecked());
         imageView->zoomManager()->setRulersTrackMouse(d->rulersTrackMouseAction->isChecked());
 
         showHideScrollbars();
     }
 
     d->filterManager.setView(imageView);
     d->selectionManager.setView(imageView);
     d->guidesManager.setView(imageView);
     d->nodeManager.setView(imageView);
     d->imageManager.setView(imageView);
     d->canvasControlsManager.setView(imageView);
     d->actionManager.setView(imageView);
     d->gridManager.setView(imageView);
     d->statusBar.setView(imageView);
     d->paintingAssistantsManager.setView(imageView);
     d->mirrorManager.setView(imageView);
 
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(true);
         d->currentImageView->canvasController()->activate();
         d->currentImageView->canvasController()->setFocus();
 
         d->viewConnections.addUniqueConnection(
                     image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)),
                     resourceProvider(), SLOT(slotImageSizeChanged()));
 
         d->viewConnections.addUniqueConnection(
                     image(), SIGNAL(sigResolutionChanged(double,double)),
                     resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
         d->viewConnections.addUniqueConnection(
                     image(), SIGNAL(sigNodeChanged(KisNodeSP)),
                     this, SLOT(updateGUI()));
 
         d->viewConnections.addUniqueConnection(
                     d->currentImageView->zoomManager()->zoomController(),
                     SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)),
                     resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
     }
 
     d->actionManager.updateGUI();
 
     resourceProvider()->slotImageSizeChanged();
     resourceProvider()->slotOnScreenResolutionChanged();
 
     Q_EMIT viewChanged();
 }
 
 
 KoZoomController *KisViewManager::zoomController() const
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomController();
     }
     return 0;
 }
 
 KisImageWSP KisViewManager::image() const
 {
     if (document()) {
         return document()->image();
     }
     return 0;
 }
 
 KisCanvasResourceProvider * KisViewManager::resourceProvider()
 {
     return &d->canvasResourceProvider;
 }
 
 KisCanvas2 * KisViewManager::canvasBase() const
 {
     if (d && d->currentImageView) {
         return d->currentImageView->canvasBase();
     }
     return 0;
 }
 
 QWidget* KisViewManager::canvas() const
 {
     if (d && d->currentImageView && d->currentImageView->canvasBase()->canvasWidget()) {
         return d->currentImageView->canvasBase()->canvasWidget();
     }
     return 0;
 }
 
 KisStatusBar * KisViewManager::statusBar() const
 {
     return &d->statusBar;
 }
 
 KisPaintopBox* KisViewManager::paintOpBox() const
 {
     return d->controlFrame.paintopBox();
 }
 
 QPointer<KoUpdater> KisViewManager::createUnthreadedUpdater(const QString &name)
 {
     return d->persistentUnthreadedProgressUpdaterRouter->startSubtask(1, name, false);
 }
 
 QPointer<KoUpdater> KisViewManager::createThreadedUpdater(const QString &name)
 {
     return d->statusBar.progressUpdater()->startSubtask(1, name, false);
 }
 
 KisSelectionManager * KisViewManager::selectionManager()
 {
     return &d->selectionManager;
 }
 
 KisNodeSP KisViewManager::activeNode()
 {
     return d->nodeManager.activeNode();
 }
 
 KisLayerSP KisViewManager::activeLayer()
 {
     return d->nodeManager.activeLayer();
 }
 
 KisPaintDeviceSP KisViewManager::activeDevice()
 {
     return d->nodeManager.activePaintDevice();
 }
 
 KisZoomManager * KisViewManager::zoomManager()
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomManager();
     }
     return 0;
 }
 
 KisFilterManager * KisViewManager::filterManager()
 {
     return &d->filterManager;
 }
 
 KisImageManager * KisViewManager::imageManager()
 {
     return &d->imageManager;
 }
 
 KisInputManager* KisViewManager::inputManager() const
 {
     return &d->inputManager;
 }
 
 KisSelectionSP KisViewManager::selection()
 {
     if (d->currentImageView) {
         return d->currentImageView->selection();
     }
     return 0;
 
 }
 
 bool KisViewManager::selectionEditable()
 {
     KisLayerSP layer = activeLayer();
     if (layer) {
         KisSelectionMaskSP mask = layer->selectionMask();
         if (mask) {
             return mask->isEditable();
         }
     }
     // global selection is always editable
     return true;
 }
 
 KisUndoAdapter * KisViewManager::undoAdapter()
 {
     if (!document()) return 0;
 
     KisImageWSP image = document()->image();
     Q_ASSERT(image);
 
     return image->undoAdapter();
 }
 
 void KisViewManager::createActions()
 {
     KisConfig cfg(true);
 
     d->saveIncremental = actionManager()->createAction("save_incremental_version");
     connect(d->saveIncremental, SIGNAL(triggered()), this, SLOT(slotSaveIncremental()));
 
     d->saveIncrementalBackup = actionManager()->createAction("save_incremental_backup");
     connect(d->saveIncrementalBackup, SIGNAL(triggered()), this, SLOT(slotSaveIncrementalBackup()));
 
     connect(mainWindow(), SIGNAL(documentSaved()), this, SLOT(slotDocumentSaved()));
 
     d->saveIncremental->setEnabled(false);
     d->saveIncrementalBackup->setEnabled(false);
 
     KisAction *tabletDebugger = actionManager()->createAction("tablet_debugger");
     connect(tabletDebugger, SIGNAL(triggered()), this, SLOT(toggleTabletLogger()));
 
     d->createTemplate = actionManager()->createAction("create_template");
     connect(d->createTemplate, SIGNAL(triggered()), this, SLOT(slotCreateTemplate()));
 
     d->createCopy = actionManager()->createAction("create_copy");
     connect(d->createCopy, SIGNAL(triggered()), this, SLOT(slotCreateCopy()));
 
     d->openResourcesDirectory = actionManager()->createAction("open_resources_directory");
     connect(d->openResourcesDirectory, SIGNAL(triggered()), SLOT(openResourcesDirectory()));
 
     d->rotateCanvasRight   = actionManager()->createAction("rotate_canvas_right");
     d->rotateCanvasLeft    = actionManager()->createAction("rotate_canvas_left");
     d->resetCanvasRotation = actionManager()->createAction("reset_canvas_rotation");
     d->wrapAroundAction    = actionManager()->createAction("wrap_around_mode");
     d->levelOfDetailAction = actionManager()->createAction("level_of_detail_mode");
     d->softProof           = actionManager()->createAction("softProof");
     d->gamutCheck          = actionManager()->createAction("gamutCheck");
 
     KisAction *tAction = actionManager()->createAction("showStatusBar");
     tAction->setChecked(cfg.showStatusBar());
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(showStatusBar(bool)));
 
     tAction = actionManager()->createAction("view_show_canvas_only");
     tAction->setChecked(false);
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(switchCanvasOnly(bool)));
 
     //Workaround, by default has the same shortcut as mirrorCanvas
     KisAction *a = dynamic_cast<KisAction*>(actionCollection()->action("format_italic"));
     if (a) {
         a->setDefaultShortcut(QKeySequence());
     }
 
     a = actionManager()->createAction("edit_blacklist_cleanup");
     connect(a, SIGNAL(triggered()), this, SLOT(slotBlacklistCleanup()));
 
     actionManager()->createAction("ruler_pixel_multiple2");
     d->showRulersAction = actionManager()->createAction("view_ruler");
     d->showRulersAction->setChecked(cfg.showRulers());
     connect(d->showRulersAction, SIGNAL(toggled(bool)), SLOT(slotSaveShowRulersState(bool)));
 
     d->rulersTrackMouseAction = actionManager()->createAction("rulers_track_mouse");
     d->rulersTrackMouseAction->setChecked(cfg.rulersTrackMouse());
     connect(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), SLOT(slotSaveRulersTrackMouseState(bool)));
 
     d->zoomTo100pct = actionManager()->createAction("zoom_to_100pct");
 
     d->zoomIn = actionManager()->createStandardAction(KStandardAction::ZoomIn, 0, "");
     d->zoomOut = actionManager()->createStandardAction(KStandardAction::ZoomOut, 0, "");
 
     d->actionAuthor  = new KSelectAction(KisIconUtils::loadIcon("im-user"), i18n("Active Author Profile"), this);
     connect(d->actionAuthor, SIGNAL(triggered(const QString &)), this, SLOT(changeAuthorProfile(const QString &)));
     actionCollection()->addAction("settings_active_author", d->actionAuthor);
     slotUpdateAuthorProfileActions();
 
     d->showPixelGrid = actionManager()->createAction("view_pixel_grid");
     slotUpdatePixelGridAction();
 }
 
 void KisViewManager::setupManagers()
 {
     // Create the managers for filters, selections, layers etc.
     // XXX: When the currentlayer changes, call updateGUI on all
     // managers
 
     d->filterManager.setup(actionCollection(), actionManager());
 
     d->selectionManager.setup(actionManager());
 
     d->guidesManager.setup(actionManager());
 
     d->nodeManager.setup(actionCollection(), actionManager());
 
     d->imageManager.setup(actionManager());
 
     d->gridManager.setup(actionManager());
 
     d->paintingAssistantsManager.setup(actionManager());
 
     d->canvasControlsManager.setup(actionManager());
 
     d->mirrorManager.setup(actionCollection());
 }
 
 void KisViewManager::updateGUI()
 {
     d->guiUpdateCompressor.start();
 }
 
 void KisViewManager::slotBlacklistCleanup()
 {
     KisDlgBlacklistCleanup dialog;
     dialog.exec();
 }
 
 KisNodeManager * KisViewManager::nodeManager() const
 {
     return &d->nodeManager;
 }
 
 KisActionManager* KisViewManager::actionManager() const
 {
     return &d->actionManager;
 }
 
 KisGridManager * KisViewManager::gridManager() const
 {
     return &d->gridManager;
 }
 
 KisGuidesManager * KisViewManager::guidesManager() const
 {
     return &d->guidesManager;
 }
 
 KisDocument *KisViewManager::document() const
 {
     if (d->currentImageView && d->currentImageView->document()) {
         return d->currentImageView->document();
     }
     return 0;
 }
 
 int KisViewManager::viewCount() const
 {
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     if (mw) {
         return mw->viewCount();
     }
     return 0;
 }
 
 bool KisViewManager::KisViewManagerPrivate::blockUntilOperationsFinishedImpl(KisImageSP image, bool force)
 {
     const int busyWaitDelay = 1000;
     KisDelayedSaveDialog dialog(image, !force ? KisDelayedSaveDialog::GeneralDialog : KisDelayedSaveDialog::ForcedDialog, busyWaitDelay, mainWindow);
     dialog.blockIfImageIsBusy();
 
     return dialog.result() == QDialog::Accepted;
 }
 
 
 bool KisViewManager::blockUntilOperationsFinished(KisImageSP image)
 {
     return d->blockUntilOperationsFinishedImpl(image, false);
 }
 
 void KisViewManager::blockUntilOperationsFinishedForced(KisImageSP image)
 {
     d->blockUntilOperationsFinishedImpl(image, true);
 }
 
 void KisViewManager::slotCreateTemplate()
 {
     if (!document()) return;
     KisTemplateCreateDia::createTemplate( QStringLiteral("templates/"), ".kra", document(), mainWindow());
 }
 
 void KisViewManager::slotCreateCopy()
 {
     KisDocument *srcDoc = document();
     if (!srcDoc) return;
 
     if (!this->blockUntilOperationsFinished(srcDoc->image())) return;
 
     KisDocument *doc = 0;
     {
         KisImageBarrierLocker l(srcDoc->image());
         doc = srcDoc->clone();
     }
     KIS_SAFE_ASSERT_RECOVER_RETURN(doc);
 
     QString name = srcDoc->documentInfo()->aboutInfo("name");
     if (name.isEmpty()) {
         name = document()->url().toLocalFile();
     }
     name = i18n("%1 (Copy)", name);
     doc->documentInfo()->setAboutInfo("title", name);
 
     KisPart::instance()->addDocument(doc);
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     mw->addViewAndNotifyLoadingCompleted(doc);
 }
 
 
 QMainWindow* KisViewManager::qtMainWindow() const
 {
     if (d->mainWindow)
         return d->mainWindow;
 
     //Fallback for when we have not yet set the main window.
     QMainWindow* w = qobject_cast<QMainWindow*>(qApp->activeWindow());
     if(w)
         return w;
 
     return mainWindow();
 }
 
 void KisViewManager::setQtMainWindow(QMainWindow* newMainWindow)
 {
     d->mainWindow = newMainWindow;
 }
 
 void KisViewManager::slotDocumentSaved()
 {
     d->saveIncremental->setEnabled(true);
     d->saveIncrementalBackup->setEnabled(true);
 }
 
 void KisViewManager::slotSaveIncremental()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool foundVersion;
     bool fileAlreadyExists;
     bool isBackup;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // Find current version filenames
     // v v Regexp to find incremental versions in the filename, taking our backup scheme into account as well
     // Considering our incremental version and backup scheme, format is filename_001~001.ext
     QRegExp regex("_\\d{1,4}[.]|_\\d{1,4}[a-z][.]|_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     foundVersion = matches.at(0).isEmpty() ? false : true;
 
     // Ensure compatibility with Save Incremental Backup
     // If this regex is not kept separate, the entire algorithm needs modification;
     // It's simpler to just add this.
     QRegExp regexAux("_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regexAux.indexIn(fileName);     //  Perform the search
     QStringList matchesAux = regexAux.capturedTexts();
     isBackup = matchesAux.at(0).isEmpty() ? false : true;
 
     // If the filename has a version, prepare it for incrementation
     if (foundVersion) {
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "_"
     } else {
         // TODO: this will not work with files extensions like jp2
         // ...else, simply add a version to it so the next loop works
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(fileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(version);
         extensionPlusVersion.prepend("_");
         fileName.replace(regex2, extensionPlusVersion);
     }
 
     // Prepare the base for new version filename
     int intVersion = version.toInt(0);
     ++intVersion;
     QString baseNewVersion = QString::number(intVersion);
     while (baseNewVersion.length() < version.length()) {
         baseNewVersion.prepend("0");
     }
 
     // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
     do {
         newVersion = baseNewVersion;
         newVersion.prepend("_");
         if (!letter.isNull()) newVersion.append(letter);
         if (isBackup) {
             newVersion.append("~");
         } else {
             newVersion.append(".");
         }
         fileName.replace(regex, newVersion);
         fileAlreadyExists = QFile(fileName).exists();
         if (fileAlreadyExists) {
             if (!letter.isNull()) {
                 char letterCh = letter.at(0).toLatin1();
                 ++letterCh;
                 letter = QString(QChar(letterCh));
             } else {
                 letter = 'a';
             }
         }
     } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
     if (letter == "{") {
         QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental version"), i18n("Alternative names exhausted, try manually saving with a higher number"));
         return;
     }
     document()->setFileBatchMode(true);
     document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
     document()->setFileBatchMode(false);
 
     if (mainWindow()) {
         mainWindow()->updateCaption();
     }
 
 }
 
 void KisViewManager::slotSaveIncrementalBackup()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool workingOnBackup;
     bool fileAlreadyExists;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // First, discover if working on a backup file, or a normal file
     QRegExp regex("~\\d{1,4}[.]|~\\d{1,4}[a-z][.]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     workingOnBackup = matches.at(0).isEmpty() ? false : true;
 
     if (workingOnBackup) {
         // Try to save incremental version (of backup), use letter for alt versions
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "~"
 
         // Prepare the base for new version filename
         int intVersion = version.toInt(0);
         ++intVersion;
         QString baseNewVersion = QString::number(intVersion);
         QString backupFileName = document()->localFilePath();
         while (baseNewVersion.length() < version.length()) {
             baseNewVersion.prepend("0");
         }
 
         // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             if (!letter.isNull()) newVersion.append(letter);
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 if (!letter.isNull()) {
                     char letterCh = letter.at(0).toLatin1();
                     ++letterCh;
                     letter = QString(QChar(letterCh));
                 } else {
                     letter = 'a';
                 }
             }
         } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
         if (letter == "{") {
             QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental backup"), i18n("Alternative names exhausted, try manually saving with a higher number"));
             return;
         }
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
     else { // if NOT working on a backup...
         // Navigate directory searching for latest backup version, ignore letters
         const quint8 HARDCODED_DIGIT_COUNT = 3;
         QString baseNewVersion = "000";
         QString backupFileName = document()->localFilePath();
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(backupFileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(baseNewVersion);
         extensionPlusVersion.prepend("~");
         backupFileName.replace(regex2, extensionPlusVersion);
 
         // Save version with 1 number higher than the highest version found ignoring letters
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 // Prepare the base for new version filename, increment by 1
                 int intVersion = baseNewVersion.toInt(0);
                 ++intVersion;
                 baseNewVersion = QString::number(intVersion);
                 while (baseNewVersion.length() < HARDCODED_DIGIT_COUNT) {
                     baseNewVersion.prepend("0");
                 }
             }
         } while (fileAlreadyExists);
 
         // Save both as backup and on current file for interapplication workflow
         document()->setFileBatchMode(true);
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
         document()->setFileBatchMode(false);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
 }
 
 void KisViewManager::disableControls()
 {
     // prevents possible crashes, if somebody changes the paintop during dragging by using the mousewheel
     // this is for Bug 250944
     // the solution blocks all wheel, mouse and key event, while dragging with the freehand tool
     // see KisToolFreehand::initPaint() and endPaint()
     d->controlFrame.paintopBox()->installEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->installEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::enableControls()
 {
     d->controlFrame.paintopBox()->removeEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->removeEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::showStatusBar(bool toggled)
 {
     KisMainWindow *mw = mainWindow();
     if(mw && mw->statusBar()) {
         mw->statusBar()->setVisible(toggled);
         KisConfig cfg(false);
         cfg.setShowStatusBar(toggled);
     }
 }
 
 void KisViewManager::switchCanvasOnly(bool toggled)
 {
     KisConfig cfg(false);
     KisMainWindow* main = mainWindow();
 
     if(!main) {
         dbgUI << "Unable to switch to canvas-only mode, main window not found";
         return;
     }
 
     if (toggled) {
         d->canvasState = qtMainWindow()->saveState();
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
         d->windowFlags = main->windowState();
 #endif
     }
 
     if (cfg.hideStatusbarFullscreen()) {
         if (main->statusBar()) {
             if (!toggled) {
                 if (main->statusBar()->dynamicPropertyNames().contains("wasvisible")) {
                     if (main->statusBar()->property("wasvisible").toBool()) {
                         main->statusBar()->setVisible(true);
                     }
                 }
             }
             else {
                 main->statusBar()->setProperty("wasvisible", main->statusBar()->isVisible());
                 main->statusBar()->setVisible(false);
             }
         }
     }
 
     if (cfg.hideDockersFullscreen()) {
         KisAction* action = qobject_cast<KisAction*>(main->actionCollection()->action("view_toggledockers"));
         if (action) {
             action->setCheckable(true);
             if (toggled) {
                 if (action->isChecked()) {
                     cfg.setShowDockers(action->isChecked());
                     action->setChecked(false);
                 } else {
                     cfg.setShowDockers(false);
                 }
             } else {
                 action->setChecked(cfg.showDockers());
             }
         }
     }
 
     // QT in windows does not return to maximized upon 4th tab in a row
     // https://bugreports.qt.io/browse/QTBUG-57882, https://bugreports.qt.io/browse/QTBUG-52555, https://codereview.qt-project.org/#/c/185016/
     if (cfg.hideTitlebarFullscreen() && !cfg.fullscreenMode()) {
         if(toggled) {
             main->setWindowState( main->windowState() | Qt::WindowFullScreen);
         } else {
             main->setWindowState( main->windowState() & ~Qt::WindowFullScreen);
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
             // If window was maximized prior to fullscreen, restore that
             if (d->windowFlags & Qt::WindowMaximized) {
                 main->setWindowState( main->windowState() | Qt::WindowMaximized);
             }
 #endif
         }
     }
 
     if (cfg.hideMenuFullscreen()) {
         if (!toggled) {
             if (main->menuBar()->dynamicPropertyNames().contains("wasvisible")) {
                 if (main->menuBar()->property("wasvisible").toBool()) {
                     main->menuBar()->setVisible(true);
                 }
             }
         }
         else {
             main->menuBar()->setProperty("wasvisible", main->menuBar()->isVisible());
             main->menuBar()->setVisible(false);
         }
     }
 
     if (cfg.hideToolbarFullscreen()) {
         QList<QToolBar*> toolBars = main->findChildren<QToolBar*>();
         Q_FOREACH (QToolBar* toolbar, toolBars) {
             if (!toggled) {
                 if (toolbar->dynamicPropertyNames().contains("wasvisible")) {
                     if (toolbar->property("wasvisible").toBool()) {
                         toolbar->setVisible(true);
                     }
                 }
             }
             else {
                 toolbar->setProperty("wasvisible", toolbar->isVisible());
                 toolbar->setVisible(false);
             }
         }
     }
 
     showHideScrollbars();
 
     if (toggled) {
         // show a fading heads-up display about the shortcut to go back
 
         showFloatingMessage(i18n("Going into Canvas-Only mode.\nPress %1 to go back.",
                                  actionCollection()->action("view_show_canvas_only")->shortcut().toString()), QIcon());
     }
     else {
         main->restoreState(d->canvasState);
     }
 
 }
 
 void KisViewManager::toggleTabletLogger()
 {
     d->inputManager.toggleTabletLogger();
 }
 
 void KisViewManager::openResourcesDirectory()
 {
     QString dir = KoResourcePaths::locateLocal("data", "");
     QDesktopServices::openUrl(QUrl::fromLocalFile(dir));
 }
 
 void KisViewManager::updateIcons()
 {
     if (mainWindow()) {
         QList<QDockWidget*> dockers = mainWindow()->dockWidgets();
         Q_FOREACH (QDockWidget* dock, dockers) {
             QObjectList objects;
             objects.append(dock);
             while (!objects.isEmpty()) {
                 QObject* object = objects.takeFirst();
                 objects.append(object->children());
                 KisIconUtils::updateIconCommon(object);
             }
         }
     }
 }
 void KisViewManager::initializeStatusBarVisibility()
 {
     KisConfig cfg(true);
     d->mainWindow->statusBar()->setVisible(cfg.showStatusBar());
 }
 
 void KisViewManager::guiUpdateTimeout()
 {
     d->nodeManager.updateGUI();
     d->selectionManager.updateGUI();
     d->filterManager.updateGUI();
     if (zoomManager()) {
         zoomManager()->updateGUI();
     }
     d->gridManager.updateGUI();
     d->actionManager.updateGUI();
 }
 
 void KisViewManager::showFloatingMessage(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->currentImageView) return;
     d->currentImageView->showFloatingMessageImpl(message, icon, timeout, priority, alignment);
 
     emit floatingMessageRequested(message, icon.name());
 }
 
 KisMainWindow *KisViewManager::mainWindow() const
 {
     return qobject_cast<KisMainWindow*>(d->mainWindow);
 }
 
 
 void KisViewManager::showHideScrollbars()
 {
     if (!d->currentImageView) return;
     if (!d->currentImageView->canvasController()) return;
 
     KisConfig cfg(true);
     bool toggled = actionCollection()->action("view_show_canvas_only")->isChecked();
 
     if ( (toggled && cfg.hideScrollbarsFullscreen()) || (!toggled && cfg.hideScrollbars()) ) {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     } else {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     }
 }
 
 void KisViewManager::slotSaveShowRulersState(bool value)
 {
     KisConfig cfg(false);
     cfg.setShowRulers(value);
 }
 
 void KisViewManager::slotSaveRulersTrackMouseState(bool value)
 {
     KisConfig cfg(false);
     cfg.setRulersTrackMouse(value);
 }
 
 void KisViewManager::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisViewManager::changeAuthorProfile(const QString &profileName)
 {
     KConfigGroup appAuthorGroup(KSharedConfig::openConfig(), "Author");
     if (profileName.isEmpty() || profileName == i18nc("choice for author profile", "Anonymous")) {
         appAuthorGroup.writeEntry("active-profile", "");
     } else {
         appAuthorGroup.writeEntry("active-profile", profileName);
     }
     appAuthorGroup.sync();
     Q_FOREACH (KisDocument *doc, KisPart::instance()->documents()) {
         doc->documentInfo()->updateParameters();
     }
 }
 
 void KisViewManager::slotUpdateAuthorProfileActions()
 {
     Q_ASSERT(d->actionAuthor);
     if (!d->actionAuthor) {
         return;
     }
     d->actionAuthor->clear();
     d->actionAuthor->addAction(i18nc("choice for author profile", "Anonymous"));
 
     KConfigGroup authorGroup(KSharedConfig::openConfig(), "Author");
     QStringList profiles = authorGroup.readEntry("profile-names", QStringList());
     QString authorInfo = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/authorinfo/";
     QStringList filters = QStringList() << "*.authorinfo";
     QDir dir(authorInfo);
     Q_FOREACH(QString entry, dir.entryList(filters)) {
         int ln = QString(".authorinfo").size();
         entry.chop(ln);
         if (!profiles.contains(entry)) {
             profiles.append(entry);
         }
     }
     Q_FOREACH (const QString &profile , profiles) {
         d->actionAuthor->addAction(profile);
     }
 
     KConfigGroup appAuthorGroup(KSharedConfig::openConfig(), "Author");
     QString profileName = appAuthorGroup.readEntry("active-profile", "");
 
     if (profileName == "anonymous" || profileName.isEmpty()) {
         d->actionAuthor->setCurrentItem(0);
     } else if (profiles.contains(profileName)) {
         d->actionAuthor->setCurrentAction(profileName);
     }
 }
 
 void KisViewManager::slotUpdatePixelGridAction()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->showPixelGrid);
 
     KisSignalsBlocker b(d->showPixelGrid);
 
     KisConfig cfg(true);
     d->showPixelGrid->setChecked(cfg.pixelGridEnabled());
 }
diff --git a/libs/ui/actions/KisPasteActionFactory.cpp b/libs/ui/actions/KisPasteActionFactory.cpp
index 203741f8d7..3e3261003d 100644
--- a/libs/ui/actions/KisPasteActionFactory.cpp
+++ b/libs/ui/actions/KisPasteActionFactory.cpp
@@ -1,245 +1,245 @@
 /*
  *  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 "KisPasteActionFactory.h"
 
 #include "kis_image.h"
 #include "KisViewManager.h"
 #include "kis_tool_proxy.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_shape_layer.h"
 #include "kis_import_catcher.h"
 #include "kis_clipboard.h"
 #include "commands/kis_image_layer_add_command.h"
 #include "kis_processing_applicator.h"
 
 #include <KoSvgPaste.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
 #include <KoSelectedShapesProxy.h>
 #include "kis_algebra_2d.h"
 #include <KoShapeMoveCommand.h>
 #include <KoShapeReorderCommand.h>
 #include "kis_time_range.h"
 #include "kis_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_painter.h"
 
 namespace {
 QPointF getFittingOffset(QList<KoShape*> shapes,
                          const QPointF &shapesOffset,
                          const QRectF &documentRect,
                          const qreal fitRatio)
 {
     QPointF accumulatedFitOffset;
 
     Q_FOREACH (KoShape *shape, shapes) {
         const QRectF bounds = shape->boundingRect();
 
         const QPointF center = bounds.center() + shapesOffset;
 
         const qreal wMargin = (0.5 - fitRatio) * bounds.width();
         const qreal hMargin = (0.5 - fitRatio) * bounds.height();
         const QRectF allowedRect = documentRect.adjusted(-wMargin, -hMargin, wMargin, hMargin);
 
         const QPointF fittedCenter = KisAlgebra2D::clampPoint(center, allowedRect);
 
         accumulatedFitOffset += fittedCenter - center;
     }
 
     return accumulatedFitOffset;
 }
 
 bool tryPasteShapes(bool pasteAtCursorPosition, KisViewManager *view)
 {
     bool result = false;
 
     KoSvgPaste paste;
 
     if (paste.hasShapes()) {
         KoCanvasBase *canvas = view->canvasBase();
 
         QSizeF fragmentSize;
         QList<KoShape*> shapes =
             paste.fetchShapes(canvas->shapeController()->documentRectInPixels(),
                               canvas->shapeController()->pixelsPerInch(), &fragmentSize);
 
         if (!shapes.isEmpty()) {
             KoShapeManager *shapeManager = canvas->shapeManager();
             shapeManager->selection()->deselectAll();
 
             // adjust z-index of the shapes so that they would be
             // pasted on the top of the stack
             QList<KoShape*> topLevelShapes = shapeManager->topLevelShapes();
             auto it = std::max_element(topLevelShapes.constBegin(), topLevelShapes.constEnd(), KoShape::compareShapeZIndex);
             if (it != topLevelShapes.constEnd()) {
                 const int zIndexOffset = (*it)->zIndex();
 
                 std::stable_sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
                 QList<KoShapeReorderCommand::IndexedShape> indexedShapes;
                 std::transform(shapes.constBegin(), shapes.constEnd(),
                                std::back_inserter(indexedShapes),
                     [zIndexOffset] (KoShape *shape) {
                         KoShapeReorderCommand::IndexedShape indexedShape(shape);
                         indexedShape.zIndex += zIndexOffset;
                         return indexedShape;
                     });
 
                 indexedShapes = KoShapeReorderCommand::homogenizeZIndexesLazy(indexedShapes);
 
                 KoShapeReorderCommand cmd(indexedShapes);
                 cmd.redo();
             }
 
             KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Paste shapes"));
             canvas->shapeController()->addShapesDirect(shapes, 0, parentCommand);
 
             QPointF finalShapesOffset;
 
 
             if (pasteAtCursorPosition) {
                 QRectF boundingRect = KoShape::boundingRect(shapes);
                 const QPointF cursorPos = canvas->canvasController()->currentCursorPosition();
                 finalShapesOffset = cursorPos - boundingRect.center();
 
             } else {
                 bool foundOverlapping = false;
 
                 QRectF boundingRect = KoShape::boundingRect(shapes);
                 const QPointF offsetStep = 0.1 * QPointF(boundingRect.width(), boundingRect.height());
 
                 QPointF offset;
 
                 Q_FOREACH (KoShape *shape, shapes) {
                     QRectF br1 = shape->boundingRect();
 
                     bool hasOverlappingShape = false;
 
                     do {
                         hasOverlappingShape = false;
 
                         // we cannot use shapesAt() here, because the groups are not
                         // handled in the shape manager's tree
                         QList<KoShape*> conflicts = shapeManager->shapes();
 
                         Q_FOREACH (KoShape *intersectedShape, conflicts) {
                             if (intersectedShape == shape) continue;
 
                             QRectF br2 = intersectedShape->boundingRect();
 
                             const qreal tolerance = 2.0; /* pt */
                             if (KisAlgebra2D::fuzzyCompareRects(br1, br2, tolerance)) {
                                 br1.translate(offsetStep.x(), offsetStep.y());
                                 offset += offsetStep;
 
                                 hasOverlappingShape = true;
                                 foundOverlapping = true;
                                 break;
                             }
                         }
                     } while (hasOverlappingShape);
 
                     if (foundOverlapping) break;
                 }
 
                 if (foundOverlapping) {
                     finalShapesOffset = offset;
                 }
             }
 
             const QRectF documentRect = canvas->shapeController()->documentRect();
             finalShapesOffset += getFittingOffset(shapes, finalShapesOffset, documentRect, 0.1);
 
             if (!finalShapesOffset.isNull()) {
                 new KoShapeMoveCommand(shapes, finalShapesOffset, parentCommand);
             }
 
             canvas->addCommand(parentCommand);
 
             Q_FOREACH (KoShape *shape, shapes) {
                 canvas->selectedShapesProxy()->selection()->select(shape);
             }
 
             result = true;
         }
     }
 
     return result;
 }
 
 }
-#include "kis_painter.h"
+
 void KisPasteActionFactory::run(bool pasteAtCursorPosition, KisViewManager *view)
 {
     KisImageSP image = view->image();
     if (!image) return;
 
     if (tryPasteShapes(pasteAtCursorPosition, view)) {
         return;
     }
 
     KisTimeRange range;
     const QRect fittingBounds = pasteAtCursorPosition ? QRect() : image->bounds();
     KisPaintDeviceSP clip = KisClipboard::instance()->clip(fittingBounds, true, &range);
 
     if (clip) {
         if (pasteAtCursorPosition) {
             const QPointF docPos = view->canvasBase()->canvasController()->currentCursorPosition();
             const QPointF imagePos = view->canvasBase()->coordinatesConverter()->documentToImage(docPos);
 
             const QPointF offset = (imagePos - QRectF(clip->exactBounds()).center()).toPoint();
 
             clip->setX(clip->x() + offset.x());
             clip->setY(clip->y() + offset.y());
         }
 
         KisImportCatcher::adaptClipToImageColorSpace(clip, image);
         KisPaintLayerSP newLayer = new KisPaintLayer(image.data(),
                                                      image->nextLayerName() + i18n("(pasted)"),
                                                      OPACITY_OPAQUE_U8);
         KisNodeSP aboveNode = view->activeLayer();
         KisNodeSP parentNode = aboveNode ? aboveNode->parent() : image->root();
 
         if (range.isValid()) {
             newLayer->enableAnimation();
             KisKeyframeChannel *channel = newLayer->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             KisRasterKeyframeChannel *rasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(channel);
             rasterChannel->importFrame(range.start(), clip, 0);
 
             if (!range.isInfinite()) {
                 rasterChannel->addKeyframe(range.end() + 1, 0);
             }
         } else {
             const QRect rc = clip->extent();
             KisPainter::copyAreaOptimized(rc.topLeft(), clip, newLayer->paintDevice(), rc);
         }
 
         KUndo2Command *cmd = new KisImageLayerAddCommand(image, newLayer, parentNode, aboveNode);
         KisProcessingApplicator *ap = beginAction(view, cmd->text());
         ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
         endAction(ap, KisOperationConfiguration(id()).toXML());
     } else {
         // XXX: "Add saving of XML data for Paste of shapes"
         view->canvasBase()->toolProxy()->paste();
     }
 }
diff --git a/libs/ui/actions/kis_selection_action_factories.cpp b/libs/ui/actions/kis_selection_action_factories.cpp
index 0428aa8397..79f7b27f9e 100644
--- a/libs/ui/actions/kis_selection_action_factories.cpp
+++ b/libs/ui/actions/kis_selection_action_factories.cpp
@@ -1,594 +1,591 @@
 /*
  *  Copyright (c) 2012 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_selection_action_factories.h"
 
 #include <QMimeData>
 
 #include <klocalizedstring.h>
 #include <kundo2command.h>
 
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <KoPathShape.h>
 #include <KoShapeController.h>
 #include <KoShapeRegistry.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
-#include <KoShapeController.h>
 #include <KoDocumentResourceManager.h>
 #include <KoShapeStroke.h>
 #include <KoDocumentInfo.h>
 
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_pixel_selection.h"
 #include "kis_paint_layer.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_fill_painter.h"
 #include "kis_transaction.h"
 #include "kis_iterator_ng.h"
 #include "kis_processing_applicator.h"
 #include "kis_group_layer.h"
 #include "commands/kis_selection_commands.h"
 #include "commands/kis_image_layer_add_command.h"
 #include "kis_tool_proxy.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_selection_manager.h"
 #include "kis_transaction_based_command.h"
 #include "kis_selection_filters.h"
 #include "kis_shape_selection.h"
-#include "KisPart.h"
 #include "kis_shape_layer.h"
 #include <kis_shape_controller.h>
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_keyframe_channel.h"
 
 
 #include <processing/fill_processing_visitor.h>
 #include <kis_selection_tool_helper.h>
 
-#include "kis_canvas_resource_provider.h"
 #include "kis_figure_painting_tool_helper.h"
 
 namespace ActionHelper {
 
     void copyFromDevice(KisViewManager *view,
                         KisPaintDeviceSP device,
                         bool makeSharpClip = false,
                         const KisTimeRange &range = KisTimeRange())
     {
         KisImageWSP image = view->image();
         if (!image) return;
 
         KisSelectionSP selection = view->selection();
 
         QRect rc = (selection) ? selection->selectedExactRect() : image->bounds();
 
         KisPaintDeviceSP clip = new KisPaintDevice(device->colorSpace());
         Q_CHECK_PTR(clip);
 
         const KoColorSpace *cs = clip->colorSpace();
 
         // TODO if the source is linked... copy from all linked layers?!?
 
         // Copy image data
         KisPainter::copyAreaOptimized(QPoint(), device, clip, rc);
 
         if (selection) {
             // Apply selection mask.
             KisPaintDeviceSP selectionProjection = selection->projection();
             KisHLineIteratorSP layerIt = clip->createHLineIteratorNG(0, 0, rc.width());
             KisHLineConstIteratorSP selectionIt = selectionProjection->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 
             const KoColorSpace *selCs = selection->projection()->colorSpace();
 
             for (qint32 y = 0; y < rc.height(); y++) {
 
                 for (qint32 x = 0; x < rc.width(); x++) {
 
                     /**
                      * Sharp method is an exact reverse of COMPOSITE_OVER
                      * so if you cover the cut/copied piece over its source
                      * you get an exactly the same image without any seams
                      */
                     if (makeSharpClip) {
                         qreal dstAlpha = cs->opacityF(layerIt->rawData());
                         qreal sel = selCs->opacityF(selectionIt->oldRawData());
                         qreal newAlpha = sel * dstAlpha / (1.0 - dstAlpha + sel * dstAlpha);
                         float mask = newAlpha / dstAlpha;
 
                         cs->applyAlphaNormedFloatMask(layerIt->rawData(), &mask, 1);
                     } else {
                         cs->applyAlphaU8Mask(layerIt->rawData(), selectionIt->oldRawData(), 1);
                     }
 
                     layerIt->nextPixel();
                     selectionIt->nextPixel();
                 }
                 layerIt->nextRow();
                 selectionIt->nextRow();
             }
         }
 
         KisClipboard::instance()->setClip(clip, rc.topLeft(), range);
     }
 
 }
 
 void KisSelectAllActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
 
     KisProcessingApplicator *ap = beginAction(view, kundo2_i18n("Select All"));
 
     if (!image->globalSelection()) {
         ap->applyCommand(new KisSetEmptyGlobalSelectionCommand(image),
                          KisStrokeJobData::SEQUENTIAL,
                          KisStrokeJobData::EXCLUSIVE);
     }
 
     struct SelectAll : public KisTransactionBasedCommand {
         SelectAll(KisImageSP image) : m_image(image) {}
         KisImageSP m_image;
         KUndo2Command* paint() override {
             KisSelectionSP selection = m_image->globalSelection();
             KisSelectionTransaction transaction(selection->pixelSelection());
             selection->pixelSelection()->clear();
             selection->pixelSelection()->select(m_image->bounds());
             return transaction.endAndTake();
         }
     };
 
     ap->applyCommand(new SelectAll(image),
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::EXCLUSIVE);
 
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisDeselectActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
 
     KUndo2Command *cmd = new KisDeselectGlobalSelectionCommand(image);
 
     KisProcessingApplicator *ap = beginAction(view, cmd->text());
     ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisReselectActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
 
     KUndo2Command *cmd = new KisReselectGlobalSelectionCommand(image);
 
     KisProcessingApplicator *ap = beginAction(view, cmd->text());
     ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisFillActionFactory::run(const QString &fillSource, KisViewManager *view)
 {
     KisNodeSP node = view->activeNode();
     if (!node || !node->hasEditablePaintDevice()) return;
 
     KisSelectionSP selection = view->selection();
     QRect selectedRect = selection ?
                          selection->selectedRect() : view->image()->bounds();
     Q_UNUSED(selectedRect);
     KisPaintDeviceSP filled = node->paintDevice()->createCompositionSourceDevice();
     Q_UNUSED(filled);
     bool usePattern = false;
     bool useBgColor = false;
 
     if (fillSource.contains("pattern")) {
         usePattern = true;
     } else if (fillSource.contains("bg")) {
         useBgColor = true;
     }
 
     KisProcessingApplicator applicator(view->image(), node,
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        kundo2_i18n("Flood Fill Layer"));
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(view->image(), node, view->resourceProvider()->resourceManager());
     if (!fillSource.contains("opacity")) {
         resources->setOpacity(1.0);
     }
 
     KisProcessingVisitorSP visitor =
         new FillProcessingVisitor(QPoint(0, 0), // start position
                                   selection,
                                   resources,
                                   false, // fast mode
                                   usePattern,
                                   true, // fill only selection,
                                   0, // feathering radius
                                   0, // sizemod
                                   80, // threshold,
                                   false, // unmerged
                                   useBgColor);
 
     applicator.applyVisitor(visitor,
                             KisStrokeJobData::SEQUENTIAL,
                             KisStrokeJobData::EXCLUSIVE);
 
     applicator.end();
 }
 
 void KisClearActionFactory::run(KisViewManager *view)
 {
     // XXX: "Add saving of XML data for Clear action"
 
     view->canvasBase()->toolProxy()->deleteSelection();
 }
 
 void KisImageResizeToSelectionActionFactory::run(KisViewManager *view)
 {
     // XXX: "Add saving of XML data for Image Resize To Selection action"
 
     KisSelectionSP selection = view->selection();
     if (!selection) return;
 
     view->image()->cropImage(selection->selectedExactRect());
 }
 
 void KisCutCopyActionFactory::run(bool willCut, bool makeSharpClip, KisViewManager *view)
 {
     KisImageSP image = view->image();
     if (!image) return;
 
     bool haveShapesSelected = view->selectionManager()->haveShapesSelected();
 
     if (haveShapesSelected) {
         // XXX: "Add saving of XML data for Cut/Copy of shapes"
 
         KisImageBarrierLocker locker(image);
         if (willCut) {
             view->canvasBase()->toolProxy()->cut();
         } else {
             view->canvasBase()->toolProxy()->copy();
         }
     } else {
         KisNodeSP node = view->activeNode();
         if (!node) return;
 
         KisSelectionSP selection = view->selection();
         if (selection.isNull()) return;
 
         {
             KisImageBarrierLocker locker(image);
             KisPaintDeviceSP dev = node->paintDevice();
             if (!dev) {
                 dev = node->projection();
             }
 
             if (!dev) {
                 view->showFloatingMessage(
                     i18nc("floating message when cannot copy from a node",
                           "Cannot copy pixels from this type of layer "),
                     QIcon(), 3000, KisFloatingMessage::Medium);
 
                 return;
             }
 
             if (dev->exactBounds().isEmpty()) {
                 view->showFloatingMessage(
                     i18nc("floating message when copying empty selection",
                           "Selection is empty: no pixels were copied "),
                     QIcon(), 3000, KisFloatingMessage::Medium);
 
                 return;
             }
 
             KisTimeRange range;
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (channel) {
                 const int currentTime = image->animationInterface()->currentTime();
                 range = channel->affectedFrames(currentTime);
             }
 
             ActionHelper::copyFromDevice(view, dev, makeSharpClip, range);
         }
 
         KUndo2Command *command = 0;
 
         if (willCut && node->hasEditablePaintDevice()) {
             struct ClearSelection : public KisTransactionBasedCommand {
                 ClearSelection(KisNodeSP node, KisSelectionSP sel)
                     : m_node(node), m_sel(sel) {}
                 KisNodeSP m_node;
                 KisSelectionSP m_sel;
 
                 KUndo2Command* paint() override {
                     KisSelectionSP cutSelection = m_sel;
                     // Shrinking the cutting area was previously used
                     // for getting seamless cut-paste. Now we use makeSharpClip
                     // instead.
                     // QRect originalRect = cutSelection->selectedExactRect();
                     // static const int preciseSelectionThreshold = 16;
                     //
                     // if (originalRect.width() > preciseSelectionThreshold ||
                     //     originalRect.height() > preciseSelectionThreshold) {
                     //     cutSelection = new KisSelection(*m_sel);
                     //     delete cutSelection->flatten();
                     //
                     //     KisSelectionFilter* filter = new KisShrinkSelectionFilter(1, 1, false);
                     //
                     //     QRect processingRect = filter->changeRect(originalRect);
                     //     filter->process(cutSelection->pixelSelection(), processingRect);
                     // }
 
                     KisTransaction transaction(m_node->paintDevice());
                     m_node->paintDevice()->clearSelection(cutSelection);
                     m_node->setDirty(cutSelection->selectedRect());
                     return transaction.endAndTake();
                 }
             };
 
             command = new ClearSelection(node, selection);
         }
 
         KUndo2MagicString actionName = willCut ?
                     kundo2_i18n("Cut") :
                     kundo2_i18n("Copy");
         KisProcessingApplicator *ap = beginAction(view, actionName);
 
         if (command) {
             ap->applyCommand(command,
                              KisStrokeJobData::SEQUENTIAL,
                              KisStrokeJobData::NORMAL);
         }
 
         KisOperationConfiguration config(id());
         config.setProperty("will-cut", willCut);
         endAction(ap, config.toXML());
     }
 }
 
 void KisCopyMergedActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
     if (!view->blockUntilOperationsFinished(image)) return;
 
     image->barrierLock();
     KisPaintDeviceSP dev = image->root()->projection();
     ActionHelper::copyFromDevice(view, dev);
     image->unlock();
 
     KisProcessingApplicator *ap = beginAction(view, kundo2_i18n("Copy Merged"));
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisPasteNewActionFactory::run(KisViewManager *viewManager)
 {
     Q_UNUSED(viewManager);
 
     KisPaintDeviceSP clip = KisClipboard::instance()->clip(QRect(), true);
     if (!clip) return;
 
     QRect rect = clip->exactBounds();
     if (rect.isEmpty()) return;
 
     KisDocument *doc = KisPart::instance()->createDocument();
     doc->documentInfo()->setAboutInfo("title", i18n("Untitled"));
     KisImageSP image = new KisImage(doc->createUndoStore(),
                                     rect.width(),
                                     rect.height(),
                                     clip->colorSpace(),
                                     i18n("Pasted"));
     KisPaintLayerSP layer =
         new KisPaintLayer(image.data(), image->nextLayerName() + " " + i18n("(pasted)"),
                           OPACITY_OPAQUE_U8, clip->colorSpace());
 
     KisPainter::copyAreaOptimized(QPoint(), clip, layer->paintDevice(), rect);
 
     image->addNode(layer.data(), image->rootLayer());
     doc->setCurrentImage(image);
     KisPart::instance()->addDocument(doc);
 
     KisMainWindow *win = viewManager->mainWindow();
     win->addViewAndNotifyLoadingCompleted(doc);
 }
 
 void KisInvertSelectionOperation::runFromXML(KisViewManager* view, const KisOperationConfiguration& config)
 {
     KisSelectionFilter* filter = new KisInvertSelectionFilter();
     runFilter(filter, view, config);
 }
 
 void KisSelectionToVectorActionFactory::run(KisViewManager *view)
 {
     KisSelectionSP selection = view->selection();
 
     if (selection->hasShapeSelection() ||
         !selection->outlineCacheValid()) {
 
         return;
     }
 
     QPainterPath selectionOutline = selection->outlineCache();
     QTransform transform = view->canvasBase()->coordinatesConverter()->imageToDocumentTransform();
 
     KoShape *shape = KoPathShape::createShapeFromPainterPath(transform.map(selectionOutline));
     shape->setShapeId(KoPathShapeId);
 
     /**
      * Mark a shape that it belongs to a shape selection
      */
     if(!shape->userData()) {
         shape->setUserData(new KisShapeSelectionMarker);
     }
 
     KisProcessingApplicator *ap = beginAction(view, kundo2_i18n("Convert to Vector Selection"));
 
     ap->applyCommand(view->canvasBase()->shapeController()->addShape(shape, 0),
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::EXCLUSIVE);
 
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisShapesToVectorSelectionActionFactory::run(KisViewManager* view)
 {
     const QList<KoShape*> originalShapes = view->canvasBase()->shapeManager()->selection()->selectedShapes();
 
     QList<KoShape*> clonedShapes;
     Q_FOREACH (KoShape *shape, originalShapes) {
         clonedShapes << shape->cloneShape();
     }
 
     KisSelectionToolHelper helper(view->canvasBase(), kundo2_i18n("Convert shapes to vector selection"));
     helper.addSelectionShapes(clonedShapes);
 }
 
 void KisSelectionToShapeActionFactory::run(KisViewManager *view)
 {
     KisSelectionSP selection = view->selection();
     if (!selection->outlineCacheValid()) {
         return;
     }
 
     QPainterPath selectionOutline = selection->outlineCache();
     QTransform transform = view->canvasBase()->coordinatesConverter()->imageToDocumentTransform();
 
     KoShape *shape = KoPathShape::createShapeFromPainterPath(transform.map(selectionOutline));
     shape->setShapeId(KoPathShapeId);
 
     KoColor fgColor = view->canvasBase()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     KoShapeStrokeSP border(new KoShapeStroke(1.0, fgColor.toQColor()));
     shape->setStroke(border);
 
     view->document()->shapeController()->addShape(shape);
 }
 
 void KisStrokeSelectionActionFactory::run(KisViewManager *view, StrokeSelectionOptions params)
 {
     KisImageWSP image = view->image();
     if (!image) {
         return;
     }
 
     KisSelectionSP selection = view->selection();
     if (!selection) {
         return;
     }
 
     int size = params.lineSize;
 
     KisPixelSelectionSP pixelSelection = selection->projection();
     if (!pixelSelection->outlineCacheValid()) {
         pixelSelection->recalculateOutlineCache();
     }
 
     QPainterPath outline = pixelSelection->outlineCache();
     QColor color = params.color.toQColor();
 
     KisNodeSP currentNode = view->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     if (!currentNode->inherits("KisShapeLayer") && currentNode->childCount() == 0) {
         KoCanvasResourceManager * rManager = view->resourceProvider()->resourceManager();
         KisPainter::StrokeStyle strokeStyle =  KisPainter::StrokeStyleBrush;
         KisPainter::FillStyle fillStyle =  params.fillStyle();
 
         KisFigurePaintingToolHelper helper(kundo2_i18n("Draw Polyline"),
                                        image,
                                        currentNode,
                                        rManager ,
                                        strokeStyle,
                                        fillStyle);
         helper.setFGColorOverride(params.color);
         helper.setSelectionOverride(0);
         QPen pen(Qt::red, size);
         pen.setJoinStyle(Qt::RoundJoin);
 
         if (fillStyle != KisPainter::FillStyleNone) {
             helper.paintPainterPathQPenFill(outline, pen, params.fillColor);
         }
         else {
             helper.paintPainterPathQPen(outline, pen, params.fillColor);
         }
     }
     else  {
 
         QTransform transform = view->canvasBase()->coordinatesConverter()->imageToDocumentTransform();
 
         KoShape *shape = KoPathShape::createShapeFromPainterPath(transform.map(outline));
         shape->setShapeId(KoPathShapeId);
 
         KoShapeStrokeSP border(new KoShapeStroke(size, color));
         shape->setStroke(border);
 
         view->document()->shapeController()->addShape(shape);
     }
     image->setModified();
 
 }
 
 void KisStrokeBrushSelectionActionFactory::run(KisViewManager *view, StrokeSelectionOptions params)
 {
     KisImageWSP image = view->image();
     if (!image) {
         return;
     }
 
     KisSelectionSP selection = view->selection();
     if (!selection) {
         return;
     }
 
     KisPixelSelectionSP pixelSelection = selection->projection();
     if (!pixelSelection->outlineCacheValid()) {
         pixelSelection->recalculateOutlineCache();
     }
 
     KisNodeSP currentNode = view->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     if (!currentNode->inherits("KisShapeLayer") && currentNode->childCount() == 0)
     {
         KoCanvasResourceManager * rManager = view->resourceProvider()->resourceManager();
         QPainterPath outline = pixelSelection->outlineCache();
         KisPainter::StrokeStyle strokeStyle =  KisPainter::StrokeStyleBrush;
         KisPainter::FillStyle fillStyle =  KisPainter::FillStyleNone;
         KoColor color = params.color;
 
         KisFigurePaintingToolHelper helper(kundo2_i18n("Draw Polyline"),
                                        image,
                                        currentNode,
                                        rManager ,
                                        strokeStyle,
                                        fillStyle);
         helper.setFGColorOverride(color);
         helper.setSelectionOverride(0);
         helper.paintPainterPath(outline);
         image->setModified();
     }
 }
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index 6fc49e542f..f46200c8e0 100644
--- a/libs/ui/canvas/kis_canvas2.cpp
+++ b/libs/ui/canvas/kis_canvas2.cpp
@@ -1,1148 +1,1147 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) Lukáš Tvrdý <lukast.dev@gmail.com>, (C) 2010
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA..
  */
 
 #include "kis_canvas2.h"
 
 #include <functional>
 #include <numeric>
 
 #include <QApplication>
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QTime>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QDesktopWidget>
 
 #include <kis_debug.h>
 
 #include <KoUnit.h>
 #include <KoShapeManager.h>
 #include <KisSelectedShapesProxy.h>
 #include <KoColorProfile.h>
 #include <KoCanvasControllerWidget.h>
 #include <KisDocument.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 
 #include <kis_lod_transform.h>
 #include "kis_tool_proxy.h"
 #include "kis_coordinates_converter.h"
 #include "kis_prescaled_projection.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_undo_adapter.h"
-#include "KisDocument.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_abstract_canvas_widget.h"
 #include "kis_qpainter_canvas.h"
 #include "kis_group_layer.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_node_manager.h"
 #include "kis_selection.h"
 #include "kis_selection_component.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image_config.h"
 #include "kis_infinity_manager.h"
 #include "kis_signal_compressor.h"
 #include "kis_display_color_converter.h"
 #include "kis_exposure_gamma_correction_interface.h"
 #include "KisView.h"
 #include "kis_canvas_controller.h"
 #include "kis_grid_config.h"
 
 #include "kis_animation_player.h"
 #include "kis_animation_frame_cache.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl.h"
 #include "kis_fps_decoration.h"
 
 #include "KoColorConversionTransformation.h"
 #include "KisProofingConfiguration.h"
 
 #include <kis_favorite_resource_manager.h>
 #include <kis_popup_palette.h>
 
 #include "input/kis_input_manager.h"
 #include "kis_painting_assistants_decoration.h"
 
 #include "kis_canvas_updates_compressor.h"
 #include "KoZoomController.h"
 
 #include <KisStrokeSpeedMonitor.h>
 #include "opengl/kis_opengl_canvas_debugger.h"
 
 #include "kis_algebra_2d.h"
 
 class Q_DECL_HIDDEN KisCanvas2::KisCanvas2Private
 {
 
 public:
 
     KisCanvas2Private(KoCanvasBase *parent, KisCoordinatesConverter* coordConverter, QPointer<KisView> view, KoCanvasResourceManager* resourceManager)
         : coordinatesConverter(coordConverter)
         , view(view)
         , shapeManager(parent)
         , selectedShapesProxy(&shapeManager)
         , toolProxy(parent)
         , displayColorConverter(resourceManager, view)
         , regionOfInterestUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
     {
     }
 
     KisCoordinatesConverter *coordinatesConverter;
     QPointer<KisView>view;
     KisAbstractCanvasWidget *canvasWidget = 0;
     KoShapeManager shapeManager;
     KisSelectedShapesProxy selectedShapesProxy;
     bool currentCanvasIsOpenGL;
     int openGLFilterMode;
     KisToolProxy toolProxy;
     KisPrescaledProjectionSP prescaledProjection;
     bool vastScrolling;
 
     KisSignalCompressor canvasUpdateCompressor;
     QRect savedUpdateRect;
 
     QBitArray channelFlags;
     KisProofingConfigurationSP proofingConfig;
     bool softProofing = false;
     bool gamutCheck = false;
     bool proofingConfigUpdated = false;
 
     KisPopupPalette *popupPalette = 0;
     KisDisplayColorConverter displayColorConverter;
 
     KisCanvasUpdatesCompressor projectionUpdatesCompressor;
     KisAnimationPlayer *animationPlayer;
     KisAnimationFrameCacheSP frameCache;
     bool lodAllowedInImage = false;
     bool bootstrapLodBlocked;
     QPointer<KoShapeManager> currentlyActiveShapeManager;
     KisInputActionGroupsMask inputActionGroupsMask = AllActionGroup;
 
     KisSignalCompressor frameRenderStartCompressor;
 
     KisSignalCompressor regionOfInterestUpdateCompressor;
     QRect regionOfInterest;
 
     QRect renderingLimit;
 
     bool effectiveLodAllowedInImage() {
         return lodAllowedInImage && !bootstrapLodBlocked;
     }
 
     void setActiveShapeManager(KoShapeManager *shapeManager);
 };
 
 namespace {
 KoShapeManager* fetchShapeManagerFromNode(KisNodeSP node)
 {
     KoShapeManager *shapeManager = 0;
 
     KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
 
     if (layer) {
         KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer);
         if (shapeLayer) {
             shapeManager = shapeLayer->shapeManager();
 
         } else {
             KisSelectionSP selection = layer->selection();
             if (selection && selection->hasShapeSelection()) {
                 KisShapeSelection *shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
                 KIS_ASSERT_RECOVER_RETURN_VALUE(shapeSelection, 0);
 
                 shapeManager = shapeSelection->shapeManager();
             }
         }
     }
 
     return shapeManager;
 }
 }
 
 KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeControllerBase *sc)
     : KoCanvasBase(sc, resourceManager)
     , m_d(new KisCanvas2Private(this, coordConverter, view, resourceManager))
 {
     /**
      * While loading LoD should be blocked. Only when GUI has finished
      * loading and zoom level settled down, LoD is given a green
      * light.
      */
     m_d->bootstrapLodBlocked = true;
     connect(view->mainWindow(), SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
 
     KisImageConfig config(false);
 
     m_d->canvasUpdateCompressor.setDelay(1000 / config.fpsLimit());
     m_d->canvasUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 
     m_d->frameRenderStartCompressor.setDelay(1000 / config.fpsLimit());
     m_d->frameRenderStartCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 }
 
 void KisCanvas2::setup()
 {
     // a bit of duplication from slotConfigChanged()
     KisConfig cfg(true);
     m_d->vastScrolling = cfg.vastScrolling();
     m_d->lodAllowedInImage = cfg.levelOfDetailEnabled();
 
     createCanvas(cfg.useOpenGL());
 
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
     m_d->animationPlayer = new KisAnimationPlayer(this);
     connect(m_d->view->canvasController()->proxyObject, SIGNAL(moveDocumentOffset(QPoint)), SLOT(documentOffsetMoved(QPoint)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 
     /**
      * We switch the shape manager every time vector layer or
      * shape selection is activated. Flake does not expect this
      * and connects all the signals of the global shape manager
      * to the clients in the constructor. To workaround this we
      * forward the signals of local shape managers stored in the
      * vector layers to the signals of global shape manager. So the
      * sequence of signal deliveries is the following:
      *
      * shapeLayer.m_d.canvas.m_shapeManager.selection() ->
      * shapeLayer ->
      * shapeController ->
      * globalShapeManager.selection()
      */
 
     KisShapeController *kritaShapeController = static_cast<KisShapeController*>(shapeController()->documentBase());
     connect(kritaShapeController, SIGNAL(selectionChanged()),
             this, SLOT(slotSelectionChanged()));
     connect(kritaShapeController, SIGNAL(selectionContentChanged()),
             globalShapeManager(), SIGNAL(selectionContentChanged()));
     connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             globalShapeManager()->selection(), SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(&m_d->canvasUpdateCompressor, SIGNAL(timeout()), SLOT(slotDoCanvasUpdate()));
 
     connect(this, SIGNAL(sigCanvasCacheUpdated()), &m_d->frameRenderStartCompressor, SLOT(start()));
     connect(&m_d->frameRenderStartCompressor, SIGNAL(timeout()), SLOT(updateCanvasProjection()));
 
     connect(this, SIGNAL(sigContinueResizeImage(qint32,qint32)), SLOT(finishResizingImage(qint32,qint32)));
 
     connect(&m_d->regionOfInterestUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdateRegionOfInterest()));
 
     connect(m_d->view->document(), SIGNAL(sigReferenceImagesChanged()), this, SLOT(slotReferenceImagesChanged()));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::initializeFpsDecoration()
 {
     KisConfig cfg(true);
 
     const bool shouldShowDebugOverlay =
         (canvasIsOpenGL() && cfg.enableOpenGLFramerateLogging()) ||
         cfg.enableBrushSpeedLogging();
 
     if (shouldShowDebugOverlay && !decoration(KisFpsDecoration::idTag)) {
         addDecoration(new KisFpsDecoration(imageView()));
 
         if (cfg.enableBrushSpeedLogging()) {
             connect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
         }
     } else if (!shouldShowDebugOverlay && decoration(KisFpsDecoration::idTag)) {
         m_d->canvasWidget->removeDecoration(KisFpsDecoration::idTag);
         disconnect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
     }
 }
 
 KisCanvas2::~KisCanvas2()
 {
     if (m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->forcedStopOnExit();
     }
     delete m_d;
 }
 
 void KisCanvas2::setCanvasWidget(KisAbstractCanvasWidget *widget)
 {
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(widget->widget());
     }
 
     if (m_d->canvasWidget != 0) {
         widget->setDecorations(m_d->canvasWidget->decorations());
 
         // Redundant check for the constructor case, see below
         if(viewManager() != 0)
             viewManager()->inputManager()->removeTrackedCanvas(this);
     }
 
     m_d->canvasWidget = widget;
 
     // Either tmp was null or we are being called by KisCanvas2 constructor that is called by KisView
     // constructor, so the view manager still doesn't exists.
     if(m_d->canvasWidget != 0 && viewManager() != 0)
         viewManager()->inputManager()->addTrackedCanvas(this);
 
     if (!m_d->canvasWidget->decoration(INFINITY_DECORATION_ID)) {
         KisInfinityManager *manager = new KisInfinityManager(m_d->view, this);
         manager->setVisible(true);
         m_d->canvasWidget->addDecoration(manager);
     }
 
     widget->widget()->setAutoFillBackground(false);
     widget->widget()->setAttribute(Qt::WA_OpaquePaintEvent);
     widget->widget()->setMouseTracking(true);
     widget->widget()->setAcceptDrops(true);
 
     KoCanvasControllerWidget *controller = dynamic_cast<KoCanvasControllerWidget*>(canvasController());
     if (controller && controller->canvas() == this) {
         controller->changeCanvasWidget(widget->widget());
     }
 }
 
 bool KisCanvas2::canvasIsOpenGL() const
 {
     return m_d->currentCanvasIsOpenGL;
 }
 
 KisOpenGL::FilterMode KisCanvas2::openGLFilterMode() const
 {
     return KisOpenGL::FilterMode(m_d->openGLFilterMode);
 }
 
 void KisCanvas2::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     QTransform transform = coordinatesConverter()->imageToDocumentTransform();
 
     const QPoint intSpacing = m_d->view->document()->gridConfig().spacing();
     const QPoint intOffset = m_d->view->document()->gridConfig().offset();
 
     QPointF size = transform.map(QPointF(intSpacing));
     spacing->rwidth() = size.x();
     spacing->rheight() = size.y();
 
     *offset = transform.map(QPointF(intOffset));
 }
 
 bool KisCanvas2::snapToGrid() const
 {
     return m_d->view->document()->gridConfig().snapToGrid();
 }
 
 qreal KisCanvas2::rotationAngle() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 bool KisCanvas2::xAxisMirrored() const
 {
     return m_d->coordinatesConverter->xAxisMirrored();
 }
 
 bool KisCanvas2::yAxisMirrored() const
 {
     return m_d->coordinatesConverter->yAxisMirrored();
 }
 
 void KisCanvas2::channelSelectionChanged()
 {
     KisImageSP image = this->image();
     m_d->channelFlags = image->rootLayer()->channelFlags();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
     startUpdateInPatches(image->bounds());
     image->unlock();
 }
 
 void KisCanvas2::addCommand(KUndo2Command *command)
 {
     // This method exists to support flake-related operations
     m_d->view->document()->addCommand(command);
 }
 
 void KisCanvas2::KisCanvas2Private::setActiveShapeManager(KoShapeManager *shapeManager)
 {
     if (shapeManager != currentlyActiveShapeManager) {
         currentlyActiveShapeManager = shapeManager;
         selectedShapesProxy.setShapeManager(shapeManager);
     }
 }
 
 KoShapeManager* KisCanvas2::shapeManager() const
 {
     KisNodeSP node = m_d->view->currentNode();
     KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
     if (localShapeManager != m_d->currentlyActiveShapeManager) {
         m_d->setActiveShapeManager(localShapeManager);
     }
 
     // sanity check for consistency of the local shape manager
     KIS_SAFE_ASSERT_RECOVER (localShapeManager == m_d->currentlyActiveShapeManager) {
         localShapeManager = globalShapeManager();
     }
 
     return localShapeManager ? localShapeManager : globalShapeManager();
 }
 
 KoSelectedShapesProxy* KisCanvas2::selectedShapesProxy() const
 {
     return &m_d->selectedShapesProxy;
 }
 
 KoShapeManager* KisCanvas2::globalShapeManager() const
 {
     return &m_d->shapeManager;
 }
 
 void KisCanvas2::updateInputMethodInfo()
 {
     // TODO call (the protected) QWidget::updateMicroFocus() on the proper canvas widget...
 }
 
 const KisCoordinatesConverter* KisCanvas2::coordinatesConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KoViewConverter* KisCanvas2::viewConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KisInputManager* KisCanvas2::globalInputManager() const
 {
     return m_d->view->globalInputManager();
 }
 
 KisInputActionGroupsMask KisCanvas2::inputActionGroupsMask() const
 {
     return m_d->inputActionGroupsMask;
 }
 
 void KisCanvas2::setInputActionGroupsMask(KisInputActionGroupsMask mask)
 {
     m_d->inputActionGroupsMask = mask;
 }
 
 QWidget* KisCanvas2::canvasWidget()
 {
     return m_d->canvasWidget->widget();
 }
 
 const QWidget* KisCanvas2::canvasWidget() const
 {
     return m_d->canvasWidget->widget();
 }
 
 
 KoUnit KisCanvas2::unit() const
 {
     KoUnit unit(KoUnit::Pixel);
 
     KisImageWSP image = m_d->view->image();
     if (image) {
         if (!qFuzzyCompare(image->xRes(), image->yRes())) {
             warnKrita << "WARNING: resolution of the image is anisotropic"
                        << ppVar(image->xRes())
                        << ppVar(image->yRes());
         }
 
         const qreal resolution = image->xRes();
         unit.setFactor(resolution);
     }
 
     return unit;
 }
 
 KoToolProxy * KisCanvas2::toolProxy() const
 {
     return &m_d->toolProxy;
 }
 
 void KisCanvas2::createQPainterCanvas()
 {
     m_d->currentCanvasIsOpenGL = false;
 
     KisQPainterCanvas * canvasWidget = new KisQPainterCanvas(this, m_d->coordinatesConverter, m_d->view);
     m_d->prescaledProjection = new KisPrescaledProjection();
     m_d->prescaledProjection->setCoordinatesConverter(m_d->coordinatesConverter);
     m_d->prescaledProjection->setMonitorProfile(m_d->displayColorConverter.monitorProfile(),
                                                 m_d->displayColorConverter.renderingIntent(),
                                                 m_d->displayColorConverter.conversionFlags());
     m_d->prescaledProjection->setDisplayFilter(m_d->displayColorConverter.displayFilter());
     canvasWidget->setPrescaledProjection(m_d->prescaledProjection);
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createOpenGLCanvas()
 {
     KisConfig cfg(true);
     m_d->openGLFilterMode = cfg.openGLFilteringMode();
     m_d->currentCanvasIsOpenGL = true;
 
     KisOpenGLCanvas2 *canvasWidget = new KisOpenGLCanvas2(this, m_d->coordinatesConverter, 0, m_d->view->image(), &m_d->displayColorConverter);
     m_d->frameCache = KisAnimationFrameCache::getFrameCache(canvasWidget->openGLImageTextures());
 
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createCanvas(bool useOpenGL)
 {
     // deinitialize previous canvas structures
     m_d->prescaledProjection = 0;
     m_d->frameCache = 0;
 
     KisConfig cfg(true);
     QDesktopWidget dw;
     const KoColorProfile *profile = cfg.displayProfile(dw.screenNumber(imageView()));
     m_d->displayColorConverter.setMonitorProfile(profile);
 
     if (useOpenGL) {
         if (KisOpenGL::hasOpenGL()) {
             createOpenGLCanvas();
             if (cfg.canvasState() == "OPENGL_FAILED") {
                 // Creating the opengl canvas failed, fall back
                 warnKrita << "OpenGL Canvas initialization returned OPENGL_FAILED. Falling back to QPainter.";
                 createQPainterCanvas();
             }
         } else {
             warnKrita << "Tried to create OpenGL widget when system doesn't have OpenGL\n";
             createQPainterCanvas();
         }
     }
     else {
         createQPainterCanvas();
     }
 
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(m_d->canvasWidget->widget());
     }
 
 }
 
 void KisCanvas2::initializeImage()
 {
     KisImageSP image = m_d->view->image();
 
     m_d->coordinatesConverter->setImage(image);
     m_d->toolProxy.initializeImage(image);
 
     connect(image, SIGNAL(sigImageUpdated(QRect)), SLOT(startUpdateCanvasProjection(QRect)), Qt::DirectConnection);
     connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
     connect(image, SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), SLOT(startResizingImage()), Qt::DirectConnection);
     connect(image->undoAdapter(), SIGNAL(selectionChanged()), SLOT(slotTrySwitchShapeManager()));
 
     connectCurrentCanvas();
 }
 
 void KisCanvas2::connectCurrentCanvas()
 {
     KisImageWSP image = m_d->view->image();
 
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setImage(image);
     }
 
     startResizingImage();
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 
     emit sigCanvasEngineChanged();
 }
 
 void KisCanvas2::resetCanvas(bool useOpenGL)
 {
     // we cannot reset the canvas before it's created, but this method might be called,
     // for instance when setting the monitor profile.
     if (!m_d->canvasWidget) {
         return;
     }
     KisConfig cfg(true);
     bool needReset = (m_d->currentCanvasIsOpenGL != useOpenGL) ||
         (m_d->currentCanvasIsOpenGL &&
          m_d->openGLFilterMode != cfg.openGLFilteringMode());
 
     if (needReset) {
         createCanvas(useOpenGL);
         connectCurrentCanvas();
         notifyZoomChanged();
     }
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::startUpdateInPatches(const QRect &imageRect)
 {
     if (m_d->currentCanvasIsOpenGL) {
         startUpdateCanvasProjection(imageRect);
     } else {
         KisImageConfig imageConfig(true);
         int patchWidth = imageConfig.updatePatchWidth();
         int patchHeight = imageConfig.updatePatchHeight();
 
         for (int y = 0; y < imageRect.height(); y += patchHeight) {
             for (int x = 0; x < imageRect.width(); x += patchWidth) {
                 QRect patchRect(x, y, patchWidth, patchHeight);
                 startUpdateCanvasProjection(patchRect);
             }
         }
     }
 }
 
 void KisCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_d->displayColorConverter.setDisplayFilter(displayFilter);
     KisImageSP image = this->image();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->setDisplayFilter(displayFilter);
     image->unlock();
 }
 
 QSharedPointer<KisDisplayFilter> KisCanvas2::displayFilter() const
 {
     return m_d->displayColorConverter.displayFilter();
 }
 
 KisDisplayColorConverter* KisCanvas2::displayColorConverter() const
 {
     return &m_d->displayColorConverter;
 }
 
 KisExposureGammaCorrectionInterface* KisCanvas2::exposureGammaCorrectionInterface() const
 {
     QSharedPointer<KisDisplayFilter> displayFilter = m_d->displayColorConverter.displayFilter();
 
     return displayFilter ?
         displayFilter->correctionInterface() :
         KisDumbExposureGammaCorrectionInterface::instance();
 }
 
 void KisCanvas2::setProofingOptions(bool softProof, bool gamutCheck)
 {
     m_d->proofingConfig = this->image()->proofingConfiguration();
     if (!m_d->proofingConfig) {
         qDebug()<<"Canvas: No proofing config found, generating one.";
         KisImageConfig cfg(false);
         m_d->proofingConfig = cfg.defaultProofingconfiguration();
     }
     KoColorConversionTransformation::ConversionFlags conversionFlags = m_d->proofingConfig->conversionFlags;
 #if QT_VERSION >= 0x050700
 
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags.setFlag(KoColorConversionTransformation::SoftProofing, softProof);
         if (softProof) {
             conversionFlags.setFlag(KoColorConversionTransformation::GamutCheck, gamutCheck);
         }
     }
 #else
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::SoftProofing;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::SoftProofing;
     }
     if (gamutCheck && softProof && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::GamutCheck;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::GamutCheck;
     }
 #endif
     m_d->proofingConfig->conversionFlags = conversionFlags;
 
     m_d->proofingConfigUpdated = true;
     startUpdateInPatches(this->image()->bounds());
 
 }
 
 void KisCanvas2::slotSoftProofing(bool softProofing)
 {
     m_d->softProofing = softProofing;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotGamutCheck(bool gamutCheck)
 {
     m_d->gamutCheck = gamutCheck;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotChangeProofingConfig()
 {
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::setProofingConfigUpdated(bool updated)
 {
     m_d->proofingConfigUpdated = updated;
 }
 
 bool KisCanvas2::proofingConfigUpdated()
 {
     return m_d->proofingConfigUpdated;
 }
 
 KisProofingConfigurationSP KisCanvas2::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
         m_d->proofingConfig = this->image()->proofingConfiguration();
         if (!m_d->proofingConfig) {
             m_d->proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
         }
     }
     return m_d->proofingConfig;
 }
 
 void KisCanvas2::startResizingImage()
 {
     KisImageWSP image = this->image();
     qint32 w = image->width();
     qint32 h = image->height();
 
     emit sigContinueResizeImage(w, h);
 
     QRect imageBounds(0, 0, w, h);
     startUpdateInPatches(imageBounds);
 }
 
 void KisCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->canvasWidget->finishResizingImage(w, h);
 }
 
 void KisCanvas2::startUpdateCanvasProjection(const QRect & rc)
 {
     KisUpdateInfoSP info = m_d->canvasWidget->startUpdateCanvasProjection(rc, m_d->channelFlags);
     if (m_d->projectionUpdatesCompressor.putUpdateInfo(info)) {
         emit sigCanvasCacheUpdated();
     }
 }
 
 void KisCanvas2::updateCanvasProjection()
 {
     QVector<KisUpdateInfoSP> infoObjects;
     while (KisUpdateInfoSP info = m_d->projectionUpdatesCompressor.takeUpdateInfo()) {
         infoObjects << info;
     }
 
     QVector<QRect> viewportRects = m_d->canvasWidget->updateCanvasProjection(infoObjects);
 
     const QRect vRect = std::accumulate(viewportRects.constBegin(), viewportRects.constEnd(),
                                         QRect(), std::bit_or<QRect>());
 
     // TODO: Implement info->dirtyViewportRect() for KisOpenGLCanvas2 to avoid updating whole canvas
     if (m_d->currentCanvasIsOpenGL) {
         m_d->savedUpdateRect = QRect();
 
         // we already had a compression in frameRenderStartCompressor, so force the update directly
         slotDoCanvasUpdate();
     } else if (/* !m_d->currentCanvasIsOpenGL && */ !vRect.isEmpty()) {
         m_d->savedUpdateRect = m_d->coordinatesConverter->viewportToWidget(vRect).toAlignedRect();
 
         // we already had a compression in frameRenderStartCompressor, so force the update directly
         slotDoCanvasUpdate();
     }
 }
 
 void KisCanvas2::slotDoCanvasUpdate()
 {
     /**
      * WARNING: in isBusy() we access openGL functions without making the painting
      * context current. We hope that currently active context will be Qt's one,
      * which is shared with our own.
      */
     if (m_d->canvasWidget->isBusy()) {
         // just restarting the timer
         updateCanvasWidgetImpl(m_d->savedUpdateRect);
         return;
     }
 
     if (m_d->savedUpdateRect.isEmpty()) {
         m_d->canvasWidget->widget()->update();
         emit updateCanvasRequested(m_d->canvasWidget->widget()->rect());
     } else {
         emit updateCanvasRequested(m_d->savedUpdateRect);
         m_d->canvasWidget->widget()->update(m_d->savedUpdateRect);
     }
 
     m_d->savedUpdateRect = QRect();
 }
 
 void KisCanvas2::updateCanvasWidgetImpl(const QRect &rc)
 {
     if (!m_d->canvasUpdateCompressor.isActive() ||
         !m_d->savedUpdateRect.isEmpty()) {
         m_d->savedUpdateRect |= rc;
     }
     m_d->canvasUpdateCompressor.start();
 }
 
 void KisCanvas2::updateCanvas()
 {
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::updateCanvas(const QRectF& documentRect)
 {
     if (m_d->currentCanvasIsOpenGL && m_d->canvasWidget->decorations().size() > 0) {
         updateCanvasWidgetImpl();
     }
     else {
         // updateCanvas is called from tools, never from the projection
         // updates, so no need to prescale!
         QRect widgetRect = m_d->coordinatesConverter->documentToWidget(documentRect).toAlignedRect();
         widgetRect.adjust(-2, -2, 2, 2);
         if (!widgetRect.isEmpty()) {
             updateCanvasWidgetImpl(widgetRect);
         }
     }
 }
 
 void KisCanvas2::disconnectCanvasObserver(QObject *object)
 {
     KoCanvasBase::disconnectCanvasObserver(object);
     m_d->view->disconnect(object);
 }
 
 void KisCanvas2::notifyZoomChanged()
 {
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->notifyZoomChanged();
     }
 
     notifyLevelOfDetailChange();
     updateCanvas(); // update the canvas, because that isn't done when zooming using KoZoomAction
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 QRect KisCanvas2::regionOfInterest() const
 {
     return m_d->regionOfInterest;
 }
 
 void KisCanvas2::slotUpdateRegionOfInterest()
 {
     const QRect oldRegionOfInterest = m_d->regionOfInterest;
 
     const qreal ratio = 0.25;
     const QRect proposedRoi = KisAlgebra2D::blowRect(m_d->coordinatesConverter->widgetRectInImagePixels(), ratio).toAlignedRect();
 
     const QRect imageRect = m_d->coordinatesConverter->imageRectInImagePixels();
 
     m_d->regionOfInterest = imageRect.contains(proposedRoi) ? proposedRoi : imageRect;
 
     if (m_d->regionOfInterest != oldRegionOfInterest) {
         emit sigRegionOfInterestChanged(m_d->regionOfInterest);
     }
 }
 
 void KisCanvas2::slotReferenceImagesChanged()
 {
     canvasController()->resetScrollBars();
 }
 
 void KisCanvas2::setRenderingLimit(const QRect &rc)
 {
     m_d->renderingLimit = rc;
 }
 
 QRect KisCanvas2::renderingLimit() const
 {
     return m_d->renderingLimit;
 }
 
 void KisCanvas2::slotTrySwitchShapeManager()
 {
     KisNodeSP node = m_d->view->currentNode();
 
     QPointer<KoShapeManager> newManager;
     newManager = fetchShapeManagerFromNode(node);
 
     m_d->setActiveShapeManager(newManager);
 }
 
 void KisCanvas2::notifyLevelOfDetailChange()
 {
     if (!m_d->effectiveLodAllowedInImage()) return;
 
     const qreal effectiveZoom = m_d->coordinatesConverter->effectiveZoom();
 
     KisConfig cfg(true);
     const int maxLod = cfg.numMipmapLevels();
 
     const int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
 
     if (m_d->effectiveLodAllowedInImage()) {
         KisImageSP image = this->image();
         image->setDesiredLevelOfDetail(lod);
     }
 }
 
 const KoColorProfile *  KisCanvas2::monitorProfile()
 {
     return m_d->displayColorConverter.monitorProfile();
 }
 
 KisViewManager* KisCanvas2::viewManager() const
 {
     if (m_d->view) {
         return m_d->view->viewManager();
     }
     return 0;
 }
 
 QPointer<KisView>KisCanvas2::imageView() const
 {
     return m_d->view;
 }
 
 KisImageWSP KisCanvas2::image() const
 {
     return m_d->view->image();
 
 }
 
 KisImageWSP KisCanvas2::currentImage() const
 {
     return m_d->view->image();
 }
 
 void KisCanvas2::documentOffsetMoved(const QPoint &documentOffset)
 {
     QPointF offsetBefore = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
     m_d->coordinatesConverter->setDocumentOffset(documentOffset);
     QPointF offsetAfter = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
 
     QPointF moveOffset = offsetAfter - offsetBefore;
 
     if (!m_d->currentCanvasIsOpenGL)
         m_d->prescaledProjection->viewportMoved(moveOffset);
 
     emit documentOffsetUpdateFinished();
 
     updateCanvas();
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 void KisCanvas2::slotConfigChanged()
 {
     KisConfig cfg(true);
     m_d->vastScrolling = cfg.vastScrolling();
 
     resetCanvas(cfg.useOpenGL());
     slotSetDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this->canvasWidget())));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::refetchDataFromImage()
 {
     KisImageSP image = this->image();
     KisImageBarrierLocker l(image);
     startUpdateInPatches(image->bounds());
 }
 
 void KisCanvas2::slotSetDisplayProfile(const KoColorProfile *monitorProfile)
 {
     if (m_d->displayColorConverter.monitorProfile() == monitorProfile) return;
 
     m_d->displayColorConverter.setMonitorProfile(monitorProfile);
 
     {
         KisImageSP image = this->image();
         KisImageBarrierLocker l(image);
         m_d->canvasWidget->setDisplayProfile(&m_d->displayColorConverter);
     }
 
     refetchDataFromImage();
 }
 
 void KisCanvas2::addDecoration(KisCanvasDecorationSP deco)
 {
     m_d->canvasWidget->addDecoration(deco);
 }
 
 KisCanvasDecorationSP KisCanvas2::decoration(const QString& id) const
 {
     return m_d->canvasWidget->decoration(id);
 }
 
 
 QPoint KisCanvas2::documentOrigin() const
 {
     /**
      * In Krita we don't use document origin anymore.
      * All the centering when needed (vastScrolling < 0.5) is done
      * automatically by the KisCoordinatesConverter.
      */
 
     return QPoint();
 }
 
 QPoint KisCanvas2::documentOffset() const
 {
     return m_d->coordinatesConverter->documentOffset();
 }
 
 void KisCanvas2::setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager)
 {
     m_d->popupPalette = new KisPopupPalette(viewManager(), m_d->coordinatesConverter, favoriteResourceManager, displayColorConverter()->displayRendererInterface(),
                                             m_d->view->resourceProvider(), m_d->canvasWidget->widget());
     connect(m_d->popupPalette, SIGNAL(zoomLevelChanged(int)), this, SLOT(slotPopupPaletteRequestedZoomChange(int)));
     connect(m_d->popupPalette, SIGNAL(sigUpdateCanvas()), this, SLOT(updateCanvas()));
     connect(m_d->view->mainWindow(), SIGNAL(themeChanged()), m_d->popupPalette, SLOT(slotUpdateIcons()));
 
     m_d->popupPalette->showPopupPalette(false);
 }
 
 void KisCanvas2::slotPopupPaletteRequestedZoomChange(int zoom ) {
     m_d->view->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, (qreal)(zoom/100.0)); // 1.0 is 100% zoom
     notifyZoomChanged();
 }
 
 void KisCanvas2::setCursor(const QCursor &cursor)
 {
     canvasWidget()->setCursor(cursor);
 }
 
 KisAnimationFrameCacheSP KisCanvas2::frameCache() const
 {
     return m_d->frameCache;
 }
 
 KisAnimationPlayer *KisCanvas2::animationPlayer() const
 {
     return m_d->animationPlayer;
 }
 
 void KisCanvas2::slotSelectionChanged()
 {
     KisShapeLayer* shapeLayer = dynamic_cast<KisShapeLayer*>(viewManager()->activeLayer().data());
     if (!shapeLayer) {
         return;
     }
     m_d->shapeManager.selection()->deselectAll();
     Q_FOREACH (KoShape* shape, shapeLayer->shapeManager()->selection()->selectedShapes()) {
         m_d->shapeManager.selection()->select(shape);
     }
 }
 
 bool KisCanvas2::isPopupPaletteVisible() const
 {
     if (!m_d->popupPalette) {
         return false;
     }
     return m_d->popupPalette->isVisible();
 }
 
 
 void KisCanvas2::setWrapAroundViewingMode(bool value)
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         infinityDecoration->setVisible(!value);
     }
 
     m_d->canvasWidget->setWrapAroundViewingMode(value);
 }
 
 bool KisCanvas2::wrapAroundViewingMode() const
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         return !(infinityDecoration->visible());
     }
     return false;
 }
 
 void KisCanvas2::bootstrapFinished()
 {
     if (!m_d->bootstrapLodBlocked) return;
 
     m_d->bootstrapLodBlocked = false;
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 }
 
 void KisCanvas2::setLodAllowedInCanvas(bool value)
 {
     if (!KisOpenGL::supportsLoD()) {
         qWarning() << "WARNING: Level of Detail functionality is available only with openGL + GLSL 1.3 support";
     }
 
     m_d->lodAllowedInImage =
         value &&
         m_d->currentCanvasIsOpenGL &&
         KisOpenGL::supportsLoD() &&
         (m_d->openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
          m_d->openGLFilterMode == KisOpenGL::HighQualityFiltering);
 
     KisImageSP image = this->image();
 
     if (m_d->effectiveLodAllowedInImage() != !image->levelOfDetailBlocked()) {
         image->setLevelOfDetailBlocked(!m_d->effectiveLodAllowedInImage());
     }
 
     notifyLevelOfDetailChange();
 
     KisConfig cfg(false);
     cfg.setLevelOfDetailEnabled(m_d->lodAllowedInImage);
 }
 
 bool KisCanvas2::lodAllowedInCanvas() const
 {
     return m_d->lodAllowedInImage;
 }
 
 void KisCanvas2::slotShowPopupPalette(const QPoint &p)
 {
     if (!m_d->popupPalette) {
         return;
     }
 
     m_d->popupPalette->showPopupPalette(p);
 }
 
 KisPaintingAssistantsDecorationSP KisCanvas2::paintingAssistantsDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("paintingAssistantsDecoration");
     return qobject_cast<KisPaintingAssistantsDecoration*>(deco.data());
 }
 
 KisReferenceImagesDecorationSP KisCanvas2::referenceImagesDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("referenceImagesDecoration");
     return qobject_cast<KisReferenceImagesDecoration*>(deco.data());
 }
diff --git a/libs/ui/canvas/kis_guides_manager.cpp b/libs/ui/canvas/kis_guides_manager.cpp
index 9fe764c749..aaac373af5 100644
--- a/libs/ui/canvas/kis_guides_manager.cpp
+++ b/libs/ui/canvas/kis_guides_manager.cpp
@@ -1,803 +1,802 @@
 /*
  *  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_guides_manager.h"
 
 #include <QMenu>
 #include <QGuiApplication>
 #include "kis_guides_decoration.h"
 #include <KoRuler.h>
 #include "kis_guides_config.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include "kis_signals_blocker.h"
 #include "input/kis_input_manager.h"
 #include "kis_coordinates_converter.h"
 #include "kis_zoom_manager.h"
 #include "kis_signal_auto_connection.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_algebra_2d.h"
 #include <KoSnapGuide.h>
 #include "kis_snap_line_strategy.h"
 #include "kis_change_guides_command.h"
 #include "kis_snap_config.h"
-#include "kis_coordinates_converter.h"
 #include  "kis_canvas2.h"
 #include "kis_signal_compressor.h"
 
 struct KisGuidesManager::Private
 {
     Private(KisGuidesManager *_q)
         : q(_q),
           decoration(0),
           invalidGuide(Qt::Horizontal, -1),
           currentGuide(invalidGuide),
           cursorSwitched(false),
           dragStartGuidePos(0),
           updateDocumentCompressor(40, KisSignalCompressor::FIRST_ACTIVE),
           shouldSetModified(false) {}
 
     KisGuidesManager *q;
 
     KisGuidesDecoration *decoration;
     KisGuidesConfig guidesConfig;
     KisSnapConfig snapConfig;
     QPointer<KisView> view;
 
     typedef QPair<Qt::Orientation, int> GuideHandle;
 
     GuideHandle findGuide(const QPointF &docPos);
     bool isGuideValid(const GuideHandle &h);
     qreal guideValue(const GuideHandle &h);
     void setGuideValue(const GuideHandle &h, qreal value);
     void deleteGuide(const GuideHandle &h);
     const GuideHandle invalidGuide;
 
     bool updateCursor(const QPointF &docPos, bool forceDisableCursor = false);
 
     void initDragStart(const GuideHandle &guide,
                        const QPointF &dragStart,
                        qreal guideValue,
                        bool snapToStart);
     bool mouseMoveHandler(const QPointF &docPos, Qt::KeyboardModifiers modifiers);
     bool mouseReleaseHandler(const QPointF &docPos);
 
     void updateSnappingStatus(const KisGuidesConfig &value);
     QPointF alignToPixels(const QPointF docPoint);
     QPointF getDocPointFromEvent(QEvent *event);
     Qt::MouseButton getButtonFromEvent(QEvent *event);
     QAction* createShortenedAction(const QString &text, const QString &parentId, QObject *parent);
     void syncAction(const QString &actionName, bool value);
 
     GuideHandle currentGuide;
 
     bool cursorSwitched;
     QCursor oldCursor;
 
     QPointF dragStartDoc;
     QPointF dragPointerOffset;
     qreal dragStartGuidePos;
 
     KisSignalAutoConnectionsStore viewConnections;
 
     KisSignalCompressor updateDocumentCompressor;
     bool shouldSetModified;
 };
 
 KisGuidesManager::KisGuidesManager(QObject *parent)
     : QObject(parent),
       m_d(new Private(this))
 {
     connect(&m_d->updateDocumentCompressor, SIGNAL(timeout()), SLOT(slotUploadConfigToDocument()));
 }
 
 KisGuidesManager::~KisGuidesManager()
 {
 }
 
 void KisGuidesManager::setGuidesConfig(const KisGuidesConfig &config)
 {
     if (config == m_d->guidesConfig) return;
     setGuidesConfigImpl(config, true);
 }
 
 void KisGuidesManager::slotDocumentRequestedConfig(const KisGuidesConfig &config)
 {
     if (config == m_d->guidesConfig) return;
     setGuidesConfigImpl(config, false);
 }
 
 void KisGuidesManager::slotUploadConfigToDocument()
 {
     const KisGuidesConfig &value = m_d->guidesConfig;
 
     KisDocument *doc = m_d->view ? m_d->view->document() : 0;
     if (doc) {
         KisSignalsBlocker b(doc);
 
         if (m_d->shouldSetModified) {
             KUndo2Command *cmd = new KisChangeGuidesCommand(doc, value);
             doc->addCommand(cmd);
         } else {
             doc->setGuidesConfig(value);
         }
 
         value.saveStaticData();
     }
 
     m_d->shouldSetModified = false;
 }
 
 void KisGuidesManager::setGuidesConfigImpl(const KisGuidesConfig &value, bool emitModified)
 {
     m_d->guidesConfig = value;
 
     if (m_d->decoration && value != m_d->decoration->guidesConfig()) {
         m_d->decoration->setVisible(value.showGuides());
         m_d->decoration->setGuidesConfig(value);
     }
 
     m_d->shouldSetModified |= emitModified;
     m_d->updateDocumentCompressor.start();
 
     const bool shouldFilterEvent =
         value.showGuides() && !value.lockGuides() && value.hasGuides();
 
     attachEventFilterImpl(shouldFilterEvent);
     syncActionsStatus();
 
     if (!m_d->isGuideValid(m_d->currentGuide)) {
         m_d->updateSnappingStatus(value);
     }
 
     if (m_d->view) {
         m_d->view->document()->setUnit(KoUnit(m_d->guidesConfig.unitType()));
         m_d->view->viewManager()->actionManager()->actionByName("ruler_pixel_multiple2")->setChecked(value.rulersMultiple2());
     }
 
     emit sigRequestUpdateGuidesConfig(m_d->guidesConfig);
 }
 
 void KisGuidesManager::attachEventFilterImpl(bool value)
 {
     if (!m_d->view) return;
 
     KisInputManager *inputManager = m_d->view->globalInputManager();
     if (inputManager) {
         if (value) {
             inputManager->attachPriorityEventFilter(this, 100);
         } else {
             inputManager->detachPriorityEventFilter(this);
         }
     }
 }
 
 void KisGuidesManager::Private::syncAction(const QString &actionName, bool value)
 {
     KisActionManager *actionManager = view->viewManager()->actionManager();
     KisAction *action = actionManager->actionByName(actionName);
     KIS_ASSERT_RECOVER_RETURN(action);
     KisSignalsBlocker b(action);
     action->setChecked(value);
 }
 
 void KisGuidesManager::syncActionsStatus()
 {
     if (!m_d->view) return;
 
     m_d->syncAction("view_show_guides", m_d->guidesConfig.showGuides());
     m_d->syncAction("view_lock_guides", m_d->guidesConfig.lockGuides());
     m_d->syncAction("view_snap_to_guides", m_d->guidesConfig.snapToGuides());
 
     m_d->syncAction("view_snap_orthogonal", m_d->snapConfig.orthogonal());
     m_d->syncAction("view_snap_node", m_d->snapConfig.node());
     m_d->syncAction("view_snap_extension", m_d->snapConfig.extension());
     m_d->syncAction("view_snap_intersection", m_d->snapConfig.intersection());
     m_d->syncAction("view_snap_bounding_box", m_d->snapConfig.boundingBox());
     m_d->syncAction("view_snap_image_bounds", m_d->snapConfig.imageBounds());
     m_d->syncAction("view_snap_image_center", m_d->snapConfig.imageCenter());
 }
 
 void KisGuidesManager::Private::updateSnappingStatus(const KisGuidesConfig &value)
 {
     if (!view) return;
 
     KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
     KisSnapLineStrategy *guidesSnap = 0;
 
     if (value.snapToGuides()) {
         guidesSnap = new KisSnapLineStrategy(KoSnapGuide::GuideLineSnapping);
         guidesSnap->setHorizontalLines(value.horizontalGuideLines());
         guidesSnap->setVerticalLines(value.verticalGuideLines());
     }
 
     snapGuide->overrideSnapStrategy(KoSnapGuide::GuideLineSnapping, guidesSnap);
     snapGuide->enableSnapStrategy(KoSnapGuide::GuideLineSnapping, guidesSnap);
 
     snapGuide->enableSnapStrategy(KoSnapGuide::OrthogonalSnapping, snapConfig.orthogonal());
     snapGuide->enableSnapStrategy(KoSnapGuide::NodeSnapping, snapConfig.node());
     snapGuide->enableSnapStrategy(KoSnapGuide::ExtensionSnapping, snapConfig.extension());
     snapGuide->enableSnapStrategy(KoSnapGuide::IntersectionSnapping, snapConfig.intersection());
     snapGuide->enableSnapStrategy(KoSnapGuide::BoundingBoxSnapping, snapConfig.boundingBox());
     snapGuide->enableSnapStrategy(KoSnapGuide::DocumentBoundsSnapping, snapConfig.imageBounds());
     snapGuide->enableSnapStrategy(KoSnapGuide::DocumentCenterSnapping, snapConfig.imageCenter());
 
     snapConfig.saveStaticData();
 }
 
 bool KisGuidesManager::showGuides() const
 {
     return m_d->guidesConfig.showGuides();
 }
 
 void KisGuidesManager::setShowGuides(bool value)
 {
     m_d->guidesConfig.setShowGuides(value);
     setGuidesConfigImpl(m_d->guidesConfig);
 }
 
 bool KisGuidesManager::lockGuides() const
 {
     return m_d->guidesConfig.lockGuides();
 }
 
 void KisGuidesManager::setLockGuides(bool value)
 {
     m_d->guidesConfig.setLockGuides(value);
     setGuidesConfigImpl(m_d->guidesConfig);
 }
 
 bool KisGuidesManager::snapToGuides() const
 {
     return m_d->guidesConfig.snapToGuides();
 }
 
 void KisGuidesManager::setSnapToGuides(bool value)
 {
     m_d->guidesConfig.setSnapToGuides(value);
     setGuidesConfigImpl(m_d->guidesConfig);
 }
 
 bool KisGuidesManager::rulersMultiple2() const
 {
     return m_d->guidesConfig.rulersMultiple2();
 }
 
 void KisGuidesManager::setRulersMultiple2(bool value)
 {
     m_d->guidesConfig.setRulersMultiple2(value);
     setGuidesConfigImpl(m_d->guidesConfig);
 }
 
 KoUnit::Type KisGuidesManager::unitType() const
 {
     return m_d->guidesConfig.unitType();
 }
 
 void KisGuidesManager::setUnitType(const KoUnit::Type type)
 {
     m_d->guidesConfig.setUnitType(type);
     setGuidesConfigImpl(m_d->guidesConfig, false);
 }
 
 void KisGuidesManager::setup(KisActionManager *actionManager)
 {
     KisAction *action = 0;
 
     action = actionManager->createAction("view_show_guides");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setShowGuides(bool)));
 
     action = actionManager->createAction("view_lock_guides");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setLockGuides(bool)));
 
     action = actionManager->createAction("view_snap_to_guides");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapToGuides(bool)));
 
     action = actionManager->createAction("show_snap_options_popup");
     connect(action, SIGNAL(triggered()), this, SLOT(slotShowSnapOptions()));
 
     action = actionManager->createAction("view_snap_orthogonal");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapOrthogonal(bool)));
 
     action = actionManager->createAction("view_snap_node");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapNode(bool)));
 
     action = actionManager->createAction("view_snap_extension");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapExtension(bool)));
 
     action = actionManager->createAction("view_snap_intersection");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapIntersection(bool)));
 
     action = actionManager->createAction("view_snap_bounding_box");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapBoundingBox(bool)));
 
     action = actionManager->createAction("view_snap_image_bounds");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapImageBounds(bool)));
 
     action = actionManager->createAction("view_snap_image_center");
     connect(action, SIGNAL(toggled(bool)), this, SLOT(setSnapImageCenter(bool)));
 
     m_d->updateSnappingStatus(m_d->guidesConfig);
     syncActionsStatus();
 }
 
 void KisGuidesManager::setView(QPointer<KisView> view)
 {
     if (m_d->view) {
         KoSnapGuide *snapGuide = m_d->view->canvasBase()->snapGuide();
         snapGuide->overrideSnapStrategy(KoSnapGuide::GuideLineSnapping, 0);
         snapGuide->enableSnapStrategy(KoSnapGuide::GuideLineSnapping, false);
 
         if (m_d->updateDocumentCompressor.isActive()) {
             m_d->updateDocumentCompressor.stop();
             slotUploadConfigToDocument();
         }
 
         m_d->decoration = 0;
         m_d->viewConnections.clear();
         attachEventFilterImpl(false);
     }
 
     m_d->view = view;
 
     if (m_d->view) {
         KisGuidesDecoration* decoration = qobject_cast<KisGuidesDecoration*>(m_d->view->canvasBase()->decoration(GUIDES_DECORATION_ID).data());
         if (!decoration) {
             decoration = new KisGuidesDecoration(m_d->view);
             m_d->view->canvasBase()->addDecoration(decoration);
         }
         m_d->decoration = decoration;
 
         m_d->guidesConfig = m_d->view->document()->guidesConfig();
         setGuidesConfigImpl(m_d->guidesConfig, false);
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->horizontalRuler(), SIGNAL(guideCreationInProgress(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationInProgress(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->horizontalRuler(), SIGNAL(guideCreationFinished(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationFinished(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->verticalRuler(), SIGNAL(guideCreationInProgress(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationInProgress(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->zoomManager()->verticalRuler(), SIGNAL(guideCreationFinished(Qt::Orientation, const QPoint&)),
             this, SLOT(slotGuideCreationFinished(Qt::Orientation, const QPoint&)));
 
         m_d->viewConnections.addUniqueConnection(
             m_d->view->document(), SIGNAL(sigGuidesConfigChanged(const KisGuidesConfig &)),
             this, SLOT(slotDocumentRequestedConfig(const KisGuidesConfig &)));
     }
 }
 
 KisGuidesManager::Private::GuideHandle
 KisGuidesManager::Private::findGuide(const QPointF &docPos)
 {
     const int snapRadius = 16;
 
     GuideHandle nearestGuide = invalidGuide;
     qreal nearestRadius = std::numeric_limits<int>::max();
 
     for (int i = 0; i < guidesConfig.horizontalGuideLines().size(); i++) {
         const qreal guide = guidesConfig.horizontalGuideLines()[i];
         const qreal radius = qAbs(docPos.y() - guide);
         if (radius < snapRadius && radius < nearestRadius) {
             nearestGuide = GuideHandle(Qt::Horizontal, i);
             nearestRadius = radius;
         }
     }
 
     for (int i = 0; i < guidesConfig.verticalGuideLines().size(); i++) {
         const qreal guide = guidesConfig.verticalGuideLines()[i];
         const qreal radius = qAbs(docPos.x() - guide);
         if (radius < snapRadius && radius < nearestRadius) {
             nearestGuide = GuideHandle(Qt::Vertical, i);
             nearestRadius = radius;
         }
     }
 
     return nearestGuide;
 }
 
 bool KisGuidesManager::Private::isGuideValid(const GuideHandle &h)
 {
     return h.second >= 0;
 }
 
 qreal KisGuidesManager::Private::guideValue(const GuideHandle &h)
 {
     return h.first == Qt::Horizontal ?
         guidesConfig.horizontalGuideLines()[h.second] :
         guidesConfig.verticalGuideLines()[h.second];
 }
 
 void KisGuidesManager::Private::setGuideValue(const GuideHandle &h, qreal value)
 {
     if (h.first == Qt::Horizontal) {
         QList<qreal> guides = guidesConfig.horizontalGuideLines();
         guides[h.second] = value;
         guidesConfig.setHorizontalGuideLines(guides);
     } else {
         QList<qreal> guides = guidesConfig.verticalGuideLines();
         guides[h.second] = value;
         guidesConfig.setVerticalGuideLines(guides);
     }
 }
 
 void KisGuidesManager::Private::deleteGuide(const GuideHandle &h)
 {
     if (h.first == Qt::Horizontal) {
         QList<qreal> guides = guidesConfig.horizontalGuideLines();
         guides.removeAt(h.second);
         guidesConfig.setHorizontalGuideLines(guides);
     } else {
         QList<qreal> guides = guidesConfig.verticalGuideLines();
         guides.removeAt(h.second);
         guidesConfig.setVerticalGuideLines(guides);
     }
 }
 
 bool KisGuidesManager::Private::updateCursor(const QPointF &docPos, bool forceDisableCursor)
 {
     KisCanvas2 *canvas = view->canvasBase();
 
     const GuideHandle guide = findGuide(docPos);
     const bool guideValid = isGuideValid(guide) && !forceDisableCursor;
 
     if (guideValid && !cursorSwitched) {
         oldCursor = canvas->canvasWidget()->cursor();
     }
 
     if (guideValid) {
         cursorSwitched = true;
         QCursor newCursor = guide.first == Qt::Horizontal ?
             Qt::SizeVerCursor : Qt::SizeHorCursor;
         canvas->canvasWidget()->setCursor(newCursor);
     }
 
     if (!guideValid && cursorSwitched) {
         canvas->canvasWidget()->setCursor(oldCursor);
         cursorSwitched = false;
     }
 
     return guideValid;
 }
 
 void KisGuidesManager::Private::initDragStart(const GuideHandle &guide,
                                               const QPointF &dragStart,
                                               qreal guideValue,
                                               bool snapToStart)
 {
     currentGuide = guide;
     dragStartDoc = dragStart;
     dragStartGuidePos = guideValue;
     dragPointerOffset =
         guide.first == Qt::Horizontal ?
         QPointF(0, dragStartGuidePos - dragStartDoc.y()) :
         QPointF(dragStartGuidePos - dragStartDoc.x(), 0);
 
     KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
     snapGuide->reset();
 
     if (snapToStart) {
         KisSnapLineStrategy *strategy = new KisSnapLineStrategy();
         strategy->addLine(guide.first, guideValue);
         snapGuide->addCustomSnapStrategy(strategy);
     }
 }
 
 QPointF KisGuidesManager::Private::alignToPixels(const QPointF docPoint)
 {
     KisCanvas2 *canvas = view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
     QPoint imagePoint = converter->documentToImage(docPoint).toPoint();
     return converter->imageToDocument(imagePoint);
 }
 
 bool KisGuidesManager::Private::mouseMoveHandler(const QPointF &docPos, Qt::KeyboardModifiers modifiers)
 {
     if (isGuideValid(currentGuide)) {
         KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
         const QPointF snappedPos = snapGuide->snap(docPos, dragPointerOffset, modifiers);
         const QPointF offset = snappedPos - dragStartDoc;
         const qreal newValue = dragStartGuidePos +
             (currentGuide.first == Qt::Horizontal ?
              offset.y() : offset.x());
 
         setGuideValue(currentGuide, newValue);
         q->setGuidesConfigImpl(guidesConfig);
 
     }
 
     return updateCursor(docPos);
 }
 
 bool KisGuidesManager::Private::mouseReleaseHandler(const QPointF &docPos)
 {
     bool result = false;
     KisCanvas2 *canvas = view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
 
     if (isGuideValid(currentGuide)) {
         const QRectF docRect = converter->imageRectInDocumentPixels();
         // TODO: enable work rect after we fix painting guides
         //       outside canvas in openGL mode
         const QRectF workRect = KisAlgebra2D::blowRect(docRect, 0 /*0.2*/);
         if (!workRect.contains(docPos)) {
             deleteGuide(currentGuide);
             q->setGuidesConfigImpl(guidesConfig);
 
             /**
              * When we delete a guide, it might happen that we are
              * delting the last guide. Therefore we should eat the
              * corresponding event so that the event filter would stop
              * the filter processing.
              */
             result = true;
         }
 
         currentGuide = invalidGuide;
         dragStartDoc = QPointF();
         dragPointerOffset = QPointF();
         dragStartGuidePos = 0;
 
         KoSnapGuide *snapGuide = view->canvasBase()->snapGuide();
         snapGuide->reset();
 
         updateSnappingStatus(guidesConfig);
     }
 
     return updateCursor(docPos) | result;
 }
 
 QPointF KisGuidesManager::Private::getDocPointFromEvent(QEvent *event)
 {
     QPointF result;
 
     KisCanvas2 *canvas = view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
 
     if (event->type() == QEvent::Enter) {
         QEnterEvent *enterEvent = static_cast<QEnterEvent*>(event);
         result = alignToPixels(converter->widgetToDocument(enterEvent->pos()));
     } else if (event->type() == QEvent::MouseMove ||
         event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease) {
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         result = alignToPixels(converter->widgetToDocument(mouseEvent->pos()));
 
     } else if (event->type() == QEvent::TabletMove ||
                event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         result = alignToPixels(converter->widgetToDocument(tabletEvent->pos()));
     } else {
         // we shouldn't silently return QPointF(0,0), higher level code may
         // snap to some unexpected guide
         KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "event type is not supported!");
     }
 
     return result;
 }
 
 Qt::MouseButton KisGuidesManager::Private::getButtonFromEvent(QEvent *event)
 {
     Qt::MouseButton button = Qt::NoButton;
 
     if (event->type() == QEvent::MouseMove ||
         event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease) {
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         button = mouseEvent->button();
 
     } else if (event->type() == QEvent::TabletMove ||
                event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         button = tabletEvent->button();
     }
 
     return button;
 }
 
 bool KisGuidesManager::eventFilter(QObject *obj, QEvent *event)
 {
     if (!m_d->view || obj != m_d->view->canvasBase()->canvasWidget()) return false;
 
     bool retval = false;
 
     switch (event->type()) {
     case QEvent::Leave:
         m_d->updateCursor(QPointF(), true);
         break;
     case QEvent::Enter:
     case QEvent::TabletMove:
     case QEvent::MouseMove: {
         const QPointF docPos = m_d->getDocPointFromEvent(event);
         const Qt::KeyboardModifiers modifiers = qApp->keyboardModifiers();
 
         // we should never eat Enter events, input manager may get crazy about it
         retval = m_d->mouseMoveHandler(docPos, modifiers) && event->type() != QEvent::Enter;
 
         break;
     }
     case QEvent::TabletPress:
     case QEvent::MouseButtonPress: {
         if (m_d->getButtonFromEvent(event) != Qt::LeftButton) break;
 
         const QPointF docPos = m_d->getDocPointFromEvent(event);
         const Private::GuideHandle guide = m_d->findGuide(docPos);
         const bool guideValid = m_d->isGuideValid(guide);
 
         if (guideValid) {
             m_d->initDragStart(guide, docPos, m_d->guideValue(guide), true);
         }
 
         retval = m_d->updateCursor(docPos);
 
         break;
     }
     case QEvent::TabletRelease:
     case QEvent::MouseButtonRelease: {
         if (m_d->getButtonFromEvent(event) != Qt::LeftButton) break;
 
         const QPointF docPos = m_d->getDocPointFromEvent(event);
         retval = m_d->mouseReleaseHandler(docPos);
 
         break;
     }
     default:
         break;
     }
 
     return !retval ? QObject::eventFilter(obj, event) : true;
 }
 
 void KisGuidesManager::slotGuideCreationInProgress(Qt::Orientation orientation, const QPoint &globalPos)
 {
     if (m_d->guidesConfig.lockGuides()) return;
 
     KisCanvas2 *canvas = m_d->view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
     const QPointF widgetPos = canvas->canvasWidget()->mapFromGlobal(globalPos);
     const QPointF docPos = m_d->alignToPixels(converter->widgetToDocument(widgetPos));
 
     if (m_d->isGuideValid(m_d->currentGuide)) {
         const Qt::KeyboardModifiers modifiers = qApp->keyboardModifiers();
         m_d->mouseMoveHandler(docPos, modifiers);
     } else {
         m_d->guidesConfig.setShowGuides(true);
 
         if (orientation == Qt::Horizontal) {
             QList<qreal> guides = m_d->guidesConfig.horizontalGuideLines();
             guides.append(docPos.y());
             m_d->currentGuide.first = orientation;
             m_d->currentGuide.second = guides.size() - 1;
             m_d->guidesConfig.setHorizontalGuideLines(guides);
             m_d->initDragStart(m_d->currentGuide, docPos, docPos.y(), false);
         } else {
             QList<qreal> guides = m_d->guidesConfig.verticalGuideLines();
             guides.append(docPos.x());
             m_d->currentGuide.first = orientation;
             m_d->currentGuide.second = guides.size() - 1;
             m_d->guidesConfig.setVerticalGuideLines(guides);
             m_d->initDragStart(m_d->currentGuide, docPos, docPos.x(), false);
         }
 
         setGuidesConfigImpl(m_d->guidesConfig);
     }
 }
 
 void KisGuidesManager::slotGuideCreationFinished(Qt::Orientation orientation, const QPoint &globalPos)
 {
     Q_UNUSED(orientation);
     if (m_d->guidesConfig.lockGuides()) return;
 
     KisCanvas2 *canvas = m_d->view->canvasBase();
     const KisCoordinatesConverter *converter = canvas->coordinatesConverter();
     const QPointF widgetPos = canvas->canvasWidget()->mapFromGlobal(globalPos);
     const QPointF docPos = m_d->alignToPixels(converter->widgetToDocument(widgetPos));
 
     m_d->mouseReleaseHandler(docPos);
 }
 
 QAction* KisGuidesManager::Private::createShortenedAction(const QString &text, const QString &parentId, QObject *parent)
 {
     KisActionManager *actionManager = view->viewManager()->actionManager();
     QAction *action = 0;
     KisAction *parentAction = 0;
 
     action = new QAction(text, parent);
     action->setCheckable(true);
     parentAction = actionManager->actionByName(parentId);
     action->setChecked(parentAction->isChecked());
     connect(action, SIGNAL(toggled(bool)), parentAction, SLOT(setChecked(bool)));
 
     return action;
 }
 
 void KisGuidesManager::slotShowSnapOptions()
 {
     const QPoint pos = QCursor::pos();
     QMenu menu;
 
     menu.addSection(i18n("Snap to:"));
     menu.addAction(m_d->createShortenedAction(i18n("Grid"), "view_snap_to_grid", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Guides"), "view_snap_to_guides", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Orthogonal"), "view_snap_orthogonal", &menu));
 
     menu.addAction(m_d->createShortenedAction(i18n("Node"), "view_snap_node", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Extension"), "view_snap_extension", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Intersection"), "view_snap_intersection", &menu));
 
     menu.addAction(m_d->createShortenedAction(i18n("Bounding Box"), "view_snap_bounding_box", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Image Bounds"), "view_snap_image_bounds", &menu));
     menu.addAction(m_d->createShortenedAction(i18n("Image Center"), "view_snap_image_center", &menu));
 
     menu.exec(pos);
 }
 
 void KisGuidesManager::setSnapOrthogonal(bool value)
 {
     m_d->snapConfig.setOrthogonal(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapNode(bool value)
 {
     m_d->snapConfig.setNode(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapExtension(bool value)
 {
     m_d->snapConfig.setExtension(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapIntersection(bool value)
 {
     m_d->snapConfig.setIntersection(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapBoundingBox(bool value)
 {
     m_d->snapConfig.setBoundingBox(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapImageBounds(bool value)
 {
     m_d->snapConfig.setImageBounds(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
 
 void KisGuidesManager::setSnapImageCenter(bool value)
 {
     m_d->snapConfig.setImageCenter(value);
     m_d->updateSnappingStatus(m_d->guidesConfig);
 }
diff --git a/libs/ui/canvas/kis_qpainter_canvas.cpp b/libs/ui/canvas/kis_qpainter_canvas.cpp
index cc45134246..b2172b14a7 100644
--- a/libs/ui/canvas/kis_qpainter_canvas.cpp
+++ b/libs/ui/canvas/kis_qpainter_canvas.cpp
@@ -1,253 +1,252 @@
 /*
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  * Copyright (C) Lukas Tvrdy <lukast.dev@gmail.com>, (C) 2009
  *
  *  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_qpainter_canvas.h"
 
 
 #include <QPaintEvent>
 #include <QPoint>
 #include <QRect>
 #include <QPainter>
 #include <QImage>
 #include <QBrush>
 #include <QColor>
 #include <QString>
 #include <QTime>
 #include <QTimer>
 #include <QApplication>
 #include <QMenu>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 #include <KoColorProfile.h>
 #include "kis_coordinates_converter.h"
 #include <KoZoomHandler.h>
 #include <KoToolManager.h>
 #include <KoToolProxy.h>
 
 #include <kis_image.h>
 #include <kis_layer.h>
 
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_prescaled_projection.h"
-#include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisDocument.h"
 #include "kis_selection_manager.h"
 #include "kis_selection.h"
 #include "kis_canvas_updates_compressor.h"
 #include "kis_config_notifier.h"
 #include "kis_group_layer.h"
 #include "canvas/kis_display_color_converter.h"
 
 //#define DEBUG_REPAINT
 #include <KoCanvasController.h>
 
 class KisQPainterCanvas::Private
 {
 public:
     KisPrescaledProjectionSP prescaledProjection;
     QBrush checkBrush;
     bool scrollCheckers;
 };
 
 KisQPainterCanvas::KisQPainterCanvas(KisCanvas2 *canvas, KisCoordinatesConverter *coordinatesConverter, QWidget * parent)
         : QWidget(parent)
         , KisCanvasWidgetBase(canvas, coordinatesConverter)
         , m_d(new Private())
 {
     setAutoFillBackground(true);
     setAcceptDrops(true);
     setFocusPolicy(Qt::StrongFocus);
     setAttribute(Qt::WA_InputMethodEnabled, false);
     setAttribute(Qt::WA_StaticContents);
     setAttribute(Qt::WA_OpaquePaintEvent);
 #ifdef Q_OS_OSX
     setAttribute(Qt::WA_AcceptTouchEvents, false);
 #else
     setAttribute(Qt::WA_AcceptTouchEvents, true);
 #endif
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisQPainterCanvas::~KisQPainterCanvas()
 {
     delete m_d;
 }
 
 void KisQPainterCanvas::setPrescaledProjection(KisPrescaledProjectionSP prescaledProjection)
 {
     m_d->prescaledProjection = prescaledProjection;
 }
 
 void KisQPainterCanvas::paintEvent(QPaintEvent * ev)
 {
     KisImageWSP image = canvas()->image();
     if (image == 0) return;
 
     setAutoFillBackground(false);
 
     QPainter gc(this);
     gc.setClipRegion(ev->region());
 
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     gc.save();
 
     gc.setCompositionMode(QPainter::CompositionMode_Source);
     gc.fillRect(QRect(QPoint(0, 0), size()), borderColor());
 
     QTransform checkersTransform;
     QPointF brushOrigin;
     QPolygonF polygon;
 
     converter->getQPainterCheckersInfo(&checkersTransform, &brushOrigin, &polygon, m_d->scrollCheckers);
     gc.setPen(Qt::NoPen);
     gc.setBrush(m_d->checkBrush);
     gc.setBrushOrigin(brushOrigin);
     gc.setTransform(checkersTransform);
     gc.drawPolygon(polygon);
 
     drawImage(gc, ev->rect());
 
     gc.restore();
 
 #ifdef DEBUG_REPAINT
     QColor color = QColor(random() % 255, random() % 255, random() % 255, 150);
     gc.fillRect(ev->rect(), color);
 #endif
 
     drawDecorations(gc, ev->rect());
 }
 
 void KisQPainterCanvas::drawImage(QPainter & gc, const QRect &updateWidgetRect) const
 {
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     QTransform imageTransform = converter->viewportToWidgetTransform();
     gc.setTransform(imageTransform);
     gc.setRenderHint(QPainter::SmoothPixmapTransform, true);
 
     QRectF viewportRect = converter->widgetToViewport(updateWidgetRect);
 
     gc.setCompositionMode(QPainter::CompositionMode_SourceOver);
     gc.drawImage(viewportRect, m_d->prescaledProjection->prescaledQImage(),
                  viewportRect);
 }
 
 QVariant KisQPainterCanvas::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     return processInputMethodQuery(query);
 }
 
 void KisQPainterCanvas::inputMethodEvent(QInputMethodEvent *event)
 {
     processInputMethodEvent(event);
 }
 
 void KisQPainterCanvas::channelSelectionChanged(const QBitArray &channelFlags)
 {
     Q_ASSERT(m_d->prescaledProjection);
     m_d->prescaledProjection->setChannelFlags(channelFlags);
 }
 
 void KisQPainterCanvas::setDisplayProfile(KisDisplayColorConverter *colorConverter)
 {
     Q_ASSERT(m_d->prescaledProjection);
     m_d->prescaledProjection->setMonitorProfile(colorConverter->monitorProfile(),
                                                 colorConverter->renderingIntent(),
                                                 colorConverter->conversionFlags());
 }
 
 void KisQPainterCanvas::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setDisplayFilter(displayFilter);
 
         canvas()->startUpdateInPatches(canvas()->image()->bounds());
 }
 
 
 void KisQPainterCanvas::setWrapAroundViewingMode(bool value)
 {
     Q_UNUSED(value);
     dbgKrita << "Wrap around viewing mode not implemented in QPainter Canvas.";
     return;
 }
 
 void KisQPainterCanvas::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->prescaledProjection->slotImageSizeChanged(w, h);
 }
 
 KisUpdateInfoSP KisQPainterCanvas::startUpdateCanvasProjection(const QRect & rc, const QBitArray &channelFlags)
 {
     Q_UNUSED(channelFlags);
 
     return m_d->prescaledProjection->updateCache(rc);
 }
 
 
 QRect KisQPainterCanvas::updateCanvasProjection(KisUpdateInfoSP info)
 {
     /**
     * It might happen that the canvas type is switched while the
     * update info is being stuck in the Qt's signals queue. Than a wrong
     * type of the info may come. So just check it here.
     */
     bool isPPUpdateInfo = dynamic_cast<KisPPUpdateInfo*>(info.data());
     if (isPPUpdateInfo) {
         m_d->prescaledProjection->recalculateCache(info);
         return info->dirtyViewportRect();
     } else {
         return QRect();
     }
 }
 
 
 void KisQPainterCanvas::resizeEvent(QResizeEvent *e)
 {
     QSize size(e->size());
     if (size.width() <= 0) {
         size.setWidth(1);
     }
     if (size.height() <= 0) {
         size.setHeight(1);
     }
 
     coordinatesConverter()->setCanvasWidgetSize(size);
     m_d->prescaledProjection->notifyCanvasSizeChanged(size);
 }
 
 void KisQPainterCanvas::slotConfigChanged()
 {
     KisConfig cfg(true);
 
     m_d->checkBrush = QBrush(createCheckersImage());
     m_d->scrollCheckers = cfg.scrollCheckers();
     notifyConfigChanged();
 }
 
 bool KisQPainterCanvas::callFocusNextPrevChild(bool next)
 {
     return focusNextPrevChild(next);
 }
diff --git a/libs/ui/flake/kis_shape_layer.cc b/libs/ui/flake/kis_shape_layer.cc
index d74f6bbaae..d6a5053b65 100644
--- a/libs/ui/flake/kis_shape_layer.cc
+++ b/libs/ui/flake/kis_shape_layer.cc
@@ -1,722 +1,718 @@
 /*
  *  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 <QTemporaryFile>
-#include <kis_debug.h>
 
 #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 <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();
 
     Q_FOREACH (KoShape *shape, _rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         clonedShape->setTransformation(shape->absoluteTransformation(0) * thisInvertedTransform);
         addShape(clonedShape);
     }
 }
 
 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(const QPointF&)), SLOT(slotMoveShapes(const 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)
 }
 
 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();
 }
 
-#include "SvgWriter.h"
-#include "SvgParser.h"
-
 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;
     bool ok = doc.setContent(device, false, &errorMsg, &errorLine, &errorColumn);
     if (!ok) {
         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;
 }
 
 KoShapeControllerBase *KisShapeLayer::shapeController() const
 {
     return m_d->controller;
 }
diff --git a/libs/ui/flake/kis_shape_layer_canvas.cpp b/libs/ui/flake/kis_shape_layer_canvas.cpp
index 5eae30c653..30fd664b24 100644
--- a/libs/ui/flake/kis_shape_layer_canvas.cpp
+++ b/libs/ui/flake/kis_shape_layer_canvas.cpp
@@ -1,343 +1,342 @@
 /*
  *  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_image.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_asyncUpdateSignalCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
         , m_image(image)
 {
     /**
      * 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(this, SIGNAL(forwardRepaint()), SLOT(repaint()), Qt::QueuedConnection);
     connect(&m_asyncUpdateSignalCompressor, SIGNAL(timeout()), SLOT(slotStartAsyncRepaint()));
 
     connect(m_image, SIGNAL(sigSizeChanged(const QPointF &, const QPointF &)), SLOT(slotImageSizeChanged()));
     m_cachedImageRect = m_image->bounds();
 }
 
 KisShapeLayerCanvas::~KisShapeLayerCanvas()
 {
     m_shapeManager->remove(m_parentLayer);
 }
 
 void KisShapeLayerCanvas::setImage(KisImageWSP image)
 {
     m_viewConverter->setImage(image);
 }
 
 
 #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;
     }
 
 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 if 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();
     } 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::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();
 }
 
 void KisShapeLayerCanvas::repaint()
 {
 
     QRect r;
 
     {
         QMutexLocker locker(&m_dirtyRegionMutex);
         r = m_dirtyRegion.boundingRect();
         m_dirtyRegion = QRegion();
     }
 
     if (r.isEmpty()) return;
 
     // Crop the update rect by the image bounds. We keep the cache consistent
     // by tracking the size of the image in slotImageSizeChanged()
     r = r.intersected(m_parentLayer->image()->bounds());
 
     QImage image(r.width(), r.height(), QImage::Format_ARGB32);
     image.fill(0);
     QPainter p(&image);
 
     p.setRenderHint(QPainter::Antialiasing);
     p.setRenderHint(QPainter::TextAntialiasing);
     p.translate(-r.x(), -r.y());
     p.setClipRect(r);
 #ifdef DEBUG_REPAINT
     QColor color = QColor(random() % 255, random() % 255, random() % 255);
     p.fillRect(r, color);
 #endif
 
     m_shapeManager->paint(p, *m_viewConverter, false);
     p.end();
 
     KisPaintDeviceSP dev = new KisPaintDevice(m_projection->colorSpace());
     dev->convertFromQImage(image, 0);
 
     KisPainter::copyAreaOptimized(r.topLeft(), dev, m_projection, QRect(QPoint(), r.size()));
 
     m_parentLayer->setDirty(r);
 
     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 (m_hasUpdateInCompressor) {
         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))
 
     m_hasChangedWhileBeingInvisible = false;
     resetCache();
 }
 
diff --git a/libs/ui/input/kis_input_manager_p.h b/libs/ui/input/kis_input_manager_p.h
index 1674d8ef43..f33e95c04d 100644
--- a/libs/ui/input/kis_input_manager_p.h
+++ b/libs/ui/input/kis_input_manager_p.h
@@ -1,159 +1,158 @@
 /*
  *  Copyright (C) 2015 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 <QList>
 #include <QPointer>
 #include <QSet>
 #include <QEvent>
 #include <QTouchEvent>
 #include <QScopedPointer>
-#include <QPointer>
 #include <QQueue>
 #include <QElapsedTimer>
 
 #include "kis_input_manager.h"
 #include "kis_shortcut_matcher.h"
 #include "kis_shortcut_configuration.h"
 #include "kis_canvas2.h"
 #include "kis_tool_proxy.h"
 #include "kis_signal_compressor.h"
 #include "input/kis_tablet_debugger.h"
 #include "kis_timed_signal_threshold.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_latency_tracker.h"
 
 class KisToolInvocationAction;
 
 
 class KisInputManager::Private
 {
 public:
     Private(KisInputManager *qq);
     bool tryHidePopupPalette();
     void addStrokeShortcut(KisAbstractInputAction* action, int index, const QList< Qt::Key >& modifiers, Qt::MouseButtons buttons);
     void addKeyShortcut(KisAbstractInputAction* action, int index,const QList<Qt::Key> &keys);
     void addTouchShortcut( KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture );
     bool addNativeGestureShortcut( KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture );
     void addWheelShortcut(KisAbstractInputAction* action, int index, const QList< Qt::Key >& modifiers, KisShortcutConfiguration::MouseWheelMovement wheelAction);
     bool processUnhandledEvent(QEvent *event);
     void setupActions();
     bool handleCompressedTabletEvent(QEvent *event);
 
     KisInputManager *q;
 
     QPointer<KisCanvas2> canvas;
     QPointer<KisToolProxy> toolProxy;
 
     bool forwardAllEventsToTool = false;
     bool ignoringQtCursorEvents();
 
     bool touchHasBlockedPressEvents = false;
 
     KisShortcutMatcher matcher;
 
     KisToolInvocationAction *defaultInputAction = 0;
 
     QObject *eventsReceiver = 0;
     KisSignalCompressor moveEventCompressor;
     QScopedPointer<QEvent> compressedMoveEvent;
     bool testingAcceptCompressedTabletEvents = false;
     bool testingCompressBrushEvents = false;
     bool tabletActive = false; // Indicates whether or not tablet is in proximity
 
     typedef QPair<int, QPointer<QObject> > PriorityPair;
     typedef QList<PriorityPair> PriorityList;
     PriorityList priorityEventFilter;
     int priorityEventFilterSeqNo;
 
     void blockMouseEvents();
     void allowMouseEvents();
     void eatOneMousePress();
     void setMaskSyntheticEvents(bool value);
     void setTabletActive(bool value);
     void resetCompressor();
 
     template <class Event, bool useBlocking>
     void debugEvent(QEvent *event)
     {
       if (!KisTabletDebugger::instance()->debugEnabled()) return;
 
       QString msg1 = useBlocking && ignoringQtCursorEvents() ? "[BLOCKED] " : "[       ]";
       Event *specificEvent = static_cast<Event*>(event);
       dbgTablet << KisTabletDebugger::instance()->eventToString(*specificEvent, msg1);
     }
 
     class ProximityNotifier : public QObject
     {
     public:
         ProximityNotifier(Private *_d, QObject *p);
         bool eventFilter(QObject* object, QEvent* event ) override;
     private:
         KisInputManager::Private *d;
     };
 
     class CanvasSwitcher : public QObject
     {
     public:
         CanvasSwitcher(Private *_d, QObject *p);
         void addCanvas(KisCanvas2 *canvas);
         void removeCanvas(KisCanvas2 *canvas);
         bool eventFilter(QObject* object, QEvent* event ) override;
 
     private:
         void setupFocusThreshold(QObject *object);
 
     private:
         KisInputManager::Private *d;
         QMap<QObject*, QPointer<KisCanvas2>> canvasResolver;
         int eatOneMouseStroke;
         KisTimedSignalThreshold focusSwitchThreshold;
         KisSignalAutoConnectionsStore thresholdConnections;
     };
     CanvasSwitcher canvasSwitcher;
 
     struct EventEater
     {
         bool eventFilter(QObject* target, QEvent* event);
 
         // This should be called after we're certain a tablet stroke has started.
         void activate();
         // This should be called after a tablet stroke has ended.
         void deactivate();
 
         // On Windows, we sometimes receive mouse events very late, so watch & wait.
         void eatOneMousePress();
 
         bool hungry{false};   // Continue eating mouse strokes
         bool peckish{false};  // Eat a single mouse press event
         bool eatSyntheticEvents{false}; // Mask all synthetic events
     };
     EventEater eventEater;
 
     bool containsPointer = false;
 
     int accumulatedScrollDelta = 0;
 
     class TabletLatencyTracker : public KisLatencyTracker {
     protected:
         virtual qint64 currentTimestamp() const;
         virtual void print(const QString &message);
     };
 
     KisSharedPtr<TabletLatencyTracker> tabletLatencyTracker;
 };
diff --git a/libs/ui/input/kis_tablet_debugger.cpp b/libs/ui/input/kis_tablet_debugger.cpp
index a3566953af..6e2be86f7c 100644
--- a/libs/ui/input/kis_tablet_debugger.cpp
+++ b/libs/ui/input/kis_tablet_debugger.cpp
@@ -1,239 +1,238 @@
 /*
  *  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_tablet_debugger.h"
 
 #include <QEvent>
 #include <QMessageBox>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 #include <QGlobalStatic>
-#include <QMessageBox>
 
 #include <klocalizedstring.h>
 
 Q_GLOBAL_STATIC(KisTabletDebugger, s_instance)
 
 
 inline QString button(const QWheelEvent &ev) {
     Q_UNUSED(ev);
     return "-";
 }
 
 template <class T>
 QString button(const T &ev) {
     return QString::number(ev.button());
 }
 
 template <class T>
 QString buttons(const T &ev) {
     return QString::number(ev.buttons());
 }
 
 template <class Event>
     void dumpBaseParams(QTextStream &s, const Event &ev, const QString &prefix)
 {
     s << qSetFieldWidth(5)  << left << prefix << reset << " ";
     s << qSetFieldWidth(17) << left << KisTabletDebugger::exTypeToString(ev.type()) << reset;
 }
 
 template <class Event>
     void dumpMouseRelatedParams(QTextStream &s, const Event &ev)
 {
     s << "btn: " << button(ev) << " ";
     s << "btns: " << buttons(ev) << " ";
     s << "pos: " << qSetFieldWidth(4) << ev.x() << qSetFieldWidth(0) << "," << qSetFieldWidth(4) << ev.y() << qSetFieldWidth(0) << " ";
     s << "gpos: "  << qSetFieldWidth(4) << ev.globalX() << qSetFieldWidth(0) << "," << qSetFieldWidth(4) << ev.globalY() << qSetFieldWidth(0) << " ";
 }
 
 QString KisTabletDebugger::exTypeToString(QEvent::Type type) {
     return
         type == QEvent::TabletEnterProximity ? "TabletEnterProximity" :
         type == QEvent::TabletLeaveProximity ? "TabletLeaveProximity" :
         type == QEvent::Enter ? "Enter" :
         type == QEvent::Leave ? "Leave" :
         type == QEvent::FocusIn ? "FocusIn" :
         type == QEvent::FocusOut ? "FocusOut" :
         type == QEvent::Wheel ? "Wheel" :
         type == QEvent::KeyPress ? "KeyPress" :
         type == QEvent::KeyRelease ? "KeyRelease" :
         type == QEvent::ShortcutOverride ? "ShortcutOverride" :
         type == QMouseEvent::MouseButtonPress ? "MouseButtonPress" :
         type == QMouseEvent::MouseButtonRelease ? "MouseButtonRelease" :
         type == QMouseEvent::MouseButtonDblClick ? "MouseButtonDblClick" :
         type == QMouseEvent::MouseMove ? "MouseMove" :
         type == QTabletEvent::TabletMove ? "TabletMove" :
         type == QTabletEvent::TabletPress ? "TabletPress" :
         type == QTabletEvent::TabletRelease ? "TabletRelease" :
         "unknown";
 }
 
 
 KisTabletDebugger::KisTabletDebugger()
     : m_debugEnabled(false)
 {
     KisConfig cfg(true);
     m_shouldEatDriverShortcuts = cfg.shouldEatDriverShortcuts();
 }
 
 KisTabletDebugger* KisTabletDebugger::instance()
 {
     return s_instance;
 }
 
 void KisTabletDebugger::toggleDebugging()
 {
     m_debugEnabled = !m_debugEnabled;
     QMessageBox::information(0, i18nc("@title:window", "Krita"), m_debugEnabled ?
                              i18n("Tablet Event Logging Enabled") :
                              i18n("Tablet Event Logging Disabled"));
     if (m_debugEnabled) {
         dbgTablet << "vvvvvvvvvvvvvvvvvvvvvvv START TABLET EVENT LOG vvvvvvvvvvvvvvvvvvvvvvv";
     }
     else {
         dbgTablet << "^^^^^^^^^^^^^^^^^^^^^^^ END TABLET EVENT LOG ^^^^^^^^^^^^^^^^^^^^^^^";
     }
 }
 
 bool KisTabletDebugger::debugEnabled() const
 {
     return m_debugEnabled;
 }
 
 bool KisTabletDebugger::initializationDebugEnabled() const
 {
     // FIXME: make configurable!
     return true;
 }
 
 bool KisTabletDebugger::debugRawTabletValues() const
 {
     // FIXME: make configurable!
     return m_debugEnabled;
 }
 
 bool KisTabletDebugger::shouldEatDriverShortcuts() const
 {
     return m_shouldEatDriverShortcuts;
 }
 
 QString KisTabletDebugger::eventToString(const QMouseEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
     dumpMouseRelatedParams(s, ev);
     s << "hires: " << qSetFieldWidth(8) << ev.screenPos().x() << qSetFieldWidth(0) << "," << qSetFieldWidth(8) << ev.screenPos().y() << qSetFieldWidth(0) << " ";
     s << "Source:" << ev.source();
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QKeyEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
 
     s << "key: 0x" << hex << ev.key() << reset << " ";
     s << "mod: 0x" << hex << ev.modifiers() << reset << " ";
     s << "text: " << (ev.text().isEmpty() ? "none" : ev.text());
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QWheelEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
     dumpMouseRelatedParams(s, ev);
 
     s << "delta: " << ev.delta() << " ";
     s << "orientation: " << (ev.orientation() == Qt::Horizontal ? "H" : "V") << " ";
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QEvent &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
 
     return string;
 }
 
 template <class Event>
     QString tabletEventToString(const Event &ev, const QString &prefix)
 {
     QString string;
     QTextStream s(&string);
 
     dumpBaseParams(s, ev, prefix);
     dumpMouseRelatedParams(s, ev);
 
     s << "hires: " << qSetFieldWidth(8) << ev.hiResGlobalX() << qSetFieldWidth(0) << "," << qSetFieldWidth(8) << ev.hiResGlobalY() << qSetFieldWidth(0) << " ";
     s << "prs: " << qSetFieldWidth(4) << fixed << ev.pressure() << reset << " ";
 
     s << KisTabletDebugger::tabletDeviceToString((QTabletEvent::TabletDevice) ev.device()) << " ";
     s << KisTabletDebugger::pointerTypeToString((QTabletEvent::PointerType) ev.pointerType()) << " ";
     s << "id: " << ev.uniqueId() << " ";
 
     s << "xTilt: " << ev.xTilt() << " ";
     s << "yTilt: " << ev.yTilt() << " ";
     s << "rot: " << ev.rotation() << " ";
     s << "z: " << ev.z() << " ";
     s << "tp: " << ev.tangentialPressure() << " ";
 
     return string;
 }
 
 QString KisTabletDebugger::eventToString(const QTabletEvent &ev, const QString &prefix)
 {
     return tabletEventToString(ev, prefix);
 }
 
 QString KisTabletDebugger::tabletDeviceToString(QTabletEvent::TabletDevice device)
 {
     return
         device == QTabletEvent::NoDevice ? "NoDevice" :
         device == QTabletEvent::Puck ? "Puck" :
         device == QTabletEvent::Stylus ? "Stylus" :
         device == QTabletEvent::Airbrush ? "Airbrush" :
         device == QTabletEvent::FourDMouse ? "FourDMouse" :
         device == QTabletEvent::XFreeEraser ? "XFreeEraser" :
         device == QTabletEvent::RotationStylus ? "RotationStylus" :
         "unknown";
 }
 
 QString KisTabletDebugger::pointerTypeToString(QTabletEvent::PointerType pointer) {
     return
         pointer == QTabletEvent::UnknownPointer ? "UnknownPointer" :
         pointer == QTabletEvent::Pen ? "Pen" :
         pointer == QTabletEvent::Cursor ? "Cursor" :
         pointer == QTabletEvent::Eraser ? "Eraser" :
         "unknown";
 }
 
diff --git a/libs/ui/kis_action_manager.cpp b/libs/ui/kis_action_manager.cpp
index 8dfd5fbc4d..b6aea8507b 100644
--- a/libs/ui/kis_action_manager.cpp
+++ b/libs/ui/kis_action_manager.cpp
@@ -1,488 +1,483 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_action_manager.h"
 
 #include <QList>
 #include <kactioncollection.h>
 
 #include <kis_icon.h>
 #include "KisPart.h"
 #include "kis_action.h"
 #include "KisViewManager.h"
 #include "kis_selection_manager.h"
 #include "operations/kis_operation_ui_factory.h"
 #include "operations/kis_operation_registry.h"
 #include "operations/kis_operation.h"
 #include "kis_layer.h"
 #include "KisDocument.h"
 #include "kis_clipboard.h"
 #include <kis_image_animation_interface.h>
 
 #include <QMenu>
 #include "QFile"
 #include <QDomDocument>
 #include <QDomElement>
 
-#include "QFile"
-#include <QDomDocument>
-#include <QDomElement>
-
-
 class Q_DECL_HIDDEN KisActionManager::Private {
 
 public:
     Private()
         : viewManager(0)
     {}
 
     ~Private()
     {
         qDeleteAll(uiRegistry.values());
     }
 
     KisViewManager* viewManager;
     KActionCollection *actionCollection;
 
     QList<QPointer<KisAction>> actions;
     KoGenericRegistry<KisOperationUIFactory*> uiRegistry;
     KisOperationRegistry operationRegistry;
 
 };
 
 KisActionManager::KisActionManager(KisViewManager* viewManager, KActionCollection *actionCollection)
     : d(new Private)
 {
     d->viewManager = viewManager;
     d->actionCollection = actionCollection;
 
     connect(d->actionCollection,
             SIGNAL(inserted(QAction*)), SLOT(slotActionAddedToCollection(QAction*)));
 }
 
 KisActionManager::~KisActionManager()
 {
 
 #if 0
   if ((d->actions.size() > 0)) {
 
        QDomDocument doc;
        QDomElement e = doc.createElement("Actions");
        e.setAttribute("version", "2");
        doc.appendChild(e);
 
        Q_FOREACH (KisAction *action, d->actions) {
            QDomElement a = doc.createElement("Action");
            a.setAttribute("name", action->objectName());
 
            // But seriously, XML is the worst format ever designed
            auto addElement = [&](QString title, QString content) {
                QDomElement newNode = doc.createElement(title);
                QDomText    newText = doc.createTextNode(content);
                newNode.appendChild(newText);
                a.appendChild(newNode);
            };
 
            addElement("icon", action->icon().name());
            addElement("text", action->text());
            addElement("whatsThis" , action->whatsThis());
            addElement("toolTip" , action->toolTip());
            addElement("iconText" , action->iconText());
            addElement("shortcut" , action->shortcut().toString());
            addElement("activationFlags" , QString::number(action->activationFlags(),2));
            addElement("activationConditions" , QString::number(action->activationConditions(),2));
            addElement("defaultShortcut" , action->defaultShortcut().toString());
            addElement("isCheckable" , QString((action->isChecked() ? "true" : "false")));
            addElement("statusTip", action->statusTip());
            e.appendChild(a);
        }
        QFile f("ActionManager.action");
        f.open(QFile::WriteOnly);
        f.write(doc.toString().toUtf8());
        f.close();
 
    }
 #endif
     delete d;
 }
 
 void KisActionManager::setView(QPointer<KisView> imageView)
 {
     Q_UNUSED(imageView);
 }
 
 void KisActionManager::slotActionAddedToCollection(QAction *action)
 {
     /**
      * Small hack alert: not all the actions are still created by the manager and
      * immediately added to the action collection. Some plugins add actions
      * directly to the action collection when a document is created. Here we
      * catch these cases
      */
     KisActionRegistry::instance()->updateShortcut(action->objectName(), action);
 }
 
 void KisActionManager::addAction(const QString& name, KisAction* action)
 {
     Q_ASSERT(!name.isEmpty());
     Q_ASSERT(action);
     Q_ASSERT(d->viewManager);
     Q_ASSERT(d->actionCollection);
 
     d->actionCollection->addAction(name, action);
     action->setParent(d->actionCollection);
 
     d->actions.append(action);
     action->setActionManager(this);
 }
 
 void KisActionManager::takeAction(KisAction* action)
 {
     d->actions.removeOne(action);
 
     if (!action->objectName().isEmpty()) {
         KIS_ASSERT_RECOVER_RETURN(d->actionCollection);
         d->actionCollection->takeAction(action);
     }
 }
 
 KisAction *KisActionManager::actionByName(const QString &name) const
 {
     Q_FOREACH (KisAction *action, d->actions) {
         if (action->objectName() == name) {
             return action;
         }
     }
     return 0;
 }
 
 
 KisAction *KisActionManager::createAction(const QString &name)
 {
     KisAction *a = actionByName(name); // Check if the action already exists
     if (a) {
         return a;
     }
 
     // There is some tension here. KisActionManager is supposed to be in control
     // of global actions, but these actions are supposed to be duplicated. We
     // will add them to the KisActionRegistry for the time being so we can get
     // properly categorized shortcuts.
     a = new KisAction();
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
     // Add extra properties
     actionRegistry->propertizeAction(name, a);
     bool ok; // We will skip this check
     int activationFlags = actionRegistry->getActionProperty(name, "activationFlags").toInt(&ok, 2);
     int activationConditions = actionRegistry->getActionProperty(name, "activationConditions").toInt(&ok, 2);
     a->setActivationFlags((KisAction::ActivationFlags) activationFlags);
     a->setActivationConditions((KisAction::ActivationConditions) activationConditions);
 
     addAction(name, a);
 
     return a;
 }
 
 void KisActionManager::updateGUI()
 {
     //TODO other flags
     KisAction::ActivationFlags flags;
 
     KisImageWSP image;
     KisNodeSP node;
     KisLayerSP layer;
     KisSelectionManager *selectionManager = 0;
 
     KisAction::ActivationConditions conditions = KisAction::NO_CONDITION;
 
     if (d->viewManager) {
         node = d->viewManager->activeNode();
         selectionManager = d->viewManager->selectionManager();
 
         // if there are no views, that means no document is open.
         // we cannot have nodes (selections), devices, or documents without a view
         if ( d->viewManager->viewCount() > 0 )
         {
             image = d->viewManager->image();
             flags |= KisAction::ACTIVE_IMAGE;
 
             if (image && image->animationInterface()->hasAnimation()) {
                 flags |= KisAction::IMAGE_HAS_ANIMATION;
             }
 
             if (d->viewManager->viewCount() > 1) {
                 flags |= KisAction::MULTIPLE_IMAGES;
             }
 
             if (d->viewManager->document() && d->viewManager->document()->isModified()) {
                 flags |= KisAction::CURRENT_IMAGE_MODIFIED;
             }
 
             if (d->viewManager->activeDevice()) {
                 flags |= KisAction::ACTIVE_DEVICE;
             }
         }
 
         if (d->viewManager->selectionEditable()) {
             conditions |= KisAction::SELECTION_EDITABLE;
         }
 
     }
 
     // is there a selection/mask?
     // you have to have at least one view (document) open for this to be true
     if (node) {
 
         // if a node exists, we know there is an active layer as well
         flags |= KisAction::ACTIVE_NODE;
 
         layer = qobject_cast<KisLayer*>(node.data());
         if (layer) {
             flags |= KisAction::ACTIVE_LAYER;
         }
 
         if (node->inherits("KisTransparencyMask")) {
             flags |= KisAction::ACTIVE_TRANSPARENCY_MASK;
         }
 
 
         if (layer && layer->inherits("KisShapeLayer")) {
             flags |= KisAction::ACTIVE_SHAPE_LAYER;
         }
 
         if (KisClipboard::instance()->hasLayers()) {
             flags |= KisAction::LAYERS_IN_CLIPBOARD;
         }
 
         if (selectionManager) {
 
             if (selectionManager->havePixelsSelected()) {
                 flags |= KisAction::PIXELS_SELECTED;
             }
 
             if (selectionManager->haveShapesSelected()) {
                 flags |= KisAction::SHAPES_SELECTED;
             }
 
             if (selectionManager->havePixelSelectionWithPixels()) {
                 flags |= KisAction::PIXEL_SELECTION_WITH_PIXELS;
             }
 
             if (selectionManager->havePixelsInClipboard()) {
                 flags |= KisAction::PIXELS_IN_CLIPBOARD;
             }
 
             if (selectionManager->haveShapesInClipboard()) {
                 flags |= KisAction::SHAPES_IN_CLIPBOARD;
             }
         }
 
         if (node->isEditable(false)) {
             conditions |= KisAction::ACTIVE_NODE_EDITABLE;
         }
 
         if (node->hasEditablePaintDevice()) {
             conditions |= KisAction::ACTIVE_NODE_EDITABLE_PAINT_DEVICE;
         }
     }
 
 
     // loop through all actions in action manager and determine what should be enabled
     Q_FOREACH (QPointer<KisAction> action, d->actions) {
         bool enable;
         if (action) {
             if (action->activationFlags() == KisAction::NONE) {
                 enable = true;
             }
             else {
                 enable = action->activationFlags() & flags; // combine action flags with updateGUI flags
             }
 
             enable = enable && (int)(action->activationConditions() & conditions) == (int)action->activationConditions();
 
             if (node && enable) {
                 Q_FOREACH (const QString &type, action->excludedNodeTypes()) {
                     if (node->inherits(type.toLatin1())) {
                         enable = false;
                         break;
                     }
                 }
             }
 
             action->setActionEnabled(enable);
         }
     }
 }
 
 KisAction *KisActionManager::createStandardAction(KStandardAction::StandardAction actionType, const QObject *receiver, const char *member)
 {
     QAction *standardAction = KStandardAction::create(actionType, receiver, member, 0);
     KisAction *action = new KisAction(standardAction->icon(), standardAction->text());
 
     const QList<QKeySequence> defaultShortcuts = standardAction->property("defaultShortcuts").value<QList<QKeySequence> >();
     const QKeySequence defaultShortcut = defaultShortcuts.isEmpty() ? QKeySequence() : defaultShortcuts.at(0);
     action->setDefaultShortcut(standardAction->shortcut());
 #ifdef Q_OS_WIN
     if (actionType == KStandardAction::SaveAs && defaultShortcuts.isEmpty()) {
         action->setShortcut(QKeySequence("CTRL+SHIFT+S"));
     }
 #endif
     action->setCheckable(standardAction->isCheckable());
     if (action->isCheckable()) {
         action->setChecked(standardAction->isChecked());
     }
     action->setMenuRole(standardAction->menuRole());
     action->setText(standardAction->text());
     action->setToolTip(standardAction->toolTip());
 
     if (receiver && member) {
         if (actionType == KStandardAction::OpenRecent) {
             QObject::connect(action, SIGNAL(urlSelected(QUrl)), receiver, member);
         }
         else if (actionType == KStandardAction::ConfigureToolbars) {
             QObject::connect(action, SIGNAL(triggered(bool)), receiver, member, Qt::QueuedConnection);
         }
         else {
             QObject::connect(action, SIGNAL(triggered(bool)), receiver, member);
         }
     }
 
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
     actionRegistry->propertizeAction(standardAction->objectName(), action);
 
     addAction(standardAction->objectName(), action);
     delete standardAction;
     return action;
 }
 
 void KisActionManager::safePopulateMenu(QMenu *menu, const QString &actionId, KisActionManager *actionManager)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(actionManager);
 
     KisAction *action = actionManager->actionByName(actionId);
     KIS_SAFE_ASSERT_RECOVER_RETURN(action);
 
     menu->addAction(action);
 }
 
 void KisActionManager::registerOperationUIFactory(KisOperationUIFactory* factory)
 {
     d->uiRegistry.add(factory);
 }
 
 void KisActionManager::registerOperation(KisOperation* operation)
 {
     d->operationRegistry.add(operation);
 }
 
 void KisActionManager::runOperation(const QString& id)
 {
     KisOperationConfigurationSP config = new KisOperationConfiguration(id);
 
     KisOperationUIFactory* uiFactory = d->uiRegistry.get(id);
     if (uiFactory) {
         bool gotConfig = uiFactory->fetchConfiguration(d->viewManager, config);
         if (!gotConfig) {
             return;
         }
     }
     runOperationFromConfiguration(config);
 }
 
 void KisActionManager::runOperationFromConfiguration(KisOperationConfigurationSP config)
 {
     KisOperation* operation = d->operationRegistry.get(config->id());
     Q_ASSERT(operation);
     operation->runFromXML(d->viewManager, *config);
 }
 
 void KisActionManager::dumpActionFlags()
 {
     QFile data("actions.txt");
     if (data.open(QFile::WriteOnly | QFile::Truncate)) {
         QTextStream out(&data);
         out.setCodec("UTF-8");
 
         Q_FOREACH (KisAction* action, d->actions) {
             KisAction::ActivationFlags flags = action->activationFlags();
             out << "-------- " << action->text() << " --------\n";
             out << "Action will activate on: \n";
 
             if (flags & KisAction::ACTIVE_IMAGE) {
                 out << "    Active image\n";
             }
             if (flags & KisAction::MULTIPLE_IMAGES) {
                 out << "    More than one image open\n";
             }
             if (flags & KisAction::CURRENT_IMAGE_MODIFIED) {
                 out << "    Active image modified\n";
             }
             if (flags & KisAction::ACTIVE_DEVICE) {
                 out << "    Active device\n";
             }
             if (flags & KisAction::ACTIVE_LAYER) {
                 out << "    Active layer\n";
             }
             if (flags & KisAction::ACTIVE_TRANSPARENCY_MASK) {
                 out << "    Active transparency mask\n";
             }
             if (flags & KisAction::ACTIVE_NODE) {
                 out << "    Active node\n";
             }
             if (flags & KisAction::ACTIVE_SHAPE_LAYER) {
                 out << "    Active shape layer\n";
             }
             if (flags & KisAction::PIXELS_SELECTED) {
                 out << "    Pixels selected\n";
             }
             if (flags & KisAction::SHAPES_SELECTED) {
                 out << "    Shapes selected\n";
             }
             if (flags & KisAction::PIXEL_SELECTION_WITH_PIXELS) {
                 out << "    Pixel selection with pixels\n";
             }
             if (flags & KisAction::PIXELS_IN_CLIPBOARD) {
                 out << "    Pixels in clipboard\n";
             }
             if (flags & KisAction::SHAPES_IN_CLIPBOARD) {
                 out << "    Shape in clipboard\n";
             }
             if (flags & KisAction::IMAGE_HAS_ANIMATION) {
                 out << "    Image has animation\n";
             }
 
             out << "\n\n";
             out << "Action will only activate if the following conditions are met: \n";
             KisAction::ActivationConditions conditions = action->activationConditions();
             if ((int)conditions == 0) {
                 out << "    -\n";
             }
             if (conditions & KisAction::ACTIVE_NODE_EDITABLE) {
                 out << "    Active Node editable\n";
             }
             if (conditions & KisAction::ACTIVE_NODE_EDITABLE_PAINT_DEVICE) {
                 out << "    Active Node has editable paint device\n";
             }
             if (conditions & KisAction::SELECTION_EDITABLE) {
                 out << "    Selection is editable\n";
             }
             out << "\n\n";
         }
     }
 }
diff --git a/libs/ui/kis_config.cc b/libs/ui/kis_config.cc
index 9342d33d7c..bebb89bdbf 100644
--- a/libs/ui/kis_config.cc
+++ b/libs/ui/kis_config.cc
@@ -1,1987 +1,1986 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_config.h"
 
 #include <limits.h>
 
 #include <QtGlobal>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 #include <QFont>
 #include <QThread>
 #include <QStringList>
 #include <QSettings>
 #include <QStandardPaths>
 
 #include <kconfig.h>
 
 #include <KisDocument.h>
 
 #include <KoColor.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 
 #include <kis_debug.h>
 #include <kis_types.h>
 
 #include "kis_canvas_resource_provider.h"
 #include "kis_config_notifier.h"
 #include "kis_snap_config.h"
 
 #include <config-ocio.h>
 
 #include <kis_color_manager.h>
-#include <kis_debug.h>
 
 KisConfig::KisConfig(bool readOnly)
     : m_cfg( KSharedConfig::openConfig()->group(""))
     , m_readOnly(readOnly)
 {
     if (!readOnly) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
     }
 }
 
 KisConfig::~KisConfig()
 {
     if (m_readOnly) return;
 
     if (qApp->thread() != QThread::currentThread()) {
         dbgKrita << "WARNING: KisConfig: requested config synchronization from nonGUI thread! Called from:" << kisBacktrace();
         return;
     }
 
     m_cfg.sync();
 }
 
 
 bool KisConfig::disableTouchOnCanvas(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableTouchOnCanvas", false));
 }
 
 void KisConfig::setDisableTouchOnCanvas(bool value) const
 {
     m_cfg.writeEntry("disableTouchOnCanvas", value);
 }
 
 bool KisConfig::useProjections(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useProjections", true));
 }
 
 void KisConfig::setUseProjections(bool useProj) const
 {
     m_cfg.writeEntry("useProjections", useProj);
 }
 
 bool KisConfig::undoEnabled(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("undoEnabled", true));
 }
 
 void KisConfig::setUndoEnabled(bool undo) const
 {
     m_cfg.writeEntry("undoEnabled", undo);
 }
 
 int KisConfig::undoStackLimit(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("undoStackLimit", 30));
 }
 
 void KisConfig::setUndoStackLimit(int limit) const
 {
     m_cfg.writeEntry("undoStackLimit", limit);
 }
 
 bool KisConfig::useCumulativeUndoRedo(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("useCumulativeUndoRedo",false));
 }
 
 void KisConfig::setCumulativeUndoRedo(bool value)
 {
     m_cfg.writeEntry("useCumulativeUndoRedo", value);
 }
 
 qreal KisConfig::stackT1(bool defaultValue) const
 {
      return (defaultValue ? 5 : m_cfg.readEntry("stackT1",5));
 }
 
 void KisConfig::setStackT1(int T1)
 {
     m_cfg.writeEntry("stackT1", T1);
 }
 
 qreal KisConfig::stackT2(bool defaultValue) const
 {
      return (defaultValue ? 1 : m_cfg.readEntry("stackT2",1));
 }
 
 void KisConfig::setStackT2(int T2)
 {
     m_cfg.writeEntry("stackT2", T2);
 }
 
 int KisConfig::stackN(bool defaultValue) const
 {
     return (defaultValue ? 5 : m_cfg.readEntry("stackN",5));
 }
 
 void KisConfig::setStackN(int N)
 {
      m_cfg.writeEntry("stackN", N);
 }
 
 qint32 KisConfig::defImageWidth(bool defaultValue) const
 {
     return (defaultValue ? 1600 : m_cfg.readEntry("imageWidthDef", 1600));
 }
 
 qint32 KisConfig::defImageHeight(bool defaultValue) const
 {
     return (defaultValue ? 1200 : m_cfg.readEntry("imageHeightDef", 1200));
 }
 
 qreal KisConfig::defImageResolution(bool defaultValue) const
 {
     return (defaultValue ? 100.0 : m_cfg.readEntry("imageResolutionDef", 100.0)) / 72.0;
 }
 
 QString KisConfig::defColorModel(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->colorModelId().id()
                         : m_cfg.readEntry("colorModelDef", KoColorSpaceRegistry::instance()->rgb8()->colorModelId().id()));
 }
 
 void KisConfig::defColorModel(const QString & model) const
 {
     m_cfg.writeEntry("colorModelDef", model);
 }
 
 QString KisConfig::defaultColorDepth(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()
                         : m_cfg.readEntry("colorDepthDef", KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()));
 }
 
 void KisConfig::setDefaultColorDepth(const QString & depth) const
 {
     m_cfg.writeEntry("colorDepthDef", depth);
 }
 
 QString KisConfig::defColorProfile(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->profile()->name() :
                            m_cfg.readEntry("colorProfileDef",
                                            KoColorSpaceRegistry::instance()->rgb8()->profile()->name()));
 }
 
 void KisConfig::defColorProfile(const QString & profile) const
 {
     m_cfg.writeEntry("colorProfileDef", profile);
 }
 
 void KisConfig::defImageWidth(qint32 width) const
 {
     m_cfg.writeEntry("imageWidthDef", width);
 }
 
 void KisConfig::defImageHeight(qint32 height) const
 {
     m_cfg.writeEntry("imageHeightDef", height);
 }
 
 void KisConfig::defImageResolution(qreal res) const
 {
     m_cfg.writeEntry("imageResolutionDef", res*72.0);
 }
 
 int KisConfig::preferredVectorImportResolutionPPI(bool defaultValue) const
 {
     return defaultValue ? 100.0 : m_cfg.readEntry("preferredVectorImportResolution", 100.0);
 }
 
 void KisConfig::setPreferredVectorImportResolutionPPI(int value) const
 {
     m_cfg.writeEntry("preferredVectorImportResolution", value);
 }
 
 void cleanOldCursorStyleKeys(KConfigGroup &cfg)
 {
     if (cfg.hasKey("newCursorStyle") &&
         cfg.hasKey("newOutlineStyle")) {
 
         cfg.deleteEntry("cursorStyleDef");
     }
 }
 
 CursorStyle KisConfig::newCursorStyle(bool defaultValue) const
 {
     if (defaultValue) {
         return CURSOR_STYLE_NO_CURSOR;
     }
 
 
     int style = m_cfg.readEntry("newCursorStyle", int(-1));
 
     if (style < 0) {
         // old style format
         style = m_cfg.readEntry("cursorStyleDef", int(OLD_CURSOR_STYLE_OUTLINE));
 
         switch (style) {
         case OLD_CURSOR_STYLE_TOOLICON:
             style = CURSOR_STYLE_TOOLICON;
             break;
         case OLD_CURSOR_STYLE_CROSSHAIR:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS:
             style = CURSOR_STYLE_CROSSHAIR;
             break;
         case OLD_CURSOR_STYLE_POINTER:
             style = CURSOR_STYLE_POINTER;
             break;
         case OLD_CURSOR_STYLE_OUTLINE:
         case OLD_CURSOR_STYLE_NO_CURSOR:
             style = CURSOR_STYLE_NO_CURSOR;
             break;
         case OLD_CURSOR_STYLE_SMALL_ROUND:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT:
             style = CURSOR_STYLE_SMALL_ROUND;
             break;
         case OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED:
             style = CURSOR_STYLE_TRIANGLE_RIGHTHANDED;
             break;
         case OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED:
             style = CURSOR_STYLE_TRIANGLE_LEFTHANDED;
             break;
         default:
             style = -1;
         }
     }
 
     cleanOldCursorStyleKeys(m_cfg);
 
     // compatibility with future versions
     if (style < 0 || style >= N_CURSOR_STYLE_SIZE) {
         style = CURSOR_STYLE_NO_CURSOR;
     }
 
     return (CursorStyle) style;
 }
 
 void KisConfig::setNewCursorStyle(CursorStyle style)
 {
     m_cfg.writeEntry("newCursorStyle", (int)style);
 }
 
 QColor KisConfig::getCursorMainColor(bool defaultValue) const
 {
     QColor col;
     col.setRgbF(0.501961, 1.0, 0.501961);
     return (defaultValue ? col : m_cfg.readEntry("cursorMaincColor", col));
 }
 
 void KisConfig::setCursorMainColor(const QColor &v) const
 {
     m_cfg.writeEntry("cursorMaincColor", v);
 }
 
 OutlineStyle KisConfig::newOutlineStyle(bool defaultValue) const
 {
     if (defaultValue) {
         return OUTLINE_FULL;
     }
 
     int style = m_cfg.readEntry("newOutlineStyle", int(-1));
 
     if (style < 0) {
         // old style format
         style = m_cfg.readEntry("cursorStyleDef", int(OLD_CURSOR_STYLE_OUTLINE));
 
         switch (style) {
         case OLD_CURSOR_STYLE_TOOLICON:
         case OLD_CURSOR_STYLE_CROSSHAIR:
         case OLD_CURSOR_STYLE_POINTER:
         case OLD_CURSOR_STYLE_NO_CURSOR:
         case OLD_CURSOR_STYLE_SMALL_ROUND:
         case OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED:
             style = OUTLINE_NONE;
             break;
         case OLD_CURSOR_STYLE_OUTLINE:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED:
             style = OUTLINE_FULL;
             break;
         default:
             style = -1;
         }
     }
 
     cleanOldCursorStyleKeys(m_cfg);
 
     // compatibility with future versions
     if (style < 0 || style >= N_OUTLINE_STYLE_SIZE) {
         style = OUTLINE_FULL;
     }
 
     return (OutlineStyle) style;
 }
 
 void KisConfig::setNewOutlineStyle(OutlineStyle style)
 {
     m_cfg.writeEntry("newOutlineStyle", (int)style);
 }
 
 QRect KisConfig::colorPreviewRect() const
 {
     return m_cfg.readEntry("colorPreviewRect", QVariant(QRect(32, 32, 48, 48))).toRect();
 }
 
 void KisConfig::setColorPreviewRect(const QRect &rect)
 {
     m_cfg.writeEntry("colorPreviewRect", QVariant(rect));
 }
 
 bool KisConfig::useDirtyPresets(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useDirtyPresets",false));
 }
 void KisConfig::setUseDirtyPresets(bool value)
 {
     m_cfg.writeEntry("useDirtyPresets",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushSize(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushSize",false));
 }
 
 void KisConfig::setUseEraserBrushSize(bool value)
 {
     m_cfg.writeEntry("useEraserBrushSize",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushOpacity(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushOpacity",false));
 }
 
 void KisConfig::setUseEraserBrushOpacity(bool value)
 {
     m_cfg.writeEntry("useEraserBrushOpacity",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 
 QColor KisConfig::getMDIBackgroundColor(bool defaultValue) const
 {
     QColor col(77, 77, 77);
     return (defaultValue ? col : m_cfg.readEntry("mdiBackgroundColor", col));
 }
 
 void KisConfig::setMDIBackgroundColor(const QColor &v) const
 {
     m_cfg.writeEntry("mdiBackgroundColor", v);
 }
 
 QString KisConfig::getMDIBackgroundImage(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("mdiBackgroundImage", ""));
 }
 
 void KisConfig::setMDIBackgroundImage(const QString &filename) const
 {
     m_cfg.writeEntry("mdiBackgroundImage", filename);
 }
 
 QString KisConfig::monitorProfile(int screen) const
 {
     // Note: keep this in sync with the default profile for the RGB colorspaces!
     QString profile = m_cfg.readEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), "sRGB-elle-V2-srgbtrc.icc");
     //dbgKrita << "KisConfig::monitorProfile()" << profile;
     return profile;
 }
 
 QString KisConfig::monitorForScreen(int screen, const QString &defaultMonitor, bool defaultValue) const
 {
     return (defaultValue ? defaultMonitor
                          : m_cfg.readEntry(QString("monitor_for_screen_%1").arg(screen), defaultMonitor));
 }
 
 void KisConfig::setMonitorForScreen(int screen, const QString& monitor)
 {
     m_cfg.writeEntry(QString("monitor_for_screen_%1").arg(screen), monitor);
 }
 
 void KisConfig::setMonitorProfile(int screen, const QString & monitorProfile, bool override) const
 {
     m_cfg.writeEntry("monitorProfile/OverrideX11", override);
     m_cfg.writeEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), monitorProfile);
 }
 
 const KoColorProfile *KisConfig::getScreenProfile(int screen)
 {
     if (screen < 0) return 0;
 
     KisConfig cfg(true);
     QString monitorId;
     if (KisColorManager::instance()->devices().size() > screen) {
         monitorId = cfg.monitorForScreen(screen, KisColorManager::instance()->devices()[screen]);
     }
     //dbgKrita << "getScreenProfile(). Screen" << screen << "monitor id" << monitorId;
 
     if (monitorId.isEmpty()) {
         return 0;
     }
 
     QByteArray bytes = KisColorManager::instance()->displayProfile(monitorId);
 
     //dbgKrita << "\tgetScreenProfile()" << bytes.size();
 
     if (bytes.length() > 0) {
         const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), bytes);
         //dbgKrita << "\tKisConfig::getScreenProfile for screen" << screen << profile->name();
         return profile;
     }
     else {
         //dbgKrita << "\tCould not get a system monitor profile";
         return 0;
     }
 }
 
 const KoColorProfile *KisConfig::displayProfile(int screen) const
 {
     if (screen < 0) return 0;
 
     // if the user plays with the settings, they can override the display profile, in which case
     // we don't want the system setting.
     bool override = useSystemMonitorProfile();
     //dbgKrita << "KisConfig::displayProfile(). Override X11:" << override;
     const KoColorProfile *profile = 0;
     if (override) {
         //dbgKrita << "\tGoing to get the screen profile";
         profile = KisConfig::getScreenProfile(screen);
     }
 
     // if it fails. check the configuration
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tGoing to get the monitor profile";
         QString monitorProfileName = monitorProfile(screen);
         //dbgKrita << "\t\tmonitorProfileName:" << monitorProfileName;
         if (!monitorProfileName.isEmpty()) {
             profile = KoColorSpaceRegistry::instance()->profileByName(monitorProfileName);
         }
         if (profile) {
             //dbgKrita << "\t\tsuitable for display" << profile->isSuitableForDisplay();
         }
         else {
             //dbgKrita << "\t\tstill no profile";
         }
     }
     // if we still don't have a profile, or the profile isn't suitable for display,
     // we need to get a last-resort profile. the built-in sRGB is a good choice then.
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tnothing worked, going to get sRGB built-in";
         profile = KoColorSpaceRegistry::instance()->profileByName("sRGB Built-in");
     }
 
     if (profile) {
         //dbgKrita << "\tKisConfig::displayProfile for screen" << screen << "is" << profile->name();
     }
     else {
         //dbgKrita << "\tCouldn't get a display profile at all";
     }
 
     return profile;
 }
 
 QString KisConfig::workingColorSpace(bool defaultValue) const
 {
     return (defaultValue ? "RGBA" : m_cfg.readEntry("workingColorSpace", "RGBA"));
 }
 
 void KisConfig::setWorkingColorSpace(const QString & workingColorSpace) const
 {
     m_cfg.writeEntry("workingColorSpace", workingColorSpace);
 }
 
 QString KisConfig::printerColorSpace(bool /*defaultValue*/) const
 {
     //TODO currently only rgb8 is supported
     //return (defaultValue ? "RGBA" : m_cfg.readEntry("printerColorSpace", "RGBA"));
     return QString("RGBA");
 }
 
 void KisConfig::setPrinterColorSpace(const QString & printerColorSpace) const
 {
     m_cfg.writeEntry("printerColorSpace", printerColorSpace);
 }
 
 
 QString KisConfig::printerProfile(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("printerProfile", ""));
 }
 
 void KisConfig::setPrinterProfile(const QString & printerProfile) const
 {
     m_cfg.writeEntry("printerProfile", printerProfile);
 }
 
 
 bool KisConfig::useBlackPointCompensation(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useBlackPointCompensation", true));
 }
 
 void KisConfig::setUseBlackPointCompensation(bool useBlackPointCompensation) const
 {
     m_cfg.writeEntry("useBlackPointCompensation", useBlackPointCompensation);
 }
 
 bool KisConfig::allowLCMSOptimization(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("allowLCMSOptimization", true));
 }
 
 void KisConfig::setAllowLCMSOptimization(bool allowLCMSOptimization)
 {
     m_cfg.writeEntry("allowLCMSOptimization", allowLCMSOptimization);
 }
 
 
 bool KisConfig::showRulers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showrulers", false));
 }
 
 void KisConfig::setShowRulers(bool rulers) const
 {
     m_cfg.writeEntry("showrulers", rulers);
 }
 
 bool KisConfig::forceShowSaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowSaveMessages", false));
 }
 
 void KisConfig::setForceShowSaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowSaveMessages", value);
 }
 
 bool KisConfig::forceShowAutosaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowAutosaveMessages", false));
 }
 
 void KisConfig::setForceShowAutosaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowAutosaveMessages", value);
 }
 
 bool KisConfig::rulersTrackMouse(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("rulersTrackMouse", true));
 }
 
 void KisConfig::setRulersTrackMouse(bool value) const
 {
     m_cfg.writeEntry("rulersTrackMouse", value);
 }
 
 qint32 KisConfig::pasteBehaviour(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("pasteBehaviour", 2));
 }
 
 void KisConfig::setPasteBehaviour(qint32 renderIntent) const
 {
     m_cfg.writeEntry("pasteBehaviour", renderIntent);
 }
 
 
 qint32 KisConfig::monitorRenderIntent(bool defaultValue) const
 {
     qint32 intent = m_cfg.readEntry("renderIntent", INTENT_PERCEPTUAL);
     if (intent > 3) intent = 3;
     if (intent < 0) intent = 0;
     return (defaultValue ? INTENT_PERCEPTUAL : intent);
 }
 
 void KisConfig::setRenderIntent(qint32 renderIntent) const
 {
     if (renderIntent > 3) renderIntent = 3;
     if (renderIntent < 0) renderIntent = 0;
     m_cfg.writeEntry("renderIntent", renderIntent);
 }
 
 bool KisConfig::useOpenGL(bool defaultValue) const
 {
     if (defaultValue) {
         return true;
     }
 
     //dbgKrita << "use opengl" << m_cfg.readEntry("useOpenGL", true) << "success" << m_cfg.readEntry("canvasState", "OPENGL_SUCCESS");
     QString cs = canvasState();
 #ifdef Q_OS_WIN
     return (m_cfg.readEntry("useOpenGLWindows", true) && (cs == "OPENGL_SUCCESS" || cs == "TRY_OPENGL"));
 #else
     return (m_cfg.readEntry("useOpenGL", true) && (cs == "OPENGL_SUCCESS" || cs == "TRY_OPENGL"));
 #endif
 }
 
 void KisConfig::setUseOpenGL(bool useOpenGL) const
 {
 #ifdef Q_OS_WIN
     m_cfg.writeEntry("useOpenGLWindows", useOpenGL);
 #else
     m_cfg.writeEntry("useOpenGL", useOpenGL);
 #endif
 }
 
 int KisConfig::openGLFilteringMode(bool defaultValue) const
 {
     return (defaultValue ? 3 : m_cfg.readEntry("OpenGLFilterMode", 3));
 }
 
 void KisConfig::setOpenGLFilteringMode(int filteringMode)
 {
     m_cfg.writeEntry("OpenGLFilterMode", filteringMode);
 }
 
 bool KisConfig::useOpenGLTextureBuffer(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useOpenGLTextureBuffer", true));
 }
 
 void KisConfig::setUseOpenGLTextureBuffer(bool useBuffer)
 {
     m_cfg.writeEntry("useOpenGLTextureBuffer", useBuffer);
 }
 
 int KisConfig::openGLTextureSize(bool defaultValue) const
 {
     return (defaultValue ? 256 : m_cfg.readEntry("textureSize", 256));
 }
 
 bool KisConfig::disableVSync(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("disableVSync", true));
 }
 
 void KisConfig::setDisableVSync(bool disableVSync)
 {
     m_cfg.writeEntry("disableVSync", disableVSync);
 }
 
 bool KisConfig::showAdvancedOpenGLSettings(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showAdvancedOpenGLSettings", false));
 }
 
 bool KisConfig::forceOpenGLFenceWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceOpenGLFenceWorkaround", false));
 }
 
 int KisConfig::numMipmapLevels(bool defaultValue) const
 {
     return (defaultValue ? 4 : m_cfg.readEntry("numMipmapLevels", 4));
 }
 
 int KisConfig::textureOverlapBorder() const
 {
     return 1 << qMax(0, numMipmapLevels());
 }
 
 quint32 KisConfig::getGridMainStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("gridmainstyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGridMainStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridmainstyle", v);
 }
 
 quint32 KisConfig::getGridSubdivisionStyle(bool defaultValue) const
 {
     quint32 v = m_cfg.readEntry("gridsubdivisionstyle", 1);
     if (v > 2) v = 2;
     return (defaultValue ? 1 : v);
 }
 
 void KisConfig::setGridSubdivisionStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridsubdivisionstyle", v);
 }
 
 QColor KisConfig::getGridMainColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("gridmaincolor", col));
 }
 
 void KisConfig::setGridMainColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridmaincolor", v);
 }
 
 QColor KisConfig::getGridSubdivisionColor(bool defaultValue) const
 {
     QColor col(150, 150, 150);
     return (defaultValue ? col : m_cfg.readEntry("gridsubdivisioncolor", col));
 }
 
 void KisConfig::setGridSubdivisionColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridsubdivisioncolor", v);
 }
 
 QColor KisConfig::getPixelGridColor(bool defaultValue) const
 {
     QColor col(255, 255, 255);
     return (defaultValue ? col : m_cfg.readEntry("pixelGridColor", col));
 }
 
 void KisConfig::setPixelGridColor(const QColor & v) const
 {
     m_cfg.writeEntry("pixelGridColor", v);
 }
 
 qreal KisConfig::getPixelGridDrawingThreshold(bool defaultValue) const
 {
     qreal border = 24.0f;
     return (defaultValue ? border : m_cfg.readEntry("pixelGridDrawingThreshold", border));
 }
 
 void KisConfig::setPixelGridDrawingThreshold(qreal v) const
 {
     m_cfg.writeEntry("pixelGridDrawingThreshold", v);
 }
 
 bool KisConfig::pixelGridEnabled(bool defaultValue) const
 {
     bool enabled = true;
     return (defaultValue ? enabled : m_cfg.readEntry("pixelGridEnabled", enabled));
 }
 
 void KisConfig::enablePixelGrid(bool v) const
 {
     m_cfg.writeEntry("pixelGridEnabled", v);
 }
 
 quint32 KisConfig::guidesLineStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("guidesLineStyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGuidesLineStyle(quint32 v) const
 {
     m_cfg.writeEntry("guidesLineStyle", v);
 }
 
 QColor KisConfig::guidesColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("guidesColor", col));
 }
 
 void KisConfig::setGuidesColor(const QColor & v) const
 {
     m_cfg.writeEntry("guidesColor", v);
 }
 
 void KisConfig::loadSnapConfig(KisSnapConfig *config, bool defaultValue) const
 {
     KisSnapConfig defaultConfig(false);
 
     if (defaultValue) {
         *config = defaultConfig;
         return;
     }
 
     config->setOrthogonal(m_cfg.readEntry("globalSnapOrthogonal", defaultConfig.orthogonal()));
     config->setNode(m_cfg.readEntry("globalSnapNode", defaultConfig.node()));
     config->setExtension(m_cfg.readEntry("globalSnapExtension", defaultConfig.extension()));
     config->setIntersection(m_cfg.readEntry("globalSnapIntersection", defaultConfig.intersection()));
     config->setBoundingBox(m_cfg.readEntry("globalSnapBoundingBox", defaultConfig.boundingBox()));
     config->setImageBounds(m_cfg.readEntry("globalSnapImageBounds", defaultConfig.imageBounds()));
     config->setImageCenter(m_cfg.readEntry("globalSnapImageCenter", defaultConfig.imageCenter()));
 }
 
 void KisConfig::saveSnapConfig(const KisSnapConfig &config)
 {
     m_cfg.writeEntry("globalSnapOrthogonal", config.orthogonal());
     m_cfg.writeEntry("globalSnapNode", config.node());
     m_cfg.writeEntry("globalSnapExtension", config.extension());
     m_cfg.writeEntry("globalSnapIntersection", config.intersection());
     m_cfg.writeEntry("globalSnapBoundingBox", config.boundingBox());
     m_cfg.writeEntry("globalSnapImageBounds", config.imageBounds());
     m_cfg.writeEntry("globalSnapImageCenter", config.imageCenter());
 }
 
 qint32 KisConfig::checkSize(bool defaultValue) const
 {
     return (defaultValue ? 32 : m_cfg.readEntry("checksize", 32));
 }
 
 void KisConfig::setCheckSize(qint32 checksize) const
 {
     m_cfg.writeEntry("checksize", checksize);
 }
 
 bool KisConfig::scrollCheckers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("scrollingcheckers", false));
 }
 
 void KisConfig::setScrollingCheckers(bool sc) const
 {
     m_cfg.writeEntry("scrollingcheckers", sc);
 }
 
 QColor KisConfig::canvasBorderColor(bool defaultValue) const
 {
     QColor color(QColor(128,128,128));
     return (defaultValue ? color : m_cfg.readEntry("canvasBorderColor", color));
 }
 
 void KisConfig::setCanvasBorderColor(const QColor& color) const
 {
     m_cfg.writeEntry("canvasBorderColor", color);
 }
 
 bool KisConfig::hideScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hideScrollbars", false));
 }
 
 void KisConfig::setHideScrollbars(bool value) const
 {
     m_cfg.writeEntry("hideScrollbars", value);
 }
 
 
 QColor KisConfig::checkersColor1(bool defaultValue) const
 {
     QColor col(220, 220, 220);
     return (defaultValue ? col : m_cfg.readEntry("checkerscolor", col));
 }
 
 void KisConfig::setCheckersColor1(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor", v);
 }
 
 QColor KisConfig::checkersColor2(bool defaultValue) const
 {
     return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("checkerscolor2", QColor(Qt::white)));
 }
 
 void KisConfig::setCheckersColor2(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor2", v);
 }
 
 bool KisConfig::antialiasCurves(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("antialiascurves", true));
 }
 
 void KisConfig::setAntialiasCurves(bool v) const
 {
     m_cfg.writeEntry("antialiascurves", v);
 }
 
 bool KisConfig::antialiasSelectionOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("AntialiasSelectionOutline", false));
 }
 
 void KisConfig::setAntialiasSelectionOutline(bool v) const
 {
     m_cfg.writeEntry("AntialiasSelectionOutline", v);
 }
 
 bool KisConfig::showRootLayer(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowRootLayer", false));
 }
 
 void KisConfig::setShowRootLayer(bool showRootLayer) const
 {
     m_cfg.writeEntry("ShowRootLayer", showRootLayer);
 }
 
 bool KisConfig::showGlobalSelection(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowGlobalSelection", false));
 }
 
 void KisConfig::setShowGlobalSelection(bool showGlobalSelection) const
 {
     m_cfg.writeEntry("ShowGlobalSelection", showGlobalSelection);
 }
 
 bool KisConfig::showOutlineWhilePainting(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ShowOutlineWhilePainting", true));
 }
 
 void KisConfig::setShowOutlineWhilePainting(bool showOutlineWhilePainting) const
 {
     m_cfg.writeEntry("ShowOutlineWhilePainting", showOutlineWhilePainting);
 }
 
 bool KisConfig::forceAlwaysFullSizedOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceAlwaysFullSizedOutline", false));
 }
 
 void KisConfig::setForceAlwaysFullSizedOutline(bool value) const
 {
     m_cfg.writeEntry("forceAlwaysFullSizedOutline", value);
 }
 
 KisConfig::SessionOnStartup KisConfig::sessionOnStartup(bool defaultValue) const
 {
     int value = defaultValue ? SOS_BlankSession : m_cfg.readEntry("sessionOnStartup", (int)SOS_BlankSession);
     return (KisConfig::SessionOnStartup)value;
 }
 void KisConfig::setSessionOnStartup(SessionOnStartup value)
 {
     m_cfg.writeEntry("sessionOnStartup", (int)value);
 }
 
 bool KisConfig::saveSessionOnQuit(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("saveSessionOnQuit", false);
 }
 void KisConfig::setSaveSessionOnQuit(bool value)
 {
     m_cfg.writeEntry("saveSessionOnQuit", value);
 }
 
 qreal KisConfig::outlineSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 1.0 : m_cfg.readEntry("OutlineSizeMinimum", 1.0));
 }
 
 void KisConfig::setOutlineSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("OutlineSizeMinimum", outlineSizeMinimum);
 }
 
 qreal KisConfig::selectionViewSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 5.0 : m_cfg.readEntry("SelectionViewSizeMinimum", 5.0));
 }
 
 void KisConfig::setSelectionViewSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("SelectionViewSizeMinimum", outlineSizeMinimum);
 }
 
 int KisConfig::autoSaveInterval(bool defaultValue)  const
 {
     return (defaultValue ? 15 * 60 : m_cfg.readEntry("AutoSaveInterval", 15 * 60));
 }
 
 void KisConfig::setAutoSaveInterval(int seconds)  const
 {
     return m_cfg.writeEntry("AutoSaveInterval", seconds);
 }
 
 bool KisConfig::backupFile(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("CreateBackupFile", true));
 }
 
 void KisConfig::setBackupFile(bool backupFile) const
 {
     m_cfg.writeEntry("CreateBackupFile", backupFile);
 }
 
 bool KisConfig::showFilterGallery(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showFilterGallery", false));
 }
 
 void KisConfig::setShowFilterGallery(bool showFilterGallery) const
 {
     m_cfg.writeEntry("showFilterGallery", showFilterGallery);
 }
 
 bool KisConfig::showFilterGalleryLayerMaskDialog(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showFilterGalleryLayerMaskDialog", true));
 }
 
 void KisConfig::setShowFilterGalleryLayerMaskDialog(bool showFilterGallery) const
 {
     m_cfg.writeEntry("setShowFilterGalleryLayerMaskDialog", showFilterGallery);
 }
 
 QString KisConfig::canvasState(bool defaultValue) const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     return (defaultValue ? "OPENGL_NOT_TRIED" : kritarc.value("canvasState", "OPENGL_NOT_TRIED").toString());
 }
 
 void KisConfig::setCanvasState(const QString& state) const
 {
     static QStringList acceptableStates;
     if (acceptableStates.isEmpty()) {
         acceptableStates << "OPENGL_SUCCESS" << "TRY_OPENGL" << "OPENGL_NOT_TRIED" << "OPENGL_FAILED";
     }
     if (acceptableStates.contains(state)) {
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", state);
     }
 }
 
 bool KisConfig::toolOptionsPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ToolOptionsPopupDetached", false));
 }
 
 void KisConfig::setToolOptionsPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("ToolOptionsPopupDetached", detached);
 }
 
 
 bool KisConfig::paintopPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("PaintopPopupDetached", false));
 }
 
 void KisConfig::setPaintopPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("PaintopPopupDetached", detached);
 }
 
 QString KisConfig::pressureTabletCurve(bool defaultValue) const
 {
     return (defaultValue ? "0,0;1,1" : m_cfg.readEntry("tabletPressureCurve","0,0;1,1;"));
 }
 
 void KisConfig::setPressureTabletCurve(const QString& curveString) const
 {
     m_cfg.writeEntry("tabletPressureCurve", curveString);
 }
 
 bool KisConfig::useWin8PointerInput(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
     return (defaultValue ? false : m_cfg.readEntry("useWin8PointerInput", false));
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseWin8PointerInput(bool value) const
 {
 #ifdef Q_OS_WIN
     // Special handling: Only set value if changed
     // I don't want it to be set if the user hasn't touched it
     if (useWin8PointerInput() != value) {
         m_cfg.writeEntry("useWin8PointerInput", value);
     }
 #else
     Q_UNUSED(value)
 #endif
 }
 
 qreal KisConfig::vastScrolling(bool defaultValue) const
 {
     return (defaultValue ? 0.9 : m_cfg.readEntry("vastScrolling", 0.9));
 }
 
 void KisConfig::setVastScrolling(const qreal factor) const
 {
     m_cfg.writeEntry("vastScrolling", factor);
 }
 
 int KisConfig::presetChooserViewMode(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("presetChooserViewMode", 0));
 }
 
 void KisConfig::setPresetChooserViewMode(const int mode) const
 {
     m_cfg.writeEntry("presetChooserViewMode", mode);
 }
 
 int KisConfig::presetIconSize(bool defaultValue) const
 {
     return (defaultValue ? 60 : m_cfg.readEntry("presetIconSize", 60));
 }
 
 void KisConfig::setPresetIconSize(const int value) const
 {
     m_cfg.writeEntry("presetIconSize", value);
 }
 
 bool KisConfig::firstRun(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("firstRun", true));
 }
 
 void KisConfig::setFirstRun(const bool first) const
 {
     m_cfg.writeEntry("firstRun", first);
 }
 
 int KisConfig::horizontalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("horizontalSplitLines", 1));
 }
 void KisConfig::setHorizontalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("horizontalSplitLines", numberLines);
 }
 
 int KisConfig::verticalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("verticalSplitLines", 1));
 }
 
 void KisConfig::setVerticalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("verticalSplitLines", numberLines);
 }
 
 bool KisConfig::clicklessSpacePan(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("clicklessSpacePan", true));
 }
 
 void KisConfig::setClicklessSpacePan(const bool toggle) const
 {
     m_cfg.writeEntry("clicklessSpacePan", toggle);
 }
 
 
 bool KisConfig::hideDockersFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideDockersFullScreen", true));
 }
 
 void KisConfig::setHideDockersFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideDockersFullScreen", value);
 }
 
 bool KisConfig::showDockers(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showDockers", true));
 }
 
 void KisConfig::setShowDockers(const bool value) const
 {
     m_cfg.writeEntry("showDockers", value);
 }
 
 bool KisConfig::showStatusBar(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showStatusBar", true));
 }
 
 void KisConfig::setShowStatusBar(const bool value) const
 {
     m_cfg.writeEntry("showStatusBar", value);
 }
 
 bool KisConfig::hideMenuFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideMenuFullScreen", true));
 }
 
 void KisConfig::setHideMenuFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideMenuFullScreen", value);
 }
 
 bool KisConfig::hideScrollbarsFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideScrollbarsFullScreen", true));
 }
 
 void KisConfig::setHideScrollbarsFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideScrollbarsFullScreen", value);
 }
 
 bool KisConfig::hideStatusbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideStatusbarFullScreen", true));
 }
 
 void KisConfig::setHideStatusbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideStatusbarFullScreen", value);
 }
 
 bool KisConfig::hideTitlebarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideTitleBarFullscreen", true));
 }
 
 void KisConfig::setHideTitlebarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideTitleBarFullscreen", value);
 }
 
 bool KisConfig::hideToolbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideToolbarFullscreen", true));
 }
 
 void KisConfig::setHideToolbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideToolbarFullscreen", value);
 }
 
 bool KisConfig::fullscreenMode(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("fullscreenMode", true));
 }
 
 void KisConfig::setFullscreenMode(const bool value) const
 {
     m_cfg.writeEntry("fullscreenMode", value);
 }
 
 QStringList KisConfig::favoriteCompositeOps(bool defaultValue) const
 {
     return (defaultValue ? QStringList() : m_cfg.readEntry("favoriteCompositeOps", QStringList()));
 }
 
 void KisConfig::setFavoriteCompositeOps(const QStringList& compositeOps) const
 {
     m_cfg.writeEntry("favoriteCompositeOps", compositeOps);
 }
 
 QString KisConfig::exportConfiguration(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ExportConfiguration-" + filterId, QString()));
 }
 
 void KisConfig::setExportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString exportConfig = properties->toXML();
     m_cfg.writeEntry("ExportConfiguration-" + filterId, exportConfig);
 }
 
 QString KisConfig::importConfiguration(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ImportConfiguration-" + filterId, QString()));
 }
 
 void KisConfig::setImportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString importConfig = properties->toXML();
     m_cfg.writeEntry("ImportConfiguration-" + filterId, importConfig);
 }
 
 bool KisConfig::useOcio(bool defaultValue) const
 {
 #ifdef HAVE_OCIO
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/UseOcio", false));
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseOcio(bool useOCIO) const
 {
     m_cfg.writeEntry("Krita/Ocio/UseOcio", useOCIO);
 }
 
 int KisConfig::favoritePresets(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("numFavoritePresets", 10));
 }
 
 void KisConfig::setFavoritePresets(const int value)
 {
     m_cfg.writeEntry("numFavoritePresets", value);
 }
 
 bool KisConfig::levelOfDetailEnabled(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("levelOfDetailEnabled", false));
 }
 
 void KisConfig::setLevelOfDetailEnabled(bool value)
 {
     m_cfg.writeEntry("levelOfDetailEnabled", value);
 }
 
 KisConfig::OcioColorManagementMode
 KisConfig::ocioColorManagementMode(bool defaultValue) const
 {
     return (OcioColorManagementMode)(defaultValue ? INTERNAL
                                                   : m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", (int) INTERNAL));
 }
 
 void KisConfig::setOcioColorManagementMode(OcioColorManagementMode mode) const
 {
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) mode);
 }
 
 QString KisConfig::ocioConfigurationPath(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("Krita/Ocio/OcioConfigPath", QString()));
 }
 
 void KisConfig::setOcioConfigurationPath(const QString &path) const
 {
     m_cfg.writeEntry("Krita/Ocio/OcioConfigPath", path);
 }
 
 QString KisConfig::ocioLutPath(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("Krita/Ocio/OcioLutPath", QString()));
 }
 
 void KisConfig::setOcioLutPath(const QString &path) const
 {
     m_cfg.writeEntry("Krita/Ocio/OcioLutPath", path);
 }
 
 int KisConfig::ocioLutEdgeSize(bool defaultValue) const
 {
     return (defaultValue ? 64 : m_cfg.readEntry("Krita/Ocio/LutEdgeSize", 64));
 }
 
 void KisConfig::setOcioLutEdgeSize(int value)
 {
     m_cfg.writeEntry("Krita/Ocio/LutEdgeSize", value);
 }
 
 bool KisConfig::ocioLockColorVisualRepresentation(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/OcioLockColorVisualRepresentation", false));
 }
 
 void KisConfig::setOcioLockColorVisualRepresentation(bool value)
 {
     m_cfg.writeEntry("Krita/Ocio/OcioLockColorVisualRepresentation", value);
 }
 
 QString KisConfig::defaultPalette(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("defaultPalette", "Default"));
 }
 
 void KisConfig::setDefaultPalette(const QString& name) const
 {
     m_cfg.writeEntry("defaultPalette", name);
 }
 
 QString KisConfig::toolbarSlider(int sliderNumber, bool defaultValue) const
 {
     QString def = "flow";
     if (sliderNumber == 1) {
         def = "opacity";
     }
     if (sliderNumber == 2) {
         def = "size";
     }
     return (defaultValue ? def : m_cfg.readEntry(QString("toolbarslider_%1").arg(sliderNumber), def));
 }
 
 void KisConfig::setToolbarSlider(int sliderNumber, const QString &slider)
 {
     m_cfg.writeEntry(QString("toolbarslider_%1").arg(sliderNumber), slider);
 }
 
 bool KisConfig::sliderLabels(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("sliderLabels", true));
 }
 
 void KisConfig::setSliderLabels(bool enabled)
 {
     m_cfg.writeEntry("sliderLabels", enabled);
 }
 
 QString KisConfig::currentInputProfile(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("currentInputProfile", QString()));
 }
 
 void KisConfig::setCurrentInputProfile(const QString& name)
 {
     m_cfg.writeEntry("currentInputProfile", name);
 }
 
 bool KisConfig::useSystemMonitorProfile(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ColorManagement/UseSystemMonitorProfile", false));
 }
 
 void KisConfig::setUseSystemMonitorProfile(bool _useSystemMonitorProfile) const
 {
     m_cfg.writeEntry("ColorManagement/UseSystemMonitorProfile", _useSystemMonitorProfile);
 }
 
 bool KisConfig::presetStripVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("presetStripVisible", true));
 }
 
 void KisConfig::setPresetStripVisible(bool visible)
 {
     m_cfg.writeEntry("presetStripVisible", visible);
 }
 
 bool KisConfig::scratchpadVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("scratchpadVisible", true));
 }
 
 void KisConfig::setScratchpadVisible(bool visible)
 {
     m_cfg.writeEntry("scratchpadVisible", visible);
 }
 
 bool KisConfig::showSingleChannelAsColor(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showSingleChannelAsColor", false));
 }
 
 void KisConfig::setShowSingleChannelAsColor(bool asColor)
 {
     m_cfg.writeEntry("showSingleChannelAsColor", asColor);
 }
 
 bool KisConfig::hidePopups(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hidePopups", false));
 }
 
 void KisConfig::setHidePopups(bool hidepopups)
 {
     m_cfg.writeEntry("hidePopups", hidepopups);
 }
 
 int KisConfig::numDefaultLayers(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("NumberOfLayersForNewImage", 2));
 }
 
 void KisConfig::setNumDefaultLayers(int num)
 {
     m_cfg.writeEntry("NumberOfLayersForNewImage", num);
 }
 
 quint8 KisConfig::defaultBackgroundOpacity(bool defaultValue) const
 {
   return (defaultValue ? (int)OPACITY_OPAQUE_U8 : m_cfg.readEntry("BackgroundOpacityForNewImage", (int)OPACITY_OPAQUE_U8));
 }
 
 void KisConfig::setDefaultBackgroundOpacity(quint8 value)
 {
   m_cfg.writeEntry("BackgroundOpacityForNewImage", (int)value);
 }
 
 QColor KisConfig::defaultBackgroundColor(bool defaultValue) const
 {
   return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("BackgroundColorForNewImage", QColor(Qt::white)));
 }
 
 void KisConfig::setDefaultBackgroundColor(QColor value)
 {
   m_cfg.writeEntry("BackgroundColorForNewImage", value);
 }
 
 KisConfig::BackgroundStyle KisConfig::defaultBackgroundStyle(bool defaultValue) const
 {
   return (KisConfig::BackgroundStyle)(defaultValue ? LAYER : m_cfg.readEntry("BackgroundStyleForNewImage", (int)LAYER));
 }
 
 void KisConfig::setDefaultBackgroundStyle(KisConfig::BackgroundStyle value)
 {
   m_cfg.writeEntry("BackgroundStyleForNewImage", (int)value);
 }
 
 int KisConfig::lineSmoothingType(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("LineSmoothingType", 1));
 }
 
 void KisConfig::setLineSmoothingType(int value)
 {
     m_cfg.writeEntry("LineSmoothingType", value);
 }
 
 qreal KisConfig::lineSmoothingDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDistance", value);
 }
 
 qreal KisConfig::lineSmoothingTailAggressiveness(bool defaultValue) const
 {
     return (defaultValue ? 0.15 : m_cfg.readEntry("LineSmoothingTailAggressiveness", 0.15));
 }
 
 void KisConfig::setLineSmoothingTailAggressiveness(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingTailAggressiveness", value);
 }
 
 bool KisConfig::lineSmoothingSmoothPressure(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("LineSmoothingSmoothPressure", false));
 }
 
 void KisConfig::setLineSmoothingSmoothPressure(bool value)
 {
     m_cfg.writeEntry("LineSmoothingSmoothPressure", value);
 }
 
 bool KisConfig::lineSmoothingScalableDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingScalableDistance", true));
 }
 
 void KisConfig::setLineSmoothingScalableDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingScalableDistance", value);
 }
 
 qreal KisConfig::lineSmoothingDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDelayDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDelayDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingUseDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingUseDelayDistance", true));
 }
 
 void KisConfig::setLineSmoothingUseDelayDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingUseDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingFinishStabilizedCurve(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingFinishStabilizedCurve", true));
 }
 
 void KisConfig::setLineSmoothingFinishStabilizedCurve(bool value)
 {
     m_cfg.writeEntry("LineSmoothingFinishStabilizedCurve", value);
 }
 
 bool KisConfig::lineSmoothingStabilizeSensors(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingStabilizeSensors", true));
 }
 
 void KisConfig::setLineSmoothingStabilizeSensors(bool value)
 {
     m_cfg.writeEntry("LineSmoothingStabilizeSensors", value);
 }
 
 int KisConfig::tabletEventsDelay(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("tabletEventsDelay", 10));
 }
 
 void KisConfig::setTabletEventsDelay(int value)
 {
     m_cfg.writeEntry("tabletEventsDelay", value);
 }
 
 bool KisConfig::trackTabletEventLatency(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("trackTabletEventLatency", false));
 }
 
 void KisConfig::setTrackTabletEventLatency(bool value)
 {
     m_cfg.writeEntry("trackTabletEventLatency", value);
 }
 
 bool KisConfig::testingAcceptCompressedTabletEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingAcceptCompressedTabletEvents", false));
 }
 
 void KisConfig::setTestingAcceptCompressedTabletEvents(bool value)
 {
     m_cfg.writeEntry("testingAcceptCompressedTabletEvents", value);
 }
 
 bool KisConfig::shouldEatDriverShortcuts(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("shouldEatDriverShortcuts", false));
 }
 
 bool KisConfig::testingCompressBrushEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingCompressBrushEvents", false));
 }
 
 void KisConfig::setTestingCompressBrushEvents(bool value)
 {
     m_cfg.writeEntry("testingCompressBrushEvents", value);
 }
 
 int KisConfig::workaroundX11SmoothPressureSteps(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("workaroundX11SmoothPressureSteps", 0));
 }
 
 bool KisConfig::showCanvasMessages(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showOnCanvasMessages", true));
 }
 
 void KisConfig::setShowCanvasMessages(bool show)
 {
     m_cfg.writeEntry("showOnCanvasMessages", show);
 }
 
 bool KisConfig::compressKra(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("compressLayersInKra", false));
 }
 
 void KisConfig::setCompressKra(bool compress)
 {
     m_cfg.writeEntry("compressLayersInKra", compress);
 }
 
 bool KisConfig::toolOptionsInDocker(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ToolOptionsInDocker", true));
 }
 
 void KisConfig::setToolOptionsInDocker(bool inDocker)
 {
     m_cfg.writeEntry("ToolOptionsInDocker", inDocker);
 }
 
 int KisConfig::kineticScrollingGesture(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("KineticScrollingGesture", 0));
 }
 
 void KisConfig::setKineticScrollingGesture(int gesture)
 {
     m_cfg.writeEntry("KineticScrollingGesture", gesture);
 }
 
 int KisConfig::kineticScrollingSensitivity(bool defaultValue) const
 {
     return (defaultValue ? 75 : m_cfg.readEntry("KineticScrollingSensitivity", 75));
 }
 
 void KisConfig::setKineticScrollingSensitivity(int sensitivity)
 {
     m_cfg.writeEntry("KineticScrollingSensitivity", sensitivity);
 }
 
 bool KisConfig::kineticScrollingScrollbar(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("KineticScrollingScrollbar", true));
 }
 
 void KisConfig::setKineticScrollingScrollbar(bool scrollbar)
 {
     m_cfg.writeEntry("KineticScrollingScrollbar", scrollbar);
 }
 
 const KoColorSpace* KisConfig::customColorSelectorColorSpace(bool defaultValue) const
 {
     const KoColorSpace *cs = 0;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     if (defaultValue || cfg.readEntry("useCustomColorSpace", true)) {
         KoColorSpaceRegistry* csr = KoColorSpaceRegistry::instance();
         QString modelID = cfg.readEntry("customColorSpaceModel", "RGBA");
         QString depthID = cfg.readEntry("customColorSpaceDepthID", "U8");
         QString profile = cfg.readEntry("customColorSpaceProfile", "sRGB built-in - (lcms internal)");
         if (profile == "default") {
           // qDebug() << "Falling back to default color profile.";
           profile = "sRGB built-in - (lcms internal)";
         }
         cs = csr->colorSpace(modelID, depthID, profile);
     }
 
     return cs;
 }
 
 void KisConfig::setCustomColorSelectorColorSpace(const KoColorSpace *cs)
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     cfg.writeEntry("useCustomColorSpace", bool(cs));
     if(cs) {
         cfg.writeEntry("customColorSpaceModel", cs->colorModelId().id());
         cfg.writeEntry("customColorSpaceDepthID", cs->colorDepthId().id());
         cfg.writeEntry("customColorSpaceProfile", cs->profile()->name());
     }
 
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::enableOpenGLFramerateLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableOpenGLFramerateLogging", false));
 }
 
 void KisConfig::setEnableOpenGLFramerateLogging(bool value) const
 {
     m_cfg.writeEntry("enableOpenGLFramerateLogging", value);
 }
 
 bool KisConfig::enableBrushSpeedLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableBrushSpeedLogging", false));
 }
 
 void KisConfig::setEnableBrushSpeedLogging(bool value) const
 {
     m_cfg.writeEntry("enableBrushSpeedLogging", value);
 }
 
 void KisConfig::setEnableAmdVectorizationWorkaround(bool value)
 {
     m_cfg.writeEntry("amdDisableVectorWorkaround", value);
 }
 
 bool KisConfig::enableAmdVectorizationWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("amdDisableVectorWorkaround", false));
 }
 
 void KisConfig::setAnimationDropFrames(bool value)
 {
     bool oldValue = animationDropFrames();
 
     if (value == oldValue) return;
 
     m_cfg.writeEntry("animationDropFrames", value);
     KisConfigNotifier::instance()->notifyDropFramesModeChanged();
 }
 
 bool KisConfig::animationDropFrames(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("animationDropFrames", true));
 }
 
 int KisConfig::scrubbingUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("scrubbingUpdatesDelay", 30));
 }
 
 void KisConfig::setScrubbingUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingUpdatesDelay", value);
 }
 
 int KisConfig::scrubbingAudioUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("scrubbingAudioUpdatesDelay", -1));
 }
 
 void KisConfig::setScrubbingAudioUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingAudioUpdatesDelay", value);
 }
 
 int KisConfig::audioOffsetTolerance(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("audioOffsetTolerance", -1));
 }
 
 void KisConfig::setAudioOffsetTolerance(int value)
 {
     m_cfg.writeEntry("audioOffsetTolerance", value);
 }
 
 bool KisConfig::switchSelectionCtrlAlt(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("switchSelectionCtrlAlt", false);
 }
 
 void KisConfig::setSwitchSelectionCtrlAlt(bool value)
 {
     m_cfg.writeEntry("switchSelectionCtrlAlt", value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::convertToImageColorspaceOnImport(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("ConvertToImageColorSpaceOnImport", false);
 }
 
 void KisConfig::setConvertToImageColorspaceOnImport(bool value)
 {
     m_cfg.writeEntry("ConvertToImageColorSpaceOnImport", value);
 }
 
 int KisConfig::stabilizerSampleSize(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
     const int defaultSampleSize = 50;
 #else
     const int defaultSampleSize = 15;
 #endif
 
     return defaultValue ?
         defaultSampleSize : m_cfg.readEntry("stabilizerSampleSize", defaultSampleSize);
 }
 
 void KisConfig::setStabilizerSampleSize(int value)
 {
     m_cfg.writeEntry("stabilizerSampleSize", value);
 }
 
 bool KisConfig::stabilizerDelayedPaint(bool defaultValue) const
 {
     const bool defaultEnabled = true;
 
     return defaultValue ?
         defaultEnabled : m_cfg.readEntry("stabilizerDelayedPaint", defaultEnabled);
 }
 
 void KisConfig::setStabilizerDelayedPaint(bool value)
 {
     m_cfg.writeEntry("stabilizerDelayedPaint", value);
 }
 
 QString KisConfig::customFFMpegPath(bool defaultValue) const
 {
     return defaultValue ? QString() : m_cfg.readEntry("ffmpegExecutablePath", QString());
 }
 
 void KisConfig::setCustomFFMpegPath(const QString &value) const
 {
     m_cfg.writeEntry("ffmpegExecutablePath", value);
 }
 
 bool KisConfig::showBrushHud(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("showBrushHud", false);
 }
 
 void KisConfig::setShowBrushHud(bool value)
 {
     m_cfg.writeEntry("showBrushHud", value);
 }
 
 QString KisConfig::brushHudSetting(bool defaultValue) const
 {
     QString defaultDoc = "<!DOCTYPE hud_properties>\n<hud_properties>\n <version value=\"1\" type=\"value\"/>\n <paintbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"angle\" type=\"value\"/>\n  </properties_list>\n </paintbrush>\n <colorsmudge>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"smudge_mode\" type=\"value\"/>\n   <item_3 value=\"smudge_length\" type=\"value\"/>\n   <item_4 value=\"smudge_color_rate\" type=\"value\"/>\n  </properties_list>\n </colorsmudge>\n <sketchbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </sketchbrush>\n <hairybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </hairybrush>\n <experimentbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"shape_windingfill\" type=\"value\"/>\n  </properties_list>\n </experimentbrush>\n <spraybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"spray_particlecount\" type=\"value\"/>\n   <item_3 value=\"spray_density\" type=\"value\"/>\n  </properties_list>\n </spraybrush>\n <hatchingbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"hatching_angle\" type=\"value\"/>\n   <item_3 value=\"hatching_thickness\" type=\"value\"/>\n   <item_4 value=\"hatching_separation\" type=\"value\"/>\n  </properties_list>\n </hatchingbrush>\n <gridbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"grid_divisionlevel\" type=\"value\"/>\n  </properties_list>\n </gridbrush>\n <curvebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"curve_historysize\" type=\"value\"/>\n   <item_2 value=\"curve_linewidth\" type=\"value\"/>\n   <item_3 value=\"curve_lineopacity\" type=\"value\"/>\n   <item_4 value=\"curve_connectionline\" type=\"value\"/>\n  </properties_list>\n </curvebrush>\n <dynabrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"dyna_diameter\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"dyna_mass\" type=\"value\"/>\n   <item_3 value=\"dyna_drag\" type=\"value\"/>\n  </properties_list>\n </dynabrush>\n <particlebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"particle_particles\" type=\"value\"/>\n   <item_2 value=\"particle_opecityweight\" type=\"value\"/>\n   <item_3 value=\"particle_iterations\" type=\"value\"/>\n  </properties_list>\n </particlebrush>\n <duplicate>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"clone_healing\" type=\"value\"/>\n   <item_3 value=\"clone_movesource\" type=\"value\"/>\n  </properties_list>\n </duplicate>\n <deformbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"deform_amount\" type=\"value\"/>\n   <item_3 value=\"deform_mode\" type=\"value\"/>\n  </properties_list>\n </deformbrush>\n <tangentnormal>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </tangentnormal>\n <filter>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </filter>\n <roundmarker>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </roundmarker>\n</hud_properties>\n";
     return defaultValue ? defaultDoc : m_cfg.readEntry("brushHudSettings", defaultDoc);
 }
 
 void KisConfig::setBrushHudSetting(const QString &value) const
 {
     m_cfg.writeEntry("brushHudSettings", value);
 }
 
 bool KisConfig::calculateAnimationCacheInBackground(bool defaultValue) const
 {
     return defaultValue ? true : m_cfg.readEntry("calculateAnimationCacheInBackground", true);
 }
 
 void KisConfig::setCalculateAnimationCacheInBackground(bool value)
 {
     m_cfg.writeEntry("calculateAnimationCacheInBackground", value);
 }
 
 QColor KisConfig::defaultAssistantsColor(bool defaultValue) const
 {
     static const QColor defaultColor = QColor(176, 176, 176, 255);
     return defaultValue ? defaultColor : m_cfg.readEntry("defaultAssistantsColor", defaultColor);
 }
 
 void KisConfig::setDefaultAssistantsColor(const QColor &color) const
 {
     m_cfg.writeEntry("defaultAssistantsColor", color);
 }
 
 #include <QDomDocument>
 #include <QDomElement>
 
 void KisConfig::writeKoColor(const QString& name, const KoColor& color) const
 {
     QDomDocument doc = QDomDocument(name);
     QDomElement el = doc.createElement(name);
     doc.appendChild(el);
     color.toXML(doc, el);
     m_cfg.writeEntry(name, doc.toString());
 }
 
 //ported from kispropertiesconfig.
 KoColor KisConfig::readKoColor(const QString& name, const KoColor& color) const
 {
     QDomDocument doc;
     if (!m_cfg.readEntry(name).isNull()) {
         doc.setContent(m_cfg.readEntry(name));
         QDomElement e = doc.documentElement().firstChild().toElement();
         return KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     } else {
         QString blackColor = "<!DOCTYPE Color>\n<Color>\n <RGB r=\"0\" space=\"sRGB-elle-V2-srgbtrc.icc\" b=\"0\" g=\"0\"/>\n</Color>\n";
         doc.setContent(blackColor);
         QDomElement e = doc.documentElement().firstChild().toElement();
         return KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     return color;
 
 }
diff --git a/libs/ui/kis_control_frame.cpp b/libs/ui/kis_control_frame.cpp
index 52a539c2c9..57722d1547 100644
--- a/libs/ui/kis_control_frame.cpp
+++ b/libs/ui/kis_control_frame.cpp
@@ -1,244 +1,243 @@
 /*
  *  kis_control_frame.cc - part of Krita
  *
  *  Copyright (c) 1999 Matthias Elter  <elter@kde.org>
  *  Copyright (c) 2003 Patrick Julien  <freak@codepimps.org>
  *  Copyright (c) 2004 Sven Langkamp  <sven.langkamp@gmail.com>
  *  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.g
  *
  *  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_control_frame.h"
 
 #include <stdlib.h>
 
 #include <QApplication>
 #include <QLayout>
 #include <QTabWidget>
 #include <QFrame>
 #include <QWidget>
 #include <QEvent>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QWidgetAction>
 #include <QFontDatabase>
 
 #include <klocalizedstring.h>
 #include <QAction>
 #include <kactioncollection.h>
 #include <KoDualColorButton.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceServerProvider.h>
 #include <KoColorSpaceRegistry.h>
 #include <kis_image.h>
 
 #include <resources/KoPattern.h>
 #include "KisResourceServerProvider.h"
 #include "kis_canvas_resource_provider.h"
 
 #include "widgets/kis_iconwidget.h"
 
 #include "widgets/kis_gradient_chooser.h"
 #include "KisViewManager.h"
 #include "kis_config.h"
 #include "kis_paintop_box.h"
 #include "kis_custom_pattern.h"
 #include "widgets/kis_pattern_chooser.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_display_color_converter.h"
 #include <kis_canvas2.h>
-#include <kis_image.h>
 
 
 KisControlFrame::KisControlFrame(KisViewManager *view, QWidget *parent, const char* name)
     : QObject(view)
     , m_viewManager(view)
     , m_patternWidget(0)
     , m_gradientWidget(0)
     , m_patternChooserPopup(0)
     , m_gradientChooserPopup(0)
     , m_paintopBox(0)
 {
     setObjectName(name);
     m_font = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
 
     m_patternWidget = new KisIconWidget(parent, "patterns");
     m_patternWidget->setToolTip(i18n("Fill Patterns"));
     m_patternWidget->setFixedSize(32, 32);
 
     m_gradientWidget = new KisIconWidget(parent, "gradients");
     m_gradientWidget->setToolTip(i18n("Gradients"));
     m_gradientWidget->setFixedSize(32, 32);
 
     KoResourceServer<KoAbstractGradient> * rserver = KoResourceServerProvider::instance()->gradientServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter (new KoResourceServerAdapter<KoAbstractGradient>(rserver));
     m_gradientWidget->setResourceAdapter(adapter);
 }
 
 void KisControlFrame::setup(QWidget *parent)
 {
     createPatternsChooser(m_viewManager);
     createGradientsChooser(m_viewManager);
 
     QWidgetAction *action  = new QWidgetAction(this);
     action->setText(i18n("&Patterns"));
     m_viewManager->actionCollection()->addAction("patterns", action);
     action->setDefaultWidget(m_patternWidget);
 
     action = new QWidgetAction(this);
     action->setText(i18n("&Gradients"));
     m_viewManager->actionCollection()->addAction("gradients", action);
     action->setDefaultWidget(m_gradientWidget);
 
 
     // XXX: KOMVC we don't have a canvas here yet, needs a setImageView
     const KoColorDisplayRendererInterface *displayRenderer = \
         KisDisplayColorConverter::dumbConverterInstance()->displayRendererInterface();
     m_dual = new KoDualColorButton(m_viewManager->resourceProvider()->fgColor(),
                                                      m_viewManager->resourceProvider()->bgColor(), displayRenderer,
                                                      m_viewManager->mainWindow(), m_viewManager->mainWindow());
     m_dual->setPopDialog(true);
     action = new QWidgetAction(this);
     action->setText(i18n("&Color"));
     m_viewManager->actionCollection()->addAction("dual", action);
     action->setDefaultWidget(m_dual);
     connect(m_dual, SIGNAL(foregroundColorChanged(KoColor)), m_viewManager->resourceProvider(), SLOT(slotSetFGColor(KoColor)));
     connect(m_dual, SIGNAL(backgroundColorChanged(KoColor)), m_viewManager->resourceProvider(), SLOT(slotSetBGColor(KoColor)));
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), m_dual, SLOT(setForegroundColor(KoColor)));
     connect(m_viewManager->resourceProvider(), SIGNAL(sigBGColorChanged(KoColor)), m_dual, SLOT(setBackgroundColor(KoColor)));
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), m_gradientWidget, SLOT(update()));
     connect(m_viewManager->resourceProvider(), SIGNAL(sigBGColorChanged(KoColor)), m_gradientWidget, SLOT(update()));
     m_dual->setFixedSize(28, 28);
     connect(m_viewManager, SIGNAL(viewChanged()), SLOT(slotUpdateDisplayRenderer()));
 
     m_paintopBox = new KisPaintopBox(m_viewManager, parent, "paintopbox");
 
     action = new QWidgetAction(this);
     action->setText(i18n("&Painter's Tools"));
     m_viewManager->actionCollection()->addAction("paintops", action);
     action->setDefaultWidget(m_paintopBox);
 }
 
 void KisControlFrame::slotUpdateDisplayRenderer()
 {
     if (m_viewManager->canvasBase()){
         m_dual->setDisplayRenderer(m_viewManager->canvasBase()->displayColorConverter()->displayRendererInterface());
         m_dual->setColorSpace(m_viewManager->canvasBase()->image()->colorSpace());
         m_viewManager->canvasBase()->image()->disconnect(m_dual);
         connect(m_viewManager->canvasBase()->image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), m_dual, SLOT(setColorSpace(const KoColorSpace*)), Qt::UniqueConnection);
     } else if (m_viewManager->viewCount()==0) {
         m_dual->setDisplayRenderer();
     }
 }
 
 void KisControlFrame::slotSetPattern(KoPattern * pattern)
 {
     m_patternWidget->slotSetItem(pattern);
     m_patternChooser->setCurrentPattern(pattern);
 }
 
 void KisControlFrame::slotSetGradient(KoAbstractGradient * gradient)
 {
     m_gradientWidget->slotSetItem(gradient);
 }
 
 void KisControlFrame::createPatternsChooser(KisViewManager * view)
 {
     if (m_patternChooserPopup) delete m_patternChooserPopup;
     m_patternChooserPopup = new QWidget(m_patternWidget);
     m_patternChooserPopup->setObjectName("pattern_chooser_popup");
     QHBoxLayout * l2 = new QHBoxLayout(m_patternChooserPopup);
     l2->setObjectName("patternpopuplayout");
 
     m_patternsTab = new QTabWidget(m_patternChooserPopup);
     m_patternsTab->setObjectName("patternstab");
     m_patternsTab->setFocusPolicy(Qt::NoFocus);
     m_patternsTab->setFont(m_font);
     l2->addWidget(m_patternsTab);
 
     m_patternChooser = new KisPatternChooser(m_patternChooserPopup);
     m_patternChooser->setFont(m_font);
     QWidget *patternChooserPage = new QWidget(m_patternChooserPopup);
     QHBoxLayout *patternChooserPageLayout  = new QHBoxLayout(patternChooserPage);
     patternChooserPageLayout->addWidget(m_patternChooser);
     m_patternsTab->addTab(patternChooserPage, i18n("Patterns"));
 
     KisCustomPattern* customPatterns = new KisCustomPattern(0, "custompatterns",
                                                             i18n("Custom Pattern"), m_viewManager);
     customPatterns->setFont(m_font);
     m_patternsTab->addTab(customPatterns, i18n("Custom Pattern"));
 
     connect(m_patternChooser, SIGNAL(resourceSelected(KoResource*)),
             view->resourceProvider(), SLOT(slotPatternActivated(KoResource*)));
 
     connect(customPatterns, SIGNAL(activatedResource(KoResource*)),
             view->resourceProvider(), SLOT(slotPatternActivated(KoResource*)));
 
     connect(view->resourceProvider(), SIGNAL(sigPatternChanged(KoPattern*)),
             this, SLOT(slotSetPattern(KoPattern*)));
 
     m_patternChooser->setCurrentItem(0, 0);
     if (m_patternChooser->currentResource() && view->resourceProvider()) {
         view->resourceProvider()->slotPatternActivated(m_patternChooser->currentResource());
     }
 
     m_patternWidget->setPopupWidget(m_patternChooserPopup);
 
 
 }
 
 void KisControlFrame::createGradientsChooser(KisViewManager * view)
 {
     if (m_gradientChooserPopup) {
         delete m_gradientChooserPopup;
         m_gradientChooserPopup = 0;
     }
 
     m_gradientChooserPopup = new QWidget(m_gradientWidget);
     m_gradientChooserPopup->setObjectName("gradient_chooser_popup");
     QHBoxLayout * l2 = new QHBoxLayout(m_gradientChooserPopup);
     l2->setObjectName("gradientpopuplayout");
 
     m_gradientTab = new QTabWidget(m_gradientChooserPopup);
     m_gradientTab->setObjectName("gradientstab");
     m_gradientTab->setFocusPolicy(Qt::NoFocus);
     m_gradientTab->setFont(m_font);
     l2->addWidget(m_gradientTab);
 
     m_gradientChooser = new KisGradientChooser(m_gradientChooserPopup);
     m_gradientChooser->setFont(m_font);
     m_gradientTab->addTab(m_gradientChooser, i18n("Gradients"));
 
     connect(m_gradientChooser, SIGNAL(resourceSelected(KoResource*)),
             view->resourceProvider(), SLOT(slotGradientActivated(KoResource*)));
 
     connect (view->mainWindow(), SIGNAL(themeChanged()), m_gradientChooser, SLOT(slotUpdateIcons()));
 
     connect(view->resourceProvider(), SIGNAL(sigGradientChanged(KoAbstractGradient*)),
             this, SLOT(slotSetGradient(KoAbstractGradient*)));
 
     m_gradientChooser->setCurrentItem(0, 0);
     if (m_gradientChooser->currentResource() && view->resourceProvider())
         view->resourceProvider()->slotGradientActivated(m_gradientChooser->currentResource());
 
     m_gradientWidget->setPopupWidget(m_gradientChooserPopup);
 
 }
 
 
diff --git a/libs/ui/kis_import_catcher.cc b/libs/ui/kis_import_catcher.cc
index df858b85f6..2d495d6c22 100644
--- a/libs/ui/kis_import_catcher.cc
+++ b/libs/ui/kis_import_catcher.cc
@@ -1,139 +1,138 @@
 /*
  *  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_import_catcher.h"
 #include <kis_debug.h>
 
 #include <klocalizedstring.h>
-#include <kis_debug.h>
 #include <QUrl>
 
 #include <KisImportExportManager.h>
 
 #include "kis_node_manager.h"
 #include "kis_count_visitor.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_group_layer.h"
 #include "kis_progress_widget.h"
 #include "kis_config.h"
 #include "KisPart.h"
 
 struct KisImportCatcher::Private
 {
 public:
     KisDocument* doc;
     KisViewManager* view;
     QUrl url;
     QString layerType;
 
     QString prettyLayerName() const;
     void importAsPaintLayer(KisPaintDeviceSP device);
     void importAsTransparencyMask(KisPaintDeviceSP device);
 };
 
 QString KisImportCatcher::Private::prettyLayerName() const
 {
     QString name = url.fileName();
     return !name.isEmpty() ? name : url.toDisplayString();
 }
 
 void KisImportCatcher::Private::importAsPaintLayer(KisPaintDeviceSP device)
 {
     KisLayerSP newLayer = new KisPaintLayer(view->image(),
                                             prettyLayerName(),
                                             OPACITY_OPAQUE_U8,
                                             device);
 
     KisNodeSP parent = 0;
     KisLayerSP currentActiveLayer = view->activeLayer();
 
     if (currentActiveLayer) {
         parent = currentActiveLayer->parent();
     }
 
     if (parent.isNull()) {
         parent = view->image()->rootLayer();
     }
 
     KisNodeCommandsAdapter adapter(view);
     adapter.addNode(newLayer, parent, currentActiveLayer);
 }
 
 KisImportCatcher::KisImportCatcher(const QUrl &url, KisViewManager *view, const QString &layerType)
     : m_d(new Private)
 {
     m_d->doc = KisPart::instance()->createDocument();
     m_d->view = view;
     m_d->url = url;
     m_d->layerType = layerType;
 
     connect(m_d->doc, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     bool result = m_d->doc->openUrl(url, KisDocument::DontAddToRecent);
 
     if (!result) {
         deleteMyself();
     }
 }
 
 void KisImportCatcher::slotLoadingFinished()
 {
     KisImageWSP importedImage = m_d->doc->image();
     importedImage->waitForDone();
 
     if (importedImage && importedImage->projection()->exactBounds().isValid()) {
         if (m_d->layerType != "KisPaintLayer") {
             m_d->view->nodeManager()->createNode(m_d->layerType, false, importedImage->projection());
         }
         else {
             KisPaintDeviceSP dev = importedImage->projection();
             adaptClipToImageColorSpace(dev, m_d->view->image());
             m_d->importAsPaintLayer(dev);
         }
     }
 
     deleteMyself();
 }
 
 void KisImportCatcher::deleteMyself()
 {
     m_d->doc->deleteLater();
     deleteLater();
 }
 
 KisImportCatcher::~KisImportCatcher()
 {
     delete m_d;
 }
 
 void KisImportCatcher::adaptClipToImageColorSpace(KisPaintDeviceSP dev, KisImageSP image)
 {
     KisConfig cfg(true);
     qDebug() << "dev" << dev->colorSpace() << "image" << image->colorSpace() << "cfg" << cfg.convertToImageColorspaceOnImport();
     if (cfg.convertToImageColorspaceOnImport() && *dev->colorSpace() != *image->colorSpace()) {
         /// XXX: do we need intent here?
         KUndo2Command* cmd = dev->convertTo(image->colorSpace());
         delete cmd;
     }
 }
 
diff --git a/libs/ui/kis_layer_manager.cc b/libs/ui/kis_layer_manager.cc
index df57ec03ca..4734d034b2 100644
--- a/libs/ui/kis_layer_manager.cc
+++ b/libs/ui/kis_layer_manager.cc
@@ -1,955 +1,952 @@
 /*
  *  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_layer_manager.h"
 
 #include <QRect>
 #include <QApplication>
 #include <QCursor>
 #include <QString>
 #include <QDialog>
 #include <QVBoxLayout>
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <QMessageBox>
 #include <QUrl>
 
 #include <kis_file_name_requester.h>
 #include <kis_icon.h>
 #include <KisImportExportManager.h>
 #include <KisDocument.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoPointerEvent.h>
 #include <KoColorProfile.h>
 #include <KoSelection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <filter/kis_filter.h>
 #include <kis_filter_strategy.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_selection.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_undo_adapter.h>
 #include <kis_painter.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_merge_strategy_registry.h>
 #include <kis_psd_layer_style.h>
 #include <KisMimeDatabase.h>
 
-#include "KisImportExportManager.h"
 #include "kis_config.h"
 #include "kis_cursor.h"
 #include "dialogs/kis_dlg_adj_layer_props.h"
 #include "dialogs/kis_dlg_adjustment_layer.h"
 #include "dialogs/kis_dlg_layer_properties.h"
 #include "dialogs/kis_dlg_generator_layer.h"
 #include "dialogs/kis_dlg_file_layer.h"
 #include "dialogs/kis_dlg_layer_style.h"
-#include "KisDocument.h"
 #include "kis_filter_manager.h"
 #include "kis_node_visitor.h"
 #include "kis_paint_layer.h"
 #include "commands/kis_image_commands.h"
 #include "commands/kis_node_commands.h"
 #include "kis_change_file_layer_command.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_selection_manager.h"
 #include "kis_statusbar.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "widgets/kis_meta_data_merge_strategy_chooser_widget.h"
 #include "widgets/kis_wdg_generator.h"
 #include "kis_progress_widget.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
-#include "KisPart.h"
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_signal_compressor_with_param.h"
 #include "kis_abstract_projection_plane.h"
 #include "commands_new/kis_set_layer_style_command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_selection_mask.h"
 #include "kis_layer_utils.h"
 #include "lazybrush/kis_colorize_mask.h"
 
 #include "KisSaveGroupVisitor.h"
 
 KisLayerManager::KisLayerManager(KisViewManager * view)
     : m_view(view)
     , m_imageView(0)
     , m_imageFlatten(0)
     , m_imageMergeLayer(0)
     , m_groupLayersSave(0)
     , m_imageResizeToLayer(0)
     , m_flattenLayer(0)
     , m_rasterizeLayer(0)
     , m_commandsAdapter(new KisNodeCommandsAdapter(m_view))
     , m_layerStyle(0)
 {
 }
 
 KisLayerManager::~KisLayerManager()
 {
     delete m_commandsAdapter;
 }
 
 void KisLayerManager::setView(QPointer<KisView>view)
 {
     m_imageView = view;
 }
 
 KisLayerSP KisLayerManager::activeLayer()
 {
     if (m_imageView) {
         return m_imageView->currentLayer();
     }
     return 0;
 }
 
 KisPaintDeviceSP KisLayerManager::activeDevice()
 {
     if (activeLayer()) {
         return activeLayer()->paintDevice();
     }
     return 0;
 }
 
 void KisLayerManager::activateLayer(KisLayerSP layer)
 {
     if (m_imageView) {
         emit sigLayerActivated(layer);
         layersUpdated();
         if (layer) {
             m_view->resourceProvider()->slotNodeActivated(layer.data());
         }
     }
 }
 
 
 void KisLayerManager::setup(KisActionManager* actionManager)
 {
     m_imageFlatten = actionManager->createAction("flatten_image");
     connect(m_imageFlatten, SIGNAL(triggered()), this, SLOT(flattenImage()));
 
     m_imageMergeLayer = actionManager->createAction("merge_layer");
     connect(m_imageMergeLayer, SIGNAL(triggered()), this, SLOT(mergeLayer()));
 
     m_flattenLayer = actionManager->createAction("flatten_layer");
     connect(m_flattenLayer, SIGNAL(triggered()), this, SLOT(flattenLayer()));
 
     m_rasterizeLayer = actionManager->createAction("rasterize_layer");
     connect(m_rasterizeLayer, SIGNAL(triggered()), this, SLOT(rasterizeLayer()));
 
     m_groupLayersSave = actionManager->createAction("save_groups_as_images");
     connect(m_groupLayersSave, SIGNAL(triggered()), this, SLOT(saveGroupLayers()));
 
     m_convertGroupAnimated = actionManager->createAction("convert_group_to_animated");
     connect(m_convertGroupAnimated, SIGNAL(triggered()), this, SLOT(convertGroupToAnimated()));
 
     m_imageResizeToLayer = actionManager->createAction("resizeimagetolayer");
     connect(m_imageResizeToLayer, SIGNAL(triggered()), this, SLOT(imageResizeToActiveLayer()));
 
     KisAction *action = actionManager->createAction("trim_to_image");
     connect(action, SIGNAL(triggered()), this, SLOT(trimToImage()));
 
     m_layerStyle  = actionManager->createAction("layer_style");
     connect(m_layerStyle, SIGNAL(triggered()), this, SLOT(layerStyle()));
 
 }
 
 void KisLayerManager::updateGUI()
 {
     KisImageSP image = m_view->image();
     KisLayerSP layer = activeLayer();
 
     const bool isGroupLayer = layer && layer->inherits("KisGroupLayer");
 
     m_imageMergeLayer->setText(
         isGroupLayer ?
             i18nc("@action:inmenu", "Merge Group") :
             i18nc("@action:inmenu", "Merge with Layer Below"));
     m_flattenLayer->setVisible(!isGroupLayer);
 
     if (m_view->statusBar())
         m_view->statusBar()->setProfile(image);
 }
 
 void KisLayerManager::imageResizeToActiveLayer()
 {
     KisLayerSP layer;
     KisImageWSP image = m_view->image();
 
     if (image && (layer = activeLayer())) {
         QRect cropRect = layer->projection()->nonDefaultPixelArea();
         if (!cropRect.isEmpty()) {
             image->cropImage(cropRect);
         } else {
             m_view->showFloatingMessage(
                 i18nc("floating message in layer manager",
                       "Layer is empty "),
                 QIcon(), 2000, KisFloatingMessage::Low);
         }
     }
 }
 
 void KisLayerManager::trimToImage()
 {
     KisImageWSP image = m_view->image();
     if (image) {
         image->cropImage(image->bounds());
     }
 }
 
 void KisLayerManager::layerProperties()
 {
     if (!m_view) return;
     if (!m_view->document()) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
     const bool multipleLayersSelected = selectedNodes.size() > 1;
 
     KisAdjustmentLayerSP alayer = KisAdjustmentLayerSP(dynamic_cast<KisAdjustmentLayer*>(layer.data()));
     KisGeneratorLayerSP glayer = KisGeneratorLayerSP(dynamic_cast<KisGeneratorLayer*>(layer.data()));
     KisFileLayerSP flayer = KisFileLayerSP(dynamic_cast<KisFileLayer*>(layer.data()));
 
     if (alayer && !multipleLayersSelected) {
 
         KisPaintDeviceSP dev = alayer->projection();
 
         KisDlgAdjLayerProps dlg(alayer, alayer.data(), dev, m_view, alayer->filter().data(), alayer->name(), i18n("Filter Layer Properties"), m_view->mainWindow(), "dlgadjlayerprops");
         dlg.resize(dlg.minimumSizeHint());
 
 
         KisFilterConfigurationSP configBefore(alayer->filter());
         KIS_ASSERT_RECOVER_RETURN(configBefore);
         QString xmlBefore = configBefore->toXML();
 
 
         if (dlg.exec() == QDialog::Accepted) {
 
             alayer->setName(dlg.layerName());
 
             KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                    = new KisChangeFilterCmd(alayer,
                                              configBefore->name(),
                                              xmlBefore,
                                              configAfter->name(),
                                              xmlAfter,
                                              false);
                 // FIXME: check whether is needed
                 cmd->redo();
                 m_view->undoAdapter()->addCommand(cmd);
                 m_view->document()->setModified(true);
             }
         }
         else {
             KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 alayer->setFilter(KisFilterRegistry::instance()->cloneConfiguration(configBefore.data()));
                 alayer->setDirty();
             }
         }
     }
     else if (glayer && !multipleLayersSelected) {
 
         KisDlgGeneratorLayer dlg(glayer->name(), m_view, m_view->mainWindow());
         dlg.setCaption(i18n("Fill Layer Properties"));
 
         KisFilterConfigurationSP configBefore(glayer->filter());
         Q_ASSERT(configBefore);
         QString xmlBefore = configBefore->toXML();
 
         dlg.setConfiguration(configBefore.data());
         dlg.resize(dlg.minimumSizeHint());
 
         if (dlg.exec() == QDialog::Accepted) {
 
             glayer->setName(dlg.layerName());
 
             KisFilterConfigurationSP configAfter(dlg.configuration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                         = new KisChangeFilterCmd(glayer,
                                                  configBefore->name(),
                                                  xmlBefore,
                                                  configAfter->name(),
                                                  xmlAfter,
                                                  true);
                 // FIXME: check whether is needed
                 cmd->redo();
                 m_view->undoAdapter()->addCommand(cmd);
                 m_view->document()->setModified(true);
             }
 
         }
     }  else if (flayer && !multipleLayersSelected){
         QString basePath = QFileInfo(m_view->document()->url().toLocalFile()).absolutePath();
         QString fileNameOld = flayer->fileName();
         KisFileLayer::ScalingMethod scalingMethodOld = flayer->scalingMethod();
         KisDlgFileLayer dlg(basePath, flayer->name(), m_view->mainWindow());
         dlg.setCaption(i18n("File Layer Properties"));
         dlg.setFileName(fileNameOld);
         dlg.setScalingMethod(scalingMethodOld);
 
         if (dlg.exec() == QDialog::Accepted) {
             const QString fileNameNew = dlg.fileName();
             KisFileLayer::ScalingMethod scalingMethodNew = dlg.scaleToImageResolution();
 
             if(fileNameNew.isEmpty()){
                 QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
                 return;
             }
             flayer->setName(dlg.layerName());
 
             if (fileNameOld!= fileNameNew || scalingMethodOld != scalingMethodNew) {
                 KisChangeFileLayerCmd *cmd
                         = new KisChangeFileLayerCmd(flayer,
                                                 basePath,
                                                 fileNameOld,
                                                 scalingMethodOld,
                                                 basePath,
                                                 fileNameNew,
                                                 scalingMethodNew);
                 m_view->undoAdapter()->addCommand(cmd);
             }
         }
     } else { // If layer == normal painting layer, vector layer, or group layer
         QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
 
         KisDlgLayerProperties *dialog = new KisDlgLayerProperties(selectedNodes, m_view);
         dialog->resize(dialog->minimumSizeHint());
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         Qt::WindowFlags flags = dialog->windowFlags();
         dialog->setWindowFlags(flags | Qt::WindowStaysOnTopHint | Qt::Dialog);
         dialog->show();
 
     }
 }
 
 void KisLayerManager::convertNodeToPaintLayer(KisNodeSP source)
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
 
     KisLayer *srcLayer = qobject_cast<KisLayer*>(source.data());
     if (srcLayer && (srcLayer->inherits("KisGroupLayer") || srcLayer->layerStyle() || srcLayer->childCount() > 0)) {
         image->flattenLayer(srcLayer);
         return;
     }
 
 
     KisPaintDeviceSP srcDevice =
         source->paintDevice() ? source->projection() : source->original();
 
     bool putBehind = false;
     QString newCompositeOp = source->compositeOpId();
     KisColorizeMask *colorizeMask = dynamic_cast<KisColorizeMask*>(source.data());
     if (colorizeMask) {
         srcDevice = colorizeMask->coloringProjection();
         putBehind = colorizeMask->compositeOpId() == COMPOSITE_BEHIND;
         if (putBehind) {
             newCompositeOp = COMPOSITE_OVER;
         }
     }
 
     if (!srcDevice) return;
 
     KisPaintDeviceSP clone;
 
     if (*srcDevice->colorSpace() !=
         *srcDevice->compositionSourceColorSpace()) {
 
         clone = new KisPaintDevice(srcDevice->compositionSourceColorSpace());
 
         QRect rc(srcDevice->extent());
         KisPainter::copyAreaOptimized(rc.topLeft(), srcDevice, clone, rc);
 
     } else {
         clone = new KisPaintDevice(*srcDevice);
     }
 
     KisLayerSP layer = new KisPaintLayer(image,
                                          source->name(),
                                          source->opacity(),
                                          clone);
     layer->setCompositeOpId(newCompositeOp);
 
     KisNodeSP parent = source->parent();
     KisNodeSP above = source->prevSibling();
 
     while (parent && !parent->allowAsChild(layer)) {
         above = above ? above->parent() : source->parent();
         parent = above ? above->parent() : 0;
     }
 
     if (putBehind && above == source->parent()) {
         above = above->prevSibling();
     }
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a Paint Layer"));
     m_commandsAdapter->removeNode(source);
     m_commandsAdapter->addNode(layer, parent, above);
     m_commandsAdapter->endMacro();
 
 }
 
 void KisLayerManager::convertGroupToAnimated()
 {
     KisGroupLayerSP group = dynamic_cast<KisGroupLayer*>(activeLayer().data());
     if (group.isNull()) return;
 
     KisPaintLayerSP animatedLayer = new KisPaintLayer(m_view->image(), group->name(), OPACITY_OPAQUE_U8);
     animatedLayer->enableAnimation();
     KisRasterKeyframeChannel *contentChannel = dynamic_cast<KisRasterKeyframeChannel*>(
             animatedLayer->getKeyframeChannel(KisKeyframeChannel::Content.id(), true));
     KIS_ASSERT_RECOVER_RETURN(contentChannel);
 
     KisNodeSP child = group->firstChild();
     int time = 0;
     while (child) {
         contentChannel->importFrame(time, child->projection(), NULL);
         time++;
 
         child = child->nextSibling();
     }
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Convert to an animated layer"));
     m_commandsAdapter->addNode(animatedLayer, group->parent(), group);
     m_commandsAdapter->removeNode(group);
     m_commandsAdapter->endMacro();
 }
 
 void KisLayerManager::convertLayerToFileLayer(KisNodeSP source)
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     KoDialog dlg;
     QWidget *page = new QWidget(&dlg);
     dlg.setMainWidget(page);
     QBoxLayout *layout = new QVBoxLayout(page);
     dlg.setWindowTitle(i18n("Save layers to..."));
     QLabel *lbl = new QLabel(i18n("Choose the location where the layer will be saved to. The new file layer will then reference this location."));
     lbl->setWordWrap(true);
     layout->addWidget(lbl);
     KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
     urlRequester->setMode(KoFileDialog::SaveFile);
     urlRequester->setMimeTypeFilters(listMimeFilter);
     urlRequester->setFileName(m_view->document()->url().toLocalFile());
     if (m_view->document()->url().isLocalFile()) {
         QFileInfo location = QFileInfo(m_view->document()->url().toLocalFile()).baseName();
         location.setFile(location.dir(), location.baseName()+"_"+ source->name()+".kra");
         urlRequester->setFileName(location.absoluteFilePath());
     } else {
         const QFileInfo location = QFileInfo(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
         const QString proposedFileName = QDir(location.absoluteFilePath()).absoluteFilePath(source->name() + ".kra");
         urlRequester->setFileName(proposedFileName);
     }
 
     layout->addWidget(urlRequester);
     if (!dlg.exec()) return;
 
     QString path = urlRequester->fileName();
 
     if (path.isEmpty()) return;
 
     QFileInfo f(path);
 
     QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName());
     if (mimeType.isEmpty()) {
         mimeType = "image/png";
     }
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     QRect bounds = source->exactBounds();
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   image->width(),
                                   image->height(),
                                   image->projection()->compositionSourceColorSpace(),
                                   source->name());
     dst->setResolution(image->xRes(), image->yRes());
     doc->setFileBatchMode(false);
     doc->setCurrentImage(dst);
     KisNodeSP node = source->clone();
     dst->addNode(node);
     dst->initialRefreshGraph();
     dst->cropImage(bounds);
     dst->waitForDone();
 
     bool r = doc->exportDocumentSync(QUrl::fromLocalFile(path), mimeType.toLatin1());
     if (!r) {
         qDebug()<< "Path:"<<path;
         qWarning() << doc->errorMessage();
     } else {
         QString basePath = QFileInfo(m_view->document()->url().toLocalFile()).absolutePath();
         QString relativePath = QDir(basePath).relativeFilePath(path);
         KisFileLayer *fileLayer = new KisFileLayer(image, basePath, relativePath, KisFileLayer::None, source->name(), OPACITY_OPAQUE_U8);
         fileLayer->setX(bounds.x());
         fileLayer->setY(bounds.y());
         KisNodeSP dstParent = source->parent();
         KisNodeSP dstAboveThis = source->prevSibling();
         m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a file layer"));
         m_commandsAdapter->removeNode(source);
         m_commandsAdapter->addNode(fileLayer, dstParent, dstAboveThis);
         m_commandsAdapter->endMacro();
     }
     doc->closeUrl(false);
 }
 
 void KisLayerManager::adjustLayerPosition(KisNodeSP node, KisNodeSP activeNode, KisNodeSP &parent, KisNodeSP &above)
 {
     Q_ASSERT(activeNode);
 
     parent = activeNode;
     above = parent->lastChild();
 
     while (parent &&
            (!parent->allowAsChild(node) || parent->userLocked())) {
 
         above = parent;
         parent = parent->parent();
     }
 
     if (!parent) {
         warnKrita << "KisLayerManager::adjustLayerPosition:"
                    << "No node accepted newly created node";
 
         parent = m_view->image()->root();
         above = parent->lastChild();
     }
 }
 
 void KisLayerManager::addLayerCommon(KisNodeSP activeNode, KisLayerSP layer, bool updateImage)
 {
     KisNodeSP parent;
     KisNodeSP above;
     adjustLayerPosition(layer, activeNode, parent, above);
 
 
     KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(parent.data());
     const bool parentForceUpdate = group && !group->projectionIsValid();
     updateImage |= parentForceUpdate;
 
     m_commandsAdapter->addNode(layer, parent, above, updateImage, updateImage);
 }
 
 KisLayerSP KisLayerManager::addLayer(KisNodeSP activeNode)
 {
     KisLayerSP layer = KisLayerUtils::constructDefaultLayer(m_view->image());
     addLayerCommon(activeNode, layer, false);
 
     return layer;
 }
 
 void KisLayerManager::addGroupLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     addLayerCommon(activeNode,
                    new KisGroupLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8), false);
 }
 
 void KisLayerManager::addCloneLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     addLayerCommon(activeNode,
                    new KisCloneLayer(activeLayer(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8));
 }
 
 void KisLayerManager::addShapeLayer(KisNodeSP activeNode)
 {
     if (!m_view) return;
     if (!m_view->document()) return;
 
     KisImageWSP image = m_view->image();
     KisShapeLayerSP layer = new KisShapeLayer(m_view->document()->shapeController(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8);
 
     addLayerCommon(activeNode, layer, false);
 }
 
 void KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
 
     KisSelectionSP selection = m_view->selection();
     KisAdjustmentLayerSP adjl = addAdjustmentLayer(activeNode, QString(), 0, selection);
     image->refreshGraph();
 
     KisPaintDeviceSP previewDevice = new KisPaintDevice(*adjl->original());
 
     KisDlgAdjustmentLayer dlg(adjl, adjl.data(), previewDevice, image->nextLayerName(), i18n("New Filter Layer"), m_view);
     dlg.resize(dlg.minimumSizeHint());
 
     // ensure that the device may be free'd by the dialog
     // when it is not needed anymore
     previewDevice = 0;
 
     if (dlg.exec() != QDialog::Accepted || adjl->filter().isNull()) {
         // XXX: add messagebox warning if there's no filter set!
         m_commandsAdapter->undoLastCommand();
     } else {
         adjl->setName(dlg.layerName());
     }
 
 }
 
 KisAdjustmentLayerSP KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode, const QString & name,
                                                          KisFilterConfigurationSP  filter, KisSelectionSP selection)
 {
     KisImageWSP image = m_view->image();
     KisAdjustmentLayerSP layer = new KisAdjustmentLayer(image, name, filter, selection);
     addLayerCommon(activeNode, layer);
 
     return layer;
 }
 
 void KisLayerManager::addGeneratorLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
 
     KisDlgGeneratorLayer dlg(image->nextLayerName(), m_view, m_view->mainWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     if (dlg.exec() == QDialog::Accepted) {
         KisSelectionSP selection = m_view->selection();
         KisFilterConfigurationSP  generator = dlg.configuration();
         QString name = dlg.layerName();
 
         addLayerCommon(activeNode,
             new KisGeneratorLayer(image, name, generator, selection));
     }
 
 }
 
 void KisLayerManager::flattenImage()
 {
     KisImageSP image = m_view->image();
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     if (image) {
         bool doIt = true;
 
         if (image->nHiddenLayers() > 0) {
             int answer = QMessageBox::warning(m_view->mainWindow(),
                                               i18nc("@title:window", "Flatten Image"),
                                               i18n("The image contains hidden layers that will be lost. Do you want to flatten the image?"),
                                               QMessageBox::Yes | QMessageBox::No,
                                               QMessageBox::No);
 
             if (answer != QMessageBox::Yes) {
                 doIt = false;
             }
         }
 
         if (doIt) {
             image->flatten();
         }
     }
 }
 
 inline bool isSelectionMask(KisNodeSP node) {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 bool tryMergeSelectionMasks(KisNodeSP currentNode, KisImageSP image)
 {
     bool result = false;
 
     KisNodeSP prevNode = currentNode->prevSibling();
     if (isSelectionMask(currentNode) &&
         prevNode && isSelectionMask(prevNode)) {
 
         QList<KisNodeSP> mergedNodes;
         mergedNodes.append(currentNode);
         mergedNodes.append(prevNode);
 
         image->mergeMultipleLayers(mergedNodes, currentNode);
 
         result = true;
     }
 
     return result;
 }
 
 bool tryFlattenGroupLayer(KisNodeSP currentNode, KisImageSP image)
 {
     bool result = false;
 
     if (currentNode->inherits("KisGroupLayer")) {
         KisGroupLayer *layer = qobject_cast<KisGroupLayer*>(currentNode.data());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(layer, false);
 
         image->flattenLayer(layer);
         result = true;
     }
 
     return result;
 }
 
 void KisLayerManager::mergeLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
       if (selectedNodes.size() > 1) {
         image->mergeMultipleLayers(selectedNodes, m_view->activeNode());
     }
 
       else if (tryMergeSelectionMasks(m_view->activeNode(), image)) {
         // already done!
     } else if (tryFlattenGroupLayer(m_view->activeNode(), image)) {
         // already done!
     } else {
 
         if (!layer->prevSibling()) return;
         KisLayer *prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
         if (!prevLayer) return;
         if (prevLayer->userLocked()) {
             m_view->showFloatingMessage(
                 i18nc("floating message in layer manager",
                       "Layer is locked "),
                 QIcon(), 2000, KisFloatingMessage::Low);
         }
 
         else if (layer->metaData()->isEmpty() && prevLayer->metaData()->isEmpty()) {
             image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         }
         else {
             const KisMetaData::MergeStrategy* strategy = KisMetaDataMergeStrategyChooserWidget::showDialog(m_view->mainWindow());
             if (!strategy) return;
             image->mergeDown(layer, strategy);
         }
     }
 
     m_view->updateGUI();
 }
 
 void KisLayerManager::flattenLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     convertNodeToPaintLayer(layer);
     m_view->updateGUI();
 }
 
 void KisLayerManager::rasterizeLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, layer->name(), layer->opacity());
     KisPainter gc(paintLayer->paintDevice());
     QRect rc = layer->projection()->exactBounds();
     gc.bitBlt(rc.topLeft(), layer->projection(), rc);
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Rasterize Layer"));
     m_commandsAdapter->addNode(paintLayer.data(), layer->parent().data(), layer.data());
 
     int childCount = layer->childCount();
     for (int i = 0; i < childCount; i++) {
         m_commandsAdapter->moveNode(layer->firstChild(), paintLayer, paintLayer->lastChild());
     }
     m_commandsAdapter->removeNode(layer);
     m_commandsAdapter->endMacro();
     updateGUI();
 }
 
 
 void KisLayerManager::layersUpdated()
 {
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     m_view->updateGUI();
 }
 
 void KisLayerManager::saveGroupLayers()
 {
     QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     KoDialog dlg;
     QWidget *page = new QWidget(&dlg);
     dlg.setMainWidget(page);
     QBoxLayout *layout = new QVBoxLayout(page);
 
     KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
     urlRequester->setMode(KoFileDialog::SaveFile);
     if (m_view->document()->url().isLocalFile()) {
         urlRequester->setStartDir(QFileInfo(m_view->document()->url().toLocalFile()).absolutePath());
     }
     urlRequester->setMimeTypeFilters(listMimeFilter);
     urlRequester->setFileName(m_view->document()->url().toLocalFile());
     layout->addWidget(urlRequester);
 
     QCheckBox *chkInvisible = new QCheckBox(i18n("Convert Invisible Groups"), page);
     chkInvisible->setChecked(false);
     layout->addWidget(chkInvisible);
     QCheckBox *chkDepth = new QCheckBox(i18n("Export Only Toplevel Groups"), page);
     chkDepth->setChecked(true);
     layout->addWidget(chkDepth);
 
     if (!dlg.exec()) return;
 
     QString path = urlRequester->fileName();
 
     if (path.isEmpty()) return;
 
     QFileInfo f(path);
 
     QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName(), false);
     if (mimeType.isEmpty()) {
         mimeType = "image/png";
     }
     QString extension = KisMimeDatabase::suffixesForMimeType(mimeType).first();
     QString basename = f.baseName();
 
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisSaveGroupVisitor v(image, chkInvisible->isChecked(), chkDepth->isChecked(), f.absolutePath(), basename, extension, mimeType);
     image->rootLayer()->accept(v);
 
 }
 
 bool KisLayerManager::activeLayerHasSelection()
 {
     return (activeLayer()->selection() != 0);
 }
 
 void KisLayerManager::addFileLayer(KisNodeSP activeNode)
 {
 
     QString basePath;
     QUrl url = m_view->document()->url();
     if (url.isLocalFile()) {
         basePath = QFileInfo(url.toLocalFile()).absolutePath();
     }
     KisImageWSP image = m_view->image();
 
     KisDlgFileLayer dlg(basePath, image->nextLayerName(), m_view->mainWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     if (dlg.exec() == QDialog::Accepted) {
         QString name = dlg.layerName();
         QString fileName = dlg.fileName();
 
         if(fileName.isEmpty()){
             QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
             return;
         }
 
         KisFileLayer::ScalingMethod scalingMethod = dlg.scaleToImageResolution();
 
         addLayerCommon(activeNode,
                        new KisFileLayer(image, basePath, fileName, scalingMethod, name, OPACITY_OPAQUE_U8));
     }
 
 }
 
 void updateLayerStyles(KisLayerSP layer, KisDlgLayerStyle *dlg)
 {
     KisSetLayerStyleCommand::updateLayerStyle(layer, dlg->style()->clone());
 }
 
 void KisLayerManager::layerStyle()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     KisPSDLayerStyleSP oldStyle;
     if (layer->layerStyle()) {
         oldStyle = layer->layerStyle()->clone();
     }
     else {
         oldStyle = toQShared(new KisPSDLayerStyle());
     }
 
     KisDlgLayerStyle dlg(oldStyle->clone(), m_view->resourceProvider());
 
     std::function<void ()> updateCall(std::bind(updateLayerStyles, layer, &dlg));
     SignalToFunctionProxy proxy(updateCall);
     connect(&dlg, SIGNAL(configChanged()), &proxy, SLOT(start()));
 
     if (dlg.exec() == QDialog::Accepted) {
         KisPSDLayerStyleSP newStyle = dlg.style();
 
         KUndo2CommandSP command = toQShared(
             new KisSetLayerStyleCommand(layer, oldStyle, newStyle));
 
         image->postExecutionUndoAdapter()->addCommand(command);
     }
 }
 
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index 1252b96629..081ec6ecae 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1348 +1,1347 @@
 /*
  *  kis_paintop_box.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2009-2011 Sven Langkamp (sven.langkamp@gmail.com)
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_box.h"
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QPixmap>
 #include <QWidgetAction>
 #include <QApplication>
 #include <QMenu>
 #include <QTime>
 
 #include <kis_debug.h>
 
 #include <kactioncollection.h>
 #include <kacceleratormanager.h>
 #include <QKeySequence>
 
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceSelector.h>
 #include <KoResourceServerAdapter.h>
 #include <KoToolManager.h>
 #include <QTemporaryFile>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_paint_device.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_settings_update_proxy.h>
 #include <kis_config_widget.h>
 #include <kis_image.h>
 #include <kis_node.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_action.h>
 
 #include "kis_canvas2.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_config.h"
 
 #include "kis_popup_button.h"
 #include "widgets/kis_iconwidget.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_popup.h"
-#include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_chooser_popup.h"
 #include "widgets/kis_workspace_chooser.h"
 #include "widgets/kis_paintop_list_widget.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_widget_chooser.h"
 #include "tool/kis_tool.h"
 #include "kis_signals_blocker.h"
 #include "kis_action_manager.h"
 #include "kis_highlighted_button.h"
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisPaintopBox::KisPaintopBox(KisViewManager *view, QWidget *parent, const char *name)
     : QWidget(parent)
     , m_resourceProvider(view->resourceProvider())
     , m_optionWidget(0)
     , m_toolOptionsPopupButton(0)
     , m_brushEditorPopupButton(0)
     , m_presetSelectorPopupButton(0)
     , m_toolOptionsPopup(0)
     , m_viewManager(view)
     , m_previousNode(0)
     , m_currTabletToolID(KoInputDevice::invalid())
     , m_presetsEnabled(true)
     , m_blockUpdate(false)
     , m_dirtyPresetsEnabled(false)
     , m_eraserBrushSizeEnabled(false)
     , m_eraserBrushOpacityEnabled(false)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
     KisConfig cfg(true);
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
     m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
 
 
     KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
     int iconsize = grp.readEntry("IconSize", 32);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopupButton = new KisPopupButton(this);
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
         m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
         m_toolOptionsPopupButton->setFixedSize(iconsize, iconsize);
     }
 
     m_brushEditorPopupButton = new KisIconWidget(this);
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
     m_brushEditorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_presetSelectorPopupButton = new KisPopupButton(this);
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
     m_presetSelectorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_eraseModeButton = new KisHighlightedToolButton(this);
     m_eraseModeButton->setFixedSize(iconsize, iconsize);
     m_eraseModeButton->setCheckable(true);
 
     m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
     m_eraseModeButton->setDefaultAction(m_eraseAction);
 
     m_reloadButton = new QToolButton(this);
     m_reloadButton->setFixedSize(iconsize, iconsize);
 
     m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
     m_reloadButton->setDefaultAction(m_reloadAction);
 
     m_alphaLockButton = new KisHighlightedToolButton(this);
     m_alphaLockButton->setFixedSize(iconsize, iconsize);
     m_alphaLockButton->setCheckable(true);
 
     KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
     m_alphaLockButton->setDefaultAction(alphaLockAction);
 
     // horizontal and vertical mirror toolbar buttons
 
     // mirror tool options for the X Mirror
     QMenu *toolbarMenuXMirror = new QMenu();
 
     hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     toolbarMenuXMirror->addAction(lockActionX);
 
     moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     toolbarMenuYMirror->addAction(lockActionY);
 
     moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     toolbarMenuYMirror->addAction(moveToCenterActionY);
 
 
 
     // create horizontal and vertical mirror buttons
 
     m_hMirrorButton = new KisHighlightedToolButton(this);
     int menuPadding = 10;
     m_hMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_hMirrorButton->setCheckable(true);
     m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
     m_hMirrorButton->setDefaultAction(m_hMirrorAction);
     m_hMirrorButton->setMenu(toolbarMenuXMirror);
     m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_vMirrorButton = new KisHighlightedToolButton(this);
     m_vMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_vMirrorButton->setCheckable(true);
     m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
     m_vMirrorButton->setDefaultAction(m_vMirrorAction);
     m_vMirrorButton->setMenu(toolbarMenuYMirror);
     m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     // add connections for horizontal and mirrror buttons
     connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
     connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
     connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
     connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
     connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
     connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
     const bool sliderLabels = cfg.sliderLabels();
     int sliderWidth;
 
     if (sliderLabels) {
         sliderWidth = 150 * logicalDpiX() / 96;
     }
     else {
         sliderWidth = 120 * logicalDpiX() / 96;
     }
 
     for (int i = 0; i < 3; ++i) {
         m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
         KisDoubleSliderSpinBox* slOpacity;
         KisDoubleSliderSpinBox* slFlow;
         KisDoubleSliderSpinBox* slSize;
         if (sliderLabels) {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
             slOpacity->setPrefix(QString("%1  ").arg(i18n("Opacity:")));
             slFlow->setPrefix(QString("%1  ").arg(i18n("Flow:")));
             slSize->setPrefix(QString("%1  ").arg(i18n("Size:")));
         }
         else {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
         }
 
         slOpacity->setRange(0, 100, 0);
         slOpacity->setValue(100);
         slOpacity->setSingleStep(5);
         slOpacity->setSuffix("%");
         slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
         slOpacity->setFixedHeight(iconsize);
         slOpacity->setBlockUpdateSignalOnDrag(true);
 
         slFlow->setRange(0, 100, 0);
         slFlow->setValue(100);
         slFlow->setSingleStep(5);
         slFlow->setSuffix("%");
         slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
         slFlow->setFixedHeight(iconsize);
         slFlow->setBlockUpdateSignalOnDrag(true);
 
         slSize->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         slSize->setValue(100);
 
         slSize->setSingleStep(1);
         slSize->setExponentRatio(3.0);
         slSize->setSuffix(i18n(" px"));
         slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
         slSize->setFixedHeight(iconsize);
         slSize->setBlockUpdateSignalOnDrag(true);
 
         m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
     }
 
     m_cmbCompositeOp = new KisCompositeOpComboBox();
     m_cmbCompositeOp->setFixedHeight(iconsize);
     Q_FOREACH (KisAction * a, m_cmbCompositeOp->blendmodeActions()) {
         m_viewManager->actionManager()->addAction(a->text(), a);
     }
 
     m_workspaceWidget = new KisPopupButton(this);
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_workspaceWidget->setToolTip(i18n("Choose workspace"));
     m_workspaceWidget->setFixedSize(iconsize, iconsize);
     m_workspaceWidget->setPopupWidget(new KisWorkspaceChooser(view));
 
     QHBoxLayout* baseLayout = new QHBoxLayout(this);
     m_paintopWidget = new QWidget(this);
     baseLayout->addWidget(m_paintopWidget);
     baseLayout->setSpacing(4);
     baseLayout->setContentsMargins(0, 0, 0, 0);
 
     m_layout = new QHBoxLayout(m_paintopWidget);
     if (!cfg.toolOptionsInDocker()) {
         m_layout->addWidget(m_toolOptionsPopupButton);
     }
     m_layout->addWidget(m_brushEditorPopupButton);
     m_layout->addWidget(m_presetSelectorPopupButton);
     m_layout->setSpacing(4);
     m_layout->setContentsMargins(0, 0, 0, 0);
 
     QWidget* compositeActions = new QWidget(this);
     QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
     compositeLayout->addWidget(m_cmbCompositeOp);
     compositeLayout->addWidget(m_eraseModeButton);
     compositeLayout->addWidget(m_alphaLockButton);
 
     compositeLayout->setSpacing(4);
     compositeLayout->setContentsMargins(0, 0, 0, 0);
 
     compositeLayout->addWidget(m_reloadButton);
 
     QWidgetAction * action;
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("composite_actions", action);
     action->setText(i18n("Brush composite"));
     action->setDefaultWidget(compositeActions);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider1", action);
     view->actionCollection()->addAction("brushslider1", action);
     action->setDefaultWidget(m_sliderChooser[0]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider2", action);
     view->actionCollection()->addAction("brushslider2", action);
     action->setDefaultWidget(m_sliderChooser[1]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider3", action);
     view->actionCollection()->addAction("brushslider3", action);
     action->setDefaultWidget(m_sliderChooser[2]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
         connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
     view->actionCollection()->addAction("next_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
     view->actionCollection()->addAction("previous_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_preset", action);
     view->actionCollection()->addAction("previous_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
     if (!cfg.toolOptionsInDocker()) {
         action = new QWidgetAction(this);
         KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
         view->actionCollection()->addAction("show_tool_options", action);
         connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
     }
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
     view->actionCollection()->addAction("show_brush_editor", action);
     connect(action, SIGNAL(triggered()), m_brushEditorPopupButton, SLOT(showPopupWidget()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
     view->actionCollection()->addAction("show_brush_presets", action);
     connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
 
     QWidget* mirrorActions = new QWidget(this);
     QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
     mirrorLayout->addWidget(m_hMirrorButton);
     mirrorLayout->addWidget(m_vMirrorButton);
     mirrorLayout->setSpacing(4);
     mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
     action->setDefaultWidget(mirrorActions);
     view->actionCollection()->addAction("mirror_actions", action);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("workspaces", action);
     view->actionCollection()->addAction("workspaces", action);
     action->setDefaultWidget(m_workspaceWidget);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopup = new KisToolOptionsPopup();
         m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
         m_toolOptionsPopup->switchDetached(false);
     }
 
 
     m_savePresetWidget = new KisPresetSaveWidget(this);
 
     m_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider, m_favoriteResourceManager, m_savePresetWidget);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->parentWidget()->setWindowTitle(i18n("Brush Editor"));
 
 
     connect(m_presetsPopup, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetsChooserPopup->setMinimumHeight(550);
     m_presetsChooserPopup->setMinimumWidth(450);
     m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     slotNodeChanged(view->activeNode());
     // Get all the paintops
     QList<QString> keys = KisPaintOpRegistry::instance()->keys();
     QList<KisPaintOpFactory*> factoryList;
 
     Q_FOREACH (const QString & paintopId, keys) {
         factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
     }
     m_presetsPopup->setPaintOpList(factoryList);
 
     connect(m_presetsPopup       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
     connect(m_presetsPopup       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
     connect(m_presetsPopup       , SIGNAL(signalResourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
     connect(m_presetsPopup       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
     connect(m_presetsPopup       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
     connect(m_presetsPopup, SIGNAL(createPresetFromScratch(QString)), this, SLOT(slotCreatePresetFromScratch(QString)));
 
     connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResource*))      , SLOT(resourceSelected(KoResource*)));
     connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResource*))      , SLOT(resourceSelected(KoResource*)));
 
     connect(m_resourceProvider   , SIGNAL(sigNodeChanged(const KisNodeSP))    , SLOT(slotNodeChanged(const KisNodeSP)));
     connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
     connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
     connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
 
     m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
     connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
     m_disablePressureAction->setChecked(true);
 
     connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
     connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
     connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
 
     //Needed to connect canvas to favorite resource manager
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
 
     connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
     connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
     // cold initialization
     m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
     m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
     connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigEnableChangeColor(bool)), m_resourceProvider, SLOT(slotResetEnableFGChange(bool)));
 
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
     connect(m_resourceProvider->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 
     KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     m_eraserName = "eraser_circle";
     m_defaultPresetName = "basic_tip_default";
     bool foundEraser = false;
     bool foundTip = false;
     for (int i=0; i<rserver->resourceCount(); i++) {
         KisPaintOpPresetSP resource = rserver->resources().at(i);
         if (resource->name().toLower().contains("eraser_circle")) {
             m_eraserName = resource->name();
             foundEraser = true;
         } else if (foundEraser == false && (resource->name().toLower().contains("eraser") ||
                                             resource->filename().toLower().contains("eraser"))) {
             m_eraserName = resource->name();
             foundEraser = true;
         }
         if (resource->name().toLower().contains("basic_tip_default")) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                          resource->filename().toLower().contains("default"))) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         }
     }
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
     KisConfig cfg(false);
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         //qDebug() << "Writing last used preset for" << iter.key().pointer << iter.key().uniqueID << iter.value().preset->name();
         if ((iter.key().pointer) == QTabletEvent::Eraser) {
             cfg.writeEntry(QString("LastEraser_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
         else {
             cfg.writeEntry(QString("LastPreset_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
     }
     // Do not delete the widget, since it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
 
     if (preset) {
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     if (m_toolOptionsPopup) {
         m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisPaintopBox::resourceSelected(KoResource* resource)
 {
     m_presetsPopup->setCreatingBrushFromScratch(false); // show normal UI elements when we are not creating
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset && preset != m_resourceProvider->currentPreset()) {
         if (!preset->settings()->isLoadable())
             return;
 
         if (!m_dirtyPresetsEnabled) {
             KisSignalsBlocker blocker(m_optionWidget);
             if (!preset->load()) {
                 warnKrita << "failed to load the preset.";
             }
         }
         //qDebug() << "resourceSelected" << resource->name();
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 
 
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop)
 {
     KisPaintOpPresetSP preset = activePreset(paintop);
     Q_ASSERT(preset && preset->settings());
     //qDebug() << "setCurrentPaintop();" << paintop << preset;
     setCurrentPaintop(preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(KisPaintOpPresetSP preset)
 {
 
     //qDebug() << "setCurrentPaintop(); " << preset->name();
 
     if (preset == m_resourceProvider->currentPreset()) {
 
         if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
             return;
         }
     }
     Q_ASSERT(preset);
     const KoID& paintop = preset->paintOp();
     m_presetConnections.clear();
 
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->hide();
         }
 
     }
 
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
     KisSignalsBlocker b(m_optionWidget);
 
     preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
     m_resourceProvider->setPaintOpPreset(preset);
 
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
 
     m_brushEditorPopupButton->slotSetItem(preset.data());
     m_presetsPopup->setCurrentPaintOpId(paintop.id());
 
 
     ////qDebug() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
     m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
     m_tabletToolMap[m_currTabletToolID].preset = preset;
     m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
     if (m_presetsPopup->currentPaintOpId() != paintop.id()) {
         // Must change the paintop as the current one is not supported
         // by the new colorspace.
         dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
     }
 }
 
 void KisPaintopBox::slotUpdateOptionsWidgetPopup()
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
     KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_optionWidget->setConfigurationSafe(preset->settings());
 
     m_presetsPopup->resourceSelected(preset.data());
     m_presetsPopup->updateViewSettings();
 
     // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
     // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
     m_optionWidget->setImage(m_viewManager->image());
 }
 
 KisPaintOpPresetSP KisPaintopBox::defaultPreset(const KoID& paintOp)
 {
     QString defaultName = paintOp.id() + ".kpp";
     QString path = KoResourcePaths::findResource("kis_defaultpresets", defaultName);
 
     KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
 
     if (!preset->load()) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
     }
 
     Q_ASSERT(preset);
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 
 KisPaintOpPresetSP KisPaintopBox::activePreset(const KoID& paintOp)
 {
     if (m_paintOpPresetMap[paintOp] == 0) {
         m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
     }
 
     return m_paintOpPresetMap[paintOp];
 }
 
 void KisPaintopBox::updateCompositeOp(QString compositeOpID)
 {
     if (!m_optionWidget) return;
     KisSignalsBlocker blocker(m_optionWidget);
 
     KisNodeSP node = m_resourceProvider->currentNode();
 
     if (node && node->paintDevice()) {
         if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
             compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
         {
             KisSignalsBlocker b1(m_cmbCompositeOp);
             m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         }
         if (compositeOpID != m_currCompositeOpID) {
             m_currCompositeOpID = compositeOpID;
         }
         if (compositeOpID == COMPOSITE_ERASE || m_resourceProvider->eraserMode()) {
             m_eraseModeButton->setChecked(true);
         }
         else {
             m_eraseModeButton->setChecked(false);
         }
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
 
         if (sliderID == "opacity" || sliderID == "flow") { // opacity and flows UI stored at 0-100%
             slider->setValue(value*100);
         } else {
             slider->setValue(value); // brush size
         }
 
 
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         //qDebug() << "slotsetpaintop" << id;
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
     //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
     m_currTabletToolID = TabletToolID(inputDevice);
 
     if (toolData == m_tabletToolMap.end()) {
         KisConfig cfg(true);
         KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         KisPaintOpPresetSP preset;
         if (inputDevice.pointer() == QTabletEvent::Eraser) {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), m_eraserName));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), m_defaultPresetName));
             //if (preset)
                 //qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
             //else
                 //qDebug() << "no preset found for" << inputDevice.uniqueTabletId();
         }
         if (!preset) {
             preset = rserver->resourceByName(m_defaultPresetName);
         }
         if (preset) {
             //qDebug() << "inputdevicechanged 1" << preset;
             setCurrentPaintop(preset);
         }
     }
     else {
         if (toolData->preset) {
             //qDebug() << "inputdevicechanged 2" << toolData->preset;
             setCurrentPaintop(toolData->preset);
         }
         else {
             //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
             setCurrentPaintop(toolData->paintOpID);
         }
     }
 }
 
 void KisPaintopBox::slotCreatePresetFromScratch(QString paintop)
 {
     //First try to select an available default preset for that engine. If it doesn't exist, then
     //manually set the engine to use a new preset.
     KoID id(paintop, KisPaintOpRegistry::instance()->get(paintop)->name());
     KisPaintOpPresetSP preset = defaultPreset(id);
 
     slotSetPaintop(paintop);  // change the paintop settings area and update the UI
 
     if (!preset) {
         m_presetsPopup->setCreatingBrushFromScratch(true); // disable UI elements while creating from scratch
         preset = m_resourceProvider->currentPreset();
     } else {
         m_resourceProvider->setPaintOpPreset(preset);
         preset->setOptionsWidget(m_optionWidget);
     }
     m_presetsPopup->resourceSelected(preset.data());  // this helps update the UI on the brush editor
 }
 
 void KisPaintopBox::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if (m_viewManager) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_viewManager->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
             QString compositeOp = preset->settings()->getString("CompositeOp");
             updateCompositeOp(compositeOp);
             resourceSelected(preset.data());
         }
 
         /**
          * Update currently selected preset in both the popup widgets
          */
         m_presetsChooserPopup->canvasResourceChanged(preset);
 
         m_presetsPopup->currentPresetChanged(preset);
 
         if (key == KisCanvasResourceProvider::CurrentCompositeOp) {
             if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                 updateCompositeOp(m_resourceProvider->currentCompositeOp());
             }
         }
 
         if (key == KisCanvasResourceProvider::Size) {
             setSliderValue("size", m_resourceProvider->size());
         }
 
         if (key == KisCanvasResourceProvider::Opacity) {
             setSliderValue("opacity", m_resourceProvider->opacity());
         }
 
         if (key == KisCanvasResourceProvider::Flow) {
             setSliderValue("flow", m_resourceProvider->flow());
         }
 
         if (key == KisCanvasResourceProvider::EraserMode) {
             m_eraseAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::DisablePressure) {
             m_disablePressureAction->setChecked(value.toBool());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotUpdatePreset()
 {
     if (!m_resourceProvider->currentPreset()) return;
 
     // block updates of avoid some over updating of the option widget
     m_blockUpdate = true;
 
     setSliderValue("size", m_resourceProvider->size());
 
     {
         qreal opacity = m_resourceProvider->currentPreset()->settings()->paintOpOpacity();
         m_resourceProvider->setOpacity(opacity);
         setSliderValue("opacity", opacity);
         setWidgetState(ENABLE_OPACITY);
     }
 
     {
         setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
         setWidgetState(ENABLE_FLOW);
     }
 
     {
         updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
         setWidgetState(ENABLE_COMPOSITEOP);
     }
 
     m_blockUpdate = false;
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
     preset->setOptionsWidget(m_optionWidget);
     m_resourceProvider->setPaintOpPreset(preset);
 
     // tell the brush editor that the resource has changed
     // so it can update everything
     m_presetsPopup->resourceSelected(preset.data());
 }
 
 void KisPaintopBox::slotNodeChanged(const KisNodeSP node)
 {
     if (m_previousNode.isValid() && m_previousNode->paintDevice())
         disconnect(m_previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
     // Reconnect colorspace change of node
     if (node && node->paintDevice()) {
         connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
         m_previousNode = node;
         slotColorSpaceChanged(node->colorSpace());
     }
 
     if (m_optionWidget) {
         m_optionWidget->setNode(node);
     }
 }
 
 void KisPaintopBox::slotColorSpaceChanged(const KoColorSpace* colorSpace)
 {
     m_cmbCompositeOp->validate(colorSpace);
 }
 
 void KisPaintopBox::slotToggleEraseMode(bool checked)
 {
     const bool oldEraserMode = m_resourceProvider->eraserMode();
     m_resourceProvider->setEraserMode(checked);
 
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
         const qreal currentSize = m_resourceProvider->size();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush size. set the eraser size to the normal brush size if not set
         if (checked) {
             settings->setSavedBrushSize(currentSize);
             if (qFuzzyIsNull(settings->savedEraserSize())) {
                 settings->setSavedEraserSize(currentSize);
             }
         } else {
             settings->setSavedEraserSize(currentSize);
             if (qFuzzyIsNull(settings->savedBrushSize())) {
                 settings->setSavedBrushSize(currentSize);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
         m_resourceProvider->setSize(newSize);
     }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
         const qreal currentOpacity = m_resourceProvider->opacity();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
         if (checked) {
             settings->setSavedBrushOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                 settings->setSavedEraserOpacity(currentOpacity);
             }
         } else {
             settings->setSavedEraserOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                 settings->setSavedBrushOpacity(currentOpacity);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
         m_resourceProvider->setOpacity(newOpacity);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
     QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
     m_resourceProvider->setCurrentCompositeOp(compositeOp);
 }
 
 void KisPaintopBox::slotHorizontalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorHorizontal(value);
 }
 
 void KisPaintopBox::slotVerticalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorVertical(value);
 }
 
 void KisPaintopBox::sliderChanged(int n)
 {
     if (!m_optionWidget) // widget will not exist if the are no documents open
         return;
 
 
     KisSignalsBlocker blocker(m_optionWidget);
 
     // flow and opacity are shown as 0-100% on the UI, but their data is actually 0-1. Convert those two values
     // back for further work
     qreal opacity = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value()/100;
     qreal flow    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value()/100;
     qreal size    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
 
 
     setSliderValue("opacity", opacity);
     setSliderValue("flow"   , flow);
     setSliderValue("size"   , size);
 
     if (m_presetsEnabled) {
         // IMPORTANT: set the PaintOp size before setting the other properties
         //            it wont work the other way
         // TODO: why?!
 
         m_resourceProvider->setSize(size);
         m_resourceProvider->setOpacity(opacity);
         m_resourceProvider->setFlow(flow);
 
 
         KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         m_optionWidget->setConfigurationSafe(m_resourceProvider->currentPreset()->settings().data());
     } else {
         m_resourceProvider->setOpacity(opacity);
     }
 
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 }
 
 void KisPaintopBox::slotSlider1Changed()
 {
     sliderChanged(0);
 }
 
 void KisPaintopBox::slotSlider2Changed()
 {
     sliderChanged(1);
 }
 
 void KisPaintopBox::slotSlider3Changed()
 {
     sliderChanged(2);
 }
 
 void KisPaintopBox::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!m_viewManager->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             setWidgetState(ENABLE_COMPOSITEOP | ENABLE_OPACITY);
         } else                                              {
             setWidgetState(DISABLE_COMPOSITEOP | DISABLE_OPACITY);
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             setWidgetState(ENABLE_PRESETS);
             slotUpdatePreset();
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS);
             m_presetsEnabled = false;
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_SIZE) {
             setWidgetState(ENABLE_SIZE | ENABLE_FLOW);
         } else {
             setWidgetState(DISABLE_SIZE | DISABLE_FLOW);
         }
 
     } else setWidgetState(DISABLE_ALL);
 }
 
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for (int i=0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset() &&
                 m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             //floating message should have least 2 lines, otherwise
             //preset thumbnail will be too small to distinguish
             //(because size of image on floating message depends on amount of lines in msg)
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for(int i = 0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         //qDebug() << "slotSwitchToPreviousPreset();" << m_resourceProvider->previousPreset();
         setCurrentPaintop(m_resourceProvider->previousPreset());
         m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
             QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
     }
 }
 
 void KisPaintopBox::slotUnsetEraseMode()
 {
     m_eraseAction->setChecked(false);
 }
 
 void KisPaintopBox::slotToggleAlphaLockMode(bool checked)
 {
     if (checked) {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-locked"));
     } else {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-unlocked"));
     }
     m_resourceProvider->setGlobalAlphaLock(checked);
 }
 
 void KisPaintopBox::slotDisablePressureMode(bool checked)
 {
     if (checked) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 
     m_resourceProvider->setDisablePressure(checked);
 }
 
 void KisPaintopBox::slotReloadPreset()
 {
     KisSignalsBlocker blocker(m_optionWidget);
 
     //Here using the name and fetching the preset from the server was the only way the load was working. Otherwise it was not loading.
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP preset = rserver->resourceByName(m_resourceProvider->currentPreset()->name());
     if (preset) {
         preset->load();
     }
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         /**
          * Here we postpone all the settings updates events until the entire writing
          * operation will be finished. As soon as it is finished, the updates will be
          * emitted happily (if there were any).
          */
 
         KisPaintOpPreset::UpdatedPostponer postponer(preset.data());
 
 
         QStringList preserveProperties;
         preserveProperties << "lodUserAllowed";
         preserveProperties << "lodSizeThreshold";
 
         // clear all the properties before dumping the stuff into the preset,
         // some of the options add the values incrementally
         // (e.g. KisPaintOpUtils::RequiredBrushFilesListTag), therefore they
         // may add up if we pass the same preset multiple times
         preset->settings()->resetSettings(preserveProperties);
 
         m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(preset->settings().data()));
     }
 
     // we should also update the preset strip to update the status of the "dirty" mark
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 
     // TODO!!!!!!!!
     //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p)
 {
 
     QMapIterator<QString, QVariant> i(p->getProperties());
     while (i.hasNext()) {
         i.next();
         m_resourceProvider->currentPreset()->settings()->setProperty(i.key(), QVariant(i.value()));
         if (m_resourceProvider->currentPreset()->settings()->hasProperty(i.key() + "_previous")) {
             m_resourceProvider->currentPreset()->settings()->removeProperty(i.key() + "_previous");
         }
 
     }
     slotGuiChangedCurrentPreset();
 
 }
 
 void KisPaintopBox::slotDropLockedOption(KisPropertiesConfigurationSP p)
 {
     KisSignalsBlocker blocker(m_optionWidget);
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         KisPaintOpPreset::DirtyStateSaver dirtySaver(preset.data());
 
         QMapIterator<QString, QVariant> i(p->getProperties());
         while (i.hasNext()) {
             i.next();
             if (preset->settings()->hasProperty(i.key() + "_previous")) {
                 preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                 preset->settings()->removeProperty(i.key() + "_previous");
             }
 
         }
     }
 
     //slotUpdatePreset();
 }
 void KisPaintopBox::slotDirtyPresetToggled(bool value)
 {
     if (!value) {
         slotReloadPreset();
         m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
         m_presetsPopup->updateViewSettings();
     }
     m_dirtyPresetsEnabled = value;
     KisConfig cfg(false);
     cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
 
 }
 void KisPaintopBox::slotEraserBrushSizeToggled(bool value)
 {
     m_eraserBrushSizeEnabled = value;
     KisConfig cfg(false);
     cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
 }
 
 void KisPaintopBox::slotEraserBrushOpacityToggled(bool value)
 {
     m_eraserBrushOpacityEnabled = value;
     KisConfig cfg(false);
     cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
 }
 
 void KisPaintopBox::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
     KisConfig cfg(true);
     if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
     }
 
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
 
     m_eraseAction->setIcon(KisIconUtils::loadIcon("draw-eraser"));
     m_reloadAction->setIcon(KisIconUtils::loadIcon("view-refresh"));
 
     if (m_disablePressureAction->isChecked()) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 }
 
 void KisPaintopBox::slotLockXMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorHorizontalLock(toggleLock);
 }
 
 void KisPaintopBox::slotLockYMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorVerticalLock(toggleLock);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorX(bool toggled) {
     m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorY(bool toggled) {
     m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorX() {
   m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorY() {
   m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
 }
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index 3d09bd6223..f66aab4085 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1314 +1,1313 @@
 /*
  *  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 <KoColorSpace.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 <metadata/kis_meta_data_io_backend.h>
 #include <metadata/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"
 
 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 ", 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);
 }
 
 
 KisImageBuilder_Result 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 (KisImageBuilder_RESULT_BAD_FETCH);
     }
 
     // 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 (KisImageBuilder_RESULT_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 (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (KisImageBuilder_RESULT_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 KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     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;
             }
         }
     }
 
     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
             }
         }
     }
     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
     const KoColorSpace* cs;
     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 {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     //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
     KoColorTransformation* transform = 0;
     if (profile && !profile->isSuitableForOutput()) {
         transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     }
 
     // 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 (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 (KisImageBuilder_RESULT_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 (transform) transform->transform(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                 } 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 (transform) transform->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                 } 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 (transform) transform->transform(d, d, 1);
                     if (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                 } 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 KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
     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 KisImageBuilder_RESULT_OK;
 
 }
 
 KisImageBuilder_Result 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 (KisImageBuilder_RESULT_FAILURE);
         }
 
         return buildImage(&fp);
     }
     return (KisImageBuilder_RESULT_NOT_EXIST);
 
 }
 
 
 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());
             KUndo2Command *cmd = dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
             delete cmd;
         }
 
         bool success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (success != KisImageBuilder_RESULT_OK) {
             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;
 
 }
 
 
 KisImageBuilder_Result 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 (KisImageBuilder_RESULT_FAILURE);
     }
 
     KisImageBuilder_Result result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImageBuilder_Result 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)
 {
     if (!device)
         return KisImageBuilder_RESULT_INVALID_ARG;
 
     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) {
         const KoColorSpace *dstcs = KoColorSpaceRegistry::instance()->colorSpace(device->colorSpace()->colorModelId().id(), Integer16BitsColorDepthID.id(), device->colorSpace()->profile());
         KisPaintDeviceSP tmp = new KisPaintDevice(dstcs);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (options.forceSRGB) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         KUndo2Command *cmd = device->convertTo(cs);
         delete cmd;
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (KisImageBuilder_RESULT_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 (KisImageBuilder_RESULT_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 (KisImageBuilder_RESULT_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;
 
     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);
     /*
      * 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);
     }*/
 
 
     // we should ensure we don't access non-existing palette object
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(palette || color_type != PNG_COLOR_TYPE_PALETTE, KisImageBuilder_RESULT_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
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (const png_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (char*)colorProfileData.constData(), 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 KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
 
     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 KisImageBuilder_RESULT_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/kis_selection_manager.cc b/libs/ui/kis_selection_manager.cc
index 22ad36152c..ebdb562892 100644
--- a/libs/ui/kis_selection_manager.cc
+++ b/libs/ui/kis_selection_manager.cc
@@ -1,608 +1,607 @@
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  The outline algorithm uses the limn algorithm of fontutils by
  *  Karl Berry <karl@cs.umb.edu> and Kathryn Hargreaves <letters@cs.umb.edu>
  *
  *  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_manager.h"
 #include <QApplication>
 #include <QClipboard>
 #include <QColor>
 #include <QTimer>
 #include <QMimeData>
 
 #include <QAction>
 #include <ktoggleaction.h>
 #include <klocalizedstring.h>
 #include <kstandardaction.h>
 #include <kactioncollection.h>
 
 #include "KoCanvasController.h"
 #include "KoChannelInfo.h"
 #include "KoIntegerMaths.h"
 #include <KisDocument.h>
 #include <KisMainWindow.h>
 #include <KoViewConverter.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoShapeStroke.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KoToolProxy.h>
 #include <KoSvgPaste.h>
 #include <kis_icon.h>
 
 #include "kis_adjustment_layer.h"
 #include "kis_node_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_config.h"
 #include "kis_convolution_painter.h"
 #include "kis_convolution_kernel.h"
 #include "kis_debug.h"
-#include "KisDocument.h"
 #include "kis_fill_painter.h"
 #include "kis_group_layer.h"
 #include "kis_layer.h"
 #include "kis_statusbar.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_painter.h"
 #include "kis_transaction.h"
 #include "kis_selection.h"
 #include "kis_types.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_undo_adapter.h"
 #include "kis_pixel_selection.h"
 #include "flake/kis_shape_selection.h"
 #include "commands/kis_selection_commands.h"
 #include "kis_selection_mask.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_selection_decoration.h"
 #include "canvas/kis_canvas_decoration.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_iterator_ng.h"
 #include "kis_clipboard.h"
 #include "KisViewManager.h"
 #include "kis_selection_filters.h"
 #include "kis_figure_painting_tool_helper.h"
 #include "KisView.h"
 #include "dialogs/kis_dlg_stroke_selection_properties.h"
 
 #include "actions/kis_selection_action_factories.h"
 #include "actions/KisPasteActionFactory.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "operations/kis_operation_configuration.h"
 //new
 #include "kis_node_query_path.h"
 #include "kis_tool_shape.h"
 
 KisSelectionManager::KisSelectionManager(KisViewManager * view)
         : m_view(view),
           m_doc(0),
           m_imageView(0),
           m_adapter(new KisNodeCommandsAdapter(view)),
           m_copy(0),
           m_copyMerged(0),
           m_cut(0),
           m_paste(0),
           m_pasteNew(0),
           m_cutToNewLayer(0),
           m_selectAll(0),
           m_deselect(0),
           m_clear(0),
           m_reselect(0),
           m_invert(0),
           m_copyToNewLayer(0),
           m_fillForegroundColor(0),
           m_fillBackgroundColor(0),
           m_fillPattern(0),
           m_imageResizeToSelection(0),
           m_selectionDecoration(0)
 {
     m_clipboard = KisClipboard::instance();
 }
 
 KisSelectionManager::~KisSelectionManager()
 {
 }
 
 void KisSelectionManager::setup(KisActionManager* actionManager)
 {
     m_cut = actionManager->createStandardAction(KStandardAction::Cut, this, SLOT(cut()));
     m_copy = actionManager->createStandardAction(KStandardAction::Copy, this, SLOT(copy()));
     m_paste = actionManager->createStandardAction(KStandardAction::Paste, this, SLOT(paste()));
 
     KisAction *action = actionManager->createAction("copy_sharp");
     connect(action, SIGNAL(triggered()), this, SLOT(copySharp()));
 
     action = actionManager->createAction("cut_sharp");
     connect(action, SIGNAL(triggered()), this, SLOT(cutSharp()));
 
     m_pasteNew = actionManager->createAction("paste_new");
     connect(m_pasteNew, SIGNAL(triggered()), this, SLOT(pasteNew()));
 
     m_pasteAt = actionManager->createAction("paste_at");
     connect(m_pasteAt, SIGNAL(triggered()), this, SLOT(pasteAt()));
 
     m_copyMerged = actionManager->createAction("copy_merged");
     connect(m_copyMerged, SIGNAL(triggered()), this, SLOT(copyMerged()));
 
     m_selectAll = actionManager->createAction("select_all");
     connect(m_selectAll, SIGNAL(triggered()), this, SLOT(selectAll()));
 
     m_deselect = actionManager->createAction("deselect");
     connect(m_deselect, SIGNAL(triggered()), this, SLOT(deselect()));
 
     m_clear = actionManager->createAction("clear");
     connect(m_clear, SIGNAL(triggered()), SLOT(clear()));
 
     m_reselect = actionManager->createAction("reselect");
     connect(m_reselect, SIGNAL(triggered()), this, SLOT(reselect()));
 
     m_invert = actionManager->createAction("invert_selection");
     m_invert->setOperationID("invertselection");
 
     actionManager->registerOperation(new KisInvertSelectionOperation);
 
     m_copyToNewLayer = actionManager->createAction("copy_selection_to_new_layer");
     connect(m_copyToNewLayer, SIGNAL(triggered()), this, SLOT(copySelectionToNewLayer()));
 
     m_cutToNewLayer = actionManager->createAction("cut_selection_to_new_layer");
     connect(m_cutToNewLayer, SIGNAL(triggered()), this, SLOT(cutToNewLayer()));
 
     m_fillForegroundColor = actionManager->createAction("fill_selection_foreground_color");
     connect(m_fillForegroundColor, SIGNAL(triggered()), this, SLOT(fillForegroundColor()));
 
     m_fillBackgroundColor  = actionManager->createAction("fill_selection_background_color");
     connect(m_fillBackgroundColor, SIGNAL(triggered()), this, SLOT(fillBackgroundColor()));
 
     m_fillPattern = actionManager->createAction("fill_selection_pattern");
     connect(m_fillPattern, SIGNAL(triggered()), this, SLOT(fillPattern()));
 
     m_fillForegroundColorOpacity  = actionManager->createAction("fill_selection_foreground_color_opacity");
     connect(m_fillForegroundColorOpacity, SIGNAL(triggered()), this, SLOT(fillForegroundColorOpacity()));
 
     m_fillBackgroundColorOpacity  = actionManager->createAction("fill_selection_background_color_opacity");
     connect(m_fillBackgroundColorOpacity, SIGNAL(triggered()), this, SLOT(fillBackgroundColorOpacity()));
 
     m_fillPatternOpacity  = actionManager->createAction("fill_selection_pattern_opacity");
     connect(m_fillPatternOpacity, SIGNAL(triggered()), this, SLOT(fillPatternOpacity()));
 
     m_strokeShapes  = actionManager->createAction("stroke_shapes");
     connect(m_strokeShapes, SIGNAL(triggered()), this, SLOT(paintSelectedShapes()));
 
     m_toggleDisplaySelection  = actionManager->createAction("toggle_display_selection");
     connect(m_toggleDisplaySelection, SIGNAL(triggered()), this, SLOT(toggleDisplaySelection()));
     m_toggleDisplaySelection->setChecked(true);
 
     m_imageResizeToSelection  = actionManager->createAction("resizeimagetoselection");
     connect(m_imageResizeToSelection, SIGNAL(triggered()), this, SLOT(imageResizeToSelection()));
 
     action = actionManager->createAction("convert_to_vector_selection");
     connect(action, SIGNAL(triggered()), SLOT(convertToVectorSelection()));
 
     action = actionManager->createAction("convert_shapes_to_vector_selection");
     connect(action, SIGNAL(triggered()), SLOT(convertShapesToVectorSelection()));
 
     action = actionManager->createAction("convert_selection_to_shape");
     connect(action, SIGNAL(triggered()), SLOT(convertToShape()));
 
     m_toggleSelectionOverlayMode  = actionManager->createAction("toggle-selection-overlay-mode");
     connect(m_toggleSelectionOverlayMode, SIGNAL(triggered()), SLOT(slotToggleSelectionDecoration()));
 
     m_strokeSelected = actionManager->createAction("stroke_selection");
     connect(m_strokeSelected, SIGNAL(triggered()), SLOT(slotStrokeSelection()));
 
     QClipboard *cb = QApplication::clipboard();
     connect(cb, SIGNAL(dataChanged()), SLOT(clipboardDataChanged()));
 }
 
 
 void KisSelectionManager::setView(QPointer<KisView>imageView)
 {
     if (m_imageView && m_imageView->canvasBase()) {
         disconnect(m_imageView->canvasBase()->toolProxy(), SIGNAL(toolChanged(const QString&)), this, SLOT(clipboardDataChanged()));
 
         KoSelection *selection = m_imageView->canvasBase()->globalShapeManager()->selection();
         selection->disconnect(this, SLOT(shapeSelectionChanged()));
         KisSelectionDecoration *decoration = qobject_cast<KisSelectionDecoration*>(m_imageView->canvasBase()->decoration("selection").data());
         if (decoration) {
             disconnect(SIGNAL(currentSelectionChanged()), decoration);
         }
         m_imageView->image()->undoAdapter()->disconnect(this);
         m_selectionDecoration = 0;
     }
 
     m_imageView = imageView;
     if (m_imageView) {
         connect(m_imageView->canvasBase()->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(shapeSelectionChanged()));
 
         KisSelectionDecoration* decoration = qobject_cast<KisSelectionDecoration*>(m_imageView->canvasBase()->decoration("selection").data());
         if (!decoration) {
             decoration = new KisSelectionDecoration(m_imageView);
             decoration->setVisible(true);
             m_imageView->canvasBase()->addDecoration(decoration);
         }
         m_selectionDecoration = decoration;
         connect(this, SIGNAL(currentSelectionChanged()), decoration, SLOT(selectionChanged()));
         connect(m_imageView->image()->undoAdapter(), SIGNAL(selectionChanged()), SLOT(selectionChanged()));
         connect(m_imageView->canvasBase()->toolProxy(), SIGNAL(toolChanged(const QString&)), SLOT(clipboardDataChanged()));
 
     }
 }
 
 
 void KisSelectionManager::clipboardDataChanged()
 {
     m_view->updateGUI();
 }
 
 bool KisSelectionManager::havePixelsSelected()
 {
     KisSelectionSP activeSelection = m_view->selection();
     return activeSelection && !activeSelection->selectedRect().isEmpty();
 }
 
 bool KisSelectionManager::havePixelsInClipboard()
 {
     return m_clipboard->hasClip();
 }
 
 bool KisSelectionManager::haveShapesSelected()
 {
     if (m_view && m_view->canvasBase()) {
         return m_view->canvasBase()->selectedShapesProxy()->selection()->count() > 0;
     }
     return false;
 }
 
 bool KisSelectionManager::haveShapesInClipboard()
 {
     KoSvgPaste paste;
     return paste.hasShapes();
 }
 
 bool KisSelectionManager::havePixelSelectionWithPixels()
 {
     KisSelectionSP selection = m_view->selection();
     if (selection && selection->hasPixelSelection()) {
         return !selection->pixelSelection()->selectedRect().isEmpty();
     }
     return false;
 }
 
 void KisSelectionManager::updateGUI()
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_clipboard);
     if (!m_view || !m_clipboard) return;
 
     bool havePixelsSelected = this->havePixelsSelected();
     bool havePixelsInClipboard = this->havePixelsInClipboard();
     bool haveShapesSelected = this->haveShapesSelected();
     bool haveShapesInClipboard = this->haveShapesInClipboard();
     bool haveDevice = m_view->activeDevice();
 
     KisLayerSP activeLayer = m_view->activeLayer();
     KisImageWSP image = activeLayer ? activeLayer->image() : 0;
     bool canReselect = image && image->canReselectGlobalSelection();
     bool canDeselect =  image && image->globalSelection();
 
     m_clear->setEnabled(haveDevice || havePixelsSelected || haveShapesSelected);
     m_cut->setEnabled(havePixelsSelected || haveShapesSelected);
     m_copy->setEnabled(havePixelsSelected || haveShapesSelected);
     m_paste->setEnabled(havePixelsInClipboard || haveShapesInClipboard);
     m_pasteAt->setEnabled(havePixelsInClipboard || haveShapesInClipboard);
     // FIXME: how about pasting shapes?
     m_pasteNew->setEnabled(havePixelsInClipboard);
 
     m_selectAll->setEnabled(true);
     m_deselect->setEnabled(canDeselect);
     m_reselect->setEnabled(canReselect);
 
 //    m_load->setEnabled(true);
 //    m_save->setEnabled(havePixelsSelected);
 
     updateStatusBar();
     emit signalUpdateGUI();
 }
 
 void KisSelectionManager::updateStatusBar()
 {
     if (m_view && m_view->statusBar()) {
         m_view->statusBar()->setSelection(m_view->image());
     }
 }
 
 void KisSelectionManager::selectionChanged()
 {
     m_view->updateGUI();
     emit currentSelectionChanged();
 }
 
 void KisSelectionManager::cut()
 {
     KisCutCopyActionFactory factory;
     factory.run(true, false, m_view);
 }
 
 void KisSelectionManager::copy()
 {
     KisCutCopyActionFactory factory;
     factory.run(false, false, m_view);
 }
 
 void KisSelectionManager::cutSharp()
 {
     KisCutCopyActionFactory factory;
     factory.run(true, true, m_view);
 }
 
 void KisSelectionManager::copySharp()
 {
     KisCutCopyActionFactory factory;
     factory.run(false, true, m_view);
 }
 
 void KisSelectionManager::copyMerged()
 {
     KisCopyMergedActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::paste()
 {
     KisPasteActionFactory factory;
     factory.run(false, m_view);
 }
 
 void KisSelectionManager::pasteAt()
 {
     KisPasteActionFactory factory;
     factory.run(true, m_view);
 }
 
 void KisSelectionManager::pasteNew()
 {
     KisPasteNewActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::selectAll()
 {
     KisSelectAllActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::deselect()
 {
     KisDeselectActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::invert()
 {
     if(m_invert)
         m_invert->trigger();
 }
 
 void KisSelectionManager::reselect()
 {
     KisReselectActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::convertToVectorSelection()
 {
     KisSelectionToVectorActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::convertShapesToVectorSelection()
 {
     KisShapesToVectorSelectionActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::convertToShape()
 {
     KisSelectionToShapeActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::clear()
 {
     KisClearActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::fillForegroundColor()
 {
     KisFillActionFactory  factory;
     factory.run("fg", m_view);
 }
 
 void KisSelectionManager::fillBackgroundColor()
 {
     KisFillActionFactory factory;
     factory.run("bg", m_view);
 }
 
 void KisSelectionManager::fillPattern()
 {
     KisFillActionFactory factory;
     factory.run("pattern", m_view);
 }
 
 void KisSelectionManager::fillForegroundColorOpacity()
 {
     KisFillActionFactory  factory;
     factory.run("fg_opacity", m_view);
 }
 
 void KisSelectionManager::fillBackgroundColorOpacity()
 {
     KisFillActionFactory factory;
     factory.run("bg_opacity", m_view);
 }
 
 void KisSelectionManager::fillPatternOpacity()
 {
     KisFillActionFactory factory;
     factory.run("pattern_opacity", m_view);
 }
 
 void KisSelectionManager::copySelectionToNewLayer()
 {
     copy();
     paste();
 }
 
 void KisSelectionManager::cutToNewLayer()
 {
     cut();
     paste();
 }
 
 void KisSelectionManager::toggleDisplaySelection()
 {
     KIS_ASSERT_RECOVER_RETURN(m_selectionDecoration);
 
     m_selectionDecoration->toggleVisibility();
     m_toggleDisplaySelection->blockSignals(true);
     m_toggleDisplaySelection->setChecked(m_selectionDecoration->visible());
     m_toggleDisplaySelection->blockSignals(false);
 
     emit displaySelectionChanged();
 }
 
 bool KisSelectionManager::displaySelection()
 {
     return m_toggleDisplaySelection->isChecked();
 }
 
 void KisSelectionManager::shapeSelectionChanged()
 {
     KoShapeManager* shapeManager = m_view->canvasBase()->globalShapeManager();
 
     KoSelection * selection = shapeManager->selection();
     QList<KoShape*> selectedShapes = selection->selectedShapes();
 
     KoShapeStrokeSP border(new KoShapeStroke(0, Qt::lightGray));
     Q_FOREACH (KoShape* shape, shapeManager->shapes()) {
         if (dynamic_cast<KisShapeSelection*>(shape->parent())) {
             if (selectedShapes.contains(shape))
                 shape->setStroke(border);
             else
                 shape->setStroke(KoShapeStrokeSP());
         }
     }
     m_view->updateGUI();
 }
 
 void KisSelectionManager::imageResizeToSelection()
 {
     KisImageResizeToSelectionActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::paintSelectedShapes()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = m_view->activeLayer();
     if (!layer) return;
 
     QList<KoShape*> shapes = m_view->canvasBase()->shapeManager()->selection()->selectedShapes();
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, i18n("Stroked Shapes"), OPACITY_OPAQUE_U8);
 
     KUndo2MagicString actionName = kundo2_i18n("Stroke Shapes");
 
     m_adapter->beginMacro(actionName);
     m_adapter->addNode(paintLayer.data(), layer->parent().data(), layer.data());
 
     KisFigurePaintingToolHelper helper(actionName,
                                        image,
                                        paintLayer.data(),
                                        m_view->resourceProvider()->resourceManager(),
                                        KisPainter::StrokeStyleBrush,
                                        KisPainter::FillStyleNone);
 
     Q_FOREACH (KoShape* shape, shapes) {
         QTransform matrix = shape->absoluteTransformation(0) * QTransform::fromScale(image->xRes(), image->yRes());
         QPainterPath mapedOutline = matrix.map(shape->outline());
         helper.paintPainterPath(mapedOutline);
     }
     m_adapter->endMacro();
 }
 
 void KisSelectionManager::slotToggleSelectionDecoration()
 {
     KIS_ASSERT_RECOVER_RETURN(m_selectionDecoration);
 
     KisSelectionDecoration::Mode mode =
         m_selectionDecoration->mode() ?
         KisSelectionDecoration::Ants : KisSelectionDecoration::Mask;
 
     m_selectionDecoration->setMode(mode);
     emit displaySelectionChanged();
 }
 
 bool KisSelectionManager::showSelectionAsMask() const
 {
     if (m_selectionDecoration) {
         return m_selectionDecoration->mode() == KisSelectionDecoration::Mask;
     }
     return false;
 }
 void KisSelectionManager::slotStrokeSelection()
 {
     KisImageWSP image = m_view->image();
 
     if (!image )     {
 
         return;
     }
     KisNodeSP currentNode = m_view->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     bool isVectorLayer = false;
     if (currentNode->inherits("KisShapeLayer")) {
         isVectorLayer = true;
     }
 
     QPointer<KisDlgStrokeSelection> dlg = new KisDlgStrokeSelection(image, m_view, isVectorLayer);
 
     if (dlg->exec() == QDialog::Accepted) {
         StrokeSelectionOptions params = dlg->getParams();
         if (params.brushSelected){
             KisStrokeBrushSelectionActionFactory factory;
             factory.run(m_view, params);
         }
         else {
             KisStrokeSelectionActionFactory factory;
             factory.run(m_view, params);
         }
     }
     delete dlg;
 
 
 }
diff --git a/libs/ui/kis_tooltip_manager.cpp b/libs/ui/kis_tooltip_manager.cpp
index 1c99269fed..1bc93e3db3 100644
--- a/libs/ui/kis_tooltip_manager.cpp
+++ b/libs/ui/kis_tooltip_manager.cpp
@@ -1,100 +1,99 @@
 /*
  *  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.1 of the License.
  *
  *  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 "kis_tooltip_manager.h"
 
 #include <QFile>
 #include <QAction>
 #include <QInputDialog>
 #include <QDomDocument>
-#include <QFile>
 #include <QMenuBar>
 #include <kactioncollection.h>
 #include <kis_debug.h>
 
 #include <KisMainWindow.h>
 #include "KisViewManager.h"
 
 KisTooltipManager::KisTooltipManager(KisViewManager* view) : QObject(view), m_view(view), m_recording(false)
 {
     m_view->mainWindow()->menuBar()->installEventFilter(this);
 }
 
 KisTooltipManager::~KisTooltipManager()
 {
     if (m_recording) {
         QFile f("tooltips.txt");
         f.open(QFile::WriteOnly);
 
         QDomDocument doc;
         QDomElement root;
 
         root = doc.createElement("tooltips");
         doc.appendChild(root);
 
 
         QMapIterator<QString, QString> it(m_tooltipMap);
         while (it.hasNext()) {
             it.next();
             QDomElement tooltip = doc.createElement("tooltip");
             tooltip.setAttribute("action", it.key());
             tooltip.appendChild(doc.createTextNode(it.value()));
             root.appendChild(tooltip);
         }
         QTextStream stream(&f);
         stream.setCodec("UTF-8");
         stream << doc.toString();
 
         f.close();
     }
 }
 
 void KisTooltipManager::record()
 {
     m_recording = true;
     QList<QAction*> actions =  m_view->actionCollection()->actions();
     Q_FOREACH (KXMLGUIClient* client, m_view->mainWindow()->childClients() ) {
         actions.append(client->actionCollection()->actions());
     }
 
     Q_FOREACH (QAction* action, actions) {
         action->disconnect();
         connect(action, SIGNAL(triggered()), this, SLOT(captureToolip()));
     }
 }
 
 void KisTooltipManager::captureToolip()
 {
     QString id = sender()->objectName();
 
     QString oldTooltip;
     if (m_tooltipMap.contains(id)) {
         oldTooltip = m_tooltipMap[id];
     }
 
     bool ok;
     QString tooltip = QInputDialog::getText(m_view->mainWindow(), "Add Tooltip",
                                             "New Tooltip:", QLineEdit::Normal,
                                             oldTooltip, &ok);
     if (ok && !tooltip.isEmpty()) {
         dynamic_cast<QAction*>(sender())->setToolTip(tooltip);
         m_tooltipMap[id] = tooltip;
     }
 }
 
 
diff --git a/libs/ui/kis_zoom_manager.cc b/libs/ui/kis_zoom_manager.cc
index b937646347..baa6e02b73 100644
--- a/libs/ui/kis_zoom_manager.cc
+++ b/libs/ui/kis_zoom_manager.cc
@@ -1,365 +1,364 @@
 /*
  *  Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (C) 2009 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_zoom_manager.h"
 
 
 #include <QGridLayout>
 
 #include <kactioncollection.h>
 #include <ktoggleaction.h>
-#include <ktoggleaction.h>
 #include <kis_debug.h>
 
 #include <KisView.h>
 #include <KoZoomAction.h>
 #include <KoRuler.h>
 #include <KoZoomHandler.h>
 #include <KoZoomController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoUnit.h>
 #include <KoDpi.h>
 
 #include "KisDocument.h"
 #include "KisViewManager.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_coordinates_converter.h"
 #include "kis_image.h"
 #include "kis_statusbar.h"
 #include "kis_config.h"
 #include "krita_utils.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_lod_transform.h"
 #include "kis_snap_line_strategy.h"
 #include "kis_guides_config.h"
 #include "kis_guides_manager.h"
 
 
 class KisZoomController : public KoZoomController
 {
 public:
     KisZoomController(KoCanvasController *co, KisCoordinatesConverter *zh, KActionCollection *actionCollection, QObject *parent)
         : KoZoomController(co, zh, actionCollection, parent),
           m_converter(zh)
     {
     }
 
 protected:
     QSize documentToViewport(const QSizeF &size) override {
         QRectF docRect(QPointF(), size);
         return m_converter->documentToWidget(docRect).toRect().size();
     }
 
 private:
     KisCoordinatesConverter *m_converter;
 };
 
 
 KisZoomManager::KisZoomManager(QPointer<KisView> view, KoZoomHandler * zoomHandler,
                                KoCanvasController * canvasController)
         : m_view(view)
         , m_zoomHandler(zoomHandler)
         , m_canvasController(canvasController)
         , m_horizontalRuler(0)
         , m_verticalRuler(0)
         , m_zoomAction(0)
         , m_zoomActionWidget(0)
 {
 }
 
 KisZoomManager::~KisZoomManager()
 {
     if (m_zoomActionWidget && !m_zoomActionWidget->parent()) {
         delete m_zoomActionWidget;
     }
 }
 
 void KisZoomManager::setup(KActionCollection * actionCollection)
 {
 
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     connect(image, SIGNAL(sigSizeChanged(const QPointF &, const QPointF &)), this, SLOT(setMinMaxZoom()));
 
     KisCoordinatesConverter *converter =
         dynamic_cast<KisCoordinatesConverter*>(m_zoomHandler);
 
     m_zoomController = new KisZoomController(m_canvasController, converter, actionCollection, this);
     m_zoomHandler->setZoomMode(KoZoomMode::ZOOM_PIXELS);
     m_zoomHandler->setZoom(1.0);
 
     m_zoomController->setPageSize(QSizeF(image->width() / image->xRes(), image->height() / image->yRes()));
     m_zoomController->setDocumentSize(QSizeF(image->width() / image->xRes(), image->height() / image->yRes()), true);
 
     m_zoomAction = m_zoomController->zoomAction();
 
     setMinMaxZoom();
 
     m_zoomActionWidget = m_zoomAction->createWidget(0);
 
 
     // Put the canvascontroller in a layout so it resizes with us
     QGridLayout * layout = new QGridLayout(m_view);
     layout->setSpacing(0);
     layout->setMargin(0);
     m_view->setLayout(layout);
 
     m_view->document()->setUnit(KoUnit(KoUnit::Pixel));
 
     m_horizontalRuler = new KoRuler(m_view, Qt::Horizontal, m_zoomHandler);
     m_horizontalRuler->setShowMousePosition(true);
     m_horizontalRuler->createGuideToolConnection(m_view->canvasBase());
     m_horizontalRuler->setVisible(false); // this prevents the rulers from flashing on to off when a new document is created
 
     m_verticalRuler = new KoRuler(m_view, Qt::Vertical, m_zoomHandler);
     m_verticalRuler->setShowMousePosition(true);
     m_verticalRuler->createGuideToolConnection(m_view->canvasBase());
     m_verticalRuler->setVisible(false);
 
 
     QAction *rulerAction = actionCollection->action("ruler_pixel_multiple2");
     if (m_view->document()->guidesConfig().rulersMultiple2()) {
         m_horizontalRuler->setUnitPixelMultiple2(true);
         m_verticalRuler->setUnitPixelMultiple2(true);
     }
     QList<QAction*> unitActions = m_view->createChangeUnitActions(true);
     unitActions.append(rulerAction);
     m_horizontalRuler->setPopupActionList(unitActions);
     m_verticalRuler->setPopupActionList(unitActions);
 
     connect(m_view->document(), SIGNAL(unitChanged(const KoUnit&)), SLOT(applyRulersUnit(const KoUnit&)));
     connect(rulerAction, SIGNAL(toggled(bool)), SLOT(setRulersPixelMultiple2(bool)));
 
     layout->addWidget(m_horizontalRuler, 0, 1);
     layout->addWidget(m_verticalRuler, 1, 0);
     layout->addWidget(static_cast<KoCanvasControllerWidget*>(m_canvasController), 1, 1);
 
     connect(m_canvasController->proxyObject, SIGNAL(canvasOffsetXChanged(int)),
             this, SLOT(pageOffsetChanged()));
 
     connect(m_canvasController->proxyObject, SIGNAL(canvasOffsetYChanged(int)),
             this, SLOT(pageOffsetChanged()));
 
     connect(m_zoomController, SIGNAL(zoomChanged(KoZoomMode::Mode, qreal)),
             this, SLOT(slotZoomChanged(KoZoomMode::Mode, qreal)));
 
     connect(m_zoomController, SIGNAL(aspectModeChanged(bool)),
             this, SLOT(changeAspectMode(bool)));
 
     applyRulersUnit(m_view->document()->unit());
 }
 
 void KisZoomManager::updateImageBoundsSnapping()
 {
     const QRectF docRect = m_view->canvasBase()->coordinatesConverter()->imageRectInDocumentPixels();
     const QPointF docCenter = docRect.center();
 
     KoSnapGuide *snapGuide = m_view->canvasBase()->snapGuide();
 
     {
         KisSnapLineStrategy *boundsSnap =
             new KisSnapLineStrategy(KoSnapGuide::DocumentBoundsSnapping);
 
         boundsSnap->addLine(Qt::Horizontal, docRect.y());
         boundsSnap->addLine(Qt::Horizontal, docRect.bottom());
         boundsSnap->addLine(Qt::Vertical, docRect.x());
         boundsSnap->addLine(Qt::Vertical, docRect.right());
 
         snapGuide->overrideSnapStrategy(KoSnapGuide::DocumentBoundsSnapping, boundsSnap);
     }
 
     {
         KisSnapLineStrategy *centerSnap =
             new KisSnapLineStrategy(KoSnapGuide::DocumentCenterSnapping);
 
         centerSnap->addLine(Qt::Horizontal, docCenter.y());
         centerSnap->addLine(Qt::Vertical, docCenter.x());
 
         snapGuide->overrideSnapStrategy(KoSnapGuide::DocumentCenterSnapping, centerSnap);
     }
 }
 
 void KisZoomManager::updateMouseTrackingConnections()
 {
     bool value = m_horizontalRuler->isVisible() &&
         m_verticalRuler->isVisible() &&
         m_horizontalRuler->showMousePosition() &&
         m_verticalRuler->showMousePosition();
 
     m_mouseTrackingConnections.clear();
 
     if (value) {
         connect(m_canvasController->proxyObject,
                 SIGNAL(canvasMousePositionChanged(const QPoint &)),
                 SLOT(mousePositionChanged(const QPoint &)));
 
     }
 }
 
 KoRuler* KisZoomManager::horizontalRuler() const
 {
     return m_horizontalRuler;
 }
 
 KoRuler* KisZoomManager::verticalRuler() const
 {
     return m_verticalRuler;
 }
 
 qreal KisZoomManager::zoom() const
 {
     qreal zoomX;
     qreal zoomY;
     m_zoomHandler->zoom(&zoomX, &zoomY);
     qDebug() << zoomX << zoomY;
     return zoomX;
 }
 
 void KisZoomManager::mousePositionChanged(const QPoint &viewPos)
 {
     QPoint pt = viewPos - m_rulersOffset;
 
     m_horizontalRuler->updateMouseCoordinate(pt.x());
     m_verticalRuler->updateMouseCoordinate(pt.y());
 }
 
 void KisZoomManager::setShowRulers(bool show)
 {
     m_horizontalRuler->setVisible(show);
     m_verticalRuler->setVisible(show);
     updateMouseTrackingConnections();
 }
 
 void KisZoomManager::setRulersTrackMouse(bool value)
 {
     m_horizontalRuler->setShowMousePosition(value);
     m_verticalRuler->setShowMousePosition(value);
     updateMouseTrackingConnections();
 }
 
 void KisZoomManager::applyRulersUnit(const KoUnit &baseUnit)
 {
     if (m_view && m_view->image()) {
         m_horizontalRuler->setUnit(KoUnit(baseUnit.type(), m_view->image()->xRes()));
         m_verticalRuler->setUnit(KoUnit(baseUnit.type(), m_view->image()->yRes()));
     }
     if (m_view->viewManager()) {
         m_view->viewManager()->guidesManager()->setUnitType(baseUnit.type());
     }
 }
 
 void KisZoomManager::setRulersPixelMultiple2(bool enabled)
 {
     m_horizontalRuler->setUnitPixelMultiple2(enabled);
     m_verticalRuler->setUnitPixelMultiple2(enabled);
     if (m_view->viewManager()) {
         m_view->viewManager()->guidesManager()->setRulersMultiple2(enabled);
     }
 }
 
 void KisZoomManager::setMinMaxZoom()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     QSize imageSize = image->size();
     qreal minDimension = qMin(imageSize.width(), imageSize.height());
     qreal minZoom = qMin(100.0 / minDimension, 0.1);
 
     m_zoomAction->setMinimumZoom(minZoom);
     m_zoomAction->setMaximumZoom(90.0);
 
 }
 
 void KisZoomManager::updateGUI()
 {
     QRectF widgetRect = m_view->canvasBase()->coordinatesConverter()->imageRectInWidgetPixels();
     QSize documentSize = m_view->canvasBase()->viewConverter()->viewToDocument(widgetRect).toAlignedRect().size();
 
     m_horizontalRuler->setRulerLength(documentSize.width());
     m_verticalRuler->setRulerLength(documentSize.height());
 
     applyRulersUnit(m_horizontalRuler->unit());
 }
 
 QWidget *KisZoomManager::zoomActionWidget() const
 {
     return m_zoomActionWidget;
 }
 
 void KisZoomManager::slotZoomChanged(KoZoomMode::Mode mode, qreal zoom)
 {
     Q_UNUSED(mode);
     Q_UNUSED(zoom);
     m_view->canvasBase()->notifyZoomChanged();
 
     qreal humanZoom = zoom * 100.0;
 
 // XXX: KOMVC -- this is very irritating in MDI mode
 
     if (m_view->viewManager()) {
         m_view->viewManager()->
                 showFloatingMessage(
                     i18nc("floating message about zoom", "Zoom: %1 %",
                           KritaUtils::prettyFormatReal(humanZoom)),
                     QIcon(), 500, KisFloatingMessage::Low, Qt::AlignCenter);
     }
 
     const qreal effectiveZoom =
         m_view->canvasBase()->coordinatesConverter()->effectiveZoom();
 
     m_view->canvasBase()->resourceManager()->setResource(KisCanvasResourceProvider::EffectiveZoom, effectiveZoom);
 }
 
 void KisZoomManager::slotScrollAreaSizeChanged()
 {
     pageOffsetChanged();
     updateGUI();
 }
 
 void KisZoomManager::changeAspectMode(bool aspectMode)
 {
     KisImageWSP image = m_view->image();
 
     KoZoomMode::Mode newMode = KoZoomMode::ZOOM_CONSTANT;
     qreal newZoom = m_zoomHandler->zoom();
 
     qreal resolutionX = aspectMode ? image->xRes() : POINT_TO_INCH(static_cast<qreal>(KoDpi::dpiX()));
     qreal resolutionY = aspectMode ? image->yRes() : POINT_TO_INCH(static_cast<qreal>(KoDpi::dpiY()));
 
     m_zoomController->setZoom(newMode, newZoom, resolutionX, resolutionY);
     m_view->canvasBase()->notifyZoomChanged();
 }
 
 
 void KisZoomManager::pageOffsetChanged()
 {
     QRectF widgetRect = m_view->canvasBase()->coordinatesConverter()->imageRectInWidgetPixels();
     m_rulersOffset = widgetRect.topLeft().toPoint();
 
     m_horizontalRuler->setOffset(m_rulersOffset.x());
     m_verticalRuler->setOffset(m_rulersOffset.y());
 }
 
 void KisZoomManager::zoomTo100()
 {
     m_zoomController->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
     m_view->canvasBase()->notifyZoomChanged();
 }
diff --git a/libs/ui/tests/ResourceBundleTest.cpp b/libs/ui/tests/ResourceBundleTest.cpp
index 319047d5b7..f914705022 100644
--- a/libs/ui/tests/ResourceBundleTest.cpp
+++ b/libs/ui/tests/ResourceBundleTest.cpp
@@ -1,179 +1,177 @@
 /*
  *  Copyright (c) 2014 Victor Lafon metabolic.ewilan@hotmail.fr
  *
  * 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 <QTest>
 #include <QFile>
 #include <QDate>
 
 #include <KoResourceServerProvider.h>
 
 #include <KisResourceServerProvider.h>
 #include "kis_workspace_resource.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "kis_brush_server.h"
 
 #include "ResourceBundleTest.h"
 #include "KisResourceBundle.h"
 
-#include <QTest>
-
 void ResourceBundleTest::testCreateBundle()
 {
     QString testbundle = QString(FILES_DATA_DIR) + "/" + "testcreatebundle.bundle";
     KisResourceBundle bundle(testbundle);
     QVERIFY(!bundle.isInstalled());
     QVERIFY(!bundle.valid());
     QVERIFY(bundle.getTagsList().isEmpty());
     QVERIFY(bundle.filename() == QString(FILES_DATA_DIR) + "/" + "testcreatebundle.bundle");
     QCOMPARE(bundle.shortFilename(), QString("testcreatebundle.bundle"));
     QCOMPARE(bundle.name(), QString("testcreatebundle"));
     QCOMPARE(bundle.defaultFileExtension(), QString(".bundle"));
 
     bundle.addMeta("author", "TestAuthor");
     QCOMPARE(bundle.getMeta("author"), QString("TestAuthor"));
 
     bundle.addMeta("email", "TestEmail");
     QCOMPARE(bundle.getMeta("email"), QString("TestEmail"));
 
     bundle.addMeta("license", "TestLicense");
     QCOMPARE(bundle.getMeta("license"), QString("TestLicense"));
 
     bundle.addMeta("website", "TestWebsite");
     QCOMPARE(bundle.getMeta("website"), QString("TestWebsite"));
 
     bundle.addMeta("created", "TestCreated");
     QCOMPARE(bundle.getMeta("created"), QString("TestCreated"));
 
     bundle.addMeta("updated", "TestUpdated");
     QCOMPARE(bundle.getMeta("updated"), QString("TestUpdated"));
 
     bundle.addMeta("description", "Test Description");
     QCOMPARE(bundle.getMeta("description"), QString("Test Description"));
 
     QVERIFY(bundle.getTagsList().isEmpty());
 }
 
 
 void ResourceBundleTest::testLoadSave()
 {
     KisResourceBundle bundle(QString(FILES_OUTPUT_DIR) + "/" + "testloadsavebundle.bundle");
     bundle.addMeta("author", "TestAuthor");
     bundle.addMeta("email", "TestEmail");
     bundle.addMeta("license", "TestLicense");
     bundle.addMeta("website", "TestWebsite");
     bundle.addMeta("created", "TestCreated");
     bundle.addMeta("updated", "TestUpdated");
     bundle.addMeta("description", "Test Description");
     bundle.setThumbnail(QString(FILES_DATA_DIR) + "/" + "thumb.png");
 
     int tagCount = 0;
 
     KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
     gradientServer->loadResources(gradientServer->fileNames());
     QVERIFY(gradientServer->resourceCount() > 0);
     Q_FOREACH (KoAbstractGradient* gradient, gradientServer->resources()) {
         if (gradient->name() == "Foreground to Transparent" || gradient->name() == "Foreground to Background") continue;
         gradientServer->addTag(gradient, QString("testtag: %1").arg(tagCount));
         tagCount++;
         bundle.addResource(gradientServer->type(), gradient->filename(), gradientServer->assignedTagsList(gradient), gradient->md5());
     }
 
     KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
     QVERIFY(patternServer->resourceCount() > 0);
     Q_FOREACH (KoPattern* pattern, patternServer->resources()) {
         patternServer->addTag(pattern, QString("testtag: %1").arg(tagCount));
         tagCount++;
         bundle.addResource(patternServer->type(), pattern->filename(), patternServer->assignedTagsList(pattern), pattern->md5());
     }
 
     KisBrushResourceServer* brushServer = KisBrushServer::instance()->brushServer();
 
     QVERIFY(brushServer->resourceCount() > 0);
 
     Q_FOREACH (KisBrushSP brush, brushServer->resources()) {
         brushServer->addTag(brush.data(), QString("testtag: %1").arg(tagCount));
         tagCount++;
         bundle.addResource(brushServer->type(), brush->filename(), brushServer->assignedTagsList(brush.data()), brush->md5());
     }
 
 
     KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
     QVERIFY(paletteServer->resourceCount() > 0);
     Q_FOREACH (KoColorSet* palette, paletteServer->resources()) {
         paletteServer->addTag(palette, QString("testtag: %1").arg(tagCount));
         tagCount++;
         bundle.addResource(paletteServer->type(), palette->filename(), paletteServer->assignedTagsList(palette), palette->md5());
     }
 
 
     KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
     QVERIFY(workspaceServer->resourceCount() > 0);
     Q_FOREACH (KisWorkspaceResource* workspace, workspaceServer->resources()) {
         workspaceServer->addTag(workspace, QString("testtag: %1").arg(tagCount));
         tagCount++;
         bundle.addResource(workspaceServer->type(), workspace->filename(), workspaceServer->assignedTagsList(workspace), workspace->md5());
     }
 
     KisPaintOpPresetResourceServer * paintopServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QVERIFY(paintopServer->resourceCount() > 0);
     Q_FOREACH (KisPaintOpPresetSP preset, paintopServer->resources()) {
         paintopServer->addTag(preset.data(), QString("testtag: %1").arg(tagCount));
         tagCount++;
         bundle.addResource(paintopServer->type(), preset->filename(), paintopServer->assignedTagsList(preset.data()), preset->md5());
     }
 
     //QCOMPARE(bundle.getTagsList(), );
 
     bool res = bundle.save();
     QCOMPARE(bundle.getMeta("updated"), QDate::currentDate().toString("dd/MM/yyyy"));
     QVERIFY(res);
 
     KisResourceBundle bundle2(QString(FILES_OUTPUT_DIR) + "/" + "testloadsavebundle.bundle");
     res = bundle2.load();
 
     QVERIFY(res);
 
     // load sets installed to true
     QVERIFY(bundle2.isInstalled());
     QVERIFY(bundle2.valid());
     //QCOMPARE(bundle2.getTagsList().size(), tagCount);
     QVERIFY(bundle2.filename() == QString(FILES_OUTPUT_DIR) + "/" + "testloadsavebundle.bundle");
     QCOMPARE(bundle2.shortFilename(), QString("testloadsavebundle.bundle"));
     QCOMPARE(bundle2.name(), QString("testloadsavebundle"));
     QCOMPARE(bundle2.defaultFileExtension(), QString(".bundle"));
     QCOMPARE(bundle2.getMeta("author"), QString("TestAuthor"));
     QCOMPARE(bundle2.getMeta("email"), QString("TestEmail"));
     QCOMPARE(bundle2.getMeta("license"), QString("TestLicense"));
     QCOMPARE(bundle2.getMeta("website"), QString("TestWebsite"));
     QCOMPARE(bundle2.getMeta("created"), QString("TestCreated"));
     QCOMPARE(bundle2.getMeta("updated"), QDate::currentDate().toString("dd/MM/yyyy"));
     QCOMPARE(bundle2.getMeta("description"), QString("Test Description"));
 
     QImage img = bundle2.image();
     QVERIFY(!img.isNull());
 }
 
 void ResourceBundleTest::testInstallUninstall()
 {
 
 }
 
 
 QTEST_MAIN(ResourceBundleTest)
 
diff --git a/libs/ui/tests/kis_animation_exporter_test.cpp b/libs/ui/tests/kis_animation_exporter_test.cpp
index 4d08718828..c5dbe390c9 100644
--- a/libs/ui/tests/kis_animation_exporter_test.cpp
+++ b/libs/ui/tests/kis_animation_exporter_test.cpp
@@ -1,102 +1,101 @@
 /*
  *  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 "kis_animation_exporter_test.h"
 
 #include "dialogs/KisAsyncAnimationFramesSaveDialog.h"
 
 #include <QTest>
 #include <testutil.h>
 #include "KisPart.h"
 #include "kis_image.h"
 #include "KisDocument.h"
 #include "kis_image_animation_interface.h"
 #include "KoColor.h"
 #include <KoUpdater.h>
 #include "kis_time_range.h"
 #include "kis_keyframe_channel.h"
 #include <kistest.h>
-#include <testutil.h>
 
 void KisAnimationExporterTest::testAnimationExport()
 {
     KisDocument *document = KisPart::instance()->createDocument();
     QRect rect(0,0,512,512);
     QRect fillRect(10,0,502,512);
     TestUtil::MaskParent p(rect);
     document->setCurrentImage(p.image);
     const KoColorSpace *cs = p.image->colorSpace();
 
     KUndo2Command parentCommand;
 
     p.layer->enableAnimation();
     KisKeyframeChannel *rasterChannel = p.layer->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
 
     rasterChannel->addKeyframe(1, &parentCommand);
     rasterChannel->addKeyframe(2, &parentCommand);
     p.image->animationInterface()->setFullClipRange(KisTimeRange::fromTime(0, 2));
 
     KisPaintDeviceSP dev = p.layer->paintDevice();
 
     dev->fill(fillRect, KoColor(Qt::red, cs));
     QImage frame0 = dev->convertToQImage(0, rect);
 
     p.image->animationInterface()->switchCurrentTimeAsync(1);
     p.image->waitForDone();
     dev->fill(fillRect, KoColor(Qt::green, cs));
     QImage frame1 = dev->convertToQImage(0, rect);
 
     p.image->animationInterface()->switchCurrentTimeAsync(2);
     p.image->waitForDone();
     dev->fill(fillRect, KoColor(Qt::blue, cs));
     QImage frame2 = dev->convertToQImage(0, rect);
 
     KisAsyncAnimationFramesSaveDialog exporter(document->image(),
                                                KisTimeRange::fromTime(0,2),
                                                "export-test.png",
                                                0,
                                                0);
 
 
 
     exporter.setBatchMode(true);
     exporter.regenerateRange(0);
 
     QTest::qWait(1000);
 
     QImage exported;
 
     QPoint errpoint;
     exported.load("export-test0000.png");
     qDebug() << exported.size() << frame0.size();
     if (!TestUtil::compareQImages(errpoint, exported, frame0)) {
         QFAIL(QString("Failed to export identical frame0, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     exported.load("export-test0001.png");
     if (!TestUtil::compareQImages(errpoint, exported, frame1)) {
         QFAIL(QString("Failed to export identical frame1, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     exported.load("export-test0002.png");
     if (!TestUtil::compareQImages(errpoint, exported, frame2)) {
         QFAIL(QString("Failed to export identical frame2, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 KISTEST_MAIN(KisAnimationExporterTest)
diff --git a/libs/ui/tests/kis_coordinates_converter_test.cpp b/libs/ui/tests/kis_coordinates_converter_test.cpp
index ffd079f162..f57c151329 100644
--- a/libs/ui/tests/kis_coordinates_converter_test.cpp
+++ b/libs/ui/tests/kis_coordinates_converter_test.cpp
@@ -1,273 +1,271 @@
 /*
  *  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_coordinates_converter_test.h"
 #include <QTest>
 
-#include <QTest>
-
 #include <QTransform>
 
 #include <KoZoomHandler.h>
 #include <KoColorSpaceRegistry.h>
 #include <kis_image.h>
 
 #include "kis_coordinates_converter.h"
 
 
 void initImage(KisImageSP *image, KoZoomHandler *zoomHandler)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     *image = new KisImage(0, 1000, 1000, cs, "projection test");
     (*image)->setResolution(100, 100);
 
     zoomHandler->setResolution(100, 100);
 }
 
 void KisCoordinatesConverterTest::testConversion()
 {
     KisImageSP image;
     KisCoordinatesConverter converter;
     initImage(&image, &converter);
 
     converter.setImage(image);
     converter.setDocumentOffset(QPoint(20,20));
     converter.setCanvasWidgetSize(QSize(500,500));
     converter.setZoom(1.);
 
     QRectF testRect(100,100,100,100);
 
     QCOMPARE(converter.imageToViewport(testRect), QRectF(80,80,100,100));
     QCOMPARE(converter.viewportToImage(testRect), QRectF(120,120,100,100));
 
     QCOMPARE(converter.widgetToViewport(testRect), QRectF(100,100,100,100));
     QCOMPARE(converter.viewportToWidget(testRect), QRectF(100,100,100,100));
 
     QCOMPARE(converter.widgetToDocument(testRect), QRectF(1.20,1.20,1,1));
     QCOMPARE(converter.documentToWidget(testRect), QRectF(9980,9980,10000,10000));
 
     QCOMPARE(converter.imageToDocument(testRect), QRectF(1,1,1,1));
     QCOMPARE(converter.documentToImage(testRect), QRectF(10000,10000,10000,10000));
 
     converter.setZoom(0.5);
 
     QCOMPARE(converter.imageToViewport(testRect), QRectF(30,30,50,50));
     QCOMPARE(converter.viewportToImage(testRect), QRectF(240,240,200,200));
 
     QCOMPARE(converter.widgetToViewport(testRect), QRectF(100,100,100,100));
     QCOMPARE(converter.viewportToWidget(testRect), QRectF(100,100,100,100));
 
     QCOMPARE(converter.widgetToDocument(testRect), QRectF(2.4,2.4,2,2));
     QCOMPARE(converter.documentToWidget(testRect), QRectF(4980,4980,5000,5000));
 
     QCOMPARE(converter.imageToDocument(testRect), QRectF(1,1,1,1));
     QCOMPARE(converter.documentToImage(testRect), QRectF(10000,10000,10000,10000));
 }
 
 void KisCoordinatesConverterTest::testImageCropping()
 {
     KisImageSP image;
     KisCoordinatesConverter converter;
     initImage(&image, &converter);
 
     converter.setImage(image);
     converter.setDocumentOffset(QPoint(0,0));
     converter.setCanvasWidgetSize(QSize(500,500));
 
     converter.setZoom(1.);
 
     // we do NOT crop here
     QCOMPARE(converter.viewportToImage(QRectF(900,900,200,200)),
              QRectF(900,900,200,200));
 }
 
 #define CHECK_TRANSFORM(trans,test,ref) QCOMPARE(trans.map(test).boundingRect(), ref)
 //#define CHECK_TRANSFORM(trans,test,ref) dbgKrita << trans.map(test).boundingRect()
 
 void KisCoordinatesConverterTest::testTransformations()
 {
     KisImageSP image;
     KisCoordinatesConverter converter;
     initImage(&image, &converter);
 
     converter.setImage(image);
     converter.setDocumentOffset(QPoint(20,30));
     converter.setCanvasWidgetSize(QSize(500,500));
 
     QRectF testRect(100,100,100,100);
     QTransform imageToWidget;
     QTransform documentToWidget;
     QTransform flakeToWidget;
     QTransform viewportToWidget;
 
     converter.setZoom(1.);
 
     imageToWidget = converter.imageToWidgetTransform();
     documentToWidget = converter.documentToWidgetTransform();
     flakeToWidget = converter.flakeToWidgetTransform();
     viewportToWidget = converter.viewportToWidgetTransform();
 
     CHECK_TRANSFORM(imageToWidget, testRect, QRectF(80,70,100,100));
     CHECK_TRANSFORM(documentToWidget, testRect, QRectF(9980,9970,10000,10000));
     CHECK_TRANSFORM(flakeToWidget, testRect, QRectF(80,70,100,100));
     CHECK_TRANSFORM(viewportToWidget, testRect, QRectF(100,100,100,100));
 
     converter.setZoom(0.5);
 
     imageToWidget = converter.imageToWidgetTransform();
     documentToWidget = converter.documentToWidgetTransform();
     flakeToWidget = converter.flakeToWidgetTransform();
     viewportToWidget = converter.viewportToWidgetTransform();
 
     CHECK_TRANSFORM(imageToWidget, testRect, QRectF(30,20,50,50));
     CHECK_TRANSFORM(documentToWidget, testRect, QRectF(4980,4970,5000,5000));
     CHECK_TRANSFORM(flakeToWidget, testRect, QRectF(80,70,100,100));
     CHECK_TRANSFORM(viewportToWidget, testRect, QRectF(100,100,100,100));
 }
 
 void KisCoordinatesConverterTest::testConsistency()
 {
     KisImageSP image;
     KisCoordinatesConverter converter;
     initImage(&image, &converter);
 
     converter.setImage(image);
     converter.setDocumentOffset(QPoint(20,30));
     converter.setCanvasWidgetSize(QSize(500,500));
 
     QRectF testRect(100,100,100,100);
     QTransform imageToWidget;
     QTransform documentToWidget;
     QTransform viewportToWidget;
 
     converter.setZoom(0.5);
 
     imageToWidget = converter.imageToWidgetTransform();
     documentToWidget = converter.documentToWidgetTransform();
     viewportToWidget = converter.viewportToWidgetTransform();
 
     QRectF fromImage = converter.viewportToWidget(converter.imageToViewport(testRect));
     QRectF fromDocument = converter.documentToWidget(testRect);
     QRectF fromViewport = converter.viewportToWidget(testRect);
 
     CHECK_TRANSFORM(imageToWidget, testRect, fromImage);
     CHECK_TRANSFORM(documentToWidget, testRect, fromDocument);
     CHECK_TRANSFORM(viewportToWidget, testRect, fromViewport);
 }
 
 void KisCoordinatesConverterTest::testRotation()
 {
     KisImageSP image;
     KisCoordinatesConverter converter;
     initImage(&image, &converter);
 
     QSize widgetSize(1000,500);
     QRectF testRect(800, 100, 300, 300);
 
     converter.setImage(image);
     converter.setDocumentOffset(QPoint(0,0));
     converter.setCanvasWidgetSize(widgetSize);
 
     converter.rotate(converter.widgetCenterPoint(), 30);
     converter.setZoom(1.);
 
     QTransform viewportToWidget = converter.viewportToWidgetTransform();
 
     QRectF boundingRect = viewportToWidget.mapRect(testRect);
     QRectF directRect = converter.viewportToWidget(testRect);
 
     QCOMPARE(boundingRect, directRect);
 
     QRectF referenceRect(QPointF(742.82,53.5898), QSizeF(409.808,409.808));
 
 #define FUZZY(a,b) ((a)-(b) < 0.01)
 
     QVERIFY(FUZZY(boundingRect.top(), referenceRect.top()));
     QVERIFY(FUZZY(boundingRect.left(), referenceRect.left()));
     QVERIFY(FUZZY(boundingRect.width(), referenceRect.width()));
     QVERIFY(FUZZY(boundingRect.height(), referenceRect.height()));
 }
 
 void KisCoordinatesConverterTest::testMirroring()
 {
     KisImageSP image;
     KisCoordinatesConverter converter;
     initImage(&image, &converter);
 
     QSize widgetSize(500,400);
 //    QSize flakeSize(1000,1000);
     QRectF testRect(300, 100, 200, 200);
 
     converter.setImage(image);
     converter.setDocumentOffset(QPoint(200,100));
     converter.setCanvasWidgetSize(widgetSize);
 
 //    QTransform imageToWidget;
 //    QTransform documentToWidget;
 //    QTransform flakeToWidget;
 //    QTransform viewportToWidget;
 
     converter.mirror(converter.imageCenterInWidgetPixel(), true, false);
     converter.setZoom(1.);
 
     // image pixels == flake pixels
 
     QRectF viewportRect = converter.imageToViewport(testRect);
     QRectF widgetRect = converter.viewportToWidget(viewportRect);
 
     QCOMPARE(widgetRect, QRectF(300,0,200,200));
     QCOMPARE(viewportRect, QRectF(0,0,200,200));
 
     QRectF roundTrip = converter.viewportToWidget(widgetRect);
     QCOMPARE(roundTrip, viewportRect);
 }
 
 void KisCoordinatesConverterTest::testMirroringCanvasBiggerThanImage()
 {
     KisImageSP image;
     KisCoordinatesConverter converter;
     initImage(&image, &converter);
 
     QSize widgetSize(2000,2000);
 //    QSize flakeSize(1000,1000);
     QRectF testRect(300, 100, 200, 200);
 
     converter.setImage(image);
     converter.setDocumentOffset(QPoint(-50,-50));
     converter.setCanvasWidgetSize(widgetSize);
 
 //    QTransform imageToWidget;
 //    QTransform documentToWidget;
 //    QTransform flakeToWidget;
 //    QTransform viewportToWidget;
 
     converter.mirror(converter.imageCenterInWidgetPixel(), true, false);
     converter.setZoom(1.);
 
     // image pixels == flake pixels
 
     QRectF viewportRect = converter.imageToViewport(testRect);
     QRectF widgetRect = converter.viewportToWidget(viewportRect);
 
     QCOMPARE(widgetRect, QRectF(550,150,200,200));
     QCOMPARE(viewportRect, QRectF(300,100,200,200));
 }
 
 
 QTEST_MAIN(KisCoordinatesConverterTest)
 
diff --git a/libs/ui/tests/kis_doc2_test.cpp b/libs/ui/tests/kis_doc2_test.cpp
index 9e54e0bb29..33125e24bf 100644
--- a/libs/ui/tests/kis_doc2_test.cpp
+++ b/libs/ui/tests/kis_doc2_test.cpp
@@ -1,52 +1,51 @@
 /*
  *  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_doc2_test.h"
 
 #include <KisMainWindow.h>
 
 #include <QTest>
 
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_undo_store.h"
 #include "KisPart.h"
 #include <KisViewManager.h>
 #include "util.h"
 #include <KisView.h>
-#include "KisPart.h"
 #include "sdk/tests/kistest.h"
 
 void KisDocumentTest::testOpenImageTwiceInSameDoc()
 {
     QString fname2 = QString(FILES_DATA_DIR) + QDir::separator() + "load_test.kra";
     QString fname = QString(FILES_DATA_DIR) + QDir::separator() + "load_test2.kra";
 
 
     Q_ASSERT(!fname.isEmpty());
     Q_ASSERT(!fname2.isEmpty());
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     doc->loadNativeFormat(fname);
     doc->loadNativeFormat(fname2);
 }
 
 
 KISTEST_MAIN(KisDocumentTest)
 
diff --git a/libs/ui/tests/kis_exiv2_test.cpp b/libs/ui/tests/kis_exiv2_test.cpp
index c1b1e2dc8e..155d8e5728 100644
--- a/libs/ui/tests/kis_exiv2_test.cpp
+++ b/libs/ui/tests/kis_exiv2_test.cpp
@@ -1,111 +1,110 @@
 /*
  * 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 "kis_exiv2_test.h"
 
 #include <QTest>
 #include <QCoreApplication>
 
-#include <QTest>
 #include <QBuffer>
 
 #include "kis_debug.h"
 #include "kis_meta_data_entry.h"
 #include "kis_meta_data_io_backend.h"
 #include "kis_meta_data_schema.h"
 #include "kis_meta_data_schema_registry.h"
 #include "kis_meta_data_store.h"
 #include "kis_meta_data_validator.h"
 #include <metadata/kis_meta_data_value.h>
 #include "kisexiv2/kis_exiv2.h"
 #include "filestest.h"
 #include "sdk/tests/kistest.h"
 
 #ifndef FILES_DATA_DIR
 #error "FILES_DATA_DIR not set. A directory with the data used for testing the metadata parser in krita"
 #endif
 
 using namespace KisMetaData;
 
 void KisExiv2Test::testExifLoader()
 {
     KisExiv2::initialize();
 
     IOBackend* exifIO = IOBackendRegistry::instance()->get("exif");
     QVERIFY(exifIO);
     QFile exifFile(QString(FILES_DATA_DIR) + "/metadata/hpim3238.exv");
     exifFile.open(QIODevice::ReadOnly);
     exifFile.seek(17);
     QByteArray exifBytes = exifFile.readAll();
     QBuffer exifBuffer(&exifBytes);
 
     Store* store = new Store;
     bool loadSuccess = exifIO->loadFrom(store, &exifBuffer);
     QVERIFY(loadSuccess);
     Validator validator(store);
 
     for (QMap<QString, Validator::Reason>::const_iterator it = validator.invalidEntries().begin();
             it != validator.invalidEntries().end(); ++it) {
         dbgKrita << it.key() << " = " << it.value().type() << " entry = " << store->getEntry(it.key());
     }
 
     QCOMPARE(validator.countInvalidEntries(), 0);
     QCOMPARE(validator.countValidEntries(), 51);
 
     const KisMetaData::Schema* tiffSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::TIFFSchemaUri);
 
     QCOMPARE(store->getEntry(tiffSchema, "Make").value(), Value("Hewlett-Packard"));
     QCOMPARE(store->getEntry(tiffSchema, "Model").value(), Value("HP PhotoSmart R707 (V01.00) "));
     QCOMPARE(store->getEntry(tiffSchema, "Orientation").value(), Value(1));
     QCOMPARE(store->getEntry(tiffSchema, "XResolution").value(), Value(Rational(72 / 1)));
     QCOMPARE(store->getEntry(tiffSchema, "YResolution").value(), Value(Rational(72 / 1)));
     QCOMPARE(store->getEntry(tiffSchema, "ResolutionUnit").value(), Value(2));
     QCOMPARE(store->getEntry(tiffSchema, "YCbCrPositioning").value(), Value(1));
 
     const KisMetaData::Schema* exifSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::EXIFSchemaUri);
 
     QCOMPARE(store->getEntry(exifSchema, "ExposureTime").value(), Value(Rational(35355, 100000)));
     QCOMPARE(store->getEntry(exifSchema, "FNumber").value(), Value(Rational(280, 100)));
     QCOMPARE(store->getEntry(exifSchema, "ExposureProgram").value(), Value(2));
 //     QCOMPARE(store->getEntry(exifSchema, "ISOSpeedRatings").value(), Value(100)); // TODO it's a list
     // TODO test OECF
     QCOMPARE(store->getEntry(exifSchema, "ExifVersion").value(), Value("0220"));
     QCOMPARE(store->getEntry(exifSchema, "DateTimeOriginal").value(), Value(QDateTime(QDate(2007, 5, 8), QTime(0, 19, 18))));
     QCOMPARE(store->getEntry(exifSchema, "DateTimeDigitized").value(), Value(QDateTime(QDate(2007, 5, 8), QTime(0, 19, 18))));
     // TODO ComponentsConfiguration
     QCOMPARE(store->getEntry(exifSchema, "ShutterSpeedValue").value(), Value(Rational(384, 256)));
     QCOMPARE(store->getEntry(exifSchema, "ApertureValue").value(), Value(Rational(780, 256)));
     QCOMPARE(store->getEntry(exifSchema, "BrightnessValue").value(), Value(Rational(-37, 256)));
     QCOMPARE(store->getEntry(exifSchema, "ExposureBiasValue").value(), Value(Rational(256, 256)));
     QCOMPARE(store->getEntry(exifSchema, "MaxApertureValue").value(), Value(Rational(280, 100)));
     QCOMPARE(store->getEntry(exifSchema, "SubjectDistance").value(), Value(Rational(65535, 1000)));
 
 
     const KisMetaData::Schema* dcSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::DublinCoreSchemaUri);
     Q_UNUSED(dcSchema);
 
     const KisMetaData::Schema* xmpSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::XMPSchemaUri);
     QCOMPARE(store->getEntry(xmpSchema, "CreatorTool").value(), Value("digiKam-0.9.1"));
     QCOMPARE(store->getEntry(xmpSchema, "ModifyDate").value(), Value(QDateTime(QDate(2007, 5, 8), QTime(0, 19, 18))));
 
     const KisMetaData::Schema* mknSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::MakerNoteSchemaUri);
     QCOMPARE(store->getEntry(mknSchema, "RawData").value(), Value("SFBNZXQ="));
 }
 
 KISTEST_MAIN(KisExiv2Test)
 
diff --git a/libs/ui/tests/kis_prescaled_projection_test.cpp b/libs/ui/tests/kis_prescaled_projection_test.cpp
index 96048052ff..f0adc83746 100644
--- a/libs/ui/tests/kis_prescaled_projection_test.cpp
+++ b/libs/ui/tests/kis_prescaled_projection_test.cpp
@@ -1,476 +1,474 @@
 /*
  * Copyright (C) 2007 Boudewijn Rempt <boud@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.
  */
 
 #include "kis_prescaled_projection_test.h"
 #include <QTest>
 #include <QCoreApplication>
 
-#include <QTest>
-
 #include <QSize>
 #include <QImage>
 
 #include <KoZoomHandler.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoCompositeOp.h>
 #include <KoColorSpaceConstants.h>
 
 #include <kis_config.h>
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_update_info.h>
 
 #include "canvas/kis_coordinates_converter.h"
 #include "canvas/kis_prescaled_projection.h"
 
 #include "../../sdk/tests/testutil.h"
 
 bool KisPrescaledProjectionTest::testProjectionScenario(KisPrescaledProjection & projection,
         KoZoomHandler * viewConverter,
         const QString & name)
 {
 
     projection.notifyCanvasSizeChanged(QSize(1000, 1000));
     projection.prescaledQImage().save(name + "_prescaled_projection_01.png");
 
     viewConverter->setZoom(0.5);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_021.png");
 
     viewConverter->setZoom(0.6);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_022.png");
 
     viewConverter->setZoom(0.71);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_023.png");
 
     viewConverter->setZoom(0.84);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_024.png");
 
     viewConverter->setZoom(0.9);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_025.png");
 
     viewConverter->setZoom(1.9);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_03.png");
 
     viewConverter->setZoom(2.0);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_04.png");
 
     viewConverter->setZoom(2.5);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_05.png");
 
     viewConverter->setZoom(16.0);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_06.png");
 
     viewConverter->setZoom(1.0);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_07.png");
 
     projection.viewportMoved(QPoint(50, 50));
     projection.prescaledQImage().save(name + "_prescaled_projection_08.png");
 
     projection.viewportMoved(QPoint(100, 100));
     projection.prescaledQImage().save(name + "_prescaled_projection_081.png");
 
     projection.viewportMoved(QPoint(200, 200));
     projection.prescaledQImage().save(name + "_prescaled_projection_082.png");
 
     projection.viewportMoved(QPoint(250, 250));
     projection.prescaledQImage().save(name + "_prescaled_projection_083.png");
 
     projection.viewportMoved(QPoint(150, 200));
     projection.prescaledQImage().save(name + "_prescaled_projection_084.png");
 
     projection.viewportMoved(QPoint(100, 200));
     projection.prescaledQImage().save(name + "_prescaled_projection_085.png");
 
     projection.viewportMoved(QPoint(50, 200));
     projection.prescaledQImage().save(name + "_prescaled_projection_086.png");
 
     projection.viewportMoved(QPoint(0, 200));
     projection.prescaledQImage().save(name + "_prescaled_projection_087.png");
 
     projection.notifyCanvasSizeChanged(QSize(750, 750));
     projection.prescaledQImage().save(name + "_prescaled_projection_09.png");
 
     viewConverter->setZoom(1.0);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_10.png");
 
     projection.notifyCanvasSizeChanged(QSize(350, 350));
     projection.prescaledQImage().save(name + "_prescaled_projection_11.png");
 
     projection.viewportMoved(QPoint(100, 100));
     projection.prescaledQImage().save(name + "_prescaled_projection_12.png");
 
     viewConverter->setZoom(0.75);
     projection.preScale();
     projection.prescaledQImage().save(name + "_prescaled_projection_13.png");
 
     projection.viewportMoved(QPoint(10, 10));
     projection.prescaledQImage().save(name + "_prescaled_projection_14.png");
 
     projection.viewportMoved(QPoint(0, 0));
     projection.prescaledQImage().save(name + "_prescaled_projection_15.png");
 
     projection.viewportMoved(QPoint(10, 10));
     projection.prescaledQImage().save(name + "_prescaled_projection_16.png");
 
     projection.viewportMoved(QPoint(30, 50));
     projection.prescaledQImage().save(name + "_prescaled_projection_17.png");
 
     return true;
 }
 
 void KisPrescaledProjectionTest::testCreation()
 {
     KisPrescaledProjection * prescaledProjection = 0;
     prescaledProjection = new KisPrescaledProjection();
     QVERIFY(prescaledProjection != 0);
     QVERIFY(prescaledProjection->prescaledQImage().isNull());
     delete prescaledProjection;
 }
 
 void KisPrescaledProjectionTest::testScalingUndeferredSmoothingPixelForPixel()
 {
     // Set up a nice image
     QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
 
     // Undo adapter not necessary
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, qimage.width(), qimage.height(), cs, "projection test");
 
     // 300 dpi recalculated to pixels per point (of which there are 72
     // to the inch)
     image->setResolution(100 / 72 , 100 / 72);
 
     KisPaintLayerSP layer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8, cs);
     image->addNode(layer.data(), image->rootLayer(), 0);
     layer->paintDevice()->convertFromQImage(qimage, 0);
 
     KisPrescaledProjection projection;
     KisCoordinatesConverter converter;
     
     converter.setImage(image);
     projection.setCoordinatesConverter(&converter);
     projection.setMonitorProfile(0,
                                  KoColorConversionTransformation::internalRenderingIntent(),
                                  KoColorConversionTransformation::internalConversionFlags());
     projection.setImage(image);
 
     // pixel-for-pixel, at 100% zoom
     converter.setResolution(image->xRes(), image->yRes());
 
     testProjectionScenario(projection, &converter, "pixel_for_pixel");
 
 }
 
 
 void KisPrescaledProjectionTest::testScalingUndeferredSmoothing()
 {
     // Set up a nice image
     QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
 
     // Undo adapter not necessary
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, qimage.width(), qimage.height(), cs, "projection test");
 
     // 300 dpi recalculated to pixels per point (of which there are 72
     // to the inch)
     image->setResolution(100, 100);
 
     KisPaintLayerSP layer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8, cs);
     image->addNode(layer.data(), image->rootLayer(), 0);
     layer->paintDevice()->convertFromQImage(qimage, 0);
 
     KisPrescaledProjection projection;
     KisCoordinatesConverter converter;
     
     converter.setImage(image);
     projection.setCoordinatesConverter(&converter);
     projection.setMonitorProfile(0,
                                  KoColorConversionTransformation::internalRenderingIntent(),
                                  KoColorConversionTransformation::internalConversionFlags());
     projection.setImage(image);
 
     testProjectionScenario(projection, &converter, "120dpi");
 
 }
 
 //#include <valgrind/callgrind.h>
 
 void KisPrescaledProjectionTest::benchmarkUpdate()
 {
     QImage referenceImage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
     QRect imageRect = QRect(QPoint(0,0), referenceImage.size());
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "projection test");
 
     // set up 300dpi
     image->setResolution(300 / 72 , 300 / 72);
 
     KisPaintLayerSP layer = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, cs);
     layer->paintDevice()->convertFromQImage(referenceImage, 0);
 
     image->addNode(layer, image->rootLayer(), 0);
 
     KisPrescaledProjection projection;
 
     KisCoordinatesConverter converter;
     converter.setImage(image);
     projection.setCoordinatesConverter(&converter);
     projection.setMonitorProfile(0,
                                  KoColorConversionTransformation::internalRenderingIntent(),
                                  KoColorConversionTransformation::internalConversionFlags());
     projection.setImage(image);
 
     // Emulate "Use same aspect as pixels"
     converter.setResolution(image->xRes(), image->yRes());
 
     converter.setZoom(1.0);
 
     KisUpdateInfoSP info = projection.updateCache(image->bounds());
     projection.recalculateCache(info);
 
     QCOMPARE(imageRect, QRect(0,0,512,512));
 
     QRect dirtyRect(0,0,20,20);
     const qint32 numShifts = 25;
     const QPoint offset(dirtyRect.width(),dirtyRect.height());
 
     //CALLGRIND_START_INSTRUMENTATION;
 
     QBENCHMARK {
         for(qint32 i = 0; i < numShifts; i++) {
             KisUpdateInfoSP tempInfo = projection.updateCache(dirtyRect);
             projection.recalculateCache(tempInfo);
 
             dirtyRect.translate(offset);
         }
     }
 
     //CALLGRIND_STOP_INSTRUMENTATION;
 
 }
 
 
 class PrescaledProjectionTester
 {
 public:
     PrescaledProjectionTester() {
         sourceImage = QImage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
 
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
         image = new KisImage(0, sourceImage.width(), sourceImage.height(), cs, "projection test");
         image->setResolution(100, 100);
 
         layer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8, cs);
         layer->paintDevice()->convertFromQImage(sourceImage, 0);
 
         image->addNode(layer, image->rootLayer(), 0);
 
         converter.setResolution(100, 100);
         converter.setZoom(1.);
         converter.setImage(image);
         converter.setCanvasWidgetSize(QSize(100,100));
         converter.setDocumentOffset(QPoint(100,100));
 
         projection.setCoordinatesConverter(&converter);
         projection.setMonitorProfile(0,
                                      KoColorConversionTransformation::internalRenderingIntent(),
                                      KoColorConversionTransformation::internalConversionFlags());
         projection.setImage(image);
         projection.notifyCanvasSizeChanged(QSize(100,100));
         projection.notifyZoomChanged();
     }
 
     QImage sourceImage;
     KisImageSP image;
     KisPaintLayerSP layer;
     KisCoordinatesConverter converter;
     KisPrescaledProjection projection;
 };
 
 void KisPrescaledProjectionTest::testScrollingZoom100()
 {
     PrescaledProjectionTester t;
 
     QImage result = t.projection.prescaledQImage();
     QImage reference = t.sourceImage.copy(QRect(100,100,100,100));
 
     QPoint pt;
     QVERIFY(TestUtil::compareQImages(pt, result, reference));
 
     // Test actual scrolling
     t.converter.setDocumentOffset(QPoint(150,150));
     t.projection.viewportMoved(QPoint(-50,-50));
 
     result = t.projection.prescaledQImage();
     reference = t.sourceImage.copy(QRect(150,150,100,100));
 
     QVERIFY(TestUtil::compareQImages(pt, result, reference));
 }
 
 void KisPrescaledProjectionTest::testScrollingZoom50()
 {
     PrescaledProjectionTester t;
 
     t.converter.setDocumentOffset(QPoint(0,0));
 
     t.converter.setCanvasWidgetSize(QSize(300,300));
     t.projection.notifyCanvasSizeChanged(QSize(300,300));
 
 
     QVERIFY(TestUtil::checkQImage(t.projection.prescaledQImage(),
                                   "prescaled_projection_test",
                                   "testScrollingZoom50",
                                   "initial"));
 
     t.converter.setZoom(0.5);
     t.projection.notifyZoomChanged();
 
     QVERIFY(TestUtil::checkQImage(t.projection.prescaledQImage(),
                                   "prescaled_projection_test",
                                   "testScrollingZoom50",
                                   "zoom50"));
 
     t.converter.setDocumentOffset(QPoint(50,50));
     t.projection.viewportMoved(QPoint(-50,-50));
 
     QVERIFY(TestUtil::checkQImage(t.projection.prescaledQImage(),
                                   "prescaled_projection_test",
                                   "testScrollingZoom50",
                                   "zoom50_moved50"));
 }
 
 void KisPrescaledProjectionTest::testUpdates()
 {
     PrescaledProjectionTester t;
 
     t.converter.setDocumentOffset(QPoint(10,10));
 
     t.converter.setCanvasWidgetSize(2*QSize(300,300));
     t.projection.notifyCanvasSizeChanged(2*QSize(300,300));
 
 
     t.converter.setZoom(0.50);
     t.projection.notifyZoomChanged();
 
     QVERIFY(TestUtil::checkQImage(t.projection.prescaledQImage(),
                                   "prescaled_projection_test",
                                   "testUpdates",
                                   "zoom50"));
 
     t.layer->setVisible(false);
     KisUpdateInfoSP info = t.projection.updateCache(t.image->bounds());
     t.projection.recalculateCache(info);
 
     QVERIFY(TestUtil::checkQImage(t.projection.prescaledQImage(),
                                   "prescaled_projection_test",
                                   "testUpdates",
                                   "cleared"));
 
     t.layer->setVisible(true);
     t.image->refreshGraph();
 
     // Update incrementally
 
     const int step = 73;
     const int patchOffset = -7;
     const int patchSize = 93;
 
     QList<KisUpdateInfoSP> infos;
 
     for(int y = 0; y < t.image->height(); y+=step) {
         for(int x = 0; x < t.image->width(); x+=step) {
             QRect patchRect(x - patchOffset, y - patchOffset,
                             patchSize, patchSize);
 
             infos.append(t.projection.updateCache(patchRect));
         }
     }
 
     Q_FOREACH (KisUpdateInfoSP info, infos) {
         t.projection.recalculateCache(info);
     }
 
     QEXPECT_FAIL("", "Testcase for bug: https://bugs.kde.org/show_bug.cgi?id=289915", Continue);
     QVERIFY(TestUtil::checkQImage(t.projection.prescaledQImage(),
                                   "prescaled_projection_test",
                                   "testUpdates",
                                   "zoom50", 1));
 }
 
 void KisPrescaledProjectionTest::testQtScaling()
 {
     // See: https://bugreports.qt.nokia.com/browse/QTBUG-22827
 
     /**
      * Currently we rely on this behavior, so let's test for it.
      */
 
     // Create a canvas image
     QImage canvas(6, 6, QImage::Format_ARGB32);
     canvas.fill(0);
 
     // Image we are going to scale down
     QImage image(7, 7, QImage::Format_ARGB32);
     QPainter imagePainter(&image);
     imagePainter.fillRect(QRect(0,0,7,7),Qt::green);
     imagePainter.end();
 
 
     QPainter gc(&canvas);
 
     // Scale down transformation
     qreal scale = 3.49/7.0;
     gc.setTransform(QTransform::fromScale(scale,scale));
 
     // Draw a rect scale*(7x7)
     gc.fillRect(QRectF(0,0,7,7), Qt::red);
 
     // Draw an image scale*(7x7)
     gc.drawImage(QPointF(), image, QRectF(0,0,7,7));
 
     gc.end();
 
     // Create an expected result
     QImage expectedResult(6, 6, QImage::Format_ARGB32);
     expectedResult.fill(0);
     QPainter expectedPainter(&expectedResult);
     expectedPainter.fillRect(QRect(0,0,4,4), Qt::red);
     expectedPainter.fillRect(QRect(0,0,3,3), Qt::green);
     expectedPainter.end();
 
     QCOMPARE(canvas, expectedResult);
 }
 
 QTEST_MAIN(KisPrescaledProjectionTest)
 
 
diff --git a/libs/ui/tests/util.h b/libs/ui/tests/util.h
index a4de442ceb..a249d6c182 100644
--- a/libs/ui/tests/util.h
+++ b/libs/ui/tests/util.h
@@ -1,234 +1,232 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt boud@valdyas.org
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef _UTIL_H_
 #define _UTIL_H_
 
-#include <QTest>
 #include <QTest>
 #include <QBitArray>
 
 #include <KisDocument.h>
 #include <KoDocumentInfo.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoShapeContainer.h>
 #include <KoColorSpace.h>
 #include <KoPathShape.h>
 
 #include <kis_count_visitor.h>
 #include "kis_types.h"
 #include "filter/kis_filter_registry.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter.h"
-#include "KisDocument.h"
 #include "KisPart.h"
 #include "kis_image.h"
 #include "kis_pixel_selection.h"
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_clone_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_shape_layer.h"
 #include "kis_filter_mask.h"
 #include "kis_transparency_mask.h"
 #include "kis_selection_mask.h"
 #include "kis_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_shape_selection.h"
 #include "kis_default_bounds.h"
 #include "kis_transform_mask_params_interface.h"
 #include "kis_shape_controller.h"
 
 
 KisSelectionSP createPixelSelection(KisPaintDeviceSP paintDevice)
 {
     KisSelectionSP pixelSelection = new KisSelection(new KisSelectionDefaultBounds(paintDevice));
 
     KisFillPainter gc(pixelSelection->pixelSelection());
     gc.fillRect(10, 10, 200, 200, KoColor(gc.device()->colorSpace()));
     gc.fillRect(150, 150, 200, 200, KoColor(QColor(100, 100, 100, 100), gc.device()->colorSpace()));
     gc.end();
 
     return pixelSelection;
 }
 
 KisSelectionSP createVectorSelection(KisPaintDeviceSP paintDevice, KisImageWSP image, KoShapeControllerBase *shapeController)
 {
     KisSelectionSP vectorSelection = new KisSelection(new KisSelectionDefaultBounds(paintDevice));
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF(10, 10) + QPointF(100, 0));
     path->lineTo(QPointF(100, 100));
     path->lineTo(QPointF(10, 10) + QPointF(0, 100));
     path->close();
     path->normalize();
     KisShapeSelection* shapeSelection = new KisShapeSelection(shapeController, image, vectorSelection);
     shapeSelection->addShape(path);
     vectorSelection->setShapeSelection(shapeSelection);
 
     return vectorSelection;
 }
 
 QTransform createTestingTransform() {
     return QTransform(1,2,3,4,5,6,7,8,9);
 }
 
 KisDocument* createCompleteDocument(bool shouldMaskToShapeLayer = false)
 {
     KisImageWSP image = new KisImage(0, 1024, 1024, KoColorSpaceRegistry::instance()->rgb8(), "test for roundtrip");
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
     doc->setCurrentImage(image);
     doc->documentInfo()->setAboutInfo("title", image->objectName());
 
     KisGroupLayerSP group1 = new KisGroupLayer(image, "group1", 50);
 
     KisGroupLayerSP group2 = new KisGroupLayer(image, "group2", 100);
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paintlayer1", OPACITY_OPAQUE_U8);
     paintLayer1->setUserLocked(true);
     QBitArray channelFlags(4);
     channelFlags[0] = true;
     channelFlags[2] = true;
     paintLayer1->setChannelFlags(channelFlags);
 
     {
         KisFillPainter gc(paintLayer1->paintDevice());
         gc.fillRect(10, 10, 200, 200, KoColor(Qt::red, paintLayer1->paintDevice()->colorSpace()));
         gc.end();
     }
 
     KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paintlayer2", OPACITY_TRANSPARENT_U8, KoColorSpaceRegistry::instance()->lab16());
     paintLayer2->setVisible(false);
     {
         KisFillPainter gc(paintLayer2->paintDevice());
         gc.fillRect(0, 0, 900, 1024, KoColor(QColor(10, 20, 30), paintLayer2->paintDevice()->colorSpace()));
         gc.end();
     }
 
 
     KisCloneLayerSP cloneLayer1 = new KisCloneLayer(group1, image, "clonelayer1", 150);
     cloneLayer1->setX(100);
     cloneLayer1->setY(100);
 
     KisSelectionSP pixelSelection = createPixelSelection(paintLayer1->paintDevice());
     KisFilterConfigurationSP kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration();
     Q_ASSERT(kfc);
     KisAdjustmentLayerSP adjustmentLayer1 = new KisAdjustmentLayer(image, "adjustmentLayer1", kfc, pixelSelection);
     kfc = 0; // kfc cannot be shared!
 
     KisSelectionSP vectorSelection = createVectorSelection(paintLayer2->paintDevice(), image, doc->shapeController());
     kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration();
     KisAdjustmentLayerSP adjustmentLayer2 = new KisAdjustmentLayer(image, "adjustmentLayer2", kfc, vectorSelection);
     kfc = 0; // kfc cannot be shared!
 
     image->addNode(paintLayer1);
     image->addNode(group1);
     image->addNode(paintLayer2, group1);
     image->addNode(group2);
     image->addNode(cloneLayer1, group2);
     image->addNode(adjustmentLayer1, group2);
 
 //    KoShapeContainer * parentContainer =
 //        dynamic_cast<KoShapeContainer*>(doc->shapeForNode(group1));
 
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF(10, 10) + QPointF(100, 0));
     path->lineTo(QPointF(100, 100));
     path->lineTo(QPointF(10, 10) + QPointF(0, 100));
     path->close();
     path->normalize();
     KisShapeLayerSP shapeLayer = new KisShapeLayer(doc->shapeController(), image, "shapeLayer1", 75);
     shapeLayer->addShape(path);
     image->addNode(shapeLayer, group1);
     image->addNode(adjustmentLayer2, group1);
 
     KisFilterMaskSP filterMask1 = new KisFilterMask();
     filterMask1->setName("filterMask1");
 
     kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration();
     filterMask1->setFilter(kfc);
     kfc = 0; // kfc cannot be shared!
 
     filterMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(filterMask1, paintLayer1);
 
     KisFilterMaskSP filterMask2 = new KisFilterMask();
     filterMask2->setName("filterMask2");
 
     kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration();
     filterMask2->setFilter(kfc);
     kfc = 0; // kfc cannot be shared!
 
     filterMask2->setSelection(createVectorSelection(paintLayer2->paintDevice(), image, doc->shapeController()));
     image->addNode(filterMask2, paintLayer2);
 
     KisTransparencyMaskSP transparencyMask1 = new KisTransparencyMask();
     transparencyMask1->setName("transparencyMask1");
     transparencyMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(transparencyMask1, group1);
 
     KisTransparencyMaskSP transparencyMask2 = new KisTransparencyMask();
     transparencyMask2->setName("transparencyMask2");
     transparencyMask2->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(transparencyMask2, group2);
 
     KisSelectionMaskSP selectionMask1 = new KisSelectionMask(image);
     image->addNode(selectionMask1, paintLayer1);
     selectionMask1->setName("selectionMask1");
     selectionMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
 
     KisSelectionMaskSP selectionMask2 = new KisSelectionMask(image);
     selectionMask2->setName("selectionMask2");
     selectionMask2->setSelection(createPixelSelection(paintLayer2->paintDevice()));
     image->addNode(selectionMask2, paintLayer2);
 
     KisTransformMaskSP transformMask = new KisTransformMask();
     transformMask->setName("testTransformMask");
     transformMask->setTransformParams(KisTransformMaskParamsInterfaceSP(
                                           new KisDumbTransformMaskParams(createTestingTransform())));
 
     image->addNode(transformMask, paintLayer2);
 
     if (shouldMaskToShapeLayer) {
         // add all-visible transparency mask to crash a shape layer
         KisTransparencyMaskSP transparencyMask3 = new KisTransparencyMask();
         transparencyMask3->setName("crashy-transparency-mask");
         transparencyMask3->initSelection(shapeLayer);
         image->addNode(transparencyMask3, shapeLayer);
     }
 
     return doc;
 }
 
 KisDocument *createEmptyDocument()
 {
     KisImageWSP image = new KisImage(0, 1024, 1024, KoColorSpaceRegistry::instance()->rgb8(), "test for roundtrip");
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     doc->setCurrentImage(image);
     doc->documentInfo()->setAboutInfo("title", image->objectName());
 
     return doc;
 }
 
 
 #endif
diff --git a/libs/ui/thememanager.cpp b/libs/ui/thememanager.cpp
index accb39af89..68a4f0f582 100644
--- a/libs/ui/thememanager.cpp
+++ b/libs/ui/thememanager.cpp
@@ -1,311 +1,310 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * http://www.digikam.org
  *
  * Date        : 2004-08-02
  * Description : theme manager
  *
  * Copyright (C) 2006-2011 by Gilles Caulier <caulier dot gilles at gmail dot 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, 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.
  *
  * ============================================================ */
 
 #include "thememanager.h"
 // Qt includes
 
 #include <QStringList>
 #include <QFileInfo>
 #include <QFile>
 #include <QApplication>
 #include <QPalette>
 #include <QColor>
 #include <QActionGroup>
 #include <QBitmap>
 #include <QPainter>
 #include <QPixmap>
 #include <QDate>
 #include <QDesktopWidget>
-#include <QApplication>
 #include <QMenu>
 #include <QMenuBar>
 #include <QStatusBar>
 #include <QDebug>
 #include <QStandardPaths>
 #include <QAction>
 #include <QMessageBox>
 
 // KDE includes
 
 #include <klocalizedstring.h>
 #include <kcolorscheme.h>
 #include <kactioncollection.h>
 #include <KoResourcePaths.h>
 #include <kactionmenu.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 // Calligra
 #include <kis_icon.h>
 
 #ifdef __APPLE__
 #include <QStyle>
 #endif
 
 namespace Digikam
 {
 
 // ---------------------------------------------------------------
 
 
 class ThemeManager::ThemeManagerPriv
 {
 public:
 
     ThemeManagerPriv()
         : themeMenuActionGroup(0)
         , themeMenuAction(0)
     {
     }
 
     QString                currentThemeName;
     QMap<QString, QString> themeMap;            // map<theme name, theme config path>
 
     QActionGroup*          themeMenuActionGroup;
     KActionMenu*           themeMenuAction;
 };
 
 ThemeManager::ThemeManager(const QString &theme, QObject *parent)
     : QObject(parent)
     , d(new ThemeManagerPriv)
 {
     //qDebug() << "Creating theme manager with theme" << theme;
     d->currentThemeName = theme;
     populateThemeMap();
 }
 
 ThemeManager::~ThemeManager()
 {
     delete d;
 }
 
 QString ThemeManager::currentThemeName() const
 {
     //qDebug() << "getting current themename";
     QString themeName;
     if (d->themeMenuAction && d->themeMenuActionGroup) {
 
         QAction* action = d->themeMenuActionGroup->checkedAction();
         if (action) {
             themeName = action->text().remove('&');
         }
 
         //qDebug() << "\tthemename from action" << themeName;
     }
     else if (!d->currentThemeName.isEmpty()) {
 
         //qDebug() << "\tcurrent themename" << d->currentThemeName;
         themeName = d->currentThemeName;
     }
     else {
         //qDebug() << "\tfallback";
         themeName = "Krita dark";
     }
     //qDebug() << "\tresult" << themeName;
     return themeName;
 }
 
 void ThemeManager::setCurrentTheme(const QString& name)
 {
     //qDebug() << "setCurrentTheme();" << d->currentThemeName << "to" << name;
     d->currentThemeName = name;
 
     if (d->themeMenuAction  && d->themeMenuActionGroup) {
         QList<QAction*> list = d->themeMenuActionGroup->actions();
         Q_FOREACH (QAction* action, list) {
             if (action->text().remove('&') == name) {
                 action->setChecked(true);
             }
         }
     }
     slotChangePalette();
 }
 
 void ThemeManager::slotChangePalette()
 {
     //qDebug() << "slotChangePalette" << sender();
 
     QString theme(currentThemeName());
     QString filename        = d->themeMap.value(theme);
     KSharedConfigPtr config = KSharedConfig::openConfig(filename);
 
     QPalette palette               = qApp->palette();
     QPalette::ColorGroup states[3] = { QPalette::Active, QPalette::Inactive, QPalette::Disabled };
     // TT thinks tooltips shouldn't use active, so we use our active colors for all states
     KColorScheme schemeTooltip(QPalette::Active, KColorScheme::Tooltip, config);
 
     for ( int i = 0; i < 3 ; ++i ) {
 
         QPalette::ColorGroup state = states[i];
         KColorScheme schemeView(state,      KColorScheme::View,      config);
         KColorScheme schemeWindow(state,    KColorScheme::Window,    config);
         KColorScheme schemeButton(state,    KColorScheme::Button,    config);
         KColorScheme schemeSelection(state, KColorScheme::Selection, config);
 
         palette.setBrush(state, QPalette::WindowText,      schemeWindow.foreground());
         palette.setBrush(state, QPalette::Window,          schemeWindow.background());
         palette.setBrush(state, QPalette::Base,            schemeView.background());
         palette.setBrush(state, QPalette::Text,            schemeView.foreground());
         palette.setBrush(state, QPalette::Button,          schemeButton.background());
         palette.setBrush(state, QPalette::ButtonText,      schemeButton.foreground());
         palette.setBrush(state, QPalette::Highlight,       schemeSelection.background());
         palette.setBrush(state, QPalette::HighlightedText, schemeSelection.foreground());
         palette.setBrush(state, QPalette::ToolTipBase,     schemeTooltip.background());
         palette.setBrush(state, QPalette::ToolTipText,     schemeTooltip.foreground());
 
         palette.setColor(state, QPalette::Light,           schemeWindow.shade(KColorScheme::LightShade));
         palette.setColor(state, QPalette::Midlight,        schemeWindow.shade(KColorScheme::MidlightShade));
         palette.setColor(state, QPalette::Mid,             schemeWindow.shade(KColorScheme::MidShade));
         palette.setColor(state, QPalette::Dark,            schemeWindow.shade(KColorScheme::DarkShade));
         palette.setColor(state, QPalette::Shadow,          schemeWindow.shade(KColorScheme::ShadowShade));
 
         palette.setBrush(state, QPalette::AlternateBase,   schemeView.background(KColorScheme::AlternateBackground));
         palette.setBrush(state, QPalette::Link,            schemeView.foreground(KColorScheme::LinkText));
         palette.setBrush(state, QPalette::LinkVisited,     schemeView.foreground(KColorScheme::VisitedText));
     }
 
     //qDebug() << ">>>>>>>>>>>>>>>>>> going to set palette on app" << theme;
     qApp->setPalette(palette);
 
 #ifdef Q_OS_OSX
     if (theme == "Krita bright" || theme.isEmpty()) {
         qApp->setStyle("Macintosh");
         qApp->style()->polish(qApp);
     } else {
         qApp->setStyle("Fusion");
         qApp->style()->polish(qApp);
     }
 #endif
 
     KisIconUtils::clearIconCache();
     emit signalThemeChanged();
 }
 
 void ThemeManager::setThemeMenuAction(KActionMenu* const action)
 {
     d->themeMenuAction = action;
     populateThemeMenu();
 }
 
 void ThemeManager::registerThemeActions(KActionCollection *actionCollection)
 {
     if (!d->themeMenuAction) return;
     actionCollection->addAction("theme_menu", d->themeMenuAction);
 }
 
 void ThemeManager::populateThemeMenu()
 {
     if (!d->themeMenuAction) return;
 
     d->themeMenuAction->menu()->clear();
     delete d->themeMenuActionGroup;
 
     d->themeMenuActionGroup = new QActionGroup(d->themeMenuAction);
     connect(d->themeMenuActionGroup, SIGNAL(triggered(QAction*)),
             this, SLOT(slotChangePalette()));
 
     QAction * action;
     const QStringList schemeFiles = KoResourcePaths::findAllResources("data", "color-schemes/*.colors");
 
     QMap<QString, QAction*> actionMap;
     for (int i = 0; i < schemeFiles.size(); ++i) {
         const QString filename  = schemeFiles.at(i);
         const QFileInfo info(filename);
         KSharedConfigPtr config = KSharedConfig::openConfig(filename);
         QIcon icon = createSchemePreviewIcon(config);
         KConfigGroup group(config, "General");
         const QString name = group.readEntry("Name", info.baseName());
         action = new QAction(name, d->themeMenuActionGroup);
         action->setIcon(icon);
         action->setCheckable(true);
         actionMap.insert(name, action);
     }
 
     // sort the list
     QStringList actionMapKeys = actionMap.keys();
     actionMapKeys.sort();
 
     Q_FOREACH (const QString& name, actionMapKeys) {
         if ( name ==  currentThemeName()) {
             actionMap.value(name)->setChecked(true);
         }
         d->themeMenuAction->addAction(actionMap.value(name));
     }
 }
 
 QPixmap ThemeManager::createSchemePreviewIcon(const KSharedConfigPtr& config)
 {
     // code taken from kdebase/workspace/kcontrol/colors/colorscm.cpp
     const uchar bits1[] = { 0xff, 0xff, 0xff, 0x2c, 0x16, 0x0b };
     const uchar bits2[] = { 0x68, 0x34, 0x1a, 0xff, 0xff, 0xff };
     const QSize bitsSize(24, 2);
     const QBitmap b1    = QBitmap::fromData(bitsSize, bits1);
     const QBitmap b2    = QBitmap::fromData(bitsSize, bits2);
 
     QPixmap pixmap(23, 16);
     pixmap.fill(Qt::black); // FIXME use some color other than black for borders?
 
     KConfigGroup group(config, "WM");
     QPainter p(&pixmap);
     KColorScheme windowScheme(QPalette::Active, KColorScheme::Window, config);
     p.fillRect(1,  1, 7, 7, windowScheme.background());
     p.fillRect(2,  2, 5, 2, QBrush(windowScheme.foreground().color(), b1));
 
     KColorScheme buttonScheme(QPalette::Active, KColorScheme::Button, config);
     p.fillRect(8,  1, 7, 7, buttonScheme.background());
     p.fillRect(9,  2, 5, 2, QBrush(buttonScheme.foreground().color(), b1));
 
     p.fillRect(15,  1, 7, 7, group.readEntry("activeBackground", QColor(96, 148, 207)));
     p.fillRect(16,  2, 5, 2, QBrush(group.readEntry("activeForeground", QColor(255, 255, 255)), b1));
 
     KColorScheme viewScheme(QPalette::Active, KColorScheme::View, config);
     p.fillRect(1,  8, 7, 7, viewScheme.background());
     p.fillRect(2, 12, 5, 2, QBrush(viewScheme.foreground().color(), b2));
 
     KColorScheme selectionScheme(QPalette::Active, KColorScheme::Selection, config);
     p.fillRect(8,  8, 7, 7, selectionScheme.background());
     p.fillRect(9, 12, 5, 2, QBrush(selectionScheme.foreground().color(), b2));
 
     p.fillRect(15,  8, 7, 7, group.readEntry("inactiveBackground", QColor(224, 223, 222)));
     p.fillRect(16, 12, 5, 2, QBrush(group.readEntry("inactiveForeground", QColor(20, 19, 18)), b2));
 
     p.end();
     return pixmap;
 }
 
 void ThemeManager::populateThemeMap()
 {
     const QStringList schemeFiles = KoResourcePaths::findAllResources("data", "color-schemes/*.colors");
     for (int i = 0; i < schemeFiles.size(); ++i) {
         const QString filename  = schemeFiles.at(i);
         const QFileInfo info(filename);
         KSharedConfigPtr config = KSharedConfig::openConfig(filename);
         KConfigGroup group(config, "General");
         const QString name = group.readEntry("Name", info.baseName());
         d->themeMap.insert(name, filename);
     }
 
 
 }
 
 }  // namespace Digikam
diff --git a/libs/ui/tool/kis_tool_paint.cc b/libs/ui/tool/kis_tool_paint.cc
index 2dd90afc38..d57b87f761 100644
--- a/libs/ui/tool/kis_tool_paint.cc
+++ b/libs/ui/tool/kis_tool_paint.cc
@@ -1,804 +1,801 @@
 /*
  *  Copyright (c) 2003-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_paint.h"
 
 #include <algorithm>
 
 #include <QWidget>
 #include <QRect>
 #include <QLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QWhatsThis>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QVariant>
 #include <QAction>
 #include <kis_debug.h>
 #include <QPoint>
 
-#include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
-#include <QAction>
 
 #include <kis_icon.h>
 #include <KoShape.h>
 #include <KoCanvasResourceManager.h>
 #include <KoColorSpace.h>
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_types.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_cubic_curve.h>
 #include "kis_display_color_converter.h"
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_tool_utils.h"
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_action_manager.h>
 #include <kis_action.h>
 #include "strokes/kis_color_picker_stroke_strategy.h"
-#include <kis_canvas_resource_provider.h>
 
 
 KisToolPaint::KisToolPaint(KoCanvasBase *canvas, const QCursor &cursor)
     : KisTool(canvas, cursor),
       m_showColorPreview(false),
       m_colorPreviewShowComparePlate(false),
       m_colorPickerDelayTimer(),
       m_isOutlineEnabled(true)
 {
     m_specialHoverModifier = false;
     m_optionsWidgetLayout = 0;
 
     m_opacity = OPACITY_OPAQUE_U8;
 
     m_supportOutline = false;
 
     {
         int maxSize = KisConfig(true).readEntry("maximumBrushSize", 1000);
 
         int brushSize = 1;
         do {
             m_standardBrushSizes.push_back(brushSize);
             int increment = qMax(1, int(std::ceil(qreal(brushSize) / 15)));
             brushSize += increment;
         } while (brushSize < maxSize);
 
         m_standardBrushSizes.push_back(maxSize);
     }
 
     KisCanvas2 *kiscanvas = dynamic_cast<KisCanvas2*>(canvas);
     KisActionManager *actionManager = kiscanvas->viewManager()->actionManager();
 
     // XXX: Perhaps a better place for these?
     if (!actionManager->actionByName("increase_brush_size")) {
         KisAction *increaseBrushSize = new KisAction(i18n("Increase Brush Size"));
         increaseBrushSize->setShortcut(Qt::Key_BracketRight);
         actionManager->addAction("increase_brush_size", increaseBrushSize);
     }
 
     if (!actionManager->actionByName("decrease_brush_size")) {
         KisAction *decreaseBrushSize = new KisAction(i18n("Decrease Brush Size"));
         decreaseBrushSize->setShortcut(Qt::Key_BracketLeft);
         actionManager->addAction("decrease_brush_size", decreaseBrushSize);
     }
 
     addAction("increase_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("increase_brush_size")));
     addAction("decrease_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("decrease_brush_size")));
 
     connect(this, SIGNAL(sigPaintingFinished()), kiscanvas->viewManager()->resourceProvider(), SLOT(slotPainting()));
 
     m_colorPickerDelayTimer.setSingleShot(true);
     connect(&m_colorPickerDelayTimer, SIGNAL(timeout()), this, SLOT(activatePickColorDelayed()));
 
     using namespace std::placeholders; // For _1 placeholder
     std::function<void(PickingJob)> callback =
         std::bind(&KisToolPaint::addPickerJob, this, _1);
     m_colorPickingCompressor.reset(
         new PickingCompressor(100, callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 
 KisToolPaint::~KisToolPaint()
 {
 }
 
 int KisToolPaint::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP;
 }
 
 void KisToolPaint::canvasResourceChanged(int key, const QVariant& v)
 {
     KisTool::canvasResourceChanged(key, v);
 
     switch(key) {
     case(KisCanvasResourceProvider::Opacity):
         setOpacity(v.toDouble());
         break;
     default: //nothing
         break;
     }
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()), Qt::UniqueConnection);
 
 }
 
 
 void KisToolPaint::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     if (currentPaintOpPreset()) {
         QString formattedBrushName = currentPaintOpPreset()->name().replace("_", " ");
         emit statusTextChanged(formattedBrushName);
     }
 
     KisTool::activate(toolActivation, shapes);
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         connect(action("increase_brush_size"), SIGNAL(triggered()), SLOT(increaseBrushSize()), Qt::UniqueConnection);
         connect(action("decrease_brush_size"), SIGNAL(triggered()), SLOT(decreaseBrushSize()), Qt::UniqueConnection);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_oldOpacity = provider->opacity();
     provider->setOpacity(m_localOpacity);
 }
 
 void KisToolPaint::deactivate()
 {
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         disconnect(action("increase_brush_size"), 0, this, 0);
         disconnect(action("decrease_brush_size"), 0, this, 0);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_localOpacity = provider->opacity();
     provider->setOpacity(m_oldOpacity);
 
     KisTool::deactivate();
 }
 
 QPainterPath KisToolPaint::tryFixBrushOutline(const QPainterPath &originalOutline)
 {
     KisConfig cfg(true);
     if (cfg.newOutlineStyle() == OUTLINE_NONE) return originalOutline;
 
     const qreal minThresholdSize = cfg.outlineSizeMinimum();
 
     /**
      * If the brush outline is bigger than the canvas itself (which
      * would make it invisible for a user in most of the cases) just
      * add a cross in the center of it
      */
 
     QSize widgetSize = canvas()->canvasWidget()->size();
     const int maxThresholdSum = widgetSize.width() + widgetSize.height();
 
     QPainterPath outline = originalOutline;
     QRectF boundingRect = outline.boundingRect();
     const qreal sum = boundingRect.width() + boundingRect.height();
 
     QPointF center = boundingRect.center();
 
     if (sum > maxThresholdSum) {
         const int hairOffset = 7;
 
         outline.moveTo(center.x(), center.y() - hairOffset);
         outline.lineTo(center.x(), center.y() + hairOffset);
 
         outline.moveTo(center.x() - hairOffset, center.y());
         outline.lineTo(center.x() + hairOffset, center.y());
     } else if (sum < minThresholdSize && !outline.isEmpty()) {
         outline = QPainterPath();
         outline.addEllipse(center, 0.5 * minThresholdSize, 0.5 * minThresholdSize);
     }
 
     return outline;
 }
 
 void KisToolPaint::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     QPainterPath path = tryFixBrushOutline(pixelToView(m_currentOutline));
     paintToolOutline(&gc, path);
 
     if (m_showColorPreview) {
         QRectF viewRect = converter.documentToView(m_oldColorPreviewRect);
         gc.fillRect(viewRect, m_colorPreviewCurrentColor);
 
         if (m_colorPreviewShowComparePlate) {
             QRectF baseColorRect = viewRect.translated(viewRect.width(), 0);
             gc.fillRect(baseColorRect, m_colorPreviewBaseColor);
         }
     }
 }
 
 void KisToolPaint::setMode(ToolMode mode)
 {
     if(this->mode() == KisTool::PAINT_MODE &&
             mode != KisTool::PAINT_MODE) {
 
         // Let's add history information about recently used colors
         emit sigPaintingFinished();
     }
 
     KisTool::setMode(mode);
 }
 
 void KisToolPaint::activatePickColor(AlternateAction action)
 {
     m_showColorPreview = true;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 
     int resource = colorPreviewResourceId(action);
     KoColor color = canvas()->resourceManager()->koColorResource(resource);
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
     m_colorPreviewCurrentColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     if (!m_colorPreviewBaseColor.isValid()) {
         m_colorPreviewBaseColor = m_colorPreviewCurrentColor;
     }
 }
 
 void KisToolPaint::deactivatePickColor(AlternateAction action)
 {
     Q_UNUSED(action);
 
     m_showColorPreview = false;
     m_oldColorPreviewRect = QRect();
     m_oldColorPreviewUpdateRect = QRect();
     m_colorPreviewCurrentColor = QColor();
 }
 
 void KisToolPaint::pickColorWasOverridden()
 {
     m_colorPreviewShowComparePlate = false;
     m_colorPreviewBaseColor = QColor();
 }
 
 void KisToolPaint::activateAlternateAction(AlternateAction action)
 {
     switch (action) {
     case PickFgNode:
         /* Falls through */
     case PickBgNode:
         /* Falls through */
     case PickFgImage:
         /* Falls through */
     case PickBgImage:
         delayedAction = action;
         m_colorPickerDelayTimer.start(100);
         /* Falls through */
     default:
         pickColorWasOverridden();
         KisTool::activateAlternateAction(action);
     };
 }
 
 void KisToolPaint::activatePickColorDelayed()
 {
     switch (delayedAction) {
         case PickFgNode:
         useCursor(KisCursor::pickerLayerForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgNode:
         useCursor(KisCursor::pickerLayerBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickFgImage:
         useCursor(KisCursor::pickerImageForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgImage:
         useCursor(KisCursor::pickerImageBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     default:
         break;
     };
 
     repaintDecorations();
 }
 
 bool KisToolPaint::isPickingAction(AlternateAction action) {
     return action == PickFgNode ||
         action == PickBgNode ||
         action == PickFgImage ||
         action == PickBgImage;
 }
 
 void KisToolPaint::deactivateAlternateAction(AlternateAction action)
 {
     if (!isPickingAction(action)) {
         KisTool::deactivateAlternateAction(action);
         return;
     }
 
     delayedAction = KisTool::NONE;
     m_colorPickerDelayTimer.stop();
 
     resetCursorStyle();
     deactivatePickColor(action);
 }
 
 void KisToolPaint::addPickerJob(const PickingJob &pickingJob)
 {
     /**
      * The actual picking is delayed by a compressor, so we can get this
      * event when the stroke is already closed
      */
     if (!m_pickerStrokeId) return;
 
     KIS_ASSERT_RECOVER_RETURN(isPickingAction(pickingJob.action));
 
     const QPoint imagePoint = image()->documentToImagePixelFloored(pickingJob.documentPixel);
     const bool fromCurrentNode = pickingJob.action == PickFgNode || pickingJob.action == PickBgNode;
     m_pickingResource = colorPreviewResourceId(pickingJob.action);
 
     if (!fromCurrentNode) {
         auto *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
         KisSharedPtr<KisReferenceImagesLayer> referencesLayer = kisCanvas->imageView()->document()->referenceImagesLayer();
         if (referencesLayer && kisCanvas->referenceImagesDecoration()->visible()) {
             QColor color = referencesLayer->getPixel(imagePoint);
             if (color.isValid() && color.alpha() != 0) {
                 slotColorPickingFinished(KoColor(color, image()->colorSpace()));
                 return;
             }
         }
     }
 
     KisPaintDeviceSP device = fromCurrentNode ?
         currentNode()->colorPickSourceDevice() : image()->projection();
 
     // Used for color picker blending.
     KoColor currentColor = canvas()->resourceManager()->foregroundColor();
     if( pickingJob.action == PickBgNode || pickingJob.action == PickBgImage ){
         currentColor = canvas()->resourceManager()->backgroundColor();
     }
 
     image()->addJob(m_pickerStrokeId,
                     new KisColorPickerStrokeStrategy::Data(device, imagePoint, currentColor));
 }
 
 void KisToolPaint::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(!m_pickerStrokeId);
         setMode(SECONDARY_PAINT_MODE);
 
         KisColorPickerStrokeStrategy *strategy = new KisColorPickerStrokeStrategy();
         connect(strategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
                 this, &KisToolPaint::slotColorPickingFinished);
 
         m_pickerStrokeId = image()->startStroke(strategy);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::beginAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::continueAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         image()->endStroke(m_pickerStrokeId);
         m_pickerStrokeId.clear();
         requestUpdateOutline(event->point, event);
         setMode(HOVER_MODE);
     } else {
         KisTool::endAlternateAction(event, action);
     }
 }
 
 int KisToolPaint::colorPreviewResourceId(AlternateAction action)
 {
     bool toForegroundColor = action == PickFgNode || action == PickFgImage;
     int resource = toForegroundColor ?
         KoCanvasResourceManager::ForegroundColor : KoCanvasResourceManager::BackgroundColor;
 
     return resource;
 }
 
 void KisToolPaint::slotColorPickingFinished(const KoColor &color)
 {
     canvas()->resourceManager()->setResource(m_pickingResource, color);
 
     if (!m_showColorPreview) return;
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     QColor previewColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     m_colorPreviewShowComparePlate = true;
     m_colorPreviewCurrentColor = previewColor;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseMoveEvent(KoPointerEvent *event)
 {
     KisTool::mouseMoveEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 QWidget * KisToolPaint::createOptionWidget()
 {
     QWidget *optionWidget = new QWidget();
     optionWidget->setObjectName(toolId());
 
     QVBoxLayout *verticalLayout = new QVBoxLayout(optionWidget);
     verticalLayout->setObjectName("KisToolPaint::OptionWidget::VerticalLayout");
     verticalLayout->setContentsMargins(0,0,0,0);
     verticalLayout->setSpacing(5);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     verticalLayout->addWidget(specialSpacer);
     verticalLayout->addWidget(specialSpacer);
 
     m_optionsWidgetLayout = new QGridLayout();
     m_optionsWidgetLayout->setColumnStretch(1, 1);
 
     verticalLayout->addLayout(m_optionsWidgetLayout);
     m_optionsWidgetLayout->setContentsMargins(0,0,0,0);
     m_optionsWidgetLayout->setSpacing(5);
 
     if (!quickHelp().isEmpty()) {
         QPushButton *push = new QPushButton(KisIconUtils::loadIcon("help-contents"), QString(), optionWidget);
         connect(push, SIGNAL(clicked()), this, SLOT(slotPopupQuickHelp()));
 
         QHBoxLayout *hLayout = new QHBoxLayout(optionWidget);
         hLayout->addWidget(push);
         hLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
         verticalLayout->addLayout(hLayout);
     }
 
     return optionWidget;
 }
 
 QWidget* findLabelWidget(QGridLayout *layout, QWidget *control)
 {
     QWidget *result = 0;
 
     int index = layout->indexOf(control);
 
     int row, col, rowSpan, colSpan;
     layout->getItemPosition(index, &row, &col, &rowSpan, &colSpan);
 
     if (col > 0) {
         QLayoutItem *item = layout->itemAtPosition(row, col - 1);
 
         if (item) {
             result = item->widget();
         }
     } else {
         QLayoutItem *item = layout->itemAtPosition(row, col + 1);
         if (item) {
             result = item->widget();
         }
     }
 
     return result;
 }
 
 void KisToolPaint::showControl(QWidget *control, bool value)
 {
     control->setVisible(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setVisible(value);
     }
 }
 
 void KisToolPaint::enableControl(QWidget *control, bool value)
 {
     control->setEnabled(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setEnabled(value);
     }
 }
 
 void KisToolPaint::addOptionWidgetLayout(QLayout *layout)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     int rowCount = m_optionsWidgetLayout->rowCount();
     m_optionsWidgetLayout->addLayout(layout, rowCount, 0, 1, 2);
 }
 
 
 void KisToolPaint::addOptionWidgetOption(QWidget *control, QWidget *label)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     if (label) {
         m_optionsWidgetLayout->addWidget(label, m_optionsWidgetLayout->rowCount(), 0);
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount() - 1, 1);
     }
     else {
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount(), 0, 1, 2);
     }
 }
 
 
 void KisToolPaint::setOpacity(qreal opacity)
 {
     m_opacity = quint8(opacity * OPACITY_OPAQUE_U8);
 }
 
 const KoCompositeOp* KisToolPaint::compositeOp()
 {
     if (currentNode()) {
         KisPaintDeviceSP device = currentNode()->paintDevice();
         if (device) {
             QString op = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentCompositeOp).toString();
             return device->colorSpace()->compositeOp(op);
         }
     }
     return 0;
 }
 
 void KisToolPaint::slotPopupQuickHelp()
 {
     QWhatsThis::showText(QCursor::pos(), quickHelp());
 }
 
 KisToolPaint::NodePaintAbility KisToolPaint::nodePaintAbility()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return NONE;
     }
     if (node->inherits("KisShapeLayer")) {
         return VECTOR;
     }
     if (node->inherits("KisCloneLayer")) {
         return CLONE;
     }
     if (node->paintDevice()) {
         return PAINT;
     }
     return NONE;
 }
 
 void KisToolPaint::activatePrimaryAction()
 {
     pickColorWasOverridden();
     setOutlineEnabled(true);
     KisTool::activatePrimaryAction();
 }
 
 void KisToolPaint::deactivatePrimaryAction()
 {
     setOutlineEnabled(false);
     KisTool::deactivatePrimaryAction();
 }
 
 bool KisToolPaint::isOutlineEnabled() const
 {
     return m_isOutlineEnabled;
 }
 
 void KisToolPaint::setOutlineEnabled(bool value)
 {
     m_isOutlineEnabled = value;
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::increaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::iterator result =
         std::upper_bound(m_standardBrushSizes.begin(),
                          m_standardBrushSizes.end(),
                          qRound(paintopSize));
 
     int newValue = result != m_standardBrushSizes.end() ? *result : m_standardBrushSizes.back();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::decreaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::reverse_iterator result =
         std::upper_bound(m_standardBrushSizes.rbegin(),
                          m_standardBrushSizes.rend(),
                          (int)paintopSize,
                          std::greater<int>());
 
     int newValue = result != m_standardBrushSizes.rend() ? *result : m_standardBrushSizes.front();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QRectF KisToolPaint::colorPreviewDocRect(const QPointF &outlineDocPoint)
 {
     if (!m_showColorPreview) return QRect();
 
     KisConfig cfg(true);
 
     const QRectF colorPreviewViewRect = cfg.colorPreviewRect();
     const QRectF colorPreviewDocumentRect = canvas()->viewConverter()->viewToDocument(colorPreviewViewRect);
 
     return colorPreviewDocumentRect.translated(outlineDocPoint);
 }
 
 void KisToolPaint::requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event)
 {
     if (!m_supportOutline) return;
 
     KisConfig cfg(true);
     KisPaintOpSettings::OutlineMode outlineMode;
 
     if (isOutlineEnabled() &&
         (mode() == KisTool::GESTURE_MODE ||
          ((cfg.newOutlineStyle() == OUTLINE_FULL ||
            cfg.newOutlineStyle() == OUTLINE_CIRCLE ||
            cfg.newOutlineStyle() == OUTLINE_TILT) &&
           ((mode() == HOVER_MODE) ||
            (mode() == PAINT_MODE && cfg.showOutlineWhilePainting()))))) { // lisp forever!
 
         outlineMode.isVisible = true;
 
         if (cfg.newOutlineStyle() == OUTLINE_CIRCLE) {
             outlineMode.forceCircle = true;
         } else if(cfg.newOutlineStyle() == OUTLINE_TILT) {
             outlineMode.forceCircle = true;
             outlineMode.showTiltDecoration = true;
         } else {
             // noop
         }
     }
 
     outlineMode.forceFullSize = cfg.forceAlwaysFullSizedOutline();
 
     m_outlineDocPoint = outlineDocPoint;
     m_currentOutline = getOutlinePath(m_outlineDocPoint, event, outlineMode);
 
     QRectF outlinePixelRect = m_currentOutline.boundingRect();
     QRectF outlineDocRect = currentImage()->pixelToDocument(outlinePixelRect);
 
     // This adjusted call is needed as we paint with a 3 pixel wide brush and the pen is outside the bounds of the path
     // Pen uses view coordinates so we have to zoom the document value to match 2 pixel in view coordiates
     // See BUG 275829
     qreal zoomX;
     qreal zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     qreal xoffset = 2.0/zoomX;
     qreal yoffset = 2.0/zoomY;
 
     if (!outlineDocRect.isEmpty()) {
         outlineDocRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     QRectF colorPreviewDocRect = this->colorPreviewDocRect(m_outlineDocPoint);
     QRectF colorPreviewDocUpdateRect;
     if (!colorPreviewDocRect.isEmpty()) {
         colorPreviewDocUpdateRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     // DIRTY HACK ALERT: we should fetch the assistant's dirty rect when requesting
     //                   the update, instead of just dumbly update the entire canvas!
 
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas());
     KisPaintingAssistantsDecorationSP decoration = kiscanvas->paintingAssistantsDecoration();
     if (decoration && decoration->visible()) {
         kiscanvas->updateCanvas();
     } else {
         // TODO: only this branch should be present!
         if (!m_oldColorPreviewUpdateRect.isEmpty()) {
             canvas()->updateCanvas(m_oldColorPreviewUpdateRect);
         }
 
         if (!m_oldOutlineRect.isEmpty()) {
             canvas()->updateCanvas(m_oldOutlineRect);
         }
 
         if (!outlineDocRect.isEmpty()) {
             canvas()->updateCanvas(outlineDocRect);
         }
 
         if (!colorPreviewDocUpdateRect.isEmpty()) {
             canvas()->updateCanvas(colorPreviewDocUpdateRect);
         }
     }
 
     m_oldOutlineRect = outlineDocRect;
     m_oldColorPreviewRect = colorPreviewDocRect;
     m_oldColorPreviewUpdateRect = colorPreviewDocUpdateRect;
 }
 
 QPainterPath KisToolPaint::getOutlinePath(const QPointF &documentPos,
                                           const KoPointerEvent *event,
                                           KisPaintOpSettings::OutlineMode outlineMode)
 {
     Q_UNUSED(event);
 
     QPointF imagePos = currentImage()->documentToPixel(documentPos);
     QPainterPath path = currentPaintOpPreset()->settings()->
         brushOutline(KisPaintInformation(imagePos), outlineMode);
 
     return path;
 }
 
diff --git a/libs/ui/widgets/KoFillConfigWidget.cpp b/libs/ui/widgets/KoFillConfigWidget.cpp
index edb2ecf96d..efd13872fb 100644
--- a/libs/ui/widgets/KoFillConfigWidget.cpp
+++ b/libs/ui/widgets/KoFillConfigWidget.cpp
@@ -1,852 +1,851 @@
 /* This file is part of the KDE project
  * Made by Tomislav Lukman (tomislav.lukman@ck.tel.hr)
  * Copyright (C) 2012 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 "KoFillConfigWidget.h"
 
 #include <QToolButton>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QButtonGroup>
 #include <QLabel>
 #include <QSizePolicy>
 #include <QBitmap>
 #include <QAction>
 #include <QSharedPointer>
 
 #include <klocalizedstring.h>
 
 #include <KoIcon.h>
 #include <KoColor.h>
 #include <KoColorPopupAction.h>
 #include "KoResourceServerProvider.h"
 #include "KoResourceServerAdapter.h"
 #include "KoResourceSelector.h"
 #include <KoSelection.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasResourceManager.h>
 #include <KoDocumentResourceManager.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoShapeBackground.h>
 #include <KoShapeBackgroundCommand.h>
 #include <KoShapeStrokeCommand.h>
 #include <KoShapeStroke.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoColorBackground.h>
 #include <KoGradientBackground.h>
 #include <KoPatternBackground.h>
 #include <KoImageCollection.h>
 #include <KoResourcePopupAction.h>
 #include "KoZoomHandler.h"
 #include "KoColorPopupButton.h"
 #include "ui_KoFillConfigWidget.h"
 #include <kis_signals_blocker.h>
 #include <kis_signal_compressor.h>
 #include <kis_acyclic_signal_connector.h>
 #include <kis_assert.h>
-#include <KoCanvasResourceManager.h>
 #include "kis_canvas_resource_provider.h"
 #include <KoStopGradient.h>
 #include <QInputDialog>
 #include <KoShapeFillWrapper.h>
 
 #include "kis_global.h"
 #include "kis_debug.h"
 
 static const char* const buttonnone[]={
     "16 16 3 1",
     "# c #000000",
     "e c #ff0000",
     "- c #ffffff",
     "################",
     "#--------------#",
     "#-e----------e-#",
     "#--e--------e--#",
     "#---e------e---#",
     "#----e----e----#",
     "#-----e--e-----#",
     "#------ee------#",
     "#------ee------#",
     "#-----e--e-----#",
     "#----e----e----#",
     "#---e------e---#",
     "#--e--------e--#",
     "#-e----------e-#",
     "#--------------#",
     "################"};
 
 static const char* const buttonsolid[]={
     "16 16 2 1",
     "# c #000000",
     ". c #969696",
     "################",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "#..............#",
     "################"};
 
 
 // FIXME: Smoother gradient button.
 
 static const char* const buttongradient[]={
     "16 16 15 1",
     "# c #000000",
     "n c #101010",
     "m c #202020",
     "l c #303030",
     "k c #404040",
     "j c #505050",
     "i c #606060",
     "h c #707070",
     "g c #808080",
     "f c #909090",
     "e c #a0a0a0",
     "d c #b0b0b0",
     "c c #c0c0c0",
     "b c #d0d0d0",
     "a c #e0e0e0",
     "################",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "#abcdefghijklmn#",
     "################"};
 
 static const char* const buttonpattern[]={
     "16 16 4 1",
     ". c #0a0a0a",
     "# c #333333",
     "a c #a0a0a0",
     "b c #ffffffff",
     "################",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "#bbbbbaaaabbbbb#",
     "#bbbbbaaaabbbbb#",
     "#bbbbbaaaabbbbb#",
     "#bbbbbaaaabbbbb#",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "#aaaaabbbbaaaaa#",
     "################"};
 
 class Q_DECL_HIDDEN KoFillConfigWidget::Private
 {
 public:
     Private(KoFlake::FillVariant _fillVariant)
     : canvas(0),
       colorChangedCompressor(100, KisSignalCompressor::FIRST_ACTIVE),
       gradientChangedCompressor(100, KisSignalCompressor::FIRST_ACTIVE),
       fillVariant(_fillVariant),
       noSelectionTrackingMode(false)
     {
     }
 
     KoColorPopupAction *colorAction;
     KoResourcePopupAction *gradientAction;
     KoResourcePopupAction *patternAction;
     QButtonGroup *group;
 
     KoCanvasBase *canvas;
 
     KisSignalCompressor colorChangedCompressor;
     KisAcyclicSignalConnector shapeChangedAcyclicConnector;
     KisAcyclicSignalConnector resourceManagerAcyclicConnector;
     KoFillConfigWidget::StyleButton selectedFillIndex;
 
     QSharedPointer<KoStopGradient> activeGradient;
     KisSignalCompressor gradientChangedCompressor;
     KoFlake::FillVariant fillVariant;
 
     bool noSelectionTrackingMode;
 
     Ui_KoFillConfigWidget *ui;
 
     std::vector<KisAcyclicSignalConnector::Blocker> deactivationLocks;
 };
 
 KoFillConfigWidget::KoFillConfigWidget(KoCanvasBase *canvas, KoFlake::FillVariant fillVariant, bool trackShapeSelection, QWidget *parent)
     :  QWidget(parent)
     , d(new Private(fillVariant))
 {
     d->canvas = canvas;
 
     if (trackShapeSelection) {
         d->shapeChangedAcyclicConnector.connectBackwardVoid(
                     d->canvas->selectedShapesProxy(), SIGNAL(selectionChanged()),
                     this, SLOT(shapeChanged()));
 
         d->shapeChangedAcyclicConnector.connectBackwardVoid(
                     d->canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()),
                     this, SLOT(shapeChanged()));
     }
 
     d->resourceManagerAcyclicConnector.connectBackwardResourcePair(
             d->canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     d->resourceManagerAcyclicConnector.connectForwardVoid(
          this, SIGNAL(sigInternalRequestColorToResourceManager()),
          this, SLOT(slotProposeCurrentColorToResourceManager()));
 
 
     // confure GUI
 
     d->ui = new Ui_KoFillConfigWidget();
     d->ui->setupUi(this);
 
     d->group = new QButtonGroup(this);
     d->group->setExclusive(true);
 
     d->ui->btnNoFill->setIcon(QPixmap((const char **) buttonnone));
     d->group->addButton(d->ui->btnNoFill, None);
 
     d->ui->btnSolidFill->setIcon(QPixmap((const char **) buttonsolid));
     d->group->addButton(d->ui->btnSolidFill, Solid);
 
     d->ui->btnGradientFill->setIcon(QPixmap((const char **) buttongradient));
     d->group->addButton(d->ui->btnGradientFill, Gradient);
 
     d->ui->btnPatternFill->setIcon(QPixmap((const char **) buttonpattern));
     d->group->addButton(d->ui->btnPatternFill, Pattern);
 
     d->colorAction = new KoColorPopupAction(d->ui->btnChooseSolidColor);
     d->colorAction->setToolTip(i18n("Change the filling color"));
     d->colorAction->setCurrentColor(Qt::white);
 
     d->ui->btnChooseSolidColor->setDefaultAction(d->colorAction);
     d->ui->btnChooseSolidColor->setPopupMode(QToolButton::InstantPopup);
     d->ui->btnSolidColorPick->setIcon(KisIconUtils::loadIcon("krita_tool_color_picker"));
 
     // TODO: for now the color picking button is disabled!
     d->ui->btnSolidColorPick->setEnabled(false);
     d->ui->btnSolidColorPick->setVisible(false);
 
     connect(d->colorAction, SIGNAL(colorChanged(const KoColor &)), &d->colorChangedCompressor, SLOT(start()));
     connect(&d->colorChangedCompressor, SIGNAL(timeout()), SLOT(colorChanged()));
 
     connect(d->ui->btnChooseSolidColor, SIGNAL(iconSizeChanged()), d->colorAction, SLOT(updateIcon()));
 
     connect(d->group, SIGNAL(buttonClicked(int)), SLOT(styleButtonPressed(int)));
 
     connect(d->group, SIGNAL(buttonClicked(int)), SLOT(slotUpdateFillTitle()));
 
     slotUpdateFillTitle();
     styleButtonPressed(d->group->checkedId());
 
 
     // Gradient selector
     d->ui->wdgGradientEditor->setCompactMode(true);
     connect(d->ui->wdgGradientEditor, SIGNAL(sigGradientChanged()), &d->gradientChangedCompressor, SLOT(start()));
     connect(&d->gradientChangedCompressor, SIGNAL(timeout()), SLOT(activeGradientChanged()));
 
     KoResourceServerProvider *serverProvider = KoResourceServerProvider::instance();
     QSharedPointer<KoAbstractResourceServerAdapter> gradientResourceAdapter(
                 new KoResourceServerAdapter<KoAbstractGradient>(serverProvider->gradientServer()));
 
     d->gradientAction = new KoResourcePopupAction(gradientResourceAdapter,
                                                   d->ui->btnChoosePredefinedGradient);
 
     d->gradientAction->setToolTip(i18n("Change filling gradient"));
     d->ui->btnChoosePredefinedGradient->setDefaultAction(d->gradientAction);
     d->ui->btnChoosePredefinedGradient->setPopupMode(QToolButton::InstantPopup);
 
     connect(d->gradientAction, SIGNAL(resourceSelected(QSharedPointer<KoShapeBackground> )),
             SLOT(gradientResourceChanged()));
     connect(d->ui->btnChoosePredefinedGradient, SIGNAL(iconSizeChanged()), d->gradientAction, SLOT(updateIcon()));
 
     d->ui->btnSaveGradient->setIcon(KisIconUtils::loadIcon("document-save"));
     connect(d->ui->btnSaveGradient, SIGNAL(clicked()), SLOT(slotSavePredefinedGradientClicked()));
 
     connect(d->ui->cmbGradientRepeat, SIGNAL(currentIndexChanged(int)), SLOT(slotGradientRepeatChanged()));
     connect(d->ui->cmbGradientType, SIGNAL(currentIndexChanged(int)), SLOT(slotGradientTypeChanged()));
 
     deactivate();
 
 #if 0
 
     // Pattern selector
     QSharedPointer<KoAbstractResourceServerAdapter>patternResourceAdapter(new KoResourceServerAdapter<KoPattern>(serverProvider->patternServer()));
     d->patternAction = new KoResourcePopupAction(patternResourceAdapter, d->colorButton);
     d->patternAction->setToolTip(i18n("Change the filling pattern"));
     connect(d->patternAction, SIGNAL(resourceSelected(QSharedPointer<KoShapeBackground> )), this, SLOT(patternChanged(QSharedPointer<KoShapeBackground> )));
     connect(d->colorButton, SIGNAL(iconSizeChanged()), d->patternAction, SLOT(updateIcon()));
 
 #endif
 
 }
 
 KoFillConfigWidget::~KoFillConfigWidget()
 {
     delete d;
 }
 
 void KoFillConfigWidget::activate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->deactivationLocks.empty());
     d->deactivationLocks.clear();
 
     if (!d->noSelectionTrackingMode) {
         shapeChanged();
     } else {
         loadCurrentFillFromResourceServer();
     }
 
     updateWidgetComponentVisbility();
 }
 
 void KoFillConfigWidget::deactivate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->deactivationLocks.empty());
     d->deactivationLocks.push_back(KisAcyclicSignalConnector::Blocker(d->shapeChangedAcyclicConnector));
     d->deactivationLocks.push_back(KisAcyclicSignalConnector::Blocker(d->resourceManagerAcyclicConnector));
 }
 
 void KoFillConfigWidget::forceUpdateOnSelectionChanged()
 {
     shapeChanged();
 }
 
 void KoFillConfigWidget::setNoSelectionTrackingMode(bool value)
 {
     d->noSelectionTrackingMode = value;
     if (!d->noSelectionTrackingMode) {
         shapeChanged();
     }
 }
 
 void KoFillConfigWidget::slotUpdateFillTitle()
 {
     QString text = d->group->checkedButton() ? d->group->checkedButton()->text() : QString();
     text.replace('&', QString());
     d->ui->lblFillTitle->setText(text);
 }
 
 void KoFillConfigWidget::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if ((key == KoCanvasResourceManager::ForegroundColor && d->fillVariant == KoFlake::Fill) ||
         (key == KoCanvasResourceManager::BackgroundColor &&
          d->fillVariant == KoFlake::StrokeFill && !d->noSelectionTrackingMode) ||
         (key == KoCanvasResourceManager::ForegroundColor && d->noSelectionTrackingMode)) {
 
         KoColor color = value.value<KoColor>();
 
         const int checkedId = d->group->checkedId();
 
         if ((checkedId < 0 || checkedId == None || checkedId == Solid) &&
             !(checkedId == Solid && d->colorAction->currentKoColor() == color)) {
 
             d->group->button(Solid)->setChecked(true);
             d->selectedFillIndex = Solid;
 
             d->colorAction->setCurrentColor(color);
             d->colorChangedCompressor.start();
         } else if (checkedId == Gradient && key == KoCanvasResourceManager::ForegroundColor) {
             d->ui->wdgGradientEditor->notifyGlobalColorChanged(color);
         }
     } else if (key == KisCanvasResourceProvider::CurrentGradient) {
         KoResource *gradient = value.value<KoAbstractGradient*>();
         const int checkedId = d->group->checkedId();
 
         if (gradient && (checkedId < 0 || checkedId == None || checkedId == Gradient)) {
             d->group->button(Gradient)->setChecked(true);
             d->gradientAction->setCurrentResource(gradient);
         }
     }
 }
 
 QList<KoShape*> KoFillConfigWidget::currentShapes()
 {
     return d->canvas->selectedShapesProxy()->selection()->selectedEditableShapes();
 }
 
 int KoFillConfigWidget::selectedFillIndex() {
     return d->selectedFillIndex;
 }
 
 void KoFillConfigWidget::styleButtonPressed(int buttonId)
 {
     switch (buttonId) {
         case KoFillConfigWidget::None:
             noColorSelected();
             break;
         case KoFillConfigWidget::Solid:
             colorChanged();
             break;
         case KoFillConfigWidget::Gradient:
             if (d->activeGradient) {
                 activeGradientChanged();
             } else {
                 gradientResourceChanged();
             }
             break;
         case KoFillConfigWidget::Pattern:
             // Only select mode in the widget, don't set actual pattern :/
             //d->colorButton->setDefaultAction(d->patternAction);
             //patternChanged(d->patternAction->currentBackground());
             break;
     }
 
     if (buttonId >= None && buttonId <= Pattern) {
         d->selectedFillIndex = static_cast<KoFillConfigWidget::StyleButton>(buttonId);
         updateWidgetComponentVisbility();
     }
 }
 
 KoShapeStrokeSP KoFillConfigWidget::createShapeStroke()
 {
     KoShapeStrokeSP stroke(new KoShapeStroke());
     KIS_ASSERT_RECOVER_RETURN_VALUE(d->fillVariant == KoFlake::StrokeFill, stroke);
 
     switch (d->group->checkedId()) {
     case KoFillConfigWidget::None:
         stroke->setColor(Qt::transparent);
         break;
     case KoFillConfigWidget::Solid:
         stroke->setColor(d->colorAction->currentColor());
         break;
     case KoFillConfigWidget::Gradient: {
         QScopedPointer<QGradient> g(d->activeGradient->toQGradient());
         QBrush newBrush = *g;
         stroke->setLineBrush(newBrush);
         stroke->setColor(Qt::transparent);
         break;
     }
     case KoFillConfigWidget::Pattern:
         break;
     }
 
     return stroke;
 }
 
 void KoFillConfigWidget::noColorSelected()
 {
     KisAcyclicSignalConnector::Blocker b(d->shapeChangedAcyclicConnector);
 
     QList<KoShape*> selectedShapes = currentShapes();
     if (selectedShapes.isEmpty()) {
         emit sigFillChanged();
         return;
     }
 
     KoShapeFillWrapper wrapper(selectedShapes, d->fillVariant);
     KUndo2Command *command = wrapper.setColor(QColor());
 
     if (command) {
         d->canvas->addCommand(command);
     }
 
     emit sigFillChanged();
 }
 
 void KoFillConfigWidget::colorChanged()
 {
     KisAcyclicSignalConnector::Blocker b(d->shapeChangedAcyclicConnector);
 
     QList<KoShape*> selectedShapes = currentShapes();
     if (selectedShapes.isEmpty()) {
         emit sigInternalRequestColorToResourceManager();
         emit sigFillChanged();
         return;
     }
 
     KoShapeFillWrapper wrapper(selectedShapes, d->fillVariant);
     KUndo2Command *command = wrapper.setColor(d->colorAction->currentColor());
 
     if (command) {
         d->canvas->addCommand(command);
     }
 
     emit sigInternalRequestColorToResourceManager();
     emit sigFillChanged();
 }
 
 void KoFillConfigWidget::slotProposeCurrentColorToResourceManager()
 {
     const int checkedId = d->group->checkedId();
 
     bool hasColor = false;
     KoColor color;
     KoCanvasResourceManager::CanvasResource colorSlot = KoCanvasResourceManager::ForegroundColor;
 
 
     if (checkedId == Solid) {
         if (d->fillVariant == KoFlake::StrokeFill) {
             colorSlot = KoCanvasResourceManager::BackgroundColor;
         }
         color = d->colorAction->currentKoColor();
         hasColor = true;
     } else if (checkedId == Gradient) {
         if (boost::optional<KoColor> gradientColor = d->ui->wdgGradientEditor->currentActiveStopColor()) {
             color = *gradientColor;
             hasColor = true;
         }
     }
 
     if (hasColor) {
         /**
          * Don't let opacity leak to our resource manager system
          *
          * NOTE: theoretically, we could guarantee it on a level of the
          * resource manager itself,
          */
         color.setOpacity(OPACITY_OPAQUE_U8);
         d->canvas->resourceManager()->setResource(colorSlot, QVariant::fromValue(color));
     }
 }
 
 template <class ResourceServer>
 QString findFirstAvailableResourceName(const QString &baseName, ResourceServer *server)
 {
     if (!server->resourceByName(baseName)) return baseName;
 
     int counter = 1;
     QString result;
     while ((result = QString("%1%2").arg(baseName).arg(counter)),
            server->resourceByName(result)) {
 
         counter++;
     }
 
     return result;
 }
 
 
 void KoFillConfigWidget::slotSavePredefinedGradientClicked()
 {
     KoResourceServerProvider *serverProvider = KoResourceServerProvider::instance();
     auto server = serverProvider->gradientServer();
 
     const QString defaultGradientNamePrefix = i18nc("default prefix for the saved gradient", "gradient");
 
     QString name = d->activeGradient->name().isEmpty() ? defaultGradientNamePrefix : d->activeGradient->name();
     name = findFirstAvailableResourceName(name, server);
     name = QInputDialog::getText(this, i18nc("@title:window", "Save Gradient"), i18n("Enter gradient name:"), QLineEdit::Normal, name);
 
     // TODO: currently we do not allow the user to
     //       create two resources with the same name!
     //       Please add some feedback for it!
     name = findFirstAvailableResourceName(name, server);
 
     d->activeGradient->setName(name);
 
     const QString saveLocation = server->saveLocation();
     d->activeGradient->setFilename(saveLocation + d->activeGradient->name() + d->activeGradient->defaultFileExtension());
 
     KoAbstractGradient *newGradient = d->activeGradient->clone();
     server->addResource(newGradient);
 
     d->gradientAction->setCurrentResource(newGradient);
 }
 
 void KoFillConfigWidget::activeGradientChanged()
 {
     setNewGradientBackgroundToShape();
     updateGradientSaveButtonAvailability();
 
     emit sigInternalRequestColorToResourceManager();
 }
 
 void KoFillConfigWidget::gradientResourceChanged()
 {
     QSharedPointer<KoGradientBackground> bg =
         qSharedPointerDynamicCast<KoGradientBackground>(
             d->gradientAction->currentBackground());
 
     uploadNewGradientBackground(bg->gradient());
 
     setNewGradientBackgroundToShape();
     updateGradientSaveButtonAvailability();
 }
 
 void KoFillConfigWidget::slotGradientTypeChanged()
 {
     QGradient::Type type =
         d->ui->cmbGradientType->currentIndex() == 0 ?
             QGradient::LinearGradient : QGradient::RadialGradient;
 
     d->activeGradient->setType(type);
     activeGradientChanged();
 }
 
 void KoFillConfigWidget::slotGradientRepeatChanged()
 {
     QGradient::Spread spread =
         QGradient::Spread(d->ui->cmbGradientRepeat->currentIndex());
 
     d->activeGradient->setSpread(spread);
     activeGradientChanged();
 }
 
 void KoFillConfigWidget::uploadNewGradientBackground(const QGradient *gradient)
 {
     KisSignalsBlocker b1(d->ui->wdgGradientEditor,
                          d->ui->cmbGradientType,
                          d->ui->cmbGradientRepeat);
 
     d->ui->wdgGradientEditor->setGradient(0);
 
     d->activeGradient.reset(KoStopGradient::fromQGradient(gradient));
 
     d->ui->wdgGradientEditor->setGradient(d->activeGradient.data());
     d->ui->cmbGradientType->setCurrentIndex(d->activeGradient->type() != QGradient::LinearGradient);
     d->ui->cmbGradientRepeat->setCurrentIndex(int(d->activeGradient->spread()));
 }
 
 void KoFillConfigWidget::setNewGradientBackgroundToShape()
 {
     QList<KoShape*> selectedShapes = currentShapes();
     if (selectedShapes.isEmpty()) {
         emit sigFillChanged();
         return;
     }
 
     KisAcyclicSignalConnector::Blocker b(d->shapeChangedAcyclicConnector);
 
     KoShapeFillWrapper wrapper(selectedShapes, d->fillVariant);
     QScopedPointer<QGradient> srcQGradient(d->activeGradient->toQGradient());
     KUndo2Command *command = wrapper.applyGradientStopsOnly(srcQGradient.data());
 
     if (command) {
         d->canvas->addCommand(command);
     }
 
     emit sigFillChanged();
 }
 
 void KoFillConfigWidget::updateGradientSaveButtonAvailability()
 {
     bool savingEnabled = false;
 
     QScopedPointer<QGradient> currentGradient(d->activeGradient->toQGradient());
     QSharedPointer<KoShapeBackground> bg = d->gradientAction->currentBackground();
     if (bg) {
         QSharedPointer<KoGradientBackground> resourceBackground =
             qSharedPointerDynamicCast<KoGradientBackground>(bg);
 
         savingEnabled = resourceBackground->gradient()->stops() != currentGradient->stops();
         savingEnabled |= resourceBackground->gradient()->type() != currentGradient->type();
         savingEnabled |= resourceBackground->gradient()->spread() != currentGradient->spread();
     }
 
     d->ui->btnSaveGradient->setEnabled(savingEnabled);
 }
 
 void KoFillConfigWidget::patternChanged(QSharedPointer<KoShapeBackground>  background)
 {
     Q_UNUSED(background);
 
 #if 0
     QSharedPointer<KoPatternBackground> patternBackground = qSharedPointerDynamicCast<KoPatternBackground>(background);
     if (! patternBackground) {
         return;
     }
 
     QList<KoShape*> selectedShapes = currentShapes();
     if (selectedShapes.isEmpty()) {
         return;
     }
 
     KoImageCollection *imageCollection = d->canvas->shapeController()->resourceManager()->imageCollection();
     if (imageCollection) {
         QSharedPointer<KoPatternBackground> fill(new KoPatternBackground(imageCollection));
         fill->setPattern(patternBackground->pattern());
         d->canvas->addCommand(new KoShapeBackgroundCommand(selectedShapes, fill));
     }
 #endif
 }
 
 void KoFillConfigWidget::loadCurrentFillFromResourceServer()
 {
     {
         KoColor color = d->canvas->resourceManager()->backgroundColor();
         slotCanvasResourceChanged(KoCanvasResourceManager::BackgroundColor, QVariant::fromValue(color));
     }
 
     {
         KoColor color = d->canvas->resourceManager()->foregroundColor();
         slotCanvasResourceChanged(KoCanvasResourceManager::ForegroundColor, QVariant::fromValue(color));
     }
 
     Q_FOREACH (QAbstractButton *button, d->group->buttons()) {
         button->setEnabled(true);
     }
 
     emit sigFillChanged();
 }
 
 void KoFillConfigWidget::shapeChanged()
 {
     if (d->noSelectionTrackingMode) return;
 
     QList<KoShape*> shapes = currentShapes();
 
     if (shapes.isEmpty() ||
         (shapes.size() > 1 && KoShapeFillWrapper(shapes, d->fillVariant).isMixedFill())) {
 
         Q_FOREACH (QAbstractButton *button, d->group->buttons()) {
             button->setEnabled(!shapes.isEmpty());
         }
 
         d->group->button(None)->setChecked(true);
         d->selectedFillIndex = None;
 
     } else {
         Q_FOREACH (QAbstractButton *button, d->group->buttons()) {
             button->setEnabled(true);
         }
 
         KoShape *shape = shapes.first();
         updateWidget(shape);
     }
 }
 
 bool KoFillConfigWidget::checkNewFillModeIsSame(const KoShapeFillWrapper &w) const
 {
     bool retval = false;
 
     switch (w.type()) {
     case KoFlake::None:
         retval = d->selectedFillIndex == None;
         break;
     case KoFlake::Solid:
         retval = d->selectedFillIndex == Solid && w.color() == d->colorAction->currentColor();
         break;
     case KoFlake::Gradient: {
         QScopedPointer<KoStopGradient> newGradient(KoStopGradient::fromQGradient(w.gradient()));
 
         retval = d->selectedFillIndex == Gradient && *newGradient == *d->activeGradient;
         break;
     }
     case KoFlake::Pattern:
         // TODO: not implemented
         retval = d->selectedFillIndex == Pattern && false;
         break;
     }
 
     return retval;
 }
 
 void KoFillConfigWidget::updateWidget(KoShape *shape)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(shape);
 
     StyleButton newActiveButton = None;
     KoShapeFillWrapper wrapper(shape, d->fillVariant);
 
     if (checkNewFillModeIsSame(wrapper)) return;
 
     switch (wrapper.type()) {
     case KoFlake::None:
         break;
     case KoFlake::Solid: {
         QColor color = wrapper.color();
         if (color.alpha() > 0) {
             newActiveButton = KoFillConfigWidget::Solid;
             d->colorAction->setCurrentColor(wrapper.color());
         }
         break;
     }
     case KoFlake::Gradient:
         newActiveButton = KoFillConfigWidget::Gradient;
         uploadNewGradientBackground(wrapper.gradient());
         updateGradientSaveButtonAvailability();
         break;
     case KoFlake::Pattern:
         newActiveButton = KoFillConfigWidget::Pattern;
         break;
     }
 
     d->group->button(newActiveButton)->setChecked(true);
 
     d->selectedFillIndex = newActiveButton;
     updateWidgetComponentVisbility();
 }
 
 
 void KoFillConfigWidget::updateWidgetComponentVisbility()
 {
     // The UI is showing/hiding things like this because the 'stacked widget' isn't very flexible
     // and makes it difficult to put anything underneath it without a lot empty space
 
     // hide everything first
     d->ui->wdgGradientEditor->setVisible(false);
     d->ui->btnChoosePredefinedGradient->setVisible(false);
     d->ui->btnChooseSolidColor->setVisible(false);
     d->ui->typeLabel->setVisible(false);
     d->ui->repeatLabel->setVisible(false);
     d->ui->cmbGradientRepeat->setVisible(false);
     d->ui->cmbGradientType->setVisible(false);
     d->ui->btnSolidColorPick->setVisible(false);
     d->ui->btnSaveGradient->setVisible(false);
     d->ui->gradientTypeLine->setVisible(false);
     d->ui->soldStrokeColorLabel->setVisible(false);
     d->ui->presetLabel->setVisible(false);
 
     switch (d->selectedFillIndex) {
         case KoFillConfigWidget::None:
             break;
         case KoFillConfigWidget::Solid:
             d->ui->btnChooseSolidColor->setVisible(true);
             d->ui->btnSolidColorPick->setVisible(true);
             d->ui->soldStrokeColorLabel->setVisible(true);
             break;
         case KoFillConfigWidget::Gradient:
             d->ui->wdgGradientEditor->setVisible(true);
             d->ui->btnChoosePredefinedGradient->setVisible(true);
             d->ui->typeLabel->setVisible(true);
             d->ui->repeatLabel->setVisible(true);
             d->ui->cmbGradientRepeat->setVisible(true);
             d->ui->cmbGradientType->setVisible(true);
             d->ui->btnSaveGradient->setVisible(true);
             d->ui->gradientTypeLine->setVisible(true);
             d->ui->presetLabel->setVisible(true);
             break;
         case KoFillConfigWidget::Pattern:
             break;
     }
 
 }
diff --git a/libs/ui/widgets/KoStrokeConfigWidget.cpp b/libs/ui/widgets/KoStrokeConfigWidget.cpp
index 3b5117b3d4..984327a767 100644
--- a/libs/ui/widgets/KoStrokeConfigWidget.cpp
+++ b/libs/ui/widgets/KoStrokeConfigWidget.cpp
@@ -1,805 +1,804 @@
 /* This file is part of the KDE project
  * Made by Tomislav Lukman (tomislav.lukman@ck.tel.hr)
  * Copyright (C) 2002 Tomislav Lukman <tomislav.lukman@ck.t-com.hr>
  * Copyright (C) 2002-2003 Rob Buis <buis@kde.org>
  * Copyright (C) 2005-2006 Tim Beaulen <tbscope@gmail.com>
  * Copyright (C) 2005-2007 Thomas Zander <zander@kde.org>
  * Copyright (C) 2005-2006, 2011 Inge Wallin <inge@lysator.liu.se>
  * Copyright (C) 2005-2008 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2006 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2006 Peter Simonsson <psn@linux.se>
  * Copyright (C) 2006 Laurent Montel <montel@kde.org>
  * Copyright (C) 2007,2011 Thorsten Zachmann <t.zachmann@zagge.de>
  * 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.
  */
 
 // Own
 #include "KoStrokeConfigWidget.h"
 
 // Qt
 #include <QMenu>
 #include <QToolButton>
 #include <QButtonGroup>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QSizePolicy>
 #include <QSignalMapper>
 
 // KDE
 #include <klocalizedstring.h>
 
 // Calligra
 #include <KoIcon.h>
 #include <KoUnit.h>
 #include <KoLineStyleSelector.h>
 #include <KoUnitDoubleSpinBox.h>
 #include <KoMarkerSelector.h>
 #include <KoColorPopupAction.h>
 #include <KoMarker.h>
 #include <KoShapeStroke.h>
 #include <KoPathShape.h>
 #include <KoMarkerCollection.h>
 #include <KoPathShapeMarkerCommand.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoCanvasResourceManager.h>
 #include <KoDocumentResourceManager.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 #include <KoShapeStrokeCommand.h>
 #include <KoShapeStrokeModel.h>
 #include <KoSelectedShapesProxy.h>
 #include "ui_KoStrokeConfigWidget.h"
 #include <KoFlakeUtils.h>
-#include <KoCanvasBase.h>
 #include <KoFillConfigWidget.h>
 #include "kis_canvas_resource_provider.h"
 #include "kis_acyclic_signal_connector.h"
 
 // Krita
 #include "kis_double_parse_unit_spin_box.h"
 
 class CapNJoinMenu : public QMenu
 {
 public:
     CapNJoinMenu(QWidget *parent = 0);
     QSize sizeHint() const override;
 
     KisDoubleParseUnitSpinBox *miterLimit;
     QButtonGroup        *capGroup;
     QButtonGroup        *joinGroup;
 };
 
 CapNJoinMenu::CapNJoinMenu(QWidget *parent)
     : QMenu(parent)
 {
     QGridLayout *mainLayout = new QGridLayout();
     mainLayout->setMargin(2);
 
      // The cap group
     capGroup = new QButtonGroup(this);
     capGroup->setExclusive(true);
 
     QToolButton *button = 0;
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-cap-butt"));
     button->setCheckable(true);
     button->setToolTip(i18n("Butt cap"));
     capGroup->addButton(button, Qt::FlatCap);
     mainLayout->addWidget(button, 2, 0);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-cap-round"));
     button->setCheckable(true);
     button->setToolTip(i18n("Round cap"));
     capGroup->addButton(button, Qt::RoundCap);
     mainLayout->addWidget(button, 2, 1);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-cap-square"));
     button->setCheckable(true);
     button->setToolTip(i18n("Square cap"));
     capGroup->addButton(button, Qt::SquareCap);
     mainLayout->addWidget(button, 2, 2, Qt::AlignLeft);
 
     // The join group
     joinGroup = new QButtonGroup(this);
     joinGroup->setExclusive(true);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-join-miter"));
     button->setCheckable(true);
     button->setToolTip(i18n("Miter join"));
     joinGroup->addButton(button, Qt::MiterJoin);
     mainLayout->addWidget(button, 3, 0);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-join-round"));
     button->setCheckable(true);
     button->setToolTip(i18n("Round join"));
     joinGroup->addButton(button, Qt::RoundJoin);
     mainLayout->addWidget(button, 3, 1);
 
     button = new QToolButton(this);
     button->setIcon(koIcon("stroke-join-bevel"));
     button->setCheckable(true);
     button->setToolTip(i18n("Bevel join"));
     joinGroup->addButton(button, Qt::BevelJoin);
     mainLayout->addWidget(button, 3, 2, Qt::AlignLeft);
 
     // Miter limit
     // set min/max/step and value in points, then set actual unit
     miterLimit = new KisDoubleParseUnitSpinBox(this);
     miterLimit->setMinMaxStep(0.0, 1000.0, 0.5);
     miterLimit->setDecimals(2);
     miterLimit->setUnit(KoUnit(KoUnit::Point));
     miterLimit->setToolTip(i18n("Miter limit"));
     mainLayout->addWidget(miterLimit, 4, 0, 1, 3);
 
     mainLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
     setLayout(mainLayout);
 }
 
 QSize CapNJoinMenu::sizeHint() const
 {
     return layout()->sizeHint();
 }
 
 
 class Q_DECL_HIDDEN KoStrokeConfigWidget::Private
 {
 public:
     Private()
         : canvas(0),
         active(true),
         allowLocalUnitManagement(true),
         fillConfigWidget(0),
         noSelectionTrackingMode(false)
     {
     }
 
     KoLineStyleSelector *lineStyle;
     KisDoubleParseUnitSpinBox *lineWidth;
     KoMarkerSelector    *startMarkerSelector;
     KoMarkerSelector    *midMarkerSelector;
     KoMarkerSelector    *endMarkerSelector;
 
    CapNJoinMenu *capNJoinMenu;
 
     QWidget *spacer;
 
     KoCanvasBase *canvas;
 
     bool active;
     bool allowLocalUnitManagement;
 
     KoFillConfigWidget *fillConfigWidget;
     bool noSelectionTrackingMode;
 
     KisAcyclicSignalConnector shapeChangedAcyclicConnector;
     KisAcyclicSignalConnector resourceManagerAcyclicConnector;
 
     std::vector<KisAcyclicSignalConnector::Blocker> deactivationLocks;
 
     Ui_KoStrokeConfigWidget *ui;
 };
 
 
 KoStrokeConfigWidget::KoStrokeConfigWidget(KoCanvasBase *canvas, QWidget * parent)
     : QWidget(parent)
     , d(new Private())
 {
     // confure GUI
     d->ui = new Ui_KoStrokeConfigWidget();
     d->ui->setupUi(this);
 
     setObjectName("Stroke widget");
 
     { // connect the canvas
         d->shapeChangedAcyclicConnector.connectBackwardVoid(
             canvas->selectedShapesProxy(), SIGNAL(selectionChanged()),
             this, SLOT(selectionChanged()));
 
         d->shapeChangedAcyclicConnector.connectBackwardVoid(
             canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()),
             this, SLOT(selectionChanged()));
 
         d->resourceManagerAcyclicConnector.connectBackwardResourcePair(
             canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
             this, SLOT(canvasResourceChanged(int, const QVariant &)));
 
         d->canvas = canvas;
     }
 
 
     {
 
        d->fillConfigWidget = new KoFillConfigWidget(canvas, KoFlake::StrokeFill, false, this);
        d->fillConfigWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
        d->ui->fillConfigWidgetLayout->addWidget(d->fillConfigWidget);
        connect(d->fillConfigWidget, SIGNAL(sigFillChanged()), SIGNAL(sigStrokeChanged()));
     }
 
     d->ui->thicknessLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     d->ui->thicknessLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     // set min/max/step and value in points, then set actual unit
     d->ui->lineWidth->setMinMaxStep(0.0, 1000.0, 0.5);
     d->ui->lineWidth->setDecimals(2);
     d->ui->lineWidth->setUnit(KoUnit(KoUnit::Point));
     d->ui->lineWidth->setToolTip(i18n("Set line width of actual selection"));
 
     d->ui->capNJoinButton->setMinimumHeight(25);
     d->capNJoinMenu = new CapNJoinMenu(this);
     d->ui->capNJoinButton->setMenu(d->capNJoinMenu);
     d->ui->capNJoinButton->setText("...");
     d->ui->capNJoinButton->setPopupMode(QToolButton::InstantPopup);
 
 
     {
         // Line style
         d->ui->strokeStyleLabel->setText(i18n("Line Style:"));
         d->ui->strokeStyleLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
 
         d->ui->lineStyle->setToolTip(i18nc("@info:tooltip", "Line style"));
         d->ui->lineStyle->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
         d->ui->lineStyle->setLineStyle(Qt::SolidLine,  QVector<qreal>());
     }
 
 
     {
         QList<KoMarker*> emptyMarkers;
 
 
         d->startMarkerSelector = new KoMarkerSelector(KoFlake::StartMarker, this);
         d->startMarkerSelector->setToolTip(i18nc("@info:tooltip", "Start marker"));
         d->startMarkerSelector->updateMarkers(emptyMarkers);
         d->startMarkerSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred );
         d->ui->markerLayout->addWidget(d->startMarkerSelector);
 
 
         d->midMarkerSelector = new KoMarkerSelector(KoFlake::MidMarker, this);
         d->midMarkerSelector->setToolTip(i18nc("@info:tooltip", "Node marker"));
         d->midMarkerSelector->updateMarkers(emptyMarkers);
         d->midMarkerSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred );
         d->ui->markerLayout->addWidget(d->midMarkerSelector);
 
 
         d->endMarkerSelector = new KoMarkerSelector(KoFlake::EndMarker, this);
         d->endMarkerSelector->setToolTip(i18nc("@info:tooltip", "End marker"));
         d->endMarkerSelector->updateMarkers(emptyMarkers);
         d->endMarkerSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred );
 
         d->ui->markerLayout->addWidget(d->endMarkerSelector);
     }
 
     // Spacer
     d->spacer = new QWidget();
     d->spacer->setObjectName("SpecialSpacer");
 
     d->ui->markerLayout->addWidget(d->spacer);
 
     connect(d->ui->lineStyle,  SIGNAL(currentIndexChanged(int)), this, SLOT(applyDashStyleChanges()));
     connect(d->ui->lineWidth,  SIGNAL(valueChangedPt(qreal)),    this, SLOT(applyLineWidthChanges()));
 
     connect(d->capNJoinMenu->capGroup,   SIGNAL(buttonClicked(int)),       this, SLOT(applyJoinCapChanges()));
     connect(d->capNJoinMenu->joinGroup,  SIGNAL(buttonClicked(int)),       this, SLOT(applyJoinCapChanges()));
     connect(d->capNJoinMenu->miterLimit, SIGNAL(valueChangedPt(qreal)),    this, SLOT(applyJoinCapChanges()));
 
     { // Map the marker signals correctly
         QSignalMapper *mapper = new QSignalMapper(this);
         connect(mapper, SIGNAL(mapped(int)), SLOT(applyMarkerChanges(int)));
 
         connect(d->startMarkerSelector,  SIGNAL(currentIndexChanged(int)), mapper, SLOT(map()));
         connect(d->midMarkerSelector,  SIGNAL(currentIndexChanged(int)), mapper, SLOT(map()));
         connect(d->endMarkerSelector,  SIGNAL(currentIndexChanged(int)), mapper, SLOT(map()));
 
         mapper->setMapping(d->startMarkerSelector, KoFlake::StartMarker);
         mapper->setMapping(d->midMarkerSelector, KoFlake::MidMarker);
         mapper->setMapping(d->endMarkerSelector, KoFlake::EndMarker);
     }
 
     KoDocumentResourceManager *resourceManager = canvas->shapeController()->resourceManager();
     if (resourceManager) {
         KoMarkerCollection *collection = resourceManager->resource(KoDocumentResourceManager::MarkerCollection).value<KoMarkerCollection*>();
         if (collection) {
             updateMarkers(collection->markers());
         }
     }
 
     selectionChanged();
 
     d->fillConfigWidget->activate();
     deactivate();
 }
 
 KoStrokeConfigWidget::~KoStrokeConfigWidget()
 {
     delete d;
 }
 
 void KoStrokeConfigWidget::setNoSelectionTrackingMode(bool value)
 {
     d->fillConfigWidget->setNoSelectionTrackingMode(value);
     d->noSelectionTrackingMode = value;
     if (!d->noSelectionTrackingMode) {
         selectionChanged();
     }
 }
 
 // ----------------------------------------------------------------
 //                         getters and setters
 
 
 Qt::PenStyle KoStrokeConfigWidget::lineStyle() const
 {
     return d->ui->lineStyle->lineStyle();
 }
 
 QVector<qreal> KoStrokeConfigWidget::lineDashes() const
 {
     return d->ui->lineStyle->lineDashes();
 }
 
 qreal KoStrokeConfigWidget::lineWidth() const
 {
     return d->ui->lineWidth->value();
 }
 
 qreal KoStrokeConfigWidget::miterLimit() const
 {
     return d->capNJoinMenu->miterLimit->value();
 }
 
 KoMarker *KoStrokeConfigWidget::startMarker() const
 {
     return d->startMarkerSelector->marker();
 }
 
 KoMarker *KoStrokeConfigWidget::endMarker() const
 {
     return d->endMarkerSelector->marker();
 }
 
 Qt::PenCapStyle KoStrokeConfigWidget::capStyle() const
 {
     return static_cast<Qt::PenCapStyle>(d->capNJoinMenu->capGroup->checkedId());
 }
 
 Qt::PenJoinStyle KoStrokeConfigWidget::joinStyle() const
 {
     return static_cast<Qt::PenJoinStyle>(d->capNJoinMenu->joinGroup->checkedId());
 }
 
 KoShapeStrokeSP KoStrokeConfigWidget::createShapeStroke()
 {
     KoShapeStrokeSP stroke(d->fillConfigWidget->createShapeStroke());
 
     stroke->setLineWidth(lineWidth());
     stroke->setCapStyle(capStyle());
     stroke->setJoinStyle(joinStyle());
     stroke->setMiterLimit(miterLimit());
     stroke->setLineStyle(lineStyle(), lineDashes());
 
     return stroke;
 }
 
 // ----------------------------------------------------------------
 //                         Other public functions
 
 void KoStrokeConfigWidget::updateStyleControlsAvailability(bool enabled)
 {
     d->ui->lineWidth->setEnabled(enabled);
     d->capNJoinMenu->setEnabled(enabled);
     d->ui->lineStyle->setEnabled(enabled);
 
     d->startMarkerSelector->setEnabled(enabled);
     d->midMarkerSelector->setEnabled(enabled);
     d->endMarkerSelector->setEnabled(enabled);
 }
 
 void KoStrokeConfigWidget::setUnit(const KoUnit &unit, KoShape *representativeShape)
 {
     if (!d->allowLocalUnitManagement) {
         return; //the unit management is completely transferred to the unitManagers.
     }
 
     blockChildSignals(true);
 
     /**
      * KoStrokeShape knows nothing about the transformations applied
      * to the shape, which doesn't prevent the shape to apply them and
      * display the stroke differently. So just take that into account
      * and show the user correct values using the multiplier in KoUnit.
      */
     KoUnit newUnit(unit);
     if (representativeShape) {
         newUnit.adjustByPixelTransform(representativeShape->absoluteTransformation(0));
     }
 
     d->ui->lineWidth->setUnit(newUnit);
     d->capNJoinMenu->miterLimit->setUnit(newUnit);
 
     d->ui->lineWidth->setLineStep(1.0);
     d->capNJoinMenu->miterLimit->setLineStep(1.0);
 
     blockChildSignals(false);
 }
 
 void KoStrokeConfigWidget::setUnitManagers(KisSpinBoxUnitManager* managerLineWidth,
                                            KisSpinBoxUnitManager *managerMitterLimit)
 {
     blockChildSignals(true);
     d->allowLocalUnitManagement = false;
     d->ui->lineWidth->setUnitManager(managerLineWidth);
     d->capNJoinMenu->miterLimit->setUnitManager(managerMitterLimit);
     blockChildSignals(false);
 }
 
 void KoStrokeConfigWidget::updateMarkers(const QList<KoMarker*> &markers)
 {
     d->startMarkerSelector->updateMarkers(markers);
     d->midMarkerSelector->updateMarkers(markers);
     d->endMarkerSelector->updateMarkers(markers);
 }
 
 void KoStrokeConfigWidget::activate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->deactivationLocks.empty());
     d->deactivationLocks.clear();
     d->fillConfigWidget->activate();
 
     if (!d->noSelectionTrackingMode) {
         selectionChanged();
     } else {
         loadCurrentStrokeFillFromResourceServer();
     }
 }
 
 void KoStrokeConfigWidget::deactivate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->deactivationLocks.empty());
 
     d->deactivationLocks.push_back(KisAcyclicSignalConnector::Blocker(d->shapeChangedAcyclicConnector));
     d->deactivationLocks.push_back(KisAcyclicSignalConnector::Blocker(d->resourceManagerAcyclicConnector));
     d->fillConfigWidget->deactivate();
 }
 
 void KoStrokeConfigWidget::blockChildSignals(bool block)
 {
     d->ui->lineWidth->blockSignals(block);
     d->capNJoinMenu->capGroup->blockSignals(block);
     d->capNJoinMenu->joinGroup->blockSignals(block);
     d->capNJoinMenu->miterLimit->blockSignals(block);
     d->ui->lineStyle->blockSignals(block);
     d->startMarkerSelector->blockSignals(block);
     d->midMarkerSelector->blockSignals(block);
     d->endMarkerSelector->blockSignals(block);
 }
 
 void KoStrokeConfigWidget::setActive(bool active)
 {
     d->active = active;
 }
 
 //------------------------
 
 template <typename ModifyFunction>
     auto applyChangeToStrokes(KoCanvasBase *canvas, ModifyFunction modifyFunction)
         -> decltype(modifyFunction(KoShapeStrokeSP()), void())
 {
     KoSelection *selection = canvas->selectedShapesProxy()->selection();
 
     if (!selection) return;
 
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     KUndo2Command *command = KoFlake::modifyShapesStrokes(shapes, modifyFunction);
 
     if (command) {
         canvas->addCommand(command);
     }
 }
 
 void KoStrokeConfigWidget::applyDashStyleChanges()
 {
     applyChangeToStrokes(
         d->canvas,
         [this] (KoShapeStrokeSP stroke) {
             stroke->setLineStyle(lineStyle(), lineDashes());
         });
 
     emit sigStrokeChanged();
 }
 
 void KoStrokeConfigWidget::applyLineWidthChanges()
 {
     applyChangeToStrokes(
         d->canvas,
         [this] (KoShapeStrokeSP stroke) {
             stroke->setLineWidth(lineWidth());
         });
 
     emit sigStrokeChanged();
 }
 
 void KoStrokeConfigWidget::applyJoinCapChanges()
 {
     applyChangeToStrokes(
         d->canvas,
         [this] (KoShapeStrokeSP stroke) {
 
             stroke->setCapStyle(static_cast<Qt::PenCapStyle>(d->capNJoinMenu->capGroup->checkedId()));
             stroke->setJoinStyle(static_cast<Qt::PenJoinStyle>(d->capNJoinMenu->joinGroup->checkedId()));
             stroke->setMiterLimit(miterLimit());
         });
 
     emit sigStrokeChanged();
 }
 
 void KoStrokeConfigWidget::applyMarkerChanges(int rawPosition)
 {
     KoSelection *selection = d->canvas->selectedShapesProxy()->selection();
     if (!selection) {
         emit sigStrokeChanged();
         return;
     }
 
     QList<KoShape*> shapes = selection->selectedEditableShapes();
     QList<KoPathShape*> pathShapes;
     Q_FOREACH (KoShape *shape, shapes) {
         KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
         if (pathShape) {
             pathShapes << pathShape;
         }
     }
 
     if (pathShapes.isEmpty()) {
         emit sigStrokeChanged();
         return;
     }
 
 
     KoFlake::MarkerPosition position = KoFlake::MarkerPosition(rawPosition);
     QScopedPointer<KoMarker> marker;
 
     switch (position) {
     case KoFlake::StartMarker:
         if (d->startMarkerSelector->marker()) {
             marker.reset(new KoMarker(*d->startMarkerSelector->marker()));
         }
         break;
     case KoFlake::MidMarker:
         if (d->midMarkerSelector->marker()) {
             marker.reset(new KoMarker(*d->midMarkerSelector->marker()));
         }
         break;
     case KoFlake::EndMarker:
         if (d->endMarkerSelector->marker()) {
             marker.reset(new KoMarker(*d->endMarkerSelector->marker()));
         }
         break;
     }
 
     KUndo2Command* command = new KoPathShapeMarkerCommand(pathShapes, marker.take(), position);
     d->canvas->addCommand(command);
 
     emit sigStrokeChanged();
 }
 
 // ----------------------------------------------------------------
 
 struct CheckShapeStrokeStyleBasePolicy
 {
     typedef KoShapeStrokeSP PointerType;
     static PointerType getProperty(KoShape *shape) {
         return qSharedPointerDynamicCast<KoShapeStroke>(shape->stroke());
     }
 };
 
 struct CheckShapeStrokeDashesPolicy : public CheckShapeStrokeStyleBasePolicy
 {
     static bool compareTo(PointerType p1, PointerType p2) {
         return p1->lineStyle() == p2->lineStyle() &&
                 p1->lineDashes() == p2->lineDashes() &&
                 p1->dashOffset() == p2->dashOffset();
     }
 };
 
 struct CheckShapeStrokeCapJoinPolicy : public CheckShapeStrokeStyleBasePolicy
 {
     static bool compareTo(PointerType p1, PointerType p2) {
         return p1->capStyle() == p2->capStyle() &&
                 p1->joinStyle() == p2->joinStyle() &&
                 p1->miterLimit() == p2->miterLimit();
     }
 };
 
 struct CheckShapeStrokeWidthPolicy : public CheckShapeStrokeStyleBasePolicy
 {
     static bool compareTo(PointerType p1, PointerType p2) {
         return p1->lineWidth() == p2->lineWidth();
     }
 };
 
 struct CheckShapeMarkerPolicy
 {
     CheckShapeMarkerPolicy(KoFlake::MarkerPosition position)
         : m_position(position)
     {
     }
 
     typedef KoMarker* PointerType;
     PointerType getProperty(KoShape *shape) const {
         KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
         return pathShape ? pathShape->marker(m_position) : 0;
     }
     bool compareTo(PointerType p1, PointerType p2) const {
         if ((!p1 || !p2) && p1 != p2) return false;
         if (!p1 && p1 == p2) return true;
 
         return p1 == p2 || *p1 == *p2;
     }
 
     KoFlake::MarkerPosition m_position;
 };
 
 void KoStrokeConfigWidget::selectionChanged()
 {
     if (d->noSelectionTrackingMode) return;
 
     KoSelection *selection = d->canvas->selectedShapesProxy()->selection();
     if (!selection) return;
 
     // we need to linearize update order, and force the child widget to update
     // before we start doing it
     d->fillConfigWidget->forceUpdateOnSelectionChanged();
 
 
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     KoShape *shape = !shapes.isEmpty() ? shapes.first() : 0;
 
     const KoShapeStrokeSP stroke = shape ? qSharedPointerDynamicCast<KoShapeStroke>(shape->stroke()) : KoShapeStrokeSP();
 
     // setUnit uses blockChildSignals() so take care not to use it inside the block
     setUnit(d->canvas->unit(), shape);
 
     blockChildSignals(true);
 
     // line width
     if (stroke && KoFlake::compareShapePropertiesEqual<CheckShapeStrokeWidthPolicy>(shapes)) {
         d->ui->lineWidth->changeValue(stroke->lineWidth());
     } else {
         d->ui->lineWidth->changeValue(0);
     }
 
 
     // caps & joins
     if (stroke && KoFlake::compareShapePropertiesEqual<CheckShapeStrokeCapJoinPolicy>(shapes)) {
         Qt::PenCapStyle capStyle = stroke->capStyle() >= 0 ? stroke->capStyle() : Qt::FlatCap;
         Qt::PenJoinStyle joinStyle = stroke->joinStyle() >= 0 ? stroke->joinStyle() : Qt::MiterJoin;
 
         {
             QAbstractButton *button = d->capNJoinMenu->capGroup->button(capStyle);
             KIS_SAFE_ASSERT_RECOVER_RETURN(button);
             button->setChecked(true);
         }
 
         {
             QAbstractButton *button = d->capNJoinMenu->joinGroup->button(joinStyle);
             KIS_SAFE_ASSERT_RECOVER_RETURN(button);
             button->setChecked(true);
         }
 
         d->capNJoinMenu->miterLimit->changeValue(stroke->miterLimit());
         d->capNJoinMenu->miterLimit->setEnabled(joinStyle == Qt::MiterJoin);
     } else {
         d->capNJoinMenu->capGroup->button(Qt::FlatCap)->setChecked(true);
         d->capNJoinMenu->joinGroup->button(Qt::MiterJoin)->setChecked(true);
         d->capNJoinMenu->miterLimit->changeValue(0.0);
         d->capNJoinMenu->miterLimit->setEnabled(true);
     }
 
 
     // dashes style
     if (stroke && KoFlake::compareShapePropertiesEqual<CheckShapeStrokeDashesPolicy>(shapes)) {
         d->ui->lineStyle->setLineStyle(stroke->lineStyle(), stroke->lineDashes());
     } else {
         d->ui->lineStyle->setLineStyle(Qt::SolidLine, QVector<qreal>());
     }
 
     // markers
     KoPathShape *pathShape = dynamic_cast<KoPathShape *>(shape);
     if (pathShape) {
         if (KoFlake::compareShapePropertiesEqual(shapes, CheckShapeMarkerPolicy(KoFlake::StartMarker))) {
             d->startMarkerSelector->setMarker(pathShape->marker(KoFlake::StartMarker));
         }
         if (KoFlake::compareShapePropertiesEqual(shapes, CheckShapeMarkerPolicy(KoFlake::MidMarker))) {
             d->midMarkerSelector->setMarker(pathShape->marker(KoFlake::MidMarker));
         }
         if (KoFlake::compareShapePropertiesEqual(shapes, CheckShapeMarkerPolicy(KoFlake::EndMarker))) {
             d->endMarkerSelector->setMarker(pathShape->marker(KoFlake::EndMarker));
         }
     }
 
     const bool lineOptionsVisible =  d->fillConfigWidget->selectedFillIndex() != 0;
 
     // This switch statement is to help the tab widget "pages" to be closer to the correct size
     // if we don't do this the internal widgets get rendered, then the tab page has to get resized to
     // fill up the space, then the internal widgets have to resize yet again...causing flicker
     switch(d->fillConfigWidget->selectedFillIndex()) {
         case 0: // no fill
             this->setMinimumHeight(130);
             break;
         case 1: // solid fill
              this->setMinimumHeight(200);
              break;
         case 2: // gradient fill
             this->setMinimumHeight(350);
         case 3: // pattern fill
             break;
     }
 
 
     d->ui->thicknessLineBreak->setVisible(lineOptionsVisible);
     d->ui->lineWidth->setVisible(lineOptionsVisible);
     d->ui->capNJoinButton->setVisible(lineOptionsVisible);
     d->ui->lineStyle->setVisible(lineOptionsVisible);
     d->startMarkerSelector->setVisible(lineOptionsVisible);
     d->midMarkerSelector->setVisible(lineOptionsVisible);
     d->endMarkerSelector->setVisible(lineOptionsVisible);
     d->ui->thicknessLabel->setVisible(lineOptionsVisible);
     d->ui->strokeStyleLabel->setVisible(lineOptionsVisible);
 
 
 
     blockChildSignals(false);
 
     updateStyleControlsAvailability(!shapes.isEmpty());
 
 }
 
 void KoStrokeConfigWidget::canvasResourceChanged(int key, const QVariant &value)
 {
     switch (key) {
     case KoCanvasResourceManager::Unit:
         // we request the whole selection to reload because the
         // unit of the stroke width depends on the selected shape
         selectionChanged();
         break;
     case KisCanvasResourceProvider::Size:
         if (d->noSelectionTrackingMode) {
             d->ui->lineWidth->changeValue(d->canvas->unit().fromUserValue(value.toReal()));
         }
         break;
     }
 }
 
 void KoStrokeConfigWidget::loadCurrentStrokeFillFromResourceServer()
 {
     if (d->canvas) {
         const QVariant value = d->canvas->resourceManager()->resource(KisCanvasResourceProvider::Size);
         canvasResourceChanged(KisCanvasResourceProvider::Size, value);
 
         updateStyleControlsAvailability(true);
 
         emit sigStrokeChanged();
     }
 }
diff --git a/libs/ui/widgets/kis_gradient_chooser.cc b/libs/ui/widgets/kis_gradient_chooser.cc
index 12db4b1c65..e3b09f3eed 100644
--- a/libs/ui/widgets/kis_gradient_chooser.cc
+++ b/libs/ui/widgets/kis_gradient_chooser.cc
@@ -1,209 +1,208 @@
 /*
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "widgets/kis_gradient_chooser.h"
 
 #include <QLabel>
 #include <QLayout>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QMenu>
 
 #include <klocalizedstring.h>
 #include <resources/KoAbstractGradient.h>
 #include <resources/KoResource.h>
 #include <resources/KoSegmentGradient.h>
 #include <KoStopGradient.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoResourceItemChooser.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerAdapter.h>
-#include <KoStopGradient.h>
 #include <kis_icon.h>
 #include <kis_config.h>
 
 #include "KisViewManager.h"
 #include "kis_global.h"
 #include "kis_autogradient.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_stopgradient_editor.h"
 
 KisCustomGradientDialog::KisCustomGradientDialog(KoAbstractGradient* gradient, QWidget * parent, const char *name)
     : KoDialog(parent)
 {
     setCaption(i18n("Custom Gradient"));
     setButtons(Close);
     setDefaultButton(Close);
     setObjectName(name);
     setModal(false);
 
     KoStopGradient* stopGradient = dynamic_cast<KoStopGradient*>(gradient);
     if (stopGradient) {
         m_page = new KisStopGradientEditor(stopGradient, this, "autogradient", i18n("Custom Gradient"));
     }
     KoSegmentGradient* segmentedGradient = dynamic_cast<KoSegmentGradient*>(gradient);
     if (segmentedGradient) {
         m_page = new KisAutogradient(segmentedGradient, this, "autogradient", i18n("Custom Gradient"));
     }
     setMainWidget(m_page);
 }
 
 KisGradientChooser::KisGradientChooser(QWidget *parent, const char *name)
     : QFrame(parent)
 {
     setObjectName(name);
     m_lbName = new QLabel();
 
     KoResourceServer<KoAbstractGradient> * rserver = KoResourceServerProvider::instance()->gradientServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter (new KoResourceServerAdapter<KoAbstractGradient>(rserver));
     m_itemChooser = new KoResourceItemChooser(adapter, this);
 
     m_itemChooser->showTaggingBar(true);
     m_itemChooser->setFixedSize(250, 250);
     m_itemChooser->setColumnCount(1);
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)),
             this, SLOT(update(KoResource *)));
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)),
             this, SIGNAL(resourceSelected(KoResource *)));
 
     QWidget* buttonWidget = new QWidget(this);
     QHBoxLayout* buttonLayout = new QHBoxLayout(buttonWidget);
 
     m_addGradient = new QToolButton(this);
 
     m_addGradient->setText(i18n("Add..."));
     m_addGradient->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     connect(m_addGradient, SIGNAL(clicked()), this, SLOT(addStopGradient()));
     buttonLayout->addWidget(m_addGradient);
 
     QMenu *menuAddGradient = new QMenu(m_addGradient);
 
     QAction* addStopGradient = new QAction(i18n("Stop gradient"), this);
     connect(addStopGradient, SIGNAL(triggered(bool)), this, SLOT(addStopGradient()));
     menuAddGradient->addAction(addStopGradient);
 
     QAction* addSegmentedGradient = new QAction(i18n("Segmented gradient"), this);
     connect(addSegmentedGradient, SIGNAL(triggered(bool)), this, SLOT(addSegmentedGradient()));
     menuAddGradient->addAction(addSegmentedGradient);
 
     m_addGradient->setMenu(menuAddGradient);
     m_addGradient->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_editGradient = new QPushButton();
     m_editGradient->setText(i18n("Edit..."));
     m_editGradient->setEnabled(false);
     connect(m_editGradient, SIGNAL(clicked()), this, SLOT(editGradient()));
     buttonLayout->addWidget(m_editGradient);
 
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->setObjectName("main layout");
     mainLayout->setMargin(2);
     mainLayout->addWidget(m_lbName);
     mainLayout->addWidget(m_itemChooser, 10);
     mainLayout->addWidget(buttonWidget);
 
     KisConfig cfg(true);
     m_itemChooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
                                              cfg.kineticScrollingSensitivity(),
                                              cfg.kineticScrollingScrollbar());
 
     slotUpdateIcons();
     setLayout(mainLayout);
 }
 
 KisGradientChooser::~KisGradientChooser()
 {
 }
 
 KoResource *KisGradientChooser::currentResource()
 {
     return m_itemChooser->currentResource();
 }
 
 void KisGradientChooser::setCurrentResource(KoResource *resource)
 {
     m_itemChooser->setCurrentResource(resource);
 }
 
 void KisGradientChooser::setCurrentItem(int row, int column)
 {
     m_itemChooser->setCurrentItem(row, column);
     if (currentResource())
         update(currentResource());
 }
 
 void KisGradientChooser::slotUpdateIcons()
 {
     if (m_addGradient && m_editGradient) {
         m_addGradient->setIcon(KisIconUtils::loadIcon("list-add"));
         m_editGradient->setIcon(KisIconUtils::loadIcon("configure"));
     }
 }
 
 void KisGradientChooser::update(KoResource * resource)
 {
     KoAbstractGradient *gradient = static_cast<KoAbstractGradient *>(resource);
     m_lbName->setText(gradient ? i18n(gradient->name().toUtf8().data()) : "");
     m_editGradient->setEnabled(gradient && gradient->removable());
 }
 
 void KisGradientChooser::addStopGradient()
 {
     KoStopGradient* gradient = new KoStopGradient("");
 
     QList<KoGradientStop> stops;
     stops << KoGradientStop(0.0, KoColor(QColor(250, 250, 0), KoColorSpaceRegistry::instance()->rgb8())) << KoGradientStop(1.0,  KoColor(QColor(255, 0, 0, 255), KoColorSpaceRegistry::instance()->rgb8()));
     gradient->setType(QGradient::LinearGradient);
     gradient->setStops(stops);
     addGradient(gradient);
 }
 
 void KisGradientChooser::addSegmentedGradient()
 {
     KoSegmentGradient* gradient = new KoSegmentGradient("");
     gradient->createSegment(INTERP_LINEAR, COLOR_INTERP_RGB, 0.0, 1.0, 0.5, Qt::black, Qt::white);
     gradient->setName(i18n("unnamed"));
     addGradient(gradient);
 }
 
 void KisGradientChooser::addGradient(KoAbstractGradient* gradient)
 {
     KoResourceServer<KoAbstractGradient> * rserver = KoResourceServerProvider::instance()->gradientServer();
     QString saveLocation = rserver->saveLocation();
 
     KisCustomGradientDialog dialog(gradient, this, "autogradient");
     dialog.exec();
 
     gradient->setFilename(saveLocation + gradient->name() + gradient->defaultFileExtension());
     gradient->setValid(true);
     rserver->addResource(gradient);
     m_itemChooser->setCurrentResource(gradient);
 }
 
 void KisGradientChooser::editGradient()
 {
     KisCustomGradientDialog dialog(static_cast<KoAbstractGradient*>(currentResource()), this, "autogradient");
     dialog.exec();
 }
 
 
 
 
diff --git a/libs/ui/widgets/kis_paintop_preset_icon_library.cpp b/libs/ui/widgets/kis_paintop_preset_icon_library.cpp
index ceb7ca9caf..1215f52e1e 100644
--- a/libs/ui/widgets/kis_paintop_preset_icon_library.cpp
+++ b/libs/ui/widgets/kis_paintop_preset_icon_library.cpp
@@ -1,166 +1,165 @@
 /* This file is part of the KDE project
  * Copyright (C) 2017 Wolthera van Hövell tot Westerflier
  *
  * 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_paintop_preset_icon_library.h"
 #include <QImage>
 #include <QStandardItem>
 #include <QSlider>
 #include <QPainter>
 #include <QLabel>
-#include <QSlider>
 #include <QListView>
 #include <kis_icon.h>
 #include <QDebug>
 #include <KoResourcePaths.h>
 
 KisPaintopPresetIconLibrary::KisPaintopPresetIconLibrary(QWidget *parent): QWidget(parent), ui(new Ui_wdgpreseticonlibrary)
 {
     ui->setupUi(this);
 
     ui->sldHue->setRange(0.0,360.0,1);
     ui->sldHue->setSingleStep(1.0);
     ui->sldHue->setPrefix(i18n("Hue:"));
 
     ui->sldSat->setRange(-50.0,50.0,1);
     ui->sldSat->setSingleStep(1.0);
     ui->sldSat->setPrefix(i18n("Saturation:"));
 
     ui->sldLevels->setRange(-50.0,50.0,1);
     ui->sldLevels->setSingleStep(1.0);
     ui->sldLevels->setPrefix(i18n("Mid-gray level:"));
 
 
     m_baseModel = new QStandardItemModel();
     ui->vwBase->setModel(m_baseModel);
 
     m_optionalModel = new QStandardItemModel();
     ui->vwOptional->setModel(m_optionalModel);
 
     QStringList background_paths = KoResourcePaths::findAllResources("data", "preset_icons/*.png");
     if (background_paths.size()>0) {
         m_background.load(background_paths.at(0));
         m_background = m_background.scaled(200, 200);
     }
     ui->lblIconPreview->setPixmap(QPixmap::fromImage(m_background));
 
 
     //empty default:
 
     QImage empty = QImage(200, 200, QImage::Format_ARGB32);
     empty.fill(Qt::transparent);
     m_baseModel->appendRow(new QStandardItem(QIcon(QPixmap::fromImage(empty)), NULL));
 
     QStringList toolIcon_paths = KoResourcePaths::findAllResources("data", "preset_icons/tool_icons/*.png");
     for (int i=0; i<toolIcon_paths.size(); i++) {
         QImage pix;
         pix.load(toolIcon_paths.at(i));
         QStandardItem *image = new QStandardItem(QIcon(QPixmap::fromImage(pix)), NULL);
         m_baseModel->appendRow(image);
     }
 
 
     empty = QImage(40, 40, QImage::Format_ARGB32);
     empty.fill(Qt::transparent);
     m_optionalModel->appendRow(new QStandardItem(QIcon(QPixmap::fromImage(empty)), NULL));
 
     QStringList emblemIcon_paths = KoResourcePaths::findAllResources("data", "preset_icons/emblem_icons/*.png");
     for (int i=0; i<emblemIcon_paths.size(); i++) {
         QImage pix;
         pix.load(emblemIcon_paths.at(i));
         QStandardItem *image = new QStandardItem(QIcon(QPixmap::fromImage(pix)), NULL);
         m_optionalModel->appendRow(image);
     }
 
     connect(ui->vwBase->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection &)), this, SLOT(updateIcon()));
     connect(ui->vwOptional->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection &)), this, SLOT(updateIcon()));
     connect(ui->sldHue, SIGNAL(valueChanged(qreal)), this, SLOT(updateIcon()));
     connect(ui->sldSat, SIGNAL(valueChanged(qreal)), this, SLOT(updateIcon()));
     connect(ui->sldLevels, SIGNAL(valueChanged(qreal)), this, SLOT(updateIcon()));
 }
 
 KisPaintopPresetIconLibrary::~KisPaintopPresetIconLibrary()
 {
     delete ui;
     m_optionalModel->clear();
     delete m_optionalModel;
     m_baseModel->clear();
     delete m_baseModel;
 }
 
 QImage KisPaintopPresetIconLibrary::getImage()
 {
     QImage preset = m_background;
     QImage base = QImage(200, 200, QImage::Format_ARGB32);
     base.fill(Qt::transparent);
     if (ui->vwBase->currentIndex().isValid()) {
         base = m_baseModel->itemFromIndex(ui->vwBase->currentIndex())->icon().pixmap(QSize(200, 200)).toImage();
     }
     if (ui->sldHue->value()>0 || ui->sldSat->value()!=0.0 || ui->sldLevels->value()!=0.0) {
         base = hueTransform(base);
     }
     QImage optional = QImage(40, 40, QImage::Format_ARGB32);
     optional.fill(Qt::transparent);
     if (ui->vwOptional->currentIndex().isValid()) {
          optional = m_optionalModel->itemFromIndex(ui->vwOptional->currentIndex())->icon().pixmap(QSize(40, 40)).toImage();
     }
 
     QPainter p(&preset);
     p.drawImage(0, 0, base);
     int x = 35;
     int y = 31;
     p.drawImage(x, y, optional);
     return preset;
 }
 
 QImage KisPaintopPresetIconLibrary::hueTransform(QImage img)
 {
     //This is a super simple levels operation instead of a regular lightness adjustment.
     //This is so that we can keep the contrasts in the icon instead of making it
     //just darker or lighter.
     QVector<int> values(256);
     values.fill(255);
     int level = qMax(qMin( 28 + ( (int(ui->sldLevels->value()) + 50) * 2), 255), 0);
     for (int v = 0; v < level; v++) {
         values[v] = int((128.0 / qreal(level))*v);
     }
     for (int v = level; v < 255; v++) {
         values[v] = qMax(qMin(int( (128.0 / qreal(255 - level)) *(v - level)+128.0), 255), 0);
     }
 
     //This is very slow by Krita standards, but we cannot get hsv transforms, ad the image is only 200x200.
     for (int x = 0; x < img.width(); x++) {
         for (int y = 0; y < img.height(); y++) {
             QColor c = img.pixelColor(x, y);
             int hue = c.hslHue()+(int)ui->sldHue->value();
             if (hue > 360) {
                 hue -= 360;
             }
             int sat = qMax(qMin(c.hslSaturation()+int(ui->sldSat->value() * (255/100)), 255), 0);
             c.setHsl(hue, sat, values.at(c.lightness()), c.alpha());
             img.setPixelColor(x, y, c);
         }
     }
     return img;
 }
 
 void KisPaintopPresetIconLibrary::updateIcon()
 {
     ui->lblIconPreview->setPixmap(QPixmap::fromImage(getImage()));
 }
 
 
diff --git a/libs/ui/widgets/kis_paintop_presets_popup.cpp b/libs/ui/widgets/kis_paintop_presets_popup.cpp
index dc1e9eb6ea..b4c6ae43a4 100644
--- a/libs/ui/widgets/kis_paintop_presets_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_popup.cpp
@@ -1,851 +1,850 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "widgets/kis_paintop_presets_popup.h"
 
 #include <QList>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QToolButton>
 #include <QGridLayout>
 #include <QFont>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 #include <QFontDatabase>
 #include <QWidgetAction>
 #include <QDesktopWidget>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 
 #include <KoDockRegistry.h>
 
-#include <kis_icon.h>
 #include <kis_icon.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_canvas_resource_provider.h>
 #include <widgets/kis_preset_chooser.h>
 #include <widgets/kis_preset_selector_strip.h>
 
 #include <ui_wdgpaintopsettings.h>
 #include <kis_node.h>
 #include "kis_config.h"
 
 #include "KisResourceServerProvider.h"
 #include "kis_lod_availability_widget.h"
 
 #include "kis_signal_auto_connection.h"
 #include <kis_paintop_settings_update_proxy.h>
 
 // ones from brush engine selector
 #include <brushengine/kis_paintop_factory.h>
 #include <kis_preset_live_preview_view.h>
 
 struct KisPaintOpPresetsPopup::Private
 {
 
 public:
 
     Ui_WdgPaintOpSettings uiWdgPaintOpPresetSettings;
     QGridLayout *layout;
     KisPaintOpConfigWidget *settingsWidget;
     QFont smallFont;
     KisCanvasResourceProvider *resourceProvider;
     KisFavoriteResourceManager *favoriteResManager;
 
     bool detached;
     bool ignoreHideEvents;
     bool isCreatingBrushFromScratch = false;
     QSize minimumSettingsWidgetSize;
     QRect detachedGeometry;
 
     KisSignalAutoConnectionsStore widgetConnections;
 };
 
 KisPaintOpPresetsPopup::KisPaintOpPresetsPopup(KisCanvasResourceProvider * resourceProvider,
                                                KisFavoriteResourceManager* favoriteResourceManager,
                                                KisPresetSaveWidget* savePresetWidget,
                                                QWidget * parent)
     : QWidget(parent)
     , m_d(new Private())
 {
     setObjectName("KisPaintOpPresetsPopup");
     setFont(KoDockRegistry::dockFont());
 
     current_paintOpId = "";
 
     m_d->resourceProvider = resourceProvider;
     m_d->favoriteResManager = favoriteResourceManager;
 
     m_d->uiWdgPaintOpPresetSettings.setupUi(this);
 
     m_d->layout = new QGridLayout(m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer);
     m_d->layout->setSizeConstraint(QLayout::SetFixedSize);
 
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setupScratchPad(resourceProvider, Qt::white);
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setCutoutOverlayRect(QRect(25, 25, 200, 200));
 
 
 
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setToolTip(i18n("The settings for this preset have changed from their default."));
 
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setToolTip(i18n("Toggle showing presets"));
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setToolTip(i18n("Toggle showing scratchpad"));
 
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setToolTip(i18n("Reload the brush preset"));
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setToolTip(i18n("Rename the brush preset"));
 
 
     // creating a new preset from scratch. Part of the brush presets area
     // the menu options will get filled up later when we are generating all available paintops
     // in the filter drop-down
     newPresetBrushEnginesMenu = new QMenu();
 
     // overwrite existing preset and saving a new preset use the same dialog
     saveDialog = savePresetWidget;
     saveDialog->scratchPadSetup(resourceProvider);
     saveDialog->setFavoriteResourceManager(m_d->favoriteResManager); // this is needed when saving the preset
     saveDialog->hide();
 
     // the area on the brush editor for renaming the brush. make sure edit fields are hidden by default
     toggleBrushRenameUIActive(false);
 
 
     // DETAIL and THUMBNAIL view changer
     QMenu* menu = new QMenu(this);
 
     menu->setStyleSheet("margin: 6px");
     menu->addSection(i18n("Display"));
 
     QActionGroup *actionGroup = new QActionGroup(this);
 
     KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig(true).presetChooserViewMode();
 
     QAction* action = menu->addAction(KisIconUtils::loadIcon("view-preview"), i18n("Thumbnails"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotThumbnailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::THUMBNAIL);
     action->setActionGroup(actionGroup);
 
     action = menu->addAction(KisIconUtils::loadIcon("view-list-details"), i18n("Details"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotDetailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::DETAIL);
     action->setActionGroup(actionGroup);
 
 
     // add horizontal slider for the icon size
     QSlider* iconSizeSlider = new QSlider(this);
     iconSizeSlider->setOrientation(Qt::Horizontal);
     iconSizeSlider->setRange(30, 80);
     iconSizeSlider->setValue(m_d->uiWdgPaintOpPresetSettings.presetWidget->iconSize());
     iconSizeSlider->setMinimumHeight(20);
     iconSizeSlider->setMinimumWidth(40);
     iconSizeSlider->setTickInterval(10);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(iconSizeSlider);
 
     menu->addSection(i18n("Icon Size"));
     menu->addAction(sliderAction);
 
 
     // configure the button and assign menu
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setMenu(menu);
 
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // loading preset from scratch option
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // show/hide buttons
 
     KisConfig cfg(true);
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setChecked(cfg.scratchpadVisible());
 
     if (cfg.scratchpadVisible()) {
         slotSwitchScratchpad(true); // show scratchpad
     } else {
         slotSwitchScratchpad(false);
     }
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setChecked(false);
     slotSwitchShowPresets(false); // hide presets by default
 
 
     // Connections
     connect(m_d->uiWdgPaintOpPresetSettings.paintPresetIcon, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(paintPresetImage()));
 
     connect(saveDialog, SIGNAL(resourceSelected(KoResource*)), this, SLOT(resourceSelected(KoResource*)));
 
     connect (m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushActivated()));
 
     connect (m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushDeactivated()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSaveRenameCurrentBrush()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField, SIGNAL(returnPressed()),
             SLOT(slotSaveRenameCurrentBrush()));
 
     connect(iconSizeSlider, SIGNAL(sliderMoved(int)),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSetIconSize(int)));
 
     connect(iconSizeSlider, SIGNAL(sliderReleased()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSaveIconSize()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showScratchpadButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSwitchScratchpad(bool)));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showPresetsButton, SIGNAL(clicked(bool)), this, SLOT(slotSwitchShowPresets(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraseScratchPad, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillDefault()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillLayer, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillLayer()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillGradient, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillGradient()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillSolid, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillBackground()));
 
 
     m_d->settingsWidget = 0;
     setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveNewBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             this, SIGNAL(reloadPresetClicked()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(dirtyPresetToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushSizeToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushOpacityToggled(bool)));
 
 
     // preset widget connections
     connect(m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(signalResourceSelected(KoResource*)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SLOT(updateViewSettings()));
 
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()), SLOT(slotUpdatePresetSettings()));
 
     m_d->detached = false;
     m_d->ignoreHideEvents = false;
     m_d->minimumSettingsWidgetSize = QSize(0, 0);
 
     m_d->detachedGeometry = QRect(100, 100, 0, 0);
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox->setChecked(cfg.useDirtyPresets());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox->setChecked(cfg.useEraserBrushSize());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox->setChecked(cfg.useEraserBrushOpacity());
 
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setCanvasResourceManager(resourceProvider->resourceManager());
 
     connect(resourceProvider->resourceManager(),
             SIGNAL(canvasResourceChanged(int,QVariant)),
             SLOT(slotResourceChanged(int, QVariant)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodAvailability(bool)),
             SLOT(slotLodAvailabilityChanged(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodThreshold(qreal)),
             SLOT(slotLodThresholdChanged(qreal)));
 
     slotResourceChanged(KisCanvasResourceProvider::LodAvailability,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodAvailability));
 
     slotResourceChanged(KisCanvasResourceProvider::LodSizeThreshold,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodSizeThreshold));
 
     connect(m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdatePaintOpFilter()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset, SIGNAL(clicked()), this, SLOT(slotBlackListCurrentPreset()));
 
     updateThemedIcons();
 
     // setup things like the scene construct images, layers, etc that is a one-time thing
     m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setup();
 
 }
 
 void KisPaintOpPresetsPopup::slotBlackListCurrentPreset()
 {
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (rServer->resourceByName(curPreset->name())) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 }
 
 
 void KisPaintOpPresetsPopup::slotRenameBrushActivated()
 {
     toggleBrushRenameUIActive(true);
 }
 
 void KisPaintOpPresetsPopup::slotRenameBrushDeactivated()
 {
     toggleBrushRenameUIActive(false);
 }
 
 void KisPaintOpPresetsPopup::toggleBrushRenameUIActive(bool isRenaming)
 {
     // This function doesn't really do anything except get the UI in a state to rename a brush preset
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton->setVisible(isRenaming);
 
 
     // hide these below areas while renaming
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setVisible(!isRenaming);
 
     // if the presets area is shown, only then can you show/hide the load default brush
     // need to think about weird state when you are in the middle of renaming a brush
     // what happens if you try to change presets. maybe we should auto-hide (or disable)
     // the presets area in this case
     if (m_d->uiWdgPaintOpPresetSettings.presetWidget->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(!isRenaming);
         m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(!isRenaming);
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotSaveRenameCurrentBrush()
 {
     // if you are renaming a brush, that is different than updating the settings
     // make sure we are in a clean state before renaming. This logic might change,
     // but that is what we are going with for now
     emit reloadPresetClicked();
 
 
     m_d->favoriteResManager->setBlockUpdates(true);
 
     // get a reference to the existing (and new) file name and path that we are working with
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (!curPreset)
         return;
 
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString saveLocation = rServer->saveLocation();
 
     QString originalPresetName = curPreset->name();
     QString renamedPresetName = m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->text();
     QString originalPresetPathAndFile = saveLocation + originalPresetName + curPreset->defaultFileExtension();
     QString renamedPresetPathAndFile = saveLocation + renamedPresetName + curPreset->defaultFileExtension();
 
 
     // create a new brush preset with the name specified and add to resource provider
     KisPaintOpPresetSP newPreset = curPreset->clone();
     newPreset->setFilename(renamedPresetPathAndFile); // this also contains the path
     newPreset->setName(renamedPresetName);
     newPreset->setImage(curPreset->image()); // use existing thumbnail (might not need to do this)
     newPreset->setPresetDirty(false);
     newPreset->setValid(true);
     rServer->addResource(newPreset);
 
     resourceSelected(newPreset.data()); // refresh and select our freshly renamed resource
 
 
     // Now blacklist the original file
     if (rServer->resourceByName(originalPresetName)) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 
     m_d->favoriteResManager->setBlockUpdates(false);
 
     toggleBrushRenameUIActive(false); // this returns the UI to its original state after saving
 
     slotUpdatePresetSettings(); // update visibility of dirty preset and icon
 }
 
 void KisPaintOpPresetsPopup::slotResourceChanged(int key, const QVariant &value)
 {
     if (key == KisCanvasResourceProvider::LodAvailability) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodAvailability(value.toBool());
     } else if (key == KisCanvasResourceProvider::LodSizeThreshold) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodThreshold(value.toDouble());
     } else if (key == KisCanvasResourceProvider::Size) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedSize(value.toDouble());
     }
 }
 
 void KisPaintOpPresetsPopup::slotLodAvailabilityChanged(bool value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodAvailability, QVariant(value));
 }
 
 void KisPaintOpPresetsPopup::slotLodThresholdChanged(qreal value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodSizeThreshold, QVariant(value));
 }
 
 KisPaintOpPresetsPopup::~KisPaintOpPresetsPopup()
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->settingsWidget->hide();
         m_d->settingsWidget->setParent(0);
         m_d->settingsWidget = 0;
     }
     delete m_d;
     delete newPresetBrushEnginesMenu;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpSettingsWidget(QWidget * widget)
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer->updateGeometry();
     }
     m_d->layout->update();
     updateGeometry();
 
     m_d->widgetConnections.clear();
     m_d->settingsWidget = 0;
 
     if (widget) {
 
         m_d->settingsWidget = dynamic_cast<KisPaintOpConfigWidget*>(widget);
         KIS_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
 
         KisConfig cfg(true);
         if (m_d->settingsWidget->supportScratchBox() && cfg.scratchpadVisible()) {
             slotSwitchScratchpad(true);
         } else {
             slotSwitchScratchpad(false);
         }
 
         m_d->widgetConnections.addConnection(m_d->settingsWidget, SIGNAL(sigConfigurationItemChanged()),
                                              this, SLOT(slotUpdateLodAvailability()));
 
         widget->setFont(m_d->smallFont);
 
         QSize hint = widget->sizeHint();
         m_d->minimumSettingsWidgetSize = QSize(qMax(hint.width(), m_d->minimumSettingsWidgetSize.width()),
                                                qMax(hint.height(), m_d->minimumSettingsWidgetSize.height()));
         widget->setMinimumSize(m_d->minimumSettingsWidgetSize);
         m_d->layout->addWidget(widget);
 
         // hook up connections that will monitor if our preset is dirty or not. Show a notification if it is
         if (m_d->resourceProvider && m_d->resourceProvider->currentPreset() ) {
 
             KisPaintOpPresetSP preset = m_d->resourceProvider->currentPreset();
             m_d->widgetConnections.addConnection(preset->updateProxy(), SIGNAL(sigSettingsChanged()),
                                                  this, SLOT(slotUpdatePresetSettings()));
         }
 
         m_d->layout->update();
         widget->show();
 
     }
     slotUpdateLodAvailability();
 }
 
 void KisPaintOpPresetsPopup::slotUpdateLodAvailability()
 {
     if (!m_d->settingsWidget) return;
 
     KisPaintopLodLimitations l = m_d->settingsWidget->lodLimitations();
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setLimitations(l);
 }
 
 QImage KisPaintOpPresetsPopup::cutOutOverlay()
 {
     return m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay();
 }
 
 void KisPaintOpPresetsPopup::contextMenuEvent(QContextMenuEvent *e)
 {
     Q_UNUSED(e);
 }
 
 void KisPaintOpPresetsPopup::switchDetached(bool show)
 {
     if (parentWidget()) {
 
         m_d->detached = !m_d->detached;
 
         if (m_d->detached) {
             m_d->ignoreHideEvents = true;
 
             if (show) {
                 parentWidget()->show();
             }
             m_d->ignoreHideEvents = false;
 
         }
         else {
             parentWidget()->hide();
         }
 
         KisConfig cfg(false);
         cfg.setPaintopPopupDetached(m_d->detached);
     }
 }
 
 void KisPaintOpPresetsPopup::setCreatingBrushFromScratch(bool enabled)
 {
     m_d->isCreatingBrushFromScratch = enabled;
 }
 
 void KisPaintOpPresetsPopup::resourceSelected(KoResource* resource)
 {
     // this gets called every time the brush editor window is opened
     // TODO: this gets called multiple times whenever the preset is changed in the presets area
     // the connections probably need to be thought about with this a bit more to keep things in sync
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(resource);
 
     // find the display name of the brush engine and append it to the selected preset display
     QString currentBrushEngineName;
     QPixmap currentBrushEngineIcon = QPixmap(26, 26);
     currentBrushEngineIcon.fill(Qt::transparent);
     for(int i=0; i < sortedBrushEnginesList.length(); i++) {
         if (sortedBrushEnginesList.at(i).id == currentPaintOpId() ) {
             currentBrushEngineName = sortedBrushEnginesList.at(i).name;
             currentBrushEngineIcon = sortedBrushEnginesList.at(i).icon.pixmap(26, 26);
         }
     }
 
     // brush names have underscores as part of the file name (to help with building). We don't really need underscores
     // when viewing the names, so replace them with spaces
     QString formattedBrushName = resource->name().replace("_", " ");
 
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setText(formattedBrushName);
     m_d->uiWdgPaintOpPresetSettings.currentBrushEngineLabel->setText(i18nc("%1 is the name of a brush engine", "%1 Engine", currentBrushEngineName));
     m_d->uiWdgPaintOpPresetSettings.currentBrushEngineIcon->setPixmap(currentBrushEngineIcon);
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setText(resource->name()); // use file name
 
     // get the preset image and pop it into the thumbnail area on the top of the brush editor
     m_d->uiWdgPaintOpPresetSettings.presetThumbnailicon->setPixmap(QPixmap::fromImage(resource->image().scaled(55, 55, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
 
     toggleBrushRenameUIActive(false); // reset the UI state of renaming a brush if we are changing brush presets
     slotUpdatePresetSettings(); // check to see if the dirty preset icon needs to be shown
 }
 
 bool variantLessThan(const KisPaintOpInfo v1, const KisPaintOpInfo v2)
 {
     return v1.priority < v2.priority;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpList(const QList< KisPaintOpFactory* >& list)
 {
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->clear(); // reset combobox list just in case
 
 
     // create a new list so we can sort it and populate the brush engine combo box
     sortedBrushEnginesList.clear(); // just in case this function is called again, don't keep adding to the list
 
     for(int i=0; i < list.length(); i++) {
         KisPaintOpInfo paintOpInfo;
         paintOpInfo.id = list.at(i)->id();
         paintOpInfo.name = list.at(i)->name();
         paintOpInfo.icon = list.at(i)->icon();
         paintOpInfo.priority = list.at(i)->priority();
 
         sortedBrushEnginesList.append(paintOpInfo);
     }
 
     std::stable_sort(sortedBrushEnginesList.begin(), sortedBrushEnginesList.end(), variantLessThan );
 
     // add an "All" option at the front to show all presets
     QPixmap emptyPixmap = QPixmap(22,22);
     emptyPixmap.fill(Qt::transparent);
 
     // if we create a new brush from scratch, we need a full list of paintops to choose from
     // we don't want "All", so populate the list before that is added
     newPresetBrushEnginesMenu->actions().clear(); // clean out list in case we run this again
     newBrushEngineOptions.clear();
 
     for (int j = 0; j < sortedBrushEnginesList.length(); j++) {
         KisAction * newEngineAction = static_cast<KisAction*>( newPresetBrushEnginesMenu->addAction(sortedBrushEnginesList[j].name));
         newEngineAction->setObjectName(sortedBrushEnginesList[j].id); // we need the ID for changing the paintop when action triggered
         newEngineAction->setIcon(sortedBrushEnginesList[j].icon);
         newBrushEngineOptions.append(newEngineAction);
         connect(newEngineAction, SIGNAL(triggered()), this, SLOT(slotCreateNewBrushPresetEngine()));
     }
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setMenu(newPresetBrushEnginesMenu);
 
     // fill the list into the brush combo box
     sortedBrushEnginesList.push_front(KisPaintOpInfo(QString("all_options"), i18n("All"), QString(""), QIcon(emptyPixmap), 0 ));
     for (int m = 0; m < sortedBrushEnginesList.length(); m++) {
         m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->addItem(sortedBrushEnginesList[m].icon, sortedBrushEnginesList[m].name, QVariant(sortedBrushEnginesList[m].id));
     }
 }
 
 
 void KisPaintOpPresetsPopup::setCurrentPaintOpId(const QString& paintOpId)
 {
     current_paintOpId = paintOpId;
 }
 
 
 QString KisPaintOpPresetsPopup::currentPaintOpId() {
     return current_paintOpId;
 }
 
 void KisPaintOpPresetsPopup::setPresetImage(const QImage& image)
 {
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setPresetImage(image);
     saveDialog->brushPresetThumbnailWidget->setPresetImage(image);
 }
 
 void KisPaintOpPresetsPopup::hideEvent(QHideEvent *event)
 {
     if (m_d->ignoreHideEvents) {
         return;
     }
     if (m_d->detached) {
         m_d->detachedGeometry = window()->geometry();
     }
     QWidget::hideEvent(event);
 }
 
 void KisPaintOpPresetsPopup::showEvent(QShowEvent *)
 {
     if (m_d->detached) {
         window()->setGeometry(m_d->detachedGeometry);
     }
 
     emit brushEditorShown();
 }
 
 void KisPaintOpPresetsPopup::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     if (parentWidget()) {
         // Make sure resizing doesn't push this widget out of the screen
         QRect screenRect = QApplication::desktop()->availableGeometry(this);
         QRect newPositionRect = kisEnsureInRect(parentWidget()->geometry(), screenRect);
         parentWidget()->setGeometry(newPositionRect);
     }
 }
 
 bool KisPaintOpPresetsPopup::detached() const
 {
     return m_d->detached;
 }
 
 void KisPaintOpPresetsPopup::slotSwitchScratchpad(bool visible)
 {
     // hide all the internal controls except the toggle button
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.scratchpadSidebarLabel->setVisible(visible);
 
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 
     KisConfig cfg(false);
     cfg.setScratchpadVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowEditor(bool visible) {
     m_d->uiWdgPaintOpPresetSettings.brushEditorSettingsControls->setVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowPresets(bool visible) {
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.engineFilterLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(visible);
 
     // we only want a spacer to work when the toggle icon is present. Otherwise the list of presets will shrink
     // which is something we don't want
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePaintOpFilter() {
     QVariant userData = m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->currentData(); // grab paintOpID from data
     QString filterPaintOpId = userData.toString();
 
     if (filterPaintOpId == "all_options") {
         filterPaintOpId = "";
     }
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setPresetFilter(filterPaintOpId);
 }
 
 void KisPaintOpPresetsPopup::slotSaveBrushPreset() {
     // here we are assuming that people want to keep their existing preset icon. We will just update the
     // settings and save a new copy with the same name.
     // there is a dialog with save options, but we don't need to show it in this situation
 
     saveDialog->useNewBrushDialog(false); // this mostly just makes sure we keep the existing brush preset name when saving
     saveDialog->loadExistingThumbnail(); // This makes sure we use the existing preset icon when updating the existing brush preset
     saveDialog->savePreset();
 
     // refresh the view settings so the brush doesn't appear dirty
     slotUpdatePresetSettings();
 }
 
 void KisPaintOpPresetsPopup::slotSaveNewBrushPreset() {
     saveDialog->useNewBrushDialog(true);
     saveDialog->saveScratchPadThumbnailArea(m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay());
     saveDialog->showDialog();
 }
 
 void KisPaintOpPresetsPopup::slotCreateNewBrushPresetEngine()
 {
     emit createPresetFromScratch(sender()->objectName());
 }
 
 void KisPaintOpPresetsPopup::updateViewSettings()
 {
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->updateViewSettings();
 }
 
 void KisPaintOpPresetsPopup::currentPresetChanged(KisPaintOpPresetSP preset)
 {
     if (preset) {
         m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(preset.data());
         setCurrentPaintOpId(preset->paintOp().id());
     }
 }
 
 void KisPaintOpPresetsPopup::updateThemedIcons()
 {
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setIcon(KisIconUtils::loadIcon("document-new"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->hide();
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setIcon(KisIconUtils::loadIcon("krita_tool_gradient"));
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setIcon(KisIconUtils::loadIcon("krita_tool_color_fill"));
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setIcon(KisIconUtils::loadIcon("edit-delete"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setIcon(KisIconUtils::loadIcon("updateColorize")); // refresh icon
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setIcon(KisIconUtils::loadIcon("dirty-preset")); // edit icon
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setIcon(KisIconUtils::loadIcon("warning"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setIcon(KisIconUtils::loadIcon("configure"));
 
     // if we cannot see the "Preset label", we know it is not visible
     // maybe this can also be stored in the config like the scratchpad?
     if (m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
     // we store whether the scratchpad if visible in the config.
     KisConfig cfg(true);
     if (cfg.scratchpadVisible()) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePresetSettings()
 {
     if (!m_d->resourceProvider) {
         return;
     }
 
     if (!m_d->resourceProvider->currentPreset()) {
         return;
     }
 
     // hide options on UI if we are creating a brush preset from scratch to prevent confusion
     if (m_d->isCreatingBrushFromScratch) {
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(false);
     } else {
         bool isPresetDirty = m_d->resourceProvider->currentPreset()->isPresetDirty();
 
         // don't need to reload or overwrite a clean preset
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(true);
     }
 
     // update live preview area in here...
     // don't update the live preview if the widget is not visible.
     if (m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setCurrentPreset(m_d->resourceProvider->currentPreset());
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->updateStroke();
     }
 }
diff --git a/libs/ui/widgets/kis_preset_chooser.cpp b/libs/ui/widgets/kis_preset_chooser.cpp
index 57e8420270..36d17f6732 100644
--- a/libs/ui/widgets/kis_preset_chooser.cpp
+++ b/libs/ui/widgets/kis_preset_chooser.cpp
@@ -1,362 +1,361 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2009 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_preset_chooser.h"
 
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QAbstractItemDelegate>
 #include <QStyleOptionViewItem>
 #include <QSortFilterProxyModel>
 #include <QApplication>
 
 #include <kis_config.h>
 #include <klocalizedstring.h>
 
 
 #include <KoIcon.h>
 #include <KoResourceItemChooser.h>
 #include <KoResourceModel.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceItemChooserSync.h>
 #include "KoResourceItemView.h"
 
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_preset.h>
 #include "KisResourceServerProvider.h"
 #include "kis_global.h"
 #include "kis_slider_spin_box.h"
-#include "kis_config.h"
 #include "kis_config_notifier.h"
 #include <kis_icon.h>
 
 /// The resource item delegate for rendering the resource preview
 class KisPresetDelegate : public QAbstractItemDelegate
 {
 public:
     KisPresetDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent), m_showText(false), m_useDirtyPresets(false) {}
     ~KisPresetDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 
     void setShowText(bool showText) {
         m_showText = showText;
     }
 
     void setUseDirtyPresets(bool value) {
         m_useDirtyPresets = value;
     }
 
 private:
     bool m_showText;
     bool m_useDirtyPresets;
 };
 
 void KisPresetDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     painter->save();
     painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 
     if (! index.isValid())
         return;
 
     KisPaintOpPreset* preset = static_cast<KisPaintOpPreset*>(index.internalPointer());
 
     QImage preview = preset->image();
 
     if(preview.isNull()) {
         return;
     }
 
     QRect paintRect = option.rect.adjusted(1, 1, -1, -1);
     if (!m_showText) {
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(paintRect.size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     } else {
         QSize pixSize(paintRect.height(), paintRect.height());
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(pixSize, Qt::KeepAspectRatio, Qt::SmoothTransformation));
 
         // Put an asterisk after the preset if it is dirty. This will help in case the pixmap icon is too small
          QString dirtyPresetIndicator = QString("");
         if (m_useDirtyPresets && preset->isPresetDirty()) {
             dirtyPresetIndicator = QString("*");
         }
 
         qreal brushSize = preset->settings()->paintOpSize();
         QString brushSizeText;
 
         // Disable displayed decimal precision beyond a certain brush size
         if (brushSize < 100) {
             brushSizeText = QString::number(brushSize, 'g', 3);
         } else {
             brushSizeText = QString::number(brushSize, 'f', 0);
         }
 
         painter->drawText(pixSize.width() + 10, option.rect.y() + option.rect.height() - 10, brushSizeText); // brush size
 
         QString presetDisplayName = preset->name().replace("_", " "); // don't need underscores that might be part of the file name
         painter->drawText(pixSize.width() + 40, option.rect.y() + option.rect.height() - 10, presetDisplayName.append(dirtyPresetIndicator));
 
     }
     if (m_useDirtyPresets && preset->isPresetDirty()) {
         const QIcon icon = KisIconUtils::loadIcon(koIconName("dirty-preset"));
         QPixmap pixmap = icon.pixmap(QSize(15,15));
         painter->drawPixmap(paintRect.x() + 3, paintRect.y() + 3, pixmap);
     }
 
     if (!preset->settings() || !preset->settings()->isValid()) {
         const QIcon icon = KisIconUtils::loadIcon("broken-preset");
         icon.paint(painter, QRect(paintRect.x() + paintRect.height() - 25, paintRect.y() + paintRect.height() - 25, 25, 25));
     }
     if (option.state & QStyle::State_Selected) {
         painter->setCompositionMode(QPainter::CompositionMode_HardLight);
         painter->setOpacity(1.0);
         painter->fillRect(option.rect, option.palette.highlight());
 
         // highlight is not strong enough to pick out preset. draw border around it.
         painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
         painter->setPen(QPen(option.palette.highlight(), 4, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
         QRect selectedBorder = option.rect.adjusted(2 , 2, -2, -2); // constrict the rectangle so it doesn't bleed into other presets
         painter->drawRect(selectedBorder);
        }
     painter->restore();
 }
 
 class KisPresetProxyAdapter : public KisPaintOpPresetResourceServerAdapter
 {
 
 public:
     KisPresetProxyAdapter(KisPaintOpPresetResourceServer* resourceServer)
         : KisPaintOpPresetResourceServerAdapter(resourceServer)
     {
         setSortingEnabled(true);
     }
     ~KisPresetProxyAdapter() override {}
 
     QList< KoResource* > resources() override {
 
         QList<KoResource*> serverResources =
             KisPaintOpPresetResourceServerAdapter::resources();
 
         if (m_paintopID.isEmpty()) {
             return serverResources;
         }
 
         QList<KoResource*> resources;
         Q_FOREACH (KoResource *resource, serverResources) {
             KisPaintOpPreset *preset = dynamic_cast<KisPaintOpPreset*>(resource);
 
             if (preset && preset->paintOp().id() == m_paintopID) {
                 resources.append(preset);
             }
         }
         return resources;
     }
 
     ///Set id for paintop to be accept by the proxy model, if not filter is set all
     ///presets will be shown.
     void setPresetFilter(const QString& paintOpId)
     {
         m_paintopID = paintOpId;
         invalidate();
     }
 
     ///Resets the model connected to the adapter
     void invalidate() {
         emitRemovingResource(0);
     }
 
     QString currentPaintOpId() const {
         return m_paintopID;
     }
 
 private:
     QString m_paintopID;
 };
 
 KisPresetChooser::KisPresetChooser(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
     QVBoxLayout * layout = new QVBoxLayout(this);
     layout->setMargin(0);
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
 
     m_adapter = QSharedPointer<KoAbstractResourceServerAdapter>(new KisPresetProxyAdapter(rserver));
 
     m_chooser = new KoResourceItemChooser(m_adapter, this);
     m_chooser->setObjectName("ResourceChooser");
     m_chooser->setColumnCount(10);
     m_chooser->setRowHeight(50);
     m_delegate = new KisPresetDelegate(this);
     m_chooser->setItemDelegate(m_delegate);
     m_chooser->setSynced(true);
     layout->addWidget(m_chooser);
 
     KisConfig cfg(true);
     m_chooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
                                          cfg.kineticScrollingSensitivity(),
                                          cfg.kineticScrollingScrollbar());
 
     connect(m_chooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(resourceSelected(KoResource*)));
     connect(m_chooser, SIGNAL(resourceClicked(KoResource*)),
             this, SIGNAL(resourceClicked(KoResource*)));
 
     m_mode = THUMBNAIL;
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(notifyConfigChanged()));
 
 
     notifyConfigChanged();
 }
 
 KisPresetChooser::~KisPresetChooser()
 {
 }
 
 void KisPresetChooser::showButtons(bool show)
 {
     m_chooser->showButtons(show);
 }
 
 void KisPresetChooser::setViewMode(KisPresetChooser::ViewMode mode)
 {
     m_mode = mode;
     updateViewSettings();
 }
 
 void KisPresetChooser::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     updateViewSettings();
 }
 
 void KisPresetChooser::notifyConfigChanged()
 {
     KisConfig cfg(true);
     m_delegate->setUseDirtyPresets(cfg.useDirtyPresets());
     setIconSize(cfg.presetIconSize());
 
     updateViewSettings();
 }
 
 void KisPresetChooser::updateViewSettings()
 {
     if (m_mode == THUMBNAIL) {
         m_chooser->setSynced(true);
         m_delegate->setShowText(false);
     } else if (m_mode == DETAIL) {
         m_chooser->setSynced(false);
         m_chooser->setColumnCount(1);
         m_chooser->setColumnWidth(m_chooser->width());
 
         KoResourceItemChooserSync* chooserSync = KoResourceItemChooserSync::instance();
         m_chooser->setRowHeight(chooserSync->baseLength());
         m_delegate->setShowText(true);
     } else if (m_mode == STRIP) {
         m_chooser->setSynced(false);
         m_chooser->setRowCount(1);
         m_chooser->itemView()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         m_chooser->itemView()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         // An offset of 7 keeps the cell exactly square, TODO: use constants, not hardcoded numbers
         m_chooser->setColumnWidth(m_chooser->viewSize().height() - 7);
         m_delegate->setShowText(false);
     }
 }
 
 void KisPresetChooser::setCurrentResource(KoResource *resource)
 {
     /**
      * HACK ALERT: here we use a direct call to an adapter to notify the view
      *             that the preset might have changed its dirty state. This state
      *             doesn't affect the filtering so the server's cache must not be
      *             invalidated!
      *
      *             Ideally, we should call some method of KoResourceServer instead,
      *             but it seems like a bit too much effort for such a small fix.
      */
     if (resource == currentResource()) {
         KisPresetProxyAdapter *adapter = static_cast<KisPresetProxyAdapter*>(m_adapter.data());
         KisPaintOpPreset *preset = dynamic_cast<KisPaintOpPreset*>(resource);
         if (preset) {
             adapter->resourceChangedNoCacheInvalidation(preset);
         }
     }
 
     m_chooser->setCurrentResource(resource);
 }
 
 KoResource* KisPresetChooser::currentResource() const
 {
     return m_chooser->currentResource();
 }
 
 void KisPresetChooser::showTaggingBar(bool show)
 {
     m_chooser->showTaggingBar(show);
 }
 
 KoResourceItemChooser *KisPresetChooser::itemChooser()
 {
     return m_chooser;
 }
 
 
 void KisPresetChooser::setPresetFilter(const QString& paintOpId)
 {
     KisPresetProxyAdapter *adapter = static_cast<KisPresetProxyAdapter*>(m_adapter.data());
 
     if (adapter->currentPaintOpId() != paintOpId) {
         adapter->setPresetFilter(paintOpId);
         updateViewSettings();
     }
 }
 
 void KisPresetChooser::setIconSize(int newSize)
 {
     KoResourceItemChooserSync* chooserSync = KoResourceItemChooserSync::instance();
     chooserSync->setBaseLength(newSize);
     updateViewSettings();
 }
 
 int KisPresetChooser::iconSize()
 {
     KoResourceItemChooserSync* chooserSync = KoResourceItemChooserSync::instance();
 
     return chooserSync->baseLength();
 }
 
 
 
 void KisPresetChooser::saveIconSize()
 {
     // save icon size
     KisConfig cfg(false);
     cfg.setPresetIconSize(iconSize());
 }
diff --git a/libs/ui/widgets/kis_tool_options_popup.cpp b/libs/ui/widgets/kis_tool_options_popup.cpp
index 2cf6ac776e..772247086a 100644
--- a/libs/ui/widgets/kis_tool_options_popup.cpp
+++ b/libs/ui/widgets/kis_tool_options_popup.cpp
@@ -1,195 +1,194 @@
 /* This file is part of the KDE project
  * Copyright (C) 2015 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 "widgets/kis_tool_options_popup.h"
 
 
 #include <QList>
 #include <QFont>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 #include <QPointer>
 #include <QGridLayout>
 #include <QFrame>
 #include <QLabel>
-#include <QPointer>
 #include <QApplication>
 #include <QFontDatabase>
 
 #include <KoDockRegistry.h>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 
 
 #include "kis_config.h"
 
 struct KisToolOptionsPopup::Private
 {
 public:
     QFont smallFont;
     bool detached;
     bool ignoreHideEvents;
     QRect detachedGeometry;
 
     QList<QPointer<QWidget> > currentWidgetList;
     QSet<QWidget *> currentAuxWidgets;
     QWidget *hiderWidget; // non current widgets are hidden by being children of this
     QGridLayout *housekeeperLayout;
 
     void recreateLayout(const QList<QPointer<QWidget> > &optionWidgetList)
     {
         Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
             if (!widget.isNull() && widget && hiderWidget) {
                 widget->setParent(hiderWidget);
             }
         }
         qDeleteAll(currentAuxWidgets);
         currentAuxWidgets.clear();
 
         currentWidgetList = optionWidgetList;
 
         // need to unstretch row that have previously been stretched
         housekeeperLayout->setRowStretch(housekeeperLayout->rowCount()-1, 0);
 
         int cnt = 0;
         QFrame *s;
         QLabel *l;
         housekeeperLayout->setHorizontalSpacing(0);
         housekeeperLayout->setVerticalSpacing(2);
         int specialCount = 0;
         Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
             if (widget.isNull() || widget->objectName().isEmpty()) {
                 continue; // skip this docker in release build when assert don't crash
             }
 
             widget->setMinimumWidth(300);
 
             if (!widget->windowTitle().isEmpty()) {
                 housekeeperLayout->addWidget(l = new QLabel(widget->windowTitle()), cnt++, 0);
                 currentAuxWidgets.insert(l);
             }
             housekeeperLayout->addWidget(widget, cnt++, 0);
             QLayout *subLayout = widget->layout();
             if (subLayout) {
                 for (int i = 0; i < subLayout->count(); ++i) {
                     QWidget *spacerWidget = subLayout->itemAt(i)->widget();
                     if (spacerWidget && spacerWidget->objectName().contains("SpecialSpacer")) {
                         specialCount++;
                     }
                 }
             }
             widget->show();
             if (widget != currentWidgetList.last()) {
                 housekeeperLayout->addWidget(s = new QFrame(), cnt++, 0);
                 s->setFrameShape(QFrame::HLine);
                 currentAuxWidgets.insert(s);
             }
         }
         if (specialCount == currentWidgetList.count() || qApp->applicationName().contains("krita")) {
             housekeeperLayout->setRowStretch(cnt, 10000);
         }
 
         housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
         housekeeperLayout->invalidate();
     }
 
 };
 
 
 KisToolOptionsPopup::KisToolOptionsPopup(QWidget *parent)
     : QWidget(parent)
     , d(new Private())
 {
     setObjectName("KisToolOptionsPopup");
 
     KConfigGroup group( KSharedConfig::openConfig(), "GUI");
     setFont(KoDockRegistry::dockFont());
 
     KisConfig cfg(true);
     d->detached = !cfg.paintopPopupDetached();
     d->ignoreHideEvents = false;
 
     d->housekeeperLayout = new QGridLayout();
     d->housekeeperLayout->setContentsMargins(4,4,4,0);
     setLayout(d->housekeeperLayout);
     d->housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
     d->hiderWidget = new QWidget(this);
     d->hiderWidget->setVisible(false);
 }
 
 
 KisToolOptionsPopup::~KisToolOptionsPopup()
 {
     delete d;
 }
 
 void KisToolOptionsPopup::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     d->recreateLayout(optionWidgetList);
 }
 
 void KisToolOptionsPopup::contextMenuEvent(QContextMenuEvent *e) {
 
     QMenu menu(this);
     QAction* action = menu.addAction(d->detached ? i18n("Attach to Toolbar") : i18n("Detach from Toolbar"));
     connect(action, SIGNAL(triggered()), this, SLOT(switchDetached()));
     menu.exec(e->globalPos());
 }
 
 void KisToolOptionsPopup::hideEvent(QHideEvent *event)
 {
     if (d->ignoreHideEvents) {
         return;
     }
     if (d->detached) {
         d->detachedGeometry = window()->geometry();
     }
     QWidget::hideEvent(event);
 }
 
 void KisToolOptionsPopup::showEvent(QShowEvent *)
 {
     if (d->detached) {
         window()->setGeometry(d->detachedGeometry);
     }
 }
 
 void KisToolOptionsPopup::switchDetached(bool show)
 {
     if (parentWidget()) {
         d->detached = !d->detached;
 
         if (d->detached) {
             d->ignoreHideEvents = true;
 
             if (show) {
                 parentWidget()->show();
             }
             d->ignoreHideEvents = false;
         }
         else {
             parentWidget()->hide();
         }
 
         KisConfig cfg(false);
         cfg.setToolOptionsPopupDetached(d->detached);
     }
 }
 
diff --git a/libs/ui/widgets/kis_widget_chooser.cpp b/libs/ui/widgets/kis_widget_chooser.cpp
index 861d26324f..14815ea359 100644
--- a/libs/ui/widgets/kis_widget_chooser.cpp
+++ b/libs/ui/widgets/kis_widget_chooser.cpp
@@ -1,289 +1,287 @@
 /*
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_widget_chooser.h"
 
 #include <kis_icon.h>
 
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QToolButton>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QFrame>
 #include <QLabel>
 #include <QButtonGroup>
 #include <QStylePainter>
 #include <QStyleOption>
 
-#include <kis_icon.h>
-
 #include "kis_config.h"
 
 KisWidgetChooser::KisWidgetChooser(int id, QWidget* parent)
     : QFrame(parent)
     , m_chooserid(id)
 {
 //     QFrame::setFrameStyle(QFrame::StyledPanel|QFrame::Raised);
 
     m_acceptIcon  = KisIconUtils::loadIcon("list-add");
     m_buttons     = new QButtonGroup();
     m_popup       = new QFrame(0, Qt::Popup);
     m_arrowButton = new QToolButton();
 
     m_popup->setFrameStyle(QFrame::Panel|QFrame::Raised);
     m_arrowButton->setFixedWidth(m_arrowButton->sizeHint().height()/2);
     m_arrowButton->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
     m_arrowButton->setAutoRaise(true);
     updateArrowIcon();
 
     connect(m_arrowButton, SIGNAL(clicked(bool)), SLOT(slotButtonPressed()));
 }
 
 KisWidgetChooser::~KisWidgetChooser()
 {
     delete m_buttons;
     delete m_popup;
     delete m_arrowButton;
 }
 
 void KisWidgetChooser::updateArrowIcon()
 {
     QImage image(16, 16, QImage::Format_ARGB32);
     image.fill(0);
 
     QStylePainter painter(&image, this);
     QStyleOption  option;
 
     option.rect    = image.rect();
     option.palette = palette();
     option.state   = QStyle::State_Enabled;
     option.palette.setBrush(QPalette::ButtonText, option.palette.text());
 
     painter.setBrush(option.palette.text().color());
     painter.setPen(option.palette.text().color());
     painter.drawPrimitive(QStyle::PE_IndicatorArrowDown, option);
 
     m_arrowButton->setIcon(QIcon(QPixmap::fromImage(image)));
 }
 
 void KisWidgetChooser::addWidget(const QString& id, const QString& label, QWidget* widget)
 {
     if(id.isEmpty()) {
         delete widget;
         return;
     }
 
     removeWidget(id);
 
     if (label.isEmpty()) {
         m_widgets.push_back(Data(id, widget, 0));
     }
     else {
         m_widgets.push_back(Data(id, widget, new QLabel(label)));
     }
 
     delete m_popup->layout();
     m_popup->setLayout(createPopupLayout());
     m_popup->adjustSize();
 
     delete QWidget::layout();
     QWidget::setLayout(createLayout());
 }
 
 QLayout* KisWidgetChooser::createLayout()
 {
     QHBoxLayout* layout = new QHBoxLayout();
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(0);
 
     for(Iterator i=m_widgets.begin(); i!=m_widgets.end(); ++i) {
         if(i->choosen) {
             if (i->label) {
                 layout->addWidget(i->label);
             }
             layout->addWidget(i->widget);
             break;
         }
     }
 
     layout->addWidget(m_arrowButton);
     return layout;
 }
 
 QLayout* KisWidgetChooser::createPopupLayout()
 {
     QGridLayout* layout = new QGridLayout();
     int          row    = 0;
     int          idx    = 0;
 
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(0);
 
     QButtonGroup*           group   = new QButtonGroup();
     QList<QAbstractButton*> buttons = m_buttons->buttons();
 
     for(Iterator i=m_widgets.begin(); i!=m_widgets.end(); ++i) {
         if(!i->choosen) {
             if(row == buttons.size()) {
                 QToolButton* bn = new QToolButton();
 
                 m_acceptIcon  = KisIconUtils::loadIcon("list-add");
                 bn->setIcon(m_acceptIcon);
                 bn->setAutoRaise(true);
                 buttons.push_back(bn);
             }
 
             if (i->label) {
                 layout->addWidget(i->label    , row, 0);
                 layout->addWidget(i->widget   , row, 1);
                 layout->addWidget(buttons[row], row, 2);
             }
             else {
                 layout->addWidget(i->widget   , row, 0);
                 layout->addWidget(buttons[row], row, 1);
             }
             group->addButton(buttons[row], idx);
             ++row;
         }
 
         ++idx;
     }
 
     for(int i=row; i<buttons.size(); ++i)
         delete buttons[i];
 
     delete m_buttons;
 
     m_buttons = group;
     connect(m_buttons, SIGNAL(buttonClicked(int)), SLOT(slotWidgetChoosen(int)));
 
     return layout;
 }
 
 void KisWidgetChooser::removeWidget(const QString& id)
 {
     Iterator data = std::find(m_widgets.begin(), m_widgets.end(), Data(id));
 
     if(data != m_widgets.end()) {
         if(!data->choosen) {
             delete m_popup->layout();
             m_popup->setLayout(createPopupLayout());
             m_popup->adjustSize();
         }
         else delete QWidget::layout();
 
         if (data->label) {
             delete data->label;
         }
         delete data->widget;
         m_widgets.erase(data);
     }
 }
 
 QWidget* KisWidgetChooser::chooseWidget(const QString& id)
 {
     QWidget* choosenWidget = 0;
 
     for(Iterator i=m_widgets.begin(); i!=m_widgets.end(); ++i) {
         if(i->id == id) {
             choosenWidget = i->widget;
             i->choosen    = true;
         }
         else i->choosen = false;
     }
 
     delete m_popup->layout();
     m_popup->setLayout(createPopupLayout());
     m_popup->adjustSize();
 
     delete QWidget::layout();
     QWidget::setLayout(createLayout());
 
     KisConfig cfg(false);
     cfg.setToolbarSlider(m_chooserid, id);
 
     return choosenWidget;
 }
 
 QWidget* KisWidgetChooser::getWidget(const QString& id) const
 {
     ConstIterator data = std::find(m_widgets.begin(), m_widgets.end(), Data(id));
 
     if(data != m_widgets.end())
         return data->widget;
 
     return 0;
 }
 
 void KisWidgetChooser::showPopupWidget()
 {
     QSize popSize = m_popup->size();
     QRect popupRect(QFrame::mapToGlobal(QPoint(-1, QFrame::height())), popSize);
 
     // Get the available geometry of the screen which contains this KisPopupButton
     QRect screenRect = QApplication::desktop()->availableGeometry(this);
 
     // Make sure the popup is not drawn outside the screen area
     if(popupRect.right() > screenRect.right())
         popupRect.translate(screenRect.right() - popupRect.right(), 0);
     if(popupRect.left() < screenRect.left())
         popupRect.translate(screenRect.left() - popupRect.left(), 0);
     if(popupRect.bottom() > screenRect.bottom())
         popupRect.translate(0, -popupRect.height());
 
     m_popup->setGeometry(popupRect);
     m_popup->show();
 }
 
 
 void KisWidgetChooser::updateThemedIcons()
 {
     for (int i = 0; i < m_buttons->buttons().length(); i++) {
          if ( m_buttons->button(i)) {
               m_buttons->button(i)->setIcon(KisIconUtils::loadIcon("list-add"));
          }
     }
 }
 
 void KisWidgetChooser::slotButtonPressed()
 {
     showPopupWidget();
 }
 
 void KisWidgetChooser::slotWidgetChoosen(int index)
 {
     chooseWidget(m_widgets[index].id);
     m_popup->hide();
 }
 
 
 void KisWidgetChooser::changeEvent(QEvent *e)
 {
     QFrame::changeEvent(e);
 
     switch (e->type()) {
     case QEvent::StyleChange:
     case QEvent::PaletteChange:
     case QEvent::EnabledChange:
         updateArrowIcon();
         break;
     default:
         ;
     }
 }
diff --git a/libs/widgetutils/xmlgui/kactioncollection.cpp b/libs/widgetutils/xmlgui/kactioncollection.cpp
index 230b4fd11c..d61e173488 100644
--- a/libs/widgetutils/xmlgui/kactioncollection.cpp
+++ b/libs/widgetutils/xmlgui/kactioncollection.cpp
@@ -1,759 +1,758 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1999 Reginald Stadlbauer <reggie@kde.org>
               (C) 1999 Simon Hausmann <hausmann@kde.org>
               (C) 2000 Nicolas Hadacek <haadcek@kde.org>
               (C) 2000 Kurt Granroth <granroth@kde.org>
               (C) 2000 Michael Koch <koch@kde.org>
               (C) 2001 Holger Freyther <freyther@kde.org>
               (C) 2002 Ellis Whitehead <ellis@kde.org>
               (C) 2002 Joseph Wenninger <jowenn@kde.org>
               (C) 2005-2007 Hamish Rodda <rodda@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 version 2 as published by the Free Software Foundation.
 
     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 "kactioncollection.h"
 #include "config-xmlgui.h"
 #include "kactioncategory.h"
 #include "kxmlguiclient.h"
 #include "kxmlguifactory.h"
-#include "kactioncategory.h"
 #include "kis_action_registry.h"
 
 #include <kauthorized.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <QDebug>
 #include <QtXml/QDomDocument>
 #include <QtCore/QSet>
 #include <QGuiApplication>
 #include <QtCore/QMap>
 #include <QtCore/QList>
 #include <QAction>
 #include <QMetaMethod>
 
 #include <stdio.h>
 
 #if defined(KCONFIG_BEFORE_5_24)
 # define authorizeAction authorizeKAction
 #endif
 
 class KActionCollectionPrivate
 {
 public:
     KActionCollectionPrivate()
         : m_parentGUIClient(0L),
           configGroup(QStringLiteral("Shortcuts")),
           connectTriggered(false),
           connectHovered(false),
           q(0)
 
     {
     }
 
     void setComponentForAction(QAction *action)
     {
         Q_UNUSED(action)
     }
 
     static QList<KActionCollection *> s_allCollections;
 
     void _k_associatedWidgetDestroyed(QObject *obj);
     void _k_actionDestroyed(QObject *obj);
 
     bool writeKXMLGUIConfigFile();
 
     QString m_componentName;
     QString m_componentDisplayName;
 
     //! Remove a action from our internal bookkeeping. Returns 0 if the
     //! action doesn't belong to us.
     QAction *unlistAction(QAction *);
 
     QMap<QString, QAction *> actionByName;
     QList<QAction *> actions;
 
     const KXMLGUIClient *m_parentGUIClient;
 
     QString configGroup;
     bool configIsGlobal : 1;
 
     bool connectTriggered : 1;
     bool connectHovered : 1;
 
     KActionCollection *q;
 
     QList<QWidget *> associatedWidgets;
 };
 
 QList<KActionCollection *> KActionCollectionPrivate::s_allCollections;
 
 KActionCollection::KActionCollection(QObject *parent, const QString &cName)
     : QObject(parent)
     , d(new KActionCollectionPrivate)
 {
     d->q = this;
     KActionCollectionPrivate::s_allCollections.append(this);
 
     setComponentName(cName);
 }
 
 KActionCollection::KActionCollection(const KXMLGUIClient *parent)
     : QObject(0)
     , d(new KActionCollectionPrivate)
 {
     d->q = this;
     KActionCollectionPrivate::s_allCollections.append(this);
 
     d->m_parentGUIClient = parent;
     d->m_componentName = parent->componentName();
 }
 
 KActionCollection::~KActionCollection()
 {
     KActionCollectionPrivate::s_allCollections.removeAll(this);
 
     delete d;
 }
 
 
 QList<KActionCategory *> KActionCollection::categories() const
 {
     return this->findChildren<KActionCategory *>();
 }
 
 KActionCategory *KActionCollection::getCategory(const QString &name) {
     KActionCategory *category = 0;
     foreach (KActionCategory *c, categories()) {
         if (c->text() == name) {
             category = c;
         }
     }
 
     if (category == 0) {
         category = new KActionCategory(name, this);
     }
     return category;
 };
 
 
 void KActionCollection::clear()
 {
     d->actionByName.clear();
     qDeleteAll(d->actions);
     d->actions.clear();
 }
 
 QAction *KActionCollection::action(const QString &name) const
 {
     QAction *action = 0L;
 
     if (!name.isEmpty()) {
         action = d->actionByName.value(name);
     }
 
     return action;
 }
 
 QAction *KActionCollection::action(int index) const
 {
     // ### investigate if any apps use this at all
     return actions().value(index);
 }
 
 int KActionCollection::count() const
 {
     return d->actions.count();
 }
 
 bool KActionCollection::isEmpty() const
 {
     return count() == 0;
 }
 
 void KActionCollection::setComponentName(const QString &cName)
 {
     if (count() > 0) {
         // Its component name is part of an action's signature in the context of
         // global shortcuts and the semantics of changing an existing action's
         // signature are, as it seems, impossible to get right.
         // As of now this only matters for global shortcuts. We could
         // thus relax the requirement and only refuse to change the component data
         // if we have actions with global shortcuts in this collection.
         qWarning() << "this does not work on a KActionCollection containing actions!";
     }
 
     if (!cName.isEmpty()) {
         d->m_componentName = cName;
     } else {
         d->m_componentName = QCoreApplication::applicationName();
     }
 }
 
 QString KActionCollection::componentName() const
 {
     return d->m_componentName;
 }
 
 void KActionCollection::setComponentDisplayName(const QString &displayName)
 {
     d->m_componentDisplayName = displayName;
 }
 
 QString KActionCollection::componentDisplayName() const
 {
     if (!d->m_componentDisplayName.isEmpty()) {
         return d->m_componentDisplayName;
     }
     if (!QGuiApplication::applicationDisplayName().isEmpty()) {
         return QGuiApplication::applicationDisplayName();
     }
     return QCoreApplication::applicationName();
 }
 
 const KXMLGUIClient *KActionCollection::parentGUIClient() const
 {
     return d->m_parentGUIClient;
 }
 
 QList<QAction *> KActionCollection::actions() const
 {
     return d->actions;
 }
 
 const QList< QAction * > KActionCollection::actionsWithoutGroup() const
 {
     QList<QAction *> ret;
     Q_FOREACH (QAction *action, d->actions)
         if (!action->actionGroup()) {
             ret.append(action);
         }
     return ret;
 }
 
 const QList< QActionGroup * > KActionCollection::actionGroups() const
 {
     QSet<QActionGroup *> set;
     Q_FOREACH (QAction *action, d->actions)
         if (action->actionGroup()) {
             set.insert(action->actionGroup());
         }
     return set.toList();
 }
 
 QAction *KActionCollection::addCategorizedAction(const QString &name, QAction *action, const QString &categoryName)
 {
     return getCategory(categoryName)->addAction(name, action);
 }
 
 QAction *KActionCollection::addAction(const QString &name, QAction *action)
 {
     if (!action) {
         return action;
     }
 
     const QString objectName = action->objectName();
     QString indexName = name;
 
     if (indexName.isEmpty()) {
         // No name provided. Use the objectName.
         indexName = objectName;
 
     } else {
         // Set the new name
         action->setObjectName(indexName);
     }
 
     // No name provided and the action had no name. Make one up. This will not
     // work when trying to save shortcuts.
     if (indexName.isEmpty()) {
         indexName = indexName.sprintf("unnamed-%p", (void *)action);
         action->setObjectName(indexName);
     }
 
     // From now on the objectName has to have a value. Else we cannot safely
     // remove actions.
     Q_ASSERT(!action->objectName().isEmpty());
 
     // look if we already have THIS action under THIS name ;)
     if (d->actionByName.value(indexName, 0) == action) {
         // This is not a multi map!
         Q_ASSERT(d->actionByName.count(indexName) == 1);
         return action;
     }
 
     if (!KAuthorized::authorizeAction(indexName)) {
         // Disable this action
         action->setEnabled(false);
         action->setVisible(false);
         action->blockSignals(true);
     }
 
     // Check if we have another action under this name
     if (QAction *oldAction = d->actionByName.value(indexName)) {
         takeAction(oldAction);
     }
 
     // Check if we have this action under a different name.
     // Not using takeAction because we don't want to remove it from categories,
     // and because it has the new name already.
     const int oldIndex = d->actions.indexOf(action);
     if (oldIndex != -1) {
         d->actionByName.remove(d->actionByName.key(action));
         d->actions.removeAt(oldIndex);
     }
 
     // Add action to our lists.
     d->actionByName.insert(indexName, action);
     d->actions.append(action);
 
     Q_FOREACH (QWidget *widget, d->associatedWidgets) {
         widget->addAction(action);
     }
 
     connect(action, SIGNAL(destroyed(QObject*)), SLOT(_k_actionDestroyed(QObject*)));
 
     d->setComponentForAction(action);
 
     if (d->connectHovered) {
         connect(action, SIGNAL(hovered()), SLOT(slotActionHovered()));
     }
 
     if (d->connectTriggered) {
         connect(action, SIGNAL(triggered(bool)), SLOT(slotActionTriggered()));
     }
 
     emit inserted(action);
     return action;
 }
 
 void KActionCollection::addActions(const QList<QAction *> &actions)
 {
     Q_FOREACH (QAction *action, actions) {
         addAction(action->objectName(), action);
     }
 }
 
 void KActionCollection::removeAction(QAction *action)
 {
     delete takeAction(action);
 }
 
 QAction *KActionCollection::takeAction(QAction *action)
 {
     if (!d->unlistAction(action)) {
         return 0;
     }
 
     // Remove the action from all widgets
     Q_FOREACH (QWidget *widget, d->associatedWidgets) {
         widget->removeAction(action);
     }
 
     action->disconnect(this);
 
     emit removed(action);   //deprecated
     return action;
 }
 
 QAction *KActionCollection::addAction(KStandardAction::StandardAction actionType, const QObject *receiver, const char *member)
 {
     QAction *action = KStandardAction::create(actionType, receiver, member, this);
     return action;
 }
 
 QAction *KActionCollection::addAction(KStandardAction::StandardAction actionType, const QString &name,
                                       const QObject *receiver, const char *member)
 {
     // pass 0 as parent, because if the parent is a KActionCollection KStandardAction::create automatically
     // adds the action to it under the default name. We would trigger the
     // warning about renaming the action then.
     QAction *action = KStandardAction::create(actionType, receiver, member, 0);
     // Give it a parent for gc.
     action->setParent(this);
     // Remove the name to get rid of the "rename action" warning above
     action->setObjectName(name);
     // And now add it with the desired name.
     return addAction(name, action);
 }
 
 QAction *KActionCollection::addAction(const QString &name, const QObject *receiver, const char *member)
 {
     QAction *a = new QAction(this);
     if (receiver && member) {
         connect(a, SIGNAL(triggered(bool)), receiver, member);
     }
     return addAction(name, a);
 }
 
 QKeySequence KActionCollection::defaultShortcut(QAction *action) const
 {
     const QList<QKeySequence> shortcuts = defaultShortcuts(action);
     return shortcuts.isEmpty() ? QKeySequence() : shortcuts.first();
 }
 
 QList<QKeySequence> KActionCollection::defaultShortcuts(QAction *action) const
 {
     return action->property("defaultShortcuts").value<QList<QKeySequence> >();
 }
 
 void KActionCollection::setDefaultShortcut(QAction *action, const QKeySequence &shortcut)
 {
     setDefaultShortcuts(action, QList<QKeySequence>() << shortcut);
 }
 
 void KActionCollection::setDefaultShortcuts(QAction *action, const QList<QKeySequence> &shortcuts)
 {
     action->setShortcuts(shortcuts);
     action->setProperty("defaultShortcuts", QVariant::fromValue(shortcuts));
 }
 
 bool KActionCollection::isShortcutsConfigurable(QAction *action) const
 {
     // Considered as true by default
     const QVariant value = action->property("isShortcutConfigurable");
     return value.isValid() ? value.toBool() : true;
 }
 
 void KActionCollection::setShortcutsConfigurable(QAction *action, bool configurable)
 {
     action->setProperty("isShortcutConfigurable", configurable);
 }
 
 QString KActionCollection::configGroup() const
 {
     return d->configGroup;
 }
 
 void KActionCollection::setConfigGroup(const QString &group)
 {
     d->configGroup = group;
 }
 
 void KActionCollection::updateShortcuts()
 {
     auto actionRegistry = KisActionRegistry::instance();
 
     for (QMap<QString, QAction *>::ConstIterator it = d->actionByName.constBegin();
          it != d->actionByName.constEnd(); ++it) {
         actionRegistry->updateShortcut(it.key(), it.value());
     }
 }
 
 
 void KActionCollection::readSettings()
 {
     auto ar = KisActionRegistry::instance();
     ar->loadCustomShortcuts();
 
     for (QMap<QString, QAction *>::ConstIterator it = d->actionByName.constBegin();
             it != d->actionByName.constEnd(); ++it) {
         QAction *action = it.value();
         if (!action) {
             continue;
         }
 
         if (isShortcutsConfigurable(action)) {
             QString actionName = it.key();
             ar->updateShortcut(actionName, action);
         }
     }
 }
 
 
 bool KActionCollectionPrivate::writeKXMLGUIConfigFile()
 {
     const KXMLGUIClient *kxmlguiClient = q->parentGUIClient();
     // return false if there is no KXMLGUIClient
     if (!kxmlguiClient || kxmlguiClient->xmlFile().isEmpty()) {
         return false;
     }
 
 
     QString attrShortcut = QStringLiteral("shortcut");
 
     // Read XML file
     QString sXml(KXMLGUIFactory::readConfigFile(kxmlguiClient->xmlFile(), q->componentName()));
     QDomDocument doc;
     doc.setContent(sXml);
 
     // Process XML data
 
     // Get hold of ActionProperties tag
     QDomElement elem = KXMLGUIFactory::actionPropertiesElement(doc);
 
     // now, iterate through our actions
     for (QMap<QString, QAction *>::ConstIterator it = actionByName.constBegin();
             it != actionByName.constEnd(); ++it) {
         QAction *action = it.value();
         if (!action) {
             continue;
         }
 
         QString actionName = it.key();
 
         // If the action name starts with unnamed- spit out a warning and ignore
         // it. That name will change at will and will break loading writing
         if (actionName.startsWith(QLatin1String("unnamed-"))) {
             qCritical() << "Skipped writing shortcut for action " << actionName << "(" << action->text() << ")!";
             continue;
         }
 
         bool bSameAsDefault = (action->shortcuts() == q->defaultShortcuts(action));
 
         // now see if this element already exists
         // and create it if necessary (unless bSameAsDefault)
         QDomElement act_elem = KXMLGUIFactory::findActionByName(elem, actionName, !bSameAsDefault);
         if (act_elem.isNull()) {
             continue;
         }
 
         if (bSameAsDefault) {
             act_elem.removeAttribute(attrShortcut);
             if (act_elem.attributes().count() == 1) {
                 elem.removeChild(act_elem);
             }
         } else {
             act_elem.setAttribute(attrShortcut, QKeySequence::listToString(action->shortcuts()));
         }
     }
 
     // Write back to XML file
     KXMLGUIFactory::saveConfigFile(doc, kxmlguiClient->localXMLFile(), q->componentName());
     return true;
 }
 
 void KActionCollection::writeSettings(KConfigGroup *config,
                                       bool writeScheme,
                                       QAction *oneAction) const
 {
     // If the caller didn't provide a config group we try to save the KXMLGUI
     // Configuration file. (This will work if the parentGUI was set and has a
     // valid configuration file.)
     if (config == 0 && d->writeKXMLGUIConfigFile()) {
         return;
     }
 
 
     KConfigGroup cg(KSharedConfig::openConfig(), configGroup());
     if (!config) {
         config = &cg;
     }
 
     QList<QAction *> writeActions;
     if (oneAction) {
         writeActions.append(oneAction);
     } else {
         writeActions = actions();
     }
 
     for (QMap<QString, QAction *>::ConstIterator it = d->actionByName.constBegin();
             it != d->actionByName.constEnd(); ++it) {
 
         QAction *action = it.value();
         if (!action) {
             continue;
         }
 
         QString actionName = it.key();
 
         // If the action name starts with unnamed- spit out a warning and ignore
         // it. That name will change at will and will break loading writing
         if (actionName.startsWith(QLatin1String("unnamed-"))) {
             qCritical() << "Skipped saving shortcut for action without name " \
                         << action->text() << "!";
             continue;
         }
 
         // Write the shortcut
         if (isShortcutsConfigurable(action)) {
             bool bConfigHasAction = !config->readEntry(actionName, QString()).isEmpty();
             bool bSameAsDefault = (action->shortcuts() == defaultShortcuts(action));
             // If the current shortcut differs from the default, we want to write.
 
             KConfigGroup::WriteConfigFlags flags = KConfigGroup::Persistent;
 
             if (writeScheme || !bSameAsDefault) {
                 // We are instructed to write all shortcuts or the shortcut is
                 // not set to its default value. Write it
                 QString s = QKeySequence::listToString(action->shortcuts());
                 if (s.isEmpty()) {
                     s = QStringLiteral("none");
                 }
                 config->writeEntry(actionName, s, flags);
             } else if (bConfigHasAction) {
                 // This key is the same as default but exists in config file.
                 // Remove it.
                 config->deleteEntry(actionName, flags);
             }
         }
     }
 
     config->sync();
 }
 
 void KActionCollection::slotActionTriggered()
 {
     QAction *action = qobject_cast<QAction *>(sender());
     if (action) {
         emit actionTriggered(action);
     }
 }
 
 void KActionCollection::slotActionHighlighted()
 {
     slotActionHovered();
 }
 
 void KActionCollection::slotActionHovered()
 {
     QAction *action = qobject_cast<QAction *>(sender());
     if (action) {
         emit actionHighlighted(action);
         emit actionHovered(action);
     }
 }
 
 void KActionCollectionPrivate::_k_actionDestroyed(QObject *obj)
 {
     // obj isn't really a QAction anymore. So make sure we don't do fancy stuff
     // with it.
     QAction *action = static_cast<QAction *>(obj);
 
     if (!unlistAction(action)) {
         return;
     }
 
     //HACK the object we emit is partly destroyed
     emit q->removed(action); //deprecated. remove in KDE5
 }
 
 void KActionCollection::connectNotify(const QMetaMethod &signal)
 {
     if (d->connectHovered && d->connectTriggered) {
         return;
     }
 
     if (signal.methodSignature() == "actionHighlighted(QAction*)" ||
             signal.methodSignature() == "actionHovered(QAction*)") {
         if (!d->connectHovered) {
             d->connectHovered = true;
             Q_FOREACH (QAction *action, actions()) {
                 connect(action, SIGNAL(hovered()), SLOT(slotActionHovered()));
             }
         }
 
     } else if (signal.methodSignature() == "actionTriggered(QAction*)") {
         if (!d->connectTriggered) {
             d->connectTriggered = true;
             Q_FOREACH (QAction *action, actions()) {
                 connect(action, SIGNAL(triggered(bool)), SLOT(slotActionTriggered()));
             }
         }
     }
 
     QObject::connectNotify(signal);
 }
 
 const QList< KActionCollection * > &KActionCollection::allCollections()
 {
     return KActionCollectionPrivate::s_allCollections;
 }
 
 void KActionCollection::associateWidget(QWidget *widget) const
 {
     Q_FOREACH (QAction *action, actions()) {
         if (!widget->actions().contains(action)) {
             widget->addAction(action);
         }
     }
 }
 
 void KActionCollection::addAssociatedWidget(QWidget *widget)
 {
     if (!d->associatedWidgets.contains(widget)) {
         widget->addActions(actions());
 
         d->associatedWidgets.append(widget);
         connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(_k_associatedWidgetDestroyed(QObject*)));
     }
 }
 
 void KActionCollection::removeAssociatedWidget(QWidget *widget)
 {
     Q_FOREACH (QAction *action, actions()) {
         widget->removeAction(action);
     }
 
     d->associatedWidgets.removeAll(widget);
     disconnect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(_k_associatedWidgetDestroyed(QObject*)));
 }
 
 QAction *KActionCollectionPrivate::unlistAction(QAction *action)
 {
     // ATTENTION:
     //   This method is called with an QObject formerly known as a QAction
     //   during _k_actionDestroyed(). So don't do fancy stuff here that needs a
     //   real QAction!
 
     // Get the index for the action
     int index = actions.indexOf(action);
 
     // Action not found.
     if (index == -1) {
         return 0;
     }
 
     // An action collection can't have the same action twice.
     Q_ASSERT(actions.indexOf(action, index + 1) == -1);
 
     // Get the actions name
     const QString name = action->objectName();
 
     // Remove the action
     actionByName.remove(name);
     actions.removeAt(index);
 
     // Remove the action from the categories. Should be only one
     QList<KActionCategory *> categories = q->findChildren<KActionCategory *>();
     Q_FOREACH (KActionCategory *category, categories) {
         category->unlistAction(action);
     }
 
     return action;
 }
 
 QList< QWidget * > KActionCollection::associatedWidgets() const
 {
     return d->associatedWidgets;
 }
 
 void KActionCollection::clearAssociatedWidgets()
 {
     Q_FOREACH (QWidget *widget, d->associatedWidgets)
         Q_FOREACH (QAction *action, actions()) {
             widget->removeAction(action);
         }
 
     d->associatedWidgets.clear();
 }
 
 void KActionCollectionPrivate::_k_associatedWidgetDestroyed(QObject *obj)
 {
     associatedWidgets.removeAll(static_cast<QWidget *>(obj));
 }
 
 #include "moc_kactioncollection.cpp"
diff --git a/libs/widgetutils/xmlgui/kbugreport.cpp b/libs/widgetutils/xmlgui/kbugreport.cpp
index 77586f2d72..d3bfbfec1e 100644
--- a/libs/widgetutils/xmlgui/kbugreport.cpp
+++ b/libs/widgetutils/xmlgui/kbugreport.cpp
@@ -1,234 +1,233 @@
 /* This file is part of the KDE project
    Copyright (C) 1999 David Faure <faure@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 "kbugreport.h"
 
 #include <QtCore/QProcess>
 #include <QtCore/QCoreApplication>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QLayout>
 #include <QRadioButton>
 #include <QGroupBox>
 #include <QLocale>
 #include <QCloseEvent>
 #include <QLabel>
 #include <QUrl>
 #include <QUrlQuery>
 #include <QStandardPaths>
 #include <QComboBox>
 #include <QLineEdit>
-#include <QStandardPaths>
 #include <QDebug>
 #include <QTextEdit>
 #include <QDesktopServices>
 
 #include <kaboutdata.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <kemailsettings.h>
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 
 #include <ktitlewidget.h>
 
 #include "systeminformation_p.h"
 
 #include "config-xmlgui.h"
 
 #include <kis_icon_utils.h>
 
 class KBugReportPrivate
 {
 public:
     KBugReportPrivate(KBugReport *q): q(q), m_aboutData(KAboutData::applicationData()) {}
 
     void _k_updateUrl();
 
     KBugReport *q;
     QProcess *m_process;
     KAboutData m_aboutData;
 
     QTextEdit *m_lineedit;
     QLineEdit *m_subject;
     QLabel *m_version;
     QString m_strVersion;
     QGroupBox *m_bgSeverity;
 
     QComboBox *appcombo;
     QString lastError;
     QString appname;
     QString os;
     QUrl url;
     QList<QRadioButton *> severityButtons;
     int currentSeverity()
     {
         for (int i = 0; i < severityButtons.count(); i++)
             if (severityButtons[i]->isChecked()) {
                 return i;
             }
         return -1;
     }
 };
 
 KBugReport::KBugReport(const KAboutData &aboutData, QWidget *_parent)
     : QDialog(_parent), d(new KBugReportPrivate(this))
 {
     setWindowTitle(i18n("Submit Bug Report"));
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(this);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
 
     d->m_aboutData = aboutData;
     d->m_process = 0;
     KGuiItem::assign(buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::close());
 
     QLabel *tmpLabel;
     QVBoxLayout *lay = new QVBoxLayout;
     setLayout(lay);
 
     KTitleWidget *title = new KTitleWidget(this);
     title->setText(i18n("Submit Bug Report"));
     title->setPixmap(KisIconUtils::loadIcon(QStringLiteral("tools-report-bug")).pixmap(32));
     lay->addWidget(title);
 
     QGridLayout *glay = new QGridLayout();
     lay->addLayout(glay);
 
     int row = 0;
 
     // Program name
     QString qwtstr = i18n("The application for which you wish to submit a bug report - if incorrect, please use the Report Bug menu item of the correct application");
     tmpLabel = new QLabel(i18n("Application: "), this);
     glay->addWidget(tmpLabel, row, 0);
     tmpLabel->setWhatsThis(qwtstr);
     d->appcombo = new QComboBox(this);
     d->appcombo->setWhatsThis(qwtstr);
 
     QStringList packageList = QStringList() << "krita";
     d->appcombo->addItems(packageList);
     connect(d->appcombo, SIGNAL(activated(int)), SLOT(_k_appChanged(int)));
     d->appname = d->m_aboutData.productName();
     glay->addWidget(d->appcombo, row, 1);
     int index = 0;
     for (; index < d->appcombo->count(); index++) {
         if (d->appcombo->itemText(index) == d->appname) {
             break;
         }
     }
     if (index == d->appcombo->count()) { // not present
         d->appcombo->addItem(d->appname);
     }
     d->appcombo->setCurrentIndex(index);
 
     tmpLabel->setWhatsThis(qwtstr);
 
     // Version
     qwtstr = i18n("The version of this application - please make sure that no newer version is available before sending a bug report");
     tmpLabel = new QLabel(i18n("Version:"), this);
     glay->addWidget(tmpLabel, ++row, 0);
     tmpLabel->setWhatsThis(qwtstr);
     d->m_strVersion = d->m_aboutData.version();
     if (d->m_strVersion.isEmpty()) {
         d->m_strVersion = i18n("no version set (programmer error)");
     }
     d->m_version = new QLabel(d->m_strVersion, this);
     d->m_version->setTextInteractionFlags(Qt::TextBrowserInteraction);
     //glay->addWidget( d->m_version, row, 1 );
     glay->addWidget(d->m_version, row, 1, 1, 2);
     d->m_version->setWhatsThis(qwtstr);
 
     tmpLabel = new QLabel(i18n("OS:"), this);
     glay->addWidget(tmpLabel, ++row, 0);
     d->os = SystemInformation::operatingSystemVersion();
 
     tmpLabel = new QLabel(d->os, this);
     tmpLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     glay->addWidget(tmpLabel, row, 1, 1, 2);
 
     tmpLabel = new QLabel(i18n("Compiler:"), this);
     glay->addWidget(tmpLabel, ++row, 0);
     tmpLabel = new QLabel(QString::fromLatin1(XMLGUI_COMPILER_VERSION), this);
     tmpLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     glay->addWidget(tmpLabel, row, 1, 1, 2);
 
     // Point to the web form
 
     lay->addSpacing(10);
     QString text = i18n("<qt>"
                         "<p>Please read <b><a href=\"https://docs.krita.org/en/untranslatable_pages/reporting_bugs.html\">this guide</a></b> for reporting bugs first!</p>"
                         "<p>To submit a bug report, click on the button below. This will open a web browser "
                         "window on <a href=\"http://bugs.kde.org\">http://bugs.kde.org</a> where you will find "
                         "a form to fill in. The information displayed above will be transferred to that server.</p></qt>");
     QLabel *label = new QLabel(text, this);
     label->setOpenExternalLinks(true);
     label->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);
     label->setWordWrap(true);
     lay->addWidget(label);
     lay->addSpacing(10);
 
     d->appcombo->setFocus();
 
     d->_k_updateUrl();
 
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setText(i18n("&Launch Bug Report Wizard"));
     okButton->setIcon(KisIconUtils::loadIcon(QStringLiteral("tools-report-bug")));
     lay->addWidget(buttonBox);
     setMinimumHeight(sizeHint().height() + 20);   // WORKAROUND: prevent "cropped" qcombobox
 }
 
 KBugReport::~KBugReport()
 {
     delete d;
 }
 
 void KBugReportPrivate::_k_updateUrl()
 {
     url = QUrl(QStringLiteral("https://bugs.kde.org/enter_bug.cgi"));
     QUrlQuery query;
     query.addQueryItem(QStringLiteral("format"), QLatin1String("guided"));    // use the guided form
 
     // the string format is product/component, where component is optional
     QStringList list = appcombo->currentText().split(QLatin1Char('/'));
     query.addQueryItem(QStringLiteral("product"), list[0]);
     if (list.size() == 2) {
         query.addQueryItem(QStringLiteral("component"), list[1]);
     }
 
     query.addQueryItem(QStringLiteral("version"), m_strVersion);
 
     // TODO: guess and fill OS(sys_os) and Platform(rep_platform) fields
 #ifdef Q_OS_WIN
     query.addQueryItem(QStringLiteral("op_sys"), QStringLiteral("MS Windows"));
     query.addQueryItem(QStringLiteral("rep_platform"), QStringLiteral("MS Windows"));
 #endif
 
     url.setQuery(query);
 }
 
 void KBugReport::accept()
 {
     QDesktopServices::openUrl(d->url);
 }
 
 
 #include "moc_kbugreport.cpp"