diff --git a/libs/command/kundo2model.cpp b/libs/command/kundo2model.cpp
index 8c4f7e0b6b..58006e4bc0 100644
--- a/libs/command/kundo2model.cpp
+++ b/libs/command/kundo2model.cpp
@@ -1,219 +1,219 @@
 /* This file is part of the KDE project
  * Copyright (C) 2010 Matus Talcik <matus.talcik@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.
  */
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
 ** This file contains pre-release code and may not be distributed.
 ** You may use this file in accordance with the terms and conditions
 ** contained in the Technology Preview License Agreement accompanying
 ** this package.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.LGPL included in the
 ** packaging of this file.  Please review the following information to
 ** ensure the GNU Lesser General Public License version 2.1 requirements
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights.  These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at qt-info@nokia.com.
 **
 **
 **
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
 #include "kundo2model.h"
 #include <klocalizedstring.h>
 KUndo2Model::KUndo2Model(QObject *parent)
     : QAbstractItemModel(parent)
 {
     m_stack = 0;
     m_sel_model = new QItemSelectionModel(this, this);
-    connect(m_sel_model, SIGNAL(currentChanged(QModelIndex, QModelIndex)), this, SLOT(setStackCurrentIndex(QModelIndex)));
+    connect(m_sel_model, SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(setStackCurrentIndex(QModelIndex)));
     m_emty_label = i18n("<empty>");
 }
 
 QItemSelectionModel *KUndo2Model::selectionModel() const
 {
     return m_sel_model;
 }
 
 KUndo2QStack *KUndo2Model::stack() const
 {
     return m_stack;
 }
 
 void KUndo2Model::setStack(KUndo2QStack *stack)
 {
     if (m_stack == stack)
         return;
 
     if (m_stack != 0) {
         disconnect(m_stack, SIGNAL(cleanChanged(bool)), this, SLOT(stackChanged()));
         disconnect(m_stack, SIGNAL(indexChanged(int)), this, SLOT(stackChanged()));
         disconnect(m_stack, SIGNAL(destroyed(QObject*)), this, SLOT(stackDestroyed(QObject*)));
         disconnect(m_stack, SIGNAL(indexChanged(int)), this, SLOT(addImage(int)));
     }
     m_stack = stack;
     if (m_stack != 0) {
         connect(m_stack, SIGNAL(cleanChanged(bool)), this, SLOT(stackChanged()));
         connect(m_stack, SIGNAL(indexChanged(int)), this, SLOT(stackChanged()));
         connect(m_stack, SIGNAL(destroyed(QObject*)), this, SLOT(stackDestroyed(QObject*)));
         connect(m_stack, SIGNAL(indexChanged(int)), this, SLOT(addImage(int)));
     }
 
     stackChanged();
 }
 
 void KUndo2Model::stackDestroyed(QObject *obj)
 {
     if (obj != m_stack)
         return;
     m_stack = 0;
 
     stackChanged();
 }
 
 void KUndo2Model::stackChanged()
 {
     beginResetModel();
     endResetModel();
     m_sel_model->setCurrentIndex(selectedIndex(), QItemSelectionModel::ClearAndSelect);
 }
 
 void KUndo2Model::setStackCurrentIndex(const QModelIndex &index)
 {
     if (m_stack == 0)
         return;
 
     if (index == selectedIndex())
         return;
 
     if (index.column() != 0)
         return;
 
     m_stack->setIndex(index.row());
 }
 
 QModelIndex KUndo2Model::selectedIndex() const
 {
     return m_stack == 0 ? QModelIndex() : createIndex(m_stack->index(), 0);
 }
 
 QModelIndex KUndo2Model::index(int row, int column, const QModelIndex &parent) const
 {
     if (m_stack == 0)
         return QModelIndex();
 
     if (parent.isValid())
         return QModelIndex();
 
     if (column != 0)
         return QModelIndex();
 
     if (row < 0 || row > m_stack->count())
         return QModelIndex();
 
     return createIndex(row, column);
 }
 
 QModelIndex KUndo2Model::parent(const QModelIndex&) const
 {
     return QModelIndex();
 }
 
 int KUndo2Model::rowCount(const QModelIndex &parent) const
 {
     if (m_stack == 0)
         return 0;
 
     if (parent.isValid())
         return 0;
 
     return m_stack->count() + 1;
 }
 
 int KUndo2Model::columnCount(const QModelIndex&) const
 {
     return 1;
 }
 
 QVariant KUndo2Model::data(const QModelIndex &index, int role) const
 {
     if (m_stack == 0)
         return QVariant();
 
     if (index.column() != 0)
         return QVariant();
 
     if (index.row() < 0 || index.row() > m_stack->count())
         return QVariant();
 
     if (role == Qt::DisplayRole) {
         if (index.row() == 0)
             return m_emty_label;
         return m_stack->text(index.row() - 1);
     } else if (role == Qt::DecorationRole) {
         if (index.row() == m_stack->cleanIndex() && !m_clean_icon.isNull())
             return m_clean_icon;
     }
 
     return QVariant();
 }
 
 QString KUndo2Model::emptyLabel() const
 {
     return m_emty_label;
 }
 
 void KUndo2Model::setEmptyLabel(const QString &label)
 {
     m_emty_label = label;
     stackChanged();
 }
 
 void KUndo2Model::setCleanIcon(const QIcon &icon)
 {
     m_clean_icon = icon;
     stackChanged();
 }
 
 QIcon KUndo2Model::cleanIcon() const
 {
     return m_clean_icon;
 }
 
diff --git a/libs/flake/KoCanvasControllerWidget.cpp b/libs/flake/KoCanvasControllerWidget.cpp
index 6520b1d76b..095058743b 100644
--- a/libs/flake/KoCanvasControllerWidget.cpp
+++ b/libs/flake/KoCanvasControllerWidget.cpp
@@ -1,622 +1,622 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2008-2009 Thomas Zander <zander@kde.org>
  * Copyright (C) 2006 Peter Simonsson <peter.simonsson@gmail.com>
  * Copyright (C) 2006, 2009 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2007-2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2007 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2006-2008 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 "KoCanvasControllerWidget.h"
 #include "KoCanvasControllerWidget_p.h"
 
 #include "KoCanvasControllerWidgetViewport_p.h"
 #include "KoShape.h"
 #include "KoViewConverter.h"
 #include "KoCanvasBase.h"
 #include "KoCanvasObserverBase.h"
 #include "KoCanvasSupervisor.h"
 #include "KoToolManager_p.h"
 
 #include <FlakeDebug.h>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QScrollBar>
 #include <QEvent>
 #include <QDockWidget>
 #include <QTimer>
 #include <QPointer>
 
 #include <QOpenGLWidget>
 
 #include <math.h>
 
 void KoCanvasControllerWidget::Private::setDocumentOffset()
 {
     // The margins scroll the canvas widget inside the viewport, not
     // the document. The documentOffset is meant to be the value that
     // the canvas must add to the update rect in its paint event, to
     // compensate.
 
     QPoint pt(q->horizontalScrollBar()->value(), q->verticalScrollBar()->value());
     q->proxyObject->emitMoveDocumentOffset(pt);
 
     QWidget *canvasWidget = canvas->canvasWidget();
 
     if (canvasWidget) {
         // If it isn't an OpenGL canvas
         if (qobject_cast<QOpenGLWidget*>(canvasWidget) == 0) {
             QPoint diff = q->documentOffset() - pt;
             canvasWidget->scroll(diff.x(), diff.y(), canvasWidget->rect());
         }
     }
 
     q->setDocumentOffset(pt);
 }
 
 void KoCanvasControllerWidget::Private::resetScrollBars()
 {
     // The scrollbar value always points at the top-left corner of the
     // bit of image we paint.
 
     int docH = q->documentSize().height() + q->margin();
     int docW = q->documentSize().width() + q->margin();
     int drawH = viewportWidget->height();
     int drawW = viewportWidget->width();
 
     QScrollBar *hScroll = q->horizontalScrollBar();
     QScrollBar *vScroll = q->verticalScrollBar();
 
     int horizontalReserve = vastScrollingFactor * drawW;
     int verticalReserve = vastScrollingFactor * drawH;
 
     int xMin = -horizontalReserve;
     int yMin = -verticalReserve;
 
     int xMax = docW - drawW + horizontalReserve;
     int yMax = docH - drawH + verticalReserve;
 
     hScroll->setRange(xMin, xMax);
     vScroll->setRange(yMin, yMax);
 
     int fontheight = QFontMetrics(q->font()).height();
 
     vScroll->setPageStep(drawH);
     vScroll->setSingleStep(fontheight);
     hScroll->setPageStep(drawW);
     hScroll->setSingleStep(fontheight);
 
 }
 
 void KoCanvasControllerWidget::Private::emitPointerPositionChangedSignals(QEvent *event)
 {
     if (!canvas) return;
     if (!canvas->viewConverter()) return;
 
     QPoint pointerPos;
     QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
     if (mouseEvent) {
         pointerPos = mouseEvent->pos();
     } else {
         QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event);
         if (tabletEvent) {
             pointerPos = tabletEvent->pos();
         }
     }
 
     QPoint pixelPos = (pointerPos - canvas->documentOrigin()) + q->documentOffset();
     QPointF documentPos = canvas->viewConverter()->viewToDocument(pixelPos);
 
     q->proxyObject->emitDocumentMousePositionChanged(documentPos);
     q->proxyObject->emitCanvasMousePositionChanged(pointerPos);
 }
 
 
 #include <QTime>
 
 void KoCanvasControllerWidget::Private::activate()
 {
     QWidget *parent = q;
     while (parent->parentWidget()) {
         parent = parent->parentWidget();
     }
     KoCanvasSupervisor *observerProvider = dynamic_cast<KoCanvasSupervisor*>(parent);
     if (!observerProvider) {
         return;
     }
 
     KoCanvasBase *canvas = q->canvas();
     Q_FOREACH (KoCanvasObserverBase *docker, observerProvider->canvasObservers()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observer->setObservedCanvas(canvas);
         }
     }
 
 }
 
 void KoCanvasControllerWidget::Private::unsetCanvas()
 {
     QWidget *parent = q;
     while (parent->parentWidget()) {
         parent = parent->parentWidget();
     }
     KoCanvasSupervisor *observerProvider = dynamic_cast<KoCanvasSupervisor*>(parent);
     if (!observerProvider) {
         return;
     }
     Q_FOREACH (KoCanvasObserverBase *docker, observerProvider->canvasObservers()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
        if (observer) {
             if (observer->observedCanvas() == q->canvas()) {
                 observer->unsetObservedCanvas();
             }
         }
     }
 }
 
 ////////////
 KoCanvasControllerWidget::KoCanvasControllerWidget(KActionCollection * actionCollection, QWidget *parent)
     : QAbstractScrollArea(parent)
     , KoCanvasController(actionCollection)
     , d(new Private(this))
 {
     // We need to set this as QDeclarativeView sets them a bit different from QAbstractScrollArea
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
     // And then our own Viewport
     d->viewportWidget = new Viewport(this);
     setViewport(d->viewportWidget);
     d->viewportWidget->setFocusPolicy(Qt::NoFocus);
     setFocusPolicy(Qt::NoFocus);
     setFrameStyle(0);
 
     //setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     setAutoFillBackground(false);
     /*
       Fixes:   apps starting at zero zoom.
       Details: Since the document is set on the mainwindow before loading commences the inial show/layout can choose
           to set the document to be very small, even to be zero pixels tall.  Setting a sane minimum size on the
           widget means we no longer get rounding errors in zooming and we no longer end up with zero-zoom.
       Note: KoPage apps should probably startup with a sane document size; for Krita that's impossible
      */
     setMinimumSize(QSize(50, 50));
     setMouseTracking(true);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(updateCanvasOffsetX()));
     connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(updateCanvasOffsetY()));
     connect(d->viewportWidget, SIGNAL(sizeChanged()), this, SLOT(updateCanvasOffsetX()));
-    connect(proxyObject, SIGNAL(moveDocumentOffset(const QPoint&)), d->viewportWidget, SLOT(documentOffsetMoved(const QPoint&)));
+    connect(proxyObject, SIGNAL(moveDocumentOffset(QPoint)), d->viewportWidget, SLOT(documentOffsetMoved(QPoint)));
 }
 
 KoCanvasControllerWidget::~KoCanvasControllerWidget()
 {
     delete d;
 }
 
 void KoCanvasControllerWidget::activate()
 {
     d->activate();
 }
 
 void KoCanvasControllerWidget::scrollContentsBy(int dx, int dy)
 {
     Q_UNUSED(dx);
     Q_UNUSED(dy);
     d->setDocumentOffset();
 }
 
 QSize KoCanvasControllerWidget::viewportSize() const
 {
     return viewport()->size();
 }
 
 void KoCanvasControllerWidget::resizeEvent(QResizeEvent *resizeEvent)
 {
     proxyObject->emitSizeChanged(resizeEvent->size());
 
     // XXX: When resizing, keep the area we're looking at now in the
     // center of the resized view.
     resetScrollBars();
     d->setDocumentOffset();
 }
 
 void KoCanvasControllerWidget::setCanvas(KoCanvasBase *canvas)
 {
     if (d->canvas) {
         d->unsetCanvas();
         proxyObject->emitCanvasRemoved(this);
         d->canvas->setCanvasController(0);
         d->canvas->canvasWidget()->removeEventFilter(this);
     }
 
     d->canvas = canvas;
 
     if (d->canvas) {
         d->canvas->setCanvasController(this);
         changeCanvasWidget(d->canvas->canvasWidget());
 
         proxyObject->emitCanvasSet(this);
         QTimer::singleShot(0, this, SLOT(activate()));
 
         setPreferredCenterFractionX(0);
         setPreferredCenterFractionY(0);
     }
 }
 
 KoCanvasBase* KoCanvasControllerWidget::canvas() const
 {
     if (d->canvas.isNull()) return 0;
     return d->canvas;
 }
 
 void KoCanvasControllerWidget::changeCanvasWidget(QWidget *widget)
 {
     if (d->viewportWidget->canvas()) {
         widget->setCursor(d->viewportWidget->canvas()->cursor());
         d->viewportWidget->canvas()->removeEventFilter(this);
     }
 
     d->viewportWidget->setCanvas(widget);
     setFocusProxy(d->canvas->canvasWidget());
 }
 
 int KoCanvasControllerWidget::visibleHeight() const
 {
     if (d->canvas == 0)
         return 0;
     QWidget *canvasWidget = canvas()->canvasWidget();
 
     int height1;
     if (canvasWidget == 0)
         height1 = viewport()->height();
     else
         height1 = qMin(viewport()->height(), canvasWidget->height());
     int height2 = height();
     return qMin(height1, height2);
 }
 
 int KoCanvasControllerWidget::visibleWidth() const
 {
     if (d->canvas == 0)
         return 0;
     QWidget *canvasWidget = canvas()->canvasWidget();
 
     int width1;
     if (canvasWidget == 0)
         width1 = viewport()->width();
     else
         width1 = qMin(viewport()->width(), canvasWidget->width());
     int width2 = width();
     return qMin(width1, width2);
 }
 
 int KoCanvasControllerWidget::canvasOffsetX() const
 {
     int offset = -horizontalScrollBar()->value();
 
     if (d->canvas) {
         offset += d->canvas->canvasWidget()->x() + frameWidth();
     }
 
     return offset;
 }
 
 int KoCanvasControllerWidget::canvasOffsetY() const
 {
     int offset = -verticalScrollBar()->value();
 
     if (d->canvas) {
         offset += d->canvas->canvasWidget()->y() + frameWidth();
     }
 
     return offset;
 }
 
 void KoCanvasControllerWidget::updateCanvasOffsetX()
 {
     proxyObject->emitCanvasOffsetXChanged(canvasOffsetX());
     if (d->ignoreScrollSignals)
         return;
 
     setPreferredCenterFractionX((horizontalScrollBar()->value()
                                  + viewport()->width() / 2.0) / documentSize().width());
 }
 
 void KoCanvasControllerWidget::updateCanvasOffsetY()
 {
     proxyObject->emitCanvasOffsetYChanged(canvasOffsetY());
     if (d->ignoreScrollSignals)
         return;
 
     setPreferredCenterFractionY((verticalScrollBar()->value()
                                  + verticalScrollBar()->pageStep() / 2.0) / documentSize().height());
 }
 
 void KoCanvasControllerWidget::ensureVisible(KoShape *shape)
 {
     Q_ASSERT(shape);
     ensureVisible(d->canvas->viewConverter()->documentToView(shape->boundingRect()));
 }
 
 void KoCanvasControllerWidget::ensureVisible(const QRectF &rect, bool smooth)
 {
     QRect currentVisible(-canvasOffsetX(), -canvasOffsetY(), visibleWidth(), visibleHeight());
 
     QRect viewRect = rect.toRect();
     viewRect.translate(d->canvas->documentOrigin());
     if (!viewRect.isValid() || currentVisible.contains(viewRect))
         return; // its visible. Nothing to do.
 
     // if we move, we move a little more so the amount of times we have to move is less.
     int jumpWidth = smooth ? 0 : currentVisible.width() / 5;
     int jumpHeight = smooth ? 0 : currentVisible.height() / 5;
     if (!smooth && viewRect.width() + jumpWidth > currentVisible.width())
         jumpWidth = 0;
     if (!smooth && viewRect.height() + jumpHeight > currentVisible.height())
         jumpHeight = 0;
 
     int horizontalMove = 0;
     if (currentVisible.width() <= viewRect.width())      // center view
         horizontalMove = viewRect.center().x() - currentVisible.center().x();
     else if (currentVisible.x() > viewRect.x())          // move left
         horizontalMove = viewRect.x() - currentVisible.x() - jumpWidth;
     else if (currentVisible.right() < viewRect.right())  // move right
         horizontalMove = viewRect.right() - qMax(0, currentVisible.right() - jumpWidth);
 
     int verticalMove = 0;
     if (currentVisible.height() <= viewRect.height())       // center view
         verticalMove = viewRect.center().y() - currentVisible.center().y();
     if (currentVisible.y() > viewRect.y())               // move up
         verticalMove = viewRect.y() - currentVisible.y() - jumpHeight;
     else if (currentVisible.bottom() < viewRect.bottom()) // move down
         verticalMove = viewRect.bottom() - qMax(0, currentVisible.bottom() - jumpHeight);
 
     pan(QPoint(horizontalMove, verticalMove));
 }
 
 void KoCanvasControllerWidget::recenterPreferred()
 {
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
 
     QPointF center = preferredCenter();
 
     // convert into a viewport based point
     center.rx() += d->canvas->canvasWidget()->x() + frameWidth();
     center.ry() += d->canvas->canvasWidget()->y() + frameWidth();
 
     // scroll to a new center point
     QPointF topLeft = center - 0.5 * QPointF(viewport()->width(), viewport()->height());
     setScrollBarValue(topLeft.toPoint());
 
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 void KoCanvasControllerWidget::zoomIn(const QPoint &center)
 {
     zoomBy(center, sqrt(2.0));
 }
 
 void KoCanvasControllerWidget::zoomOut(const QPoint &center)
 {
     zoomBy(center, sqrt(0.5));
 }
 
 void KoCanvasControllerWidget::zoomBy(const QPoint &center, qreal zoom)
 {
     setPreferredCenterFractionX(1.0 * center.x() / documentSize().width());
     setPreferredCenterFractionY(1.0 * center.y() / documentSize().height());
 
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
     proxyObject->emitZoomRelative(zoom, preferredCenter());
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 void KoCanvasControllerWidget::zoomTo(const QRect &viewRect)
 {
     qreal scale;
 
     if (1.0 * viewport()->width() / viewRect.width() > 1.0 * viewport()->height() / viewRect.height())
         scale = 1.0 * viewport()->height() / viewRect.height();
     else
         scale = 1.0 * viewport()->width() / viewRect.width();
 
     zoomBy(viewRect.center(), scale);
 }
 
 void KoCanvasControllerWidget::updateDocumentSize(const QSize &sz, bool recalculateCenter)
 {
     // Don't update if the document-size didn't changed to prevent infinite loops and unneeded updates.
     if (KoCanvasController::documentSize() == sz)
         return;
 
     if (!recalculateCenter) {
         // assume the distance from the top stays equal and recalculate the center.
         setPreferredCenterFractionX(documentSize().width() * preferredCenterFractionX() / sz.width());
         setPreferredCenterFractionY(documentSize().height() * preferredCenterFractionY() / sz.height());
     }
 
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
     KoCanvasController::setDocumentSize(sz);
     d->viewportWidget->setDocumentSize(sz);
     resetScrollBars();
 
     // Always emit the new offset.
     updateCanvasOffsetX();
     updateCanvasOffsetY();
 
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 void KoCanvasControllerWidget::setZoomWithWheel(bool zoom)
 {
     d->zoomWithWheel = zoom;
 }
 
 void KoCanvasControllerWidget::setVastScrolling(qreal factor)
 {
     d->vastScrollingFactor = factor;
 }
 
 QPointF KoCanvasControllerWidget::currentCursorPosition() const
 {
     QWidget *canvasWidget = d->canvas->canvasWidget();
     const KoViewConverter *converter = d->canvas->viewConverter();
     return converter->viewToDocument(canvasWidget->mapFromGlobal(QCursor::pos()) + d->canvas->canvasController()->documentOffset() - canvasWidget->pos());
 }
 
 void KoCanvasControllerWidget::pan(const QPoint &distance)
 {
     QPoint sourcePoint = scrollBarValue();
     setScrollBarValue(sourcePoint + distance);
 }
 
 void KoCanvasControllerWidget::panUp()
 {
     pan(QPoint(0, verticalScrollBar()->singleStep()));
 }
 
 void KoCanvasControllerWidget::panDown()
 {
     pan(QPoint(0, -verticalScrollBar()->singleStep()));
 }
 
 void KoCanvasControllerWidget::panLeft()
 {
     pan(QPoint(horizontalScrollBar()->singleStep(), 0));
 }
 
 void KoCanvasControllerWidget::panRight()
 {
     pan(QPoint(-horizontalScrollBar()->singleStep(), 0));
 }
 
 void KoCanvasControllerWidget::setPreferredCenter(const QPointF &viewPoint)
 {
     setPreferredCenterFractionX(viewPoint.x() / documentSize().width());
     setPreferredCenterFractionY(viewPoint.y() / documentSize().height());
     recenterPreferred();
 }
 
 QPointF KoCanvasControllerWidget::preferredCenter() const
 {
     QPointF center;
     center.setX(preferredCenterFractionX() * documentSize().width());
     center.setY(preferredCenterFractionY() * documentSize().height());
     return center;
 }
 
 void KoCanvasControllerWidget::paintEvent(QPaintEvent *event)
 {
     QPainter gc(viewport());
     d->viewportWidget->handlePaintEvent(gc, event);
 }
 
 void KoCanvasControllerWidget::dragEnterEvent(QDragEnterEvent *event)
 {
     d->viewportWidget->handleDragEnterEvent(event);
 }
 
 void KoCanvasControllerWidget::dropEvent(QDropEvent *event)
 {
     d->viewportWidget->handleDropEvent(event);
 }
 
 void KoCanvasControllerWidget::dragMoveEvent(QDragMoveEvent *event)
 {
     d->viewportWidget->handleDragMoveEvent(event);
 }
 
 void KoCanvasControllerWidget::dragLeaveEvent(QDragLeaveEvent *event)
 {
     d->viewportWidget->handleDragLeaveEvent(event);
 }
 
 void KoCanvasControllerWidget::wheelEvent(QWheelEvent *event)
 {
     if (d->zoomWithWheel != ((event->modifiers() & Qt::ControlModifier) == Qt::ControlModifier)) {
         const qreal zoomCoeff = event->delta() > 0 ? sqrt(2.0) : sqrt(0.5);
         zoomRelativeToPoint(event->pos(), zoomCoeff);
 
         event->accept();
     } else
         QAbstractScrollArea::wheelEvent(event);
 }
 
 void KoCanvasControllerWidget::zoomRelativeToPoint(const QPoint &widgetPoint, qreal zoomCoeff)
 {
     const QPoint offset = scrollBarValue();
     const QPoint mousePos(widgetPoint + offset);
 
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
     proxyObject->emitZoomRelative(zoomCoeff, mousePos);
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 bool KoCanvasControllerWidget::focusNextPrevChild(bool)
 {
     // we always return false meaning the canvas takes keyboard focus, but never gives it away.
     return false;
 }
 
 void KoCanvasControllerWidget::setMargin(int margin)
 {
     KoCanvasController::setMargin(margin);
     Q_ASSERT(d->viewportWidget);
     d->viewportWidget->setMargin(margin);
 }
 
 QPoint KoCanvasControllerWidget::scrollBarValue() const
 {
     QScrollBar * hBar = horizontalScrollBar();
     QScrollBar * vBar = verticalScrollBar();
 
     return QPoint(hBar->value(), vBar->value());
 }
 
 void KoCanvasControllerWidget::setScrollBarValue(const QPoint &value)
 {
     QScrollBar * hBar = horizontalScrollBar();
     QScrollBar * vBar = verticalScrollBar();
 
     hBar->setValue(value.x());
     vBar->setValue(value.y());
 }
 
 void KoCanvasControllerWidget::resetScrollBars()
 {
     d->resetScrollBars();
 }
 
 qreal KoCanvasControllerWidget::vastScrollingFactor() const
 {
     return d->vastScrollingFactor;
 }
 
 KoCanvasControllerWidget::Private *KoCanvasControllerWidget::priv()
 {
     return d;
 }
 
 //have to include this because of Q_PRIVATE_SLOT
 #include "moc_KoCanvasControllerWidget.cpp"
diff --git a/libs/flake/KoShapeFactoryBase.cpp b/libs/flake/KoShapeFactoryBase.cpp
index 0db80fea73..dd36cb2504 100644
--- a/libs/flake/KoShapeFactoryBase.cpp
+++ b/libs/flake/KoShapeFactoryBase.cpp
@@ -1,259 +1,259 @@
 /* This file is part of the KDE project
  * Copyright (c) 2006 Boudewijn Rempt (boud@valdyas.org)
  * Copyright (C) 2006-2007 Thomas Zander <zander@kde.org>
  * Copyright (C) 2008 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2008 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 "KoShapeFactoryBase.h"
 
 #include <QDebug>
 
 #include "KoDocumentResourceManager.h"
 #include "KoDeferredShapeFactoryBase.h"
 #include "KoShape.h"
 #include "KoShapeLoadingContext.h"
 
 #include <KoOdfLoadingContext.h>
 #include <KoProperties.h>
 #include <KoStyleStack.h>
 #include <KoJsonTrader.h>
 
 #include <KPluginFactory>
 #include <QPluginLoader>
 #include <QMutexLocker>
 #include <QMutex>
 #include <QPointer>
 
 
 #include <FlakeDebug.h>
 
 class Q_DECL_HIDDEN KoShapeFactoryBase::Private
 {
 public:
     Private(const QString &_id, const QString &_name, const QString &_deferredPluginName)
         : deferredFactory(0),
           deferredPluginName(_deferredPluginName),
           id(_id),
           name(_name),
           loadingPriority(0),
           hidden(false)
     {
     }
 
     ~Private() {
         Q_FOREACH (const KoShapeTemplate & t, templates)
             delete t.properties;
         templates.clear();
     }
 
     KoDeferredShapeFactoryBase *deferredFactory;
     QMutex pluginLoadingMutex;
     QString deferredPluginName;
     QList<KoShapeTemplate> templates;
     const QString id;
     const QString name;
     QString family;
     QString tooltip;
     QString iconName;
     int loadingPriority;
     QList<QPair<QString, QStringList> > xmlElements; // xml name space -> xml element names
     bool hidden;
     QList<QPointer<KoDocumentResourceManager> > resourceManagers;
 };
 
 
 KoShapeFactoryBase::KoShapeFactoryBase(const QString &id, const QString &name, const QString &deferredPluginName)
     : d(new Private(id, name, deferredPluginName))
 {
 }
 
 KoShapeFactoryBase::~KoShapeFactoryBase()
 {
     delete d;
 }
 
 QString KoShapeFactoryBase::toolTip() const
 {
     return d->tooltip;
 }
 
 QString KoShapeFactoryBase::iconName() const
 {
     return d->iconName;
 }
 
 QString KoShapeFactoryBase::name() const
 {
     return d->name;
 }
 
 QString KoShapeFactoryBase::family() const
 {
     return d->family;
 }
 
 int KoShapeFactoryBase::loadingPriority() const
 {
     return d->loadingPriority;
 }
 
 QList<QPair<QString, QStringList> > KoShapeFactoryBase::odfElements() const
 {
     return d->xmlElements;
 }
 
 void KoShapeFactoryBase::addTemplate(const KoShapeTemplate &params)
 {
     KoShapeTemplate tmplate = params;
     tmplate.id = d->id;
     d->templates.append(tmplate);
 }
 
 void KoShapeFactoryBase::setToolTip(const QString & tooltip)
 {
     d->tooltip = tooltip;
 }
 
 void KoShapeFactoryBase::setIconName(const char *iconName)
 {
     d->iconName = QLatin1String(iconName);
 }
 
 void KoShapeFactoryBase::setFamily(const QString & family)
 {
     d->family = family;
 }
 
 QString KoShapeFactoryBase::id() const
 {
     return d->id;
 }
 
 QList<KoShapeTemplate> KoShapeFactoryBase::templates() const
 {
     return d->templates;
 }
 
 void KoShapeFactoryBase::setLoadingPriority(int priority)
 {
     d->loadingPriority = priority;
 }
 
 void KoShapeFactoryBase::setXmlElementNames(const QString & nameSpace, const QStringList & names)
 {
     d->xmlElements.clear();
     d->xmlElements.append(QPair<QString, QStringList>(nameSpace, names));
 }
 
 void KoShapeFactoryBase::setXmlElements(const QList<QPair<QString, QStringList> > &elementNamesList)
 {
     d->xmlElements = elementNamesList;
 }
 
 bool KoShapeFactoryBase::hidden() const
 {
     return d->hidden;
 }
 
 void KoShapeFactoryBase::setHidden(bool hidden)
 {
     d->hidden = hidden;
 }
 
 void KoShapeFactoryBase::newDocumentResourceManager(KoDocumentResourceManager *manager) const
 {
     d->resourceManagers.append(manager);
-    connect(manager, SIGNAL(destroyed(QObject *)), this, SLOT(pruneDocumentResourceManager(QObject*)));
+    connect(manager, SIGNAL(destroyed(QObject*)), this, SLOT(pruneDocumentResourceManager(QObject*)));
 }
 
 KoShape *KoShapeFactoryBase::createDefaultShape(KoDocumentResourceManager *documentResources) const
 {
     if (!d->deferredPluginName.isEmpty()) {
         const_cast<KoShapeFactoryBase*>(this)->getDeferredPlugin();
         Q_ASSERT(d->deferredFactory);
         if (d->deferredFactory) {
             return d->deferredFactory->createDefaultShape(documentResources);
         }
     }
     return 0;
 }
 
 KoShape *KoShapeFactoryBase::createShape(const KoProperties* properties,
                                          KoDocumentResourceManager *documentResources) const
 {
     if (!d->deferredPluginName.isEmpty()) {
         const_cast<KoShapeFactoryBase*>(this)->getDeferredPlugin();
         Q_ASSERT(d->deferredFactory);
         if (d->deferredFactory) {
             return d->deferredFactory->createShape(properties, documentResources);
         }
     }
     return createDefaultShape(documentResources);
 }
 
 KoShape *KoShapeFactoryBase::createShapeFromOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     KoShape *shape = createDefaultShape(context.documentResourceManager());
     if (!shape)
         return 0;
 
     if (shape->shapeId().isEmpty())
         shape->setShapeId(id());
 
     context.odfLoadingContext().styleStack().save();
     bool loaded = shape->loadOdf(element, context);
     context.odfLoadingContext().styleStack().restore();
 
     if (!loaded) {
         delete shape;
         return 0;
     }
 
     return shape;
 }
 
 void KoShapeFactoryBase::getDeferredPlugin()
 {
     QMutexLocker(&d->pluginLoadingMutex);
     if (d->deferredFactory) return;
 
     const QList<QPluginLoader *> offers = KoJsonTrader::instance()->query("Calligra/Deferred", QString());
     Q_ASSERT(offers.size() > 0);
 
     Q_FOREACH (QPluginLoader *pluginLoader, offers) {
         KPluginFactory *factory = qobject_cast<KPluginFactory *>(pluginLoader->instance());
         KoDeferredShapeFactoryBase *plugin = factory->create<KoDeferredShapeFactoryBase>(this, QVariantList());
 
         if (plugin && plugin->deferredPluginName() == d->deferredPluginName) {
             d->deferredFactory = plugin;
         }
     }
     qDeleteAll(offers);
 }
 
 void KoShapeFactoryBase::pruneDocumentResourceManager(QObject *)
 {
     QList<QPointer<KoDocumentResourceManager> > rms;
     Q_FOREACH(QPointer<KoDocumentResourceManager> rm, d->resourceManagers) {
         if (rm) {
             rms << rm;
         }
     }
     d->resourceManagers = rms;
 }
diff --git a/libs/flake/KoToolManager.cpp b/libs/flake/KoToolManager.cpp
index 5e7415eaec..4050652412 100644
--- a/libs/flake/KoToolManager.cpp
+++ b/libs/flake/KoToolManager.cpp
@@ -1,1009 +1,1009 @@
 /* This file is part of the KDE project
  *
  * Copyright (c) 2005-2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2006-2008 Thomas Zander <zander@kde.org>
  * Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2008 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.
  */
 // flake
 #include "KoToolManager.h"
 #include "KoToolManager_p.h"
 #include "KoToolRegistry.h"
 #include "KoToolProxy.h"
 #include "KoToolProxy_p.h"
 #include "KoSelection.h"
 #include "KoCanvasController.h"
 #include "KoCanvasControllerWidget.h"
 #include "KoShape.h"
 #include "KoShapeLayer.h"
 #include "KoShapeRegistry.h"
 #include "KoShapeManager.h"
 #include "KoSelectedShapesProxy.h"
 #include "KoCanvasBase.h"
 #include "KoInputDeviceHandlerRegistry.h"
 #include "KoInputDeviceHandlerEvent.h"
 #include "KoPointerEvent.h"
 #include "tools/KoCreateShapesTool.h"
 #include "tools/KoZoomTool.h"
 #include "kis_action_registry.h"
 #include "KoToolFactoryBase.h"
 #include "kis_assert.h"
 
 #include <krita_container_utils.h>
 
 // Qt + kde
 #include <QWidget>
 #include <QEvent>
 #include <QWheelEvent>
 #include <QMouseEvent>
 #include <QPaintEvent>
 #include <QTabletEvent>
 #include <QKeyEvent>
 #include <QVBoxLayout>
 #include <QStringList>
 #include <QApplication>
 #include <kactioncollection.h>
 #include <kactioncategory.h>
 #include <FlakeDebug.h>
 
 #include <QAction>
 #include <klocalizedstring.h>
 #include <QKeySequence>
 #include <QStack>
 #include <QLabel>
 #include <QGlobalStatic>
 
 Q_GLOBAL_STATIC(KoToolManager, s_instance)
 
 
 class CanvasData
 {
 public:
     CanvasData(KoCanvasController *cc, const KoInputDevice &id)
             : activeTool(0),
             canvas(cc),
             inputDevice(id),
             dummyToolWidget(0),
             dummyToolLabel(0)
     {
     }
 
     ~CanvasData()
     {
         // the dummy tool widget does not necessarily have a parent and we create it, so we delete it.
         delete dummyToolWidget;
     }
 
     void activateToolActions()
     {
         disabledDisabledActions.clear();
         disabledActions.clear();
         disabledCanvasShortcuts.clear();
         // we do several things here
         // 1. enable the actions of the active tool
         // 2. disable conflicting actions
         // 3. replace conflicting actions in the action collection
         KActionCollection *canvasActionCollection = canvas->actionCollection();
 
         QHash<QString, QAction *> toolActions = activeTool->actions();
         QHash<QString, QAction *>::const_iterator it(toolActions.constBegin());
 
         for (; it != toolActions.constEnd(); ++it) {
             if (canvasActionCollection) {
 
                 QString toolActionID = it.key();
                 QAction *toolAction = it.value();
 
                 QAction * action = qobject_cast<QAction*>(canvasActionCollection->action(it.key()));
                 if (action) {
                     canvasActionCollection->takeAction(action);
                     if (action != it.value()) {
                         if (action->isEnabled()) {
                             action->setEnabled(false);
                             disabledActions.append(action);
                         } else  {
                             disabledDisabledActions.append(action);
                         }
                     }
                 }
                 Q_FOREACH (QAction *a, canvasActionCollection->actions()) {
                     QAction *canvasAction = dynamic_cast<QAction*>(a);
                     if (canvasAction && canvasAction->shortcut().toString() != "" && canvasAction->shortcut() == toolAction->shortcut()) {
                         warnFlake << activeToolId << ": action" << toolActionID << "conflicts with canvas action" << canvasAction->objectName() << "shortcut:" << canvasAction->shortcut().toString();
                         disabledCanvasShortcuts[canvasAction] = canvasAction->shortcut().toString();
                         canvasAction->setShortcut(QKeySequence());
                     }
                 }
                 canvasActionCollection->addAction(toolActionID, toolAction);
             }
             it.value()->setEnabled(true);
         }
         canvasActionCollection->readSettings(); // The shortcuts might have been configured in the meantime.
     }
 
     void deactivateToolActions()
     {
 
         if (!activeTool)
             return;
         // disable actions of active tool
         Q_FOREACH (QAction *action, activeTool->actions()) {
             action->setEnabled(false);
         }
 
         // enable actions which where disabled on activating the active tool
         // and re-add them to the action collection
         KActionCollection *ac = canvas->actionCollection();
         Q_FOREACH (QPointer<QAction> action, disabledDisabledActions) {
             if (action) {
                 if (ac) {
                     ac->addAction(action->objectName(), action);
                 }
             }
         }
         disabledDisabledActions.clear();
 
         Q_FOREACH (QPointer<QAction> action, disabledActions) {
             if (action) {
                 action->setEnabled(true);
                 if(ac) {
                     ac->addAction(action->objectName(), action);
                 }
             }
         }
         disabledActions.clear();
 
         QMap<QPointer<QAction>, QString>::const_iterator it(disabledCanvasShortcuts.constBegin());
         for (; it != disabledCanvasShortcuts.constEnd(); ++it) {
             QAction *action = it.key();
             QString shortcut = it.value();
             action->setShortcut(shortcut);
         }
         disabledCanvasShortcuts.clear();
     }
 
     KoToolBase *activeTool;     // active Tool
     QString activeToolId;   // the id of the active Tool
     QString activationShapeId; // the shape-type (KoShape::shapeId()) the activeTool 'belongs' to.
     QHash<QString, KoToolBase*> allTools; // all the tools that are created for this canvas.
     QStack<QString> stack; // stack of temporary tools
     KoCanvasController *const canvas;
     const KoInputDevice inputDevice;
     QWidget *dummyToolWidget;  // the widget shown in the toolDocker.
     QLabel *dummyToolLabel;
     QList<QPointer<QAction> > disabledActions; ///< disabled conflicting actions
     QList<QPointer<QAction> > disabledDisabledActions; ///< disabled conflicting actions that were already disabled
     QMap<QPointer<QAction>, QString> disabledCanvasShortcuts; ///< Shortcuts that were temporarily removed from canvas actions because the tool overrides
 };
 
 
 // ******** KoToolManager **********
 KoToolManager::KoToolManager()
     : QObject(),
     d(new Private(this))
 {
-    connect(QApplication::instance(), SIGNAL(focusChanged(QWidget*, QWidget*)),
-            this, SLOT(movedFocus(QWidget*, QWidget*)));
+    connect(QApplication::instance(), SIGNAL(focusChanged(QWidget*,QWidget*)),
+            this, SLOT(movedFocus(QWidget*,QWidget*)));
 }
 
 KoToolManager::~KoToolManager()
 {
     delete d;
 }
 
 QList<KoToolAction*> KoToolManager::toolActionList() const
 {
     QList<KoToolAction*> answer;
     answer.reserve(d->tools.count());
     Q_FOREACH (ToolHelper *tool, d->tools) {
         if (tool->id() == KoCreateShapesTool_ID)
             continue; // don't show this one.
         answer.append(tool->toolAction());
     }
     return answer;
 }
 
 void KoToolManager::requestToolActivation(KoCanvasController * controller)
 {
     if (d->canvasses.contains(controller)) {
         QString activeToolId = d->canvasses.value(controller).first()->activeToolId;
         Q_FOREACH (ToolHelper * th, d->tools) {
             if (th->id() == activeToolId) {
                 d->toolActivated(th);
                 break;
             }
         }
     }
 }
 
 KoInputDevice KoToolManager::currentInputDevice() const
 {
     return d->inputDevice;
 }
 
 void KoToolManager::registerToolActions(KActionCollection *ac, KoCanvasController *controller)
 {
     Q_ASSERT(controller);
     Q_ASSERT(ac);
 
     d->setup();
 
     if (!d->canvasses.contains(controller)) {
         return;
     }
 
     // Actions available during the use of individual tools
     CanvasData *cd = d->canvasses.value(controller).first();
     Q_FOREACH (KoToolBase *tool, cd->allTools) {
         QHash<QString, QAction*> actions = tool->actions();
         QHash<QString, QAction*>::const_iterator action(actions.constBegin());
         for (; action != actions.constEnd(); ++action) {
             if (!ac->action(action.key()))
                 ac->addAction(action.key(), action.value());
         }
     }
 
     // Actions used to switch tools via shortcuts
     Q_FOREACH (ToolHelper * th, d->tools) {
         if (ac->action(th->id())) {
             continue;
         }
         ShortcutToolAction* action = th->createShortcutToolAction(ac);
         ac->addCategorizedAction(th->id(), action, "tool-shortcuts");
     }
 }
 
 void KoToolManager::addController(KoCanvasController *controller)
 {
     Q_ASSERT(controller);
     if (d->canvasses.contains(controller))
         return;
     d->setup();
     d->attachCanvas(controller);
     connect(controller->proxyObject, SIGNAL(destroyed(QObject*)), this, SLOT(attemptCanvasControllerRemoval(QObject*)));
     connect(controller->proxyObject, SIGNAL(canvasRemoved(KoCanvasController*)), this, SLOT(detachCanvas(KoCanvasController*)));
     connect(controller->proxyObject, SIGNAL(canvasSet(KoCanvasController*)), this, SLOT(attachCanvas(KoCanvasController*)));
 }
 
 void KoToolManager::removeCanvasController(KoCanvasController *controller)
 {
     Q_ASSERT(controller);
     disconnect(controller->proxyObject, SIGNAL(canvasRemoved(KoCanvasController*)), this, SLOT(detachCanvas(KoCanvasController*)));
     disconnect(controller->proxyObject, SIGNAL(canvasSet(KoCanvasController*)), this, SLOT(attachCanvas(KoCanvasController*)));
     d->detachCanvas(controller);
 }
 
 void KoToolManager::attemptCanvasControllerRemoval(QObject* controller)
 {
     KoCanvasControllerProxyObject* controllerActual = qobject_cast<KoCanvasControllerProxyObject*>(controller);
     if (controllerActual) {
         removeCanvasController(controllerActual->canvasController());
     }
 }
 
 void KoToolManager::switchToolRequested(const QString & id)
 {
     Q_ASSERT(d->canvasData);
     if (!d->canvasData) return;
 
     while (!d->canvasData->stack.isEmpty()) // switching means to flush the stack
         d->canvasData->stack.pop();
     d->switchTool(id, false);
 }
 
 void KoToolManager::switchInputDeviceRequested(const KoInputDevice &id)
 {
     if (!d->canvasData) return;
     d->switchInputDevice(id);
 }
 
 void KoToolManager::switchToolTemporaryRequested(const QString &id)
 {
     d->switchTool(id, true);
 }
 
 void KoToolManager::switchBackRequested()
 {
     if (!d->canvasData) return;
 
     if (d->canvasData->stack.isEmpty()) {
         // default to changing to the interactionTool
         d->switchTool(KoInteractionTool_ID, false);
         return;
     }
     d->switchTool(d->canvasData->stack.pop(), false);
 }
 
 KoCreateShapesTool * KoToolManager::shapeCreatorTool(KoCanvasBase *canvas) const
 {
     Q_ASSERT(canvas);
     Q_FOREACH (KoCanvasController *controller, d->canvasses.keys()) {
         if (controller->canvas() == canvas) {
             KoCreateShapesTool *createTool = dynamic_cast<KoCreateShapesTool*>
                                              (d->canvasData->allTools.value(KoCreateShapesTool_ID));
             Q_ASSERT(createTool /* ID changed? */);
             return createTool;
         }
     }
     Q_ASSERT(0);   // this should not happen
     return 0;
 }
 
 KoToolBase *KoToolManager::toolById(KoCanvasBase *canvas, const QString &id) const
 {
     Q_ASSERT(canvas);
     Q_FOREACH (KoCanvasController *controller, d->canvasses.keys()) {
         if (controller->canvas() == canvas)
             return d->canvasData->allTools.value(id);
     }
     return 0;
 }
 
 KoCanvasController *KoToolManager::activeCanvasController() const
 {
     if (! d->canvasData) return 0;
     return d->canvasData->canvas;
 }
 
 QString KoToolManager::preferredToolForSelection(const QList<KoShape*> &shapes)
 {
     QSet<QString> shapeTypes;
     Q_FOREACH (KoShape *shape, shapes) {
         shapeTypes << shape->shapeId();
     }
     //KritaUtils::makeContainerUnique(types);
 
     QString toolType = KoInteractionTool_ID;
     int prio = INT_MAX;
     Q_FOREACH (ToolHelper *helper, d->tools) {
         if (helper->id() == KoCreateShapesTool_ID) continue;
         if (helper->priority() >= prio)
             continue;
 
         bool toolWillWork = false;
         foreach (const QString &type, shapeTypes) {
             if (helper->activationShapeId().split(',').contains(type)) {
                 toolWillWork = true;
                 break;
             }
         }
 
         if (toolWillWork) {
             toolType = helper->id();
             prio = helper->priority();
         }
     }
     return toolType;
 }
 
 
 QPair<QString, KoToolBase*> KoToolManager::createTools(KoCanvasController *controller, ToolHelper *tool)
 {
     // XXX: maybe this method should go into the private class?
 
     QHash<QString, KoToolBase*> origHash;
 
     if (d->canvasses.contains(controller)) {
         origHash = d->canvasses.value(controller).first()->allTools;
     }
 
     if (origHash.contains(tool->id())) {
         return QPair<QString, KoToolBase*>(tool->id(), origHash.value(tool->id()));
     }
 
     debugFlake << "Creating tool" << tool->id() << ". Activated on:" << tool->activationShapeId() << ", prio:" << tool->priority();
 
     KoToolBase *tl = tool->createTool(controller->canvas());
     if (tl) {
         d->uniqueToolIds.insert(tl, tool->uniqueId());
 
         tl->setObjectName(tool->id());
 
         Q_FOREACH (QAction *action, tl->actions()) {
             action->setEnabled(false);
         }
 
     }
 
     KoZoomTool *zoomTool = dynamic_cast<KoZoomTool*>(tl);
     if (zoomTool) {
         zoomTool->setCanvasController(controller);
     }
 
     return QPair<QString, KoToolBase*>(tool->id(), tl);
 }
 
 
 // NOT IMPLEMENTED
 void KoToolManager::updateToolShortcuts()
 {
     // auto actionRegistry = KisActionRegistry::instance();
     // foreach (KoToolBase *t, allTools) {
     //     for (auto it = t->actions().constBegin();
     //          it != t->actions().constEnd();
     //          ++it;) {
     //         actionRegistry->updateShortcut(it.key(), it.value());
     //     }
     // }
 }
 
 void KoToolManager::initializeCurrentToolForCanvas()
 {
     d->postSwitchTool(false);
 }
 
 KoToolManager* KoToolManager::instance()
 {
     return s_instance;
 }
 
 QString KoToolManager::activeToolId() const
 {
     if (!d->canvasData) return QString();
     return d->canvasData->activeToolId;
 }
 
 
 KoToolManager::Private *KoToolManager::priv()
 {
     return d;
 }
 
 
 /**** KoToolManager::Private ****/
 
 KoToolManager::Private::Private(KoToolManager *qq)
     : q(qq),
     canvasData(0),
     layerExplicitlyDisabled(false)
 {
 }
 
 KoToolManager::Private::~Private()
 {
     qDeleteAll(tools);
 }
 
 // helper method.
 CanvasData *KoToolManager::Private::createCanvasData(KoCanvasController *controller, const KoInputDevice &device)
 {
     QHash<QString, KoToolBase*> toolsHash;
     Q_FOREACH (ToolHelper *tool, tools) {
         QPair<QString, KoToolBase*> toolPair = q->createTools(controller, tool);
         if (toolPair.second) { // only if a real tool was created
             toolsHash.insert(toolPair.first, toolPair.second);
         }
     }
     KoCreateShapesTool *createShapesTool = dynamic_cast<KoCreateShapesTool*>(toolsHash.value(KoCreateShapesTool_ID));
     KIS_ASSERT(createShapesTool);
     QString id = KoShapeRegistry::instance()->keys()[0];
     createShapesTool->setShapeId(id);
 
     CanvasData *cd = new CanvasData(controller, device);
     cd->allTools = toolsHash;
     return cd;
 }
 
 void KoToolManager::Private::setup()
 {
     if (tools.size() > 0)
         return;
 
     KoShapeRegistry::instance();
     KoToolRegistry *registry = KoToolRegistry::instance();
     Q_FOREACH (const QString & id, registry->keys()) {
         ToolHelper *t = new ToolHelper(registry->value(id));
         tools.append(t);
     }
 
     // connect to all tools so we can hear their button-clicks
     Q_FOREACH (ToolHelper *tool, tools)
         connect(tool, SIGNAL(toolActivated(ToolHelper*)), q, SLOT(toolActivated(ToolHelper*)));
 
     // load pluggable input devices
     KoInputDeviceHandlerRegistry::instance();
 }
 
 void KoToolManager::Private::connectActiveTool()
 {
     if (canvasData->activeTool) {
-        connect(canvasData->activeTool, SIGNAL(cursorChanged(const QCursor &)),
-                q, SLOT(updateCursor(const QCursor &)));
-        connect(canvasData->activeTool, SIGNAL(activateTool(const QString &)),
-                q, SLOT(switchToolRequested(const QString &)));
-        connect(canvasData->activeTool, SIGNAL(activateTemporary(const QString &)),
-                q, SLOT(switchToolTemporaryRequested(const QString &)));
+        connect(canvasData->activeTool, SIGNAL(cursorChanged(QCursor)),
+                q, SLOT(updateCursor(QCursor)));
+        connect(canvasData->activeTool, SIGNAL(activateTool(QString)),
+                q, SLOT(switchToolRequested(QString)));
+        connect(canvasData->activeTool, SIGNAL(activateTemporary(QString)),
+                q, SLOT(switchToolTemporaryRequested(QString)));
         connect(canvasData->activeTool, SIGNAL(done()), q, SLOT(switchBackRequested()));
-        connect(canvasData->activeTool, SIGNAL(statusTextChanged(const QString &)),
-                q, SIGNAL(changedStatusText(const QString &)));
+        connect(canvasData->activeTool, SIGNAL(statusTextChanged(QString)),
+                q, SIGNAL(changedStatusText(QString)));
     }
 
     // we expect the tool to emit a cursor on activation.
     updateCursor(Qt::ForbiddenCursor);
 }
 
 
 
 void KoToolManager::Private::disconnectActiveTool()
 {
     if (canvasData->activeTool) {
         canvasData->deactivateToolActions();
         // repaint the decorations before we deactivate the tool as it might deleted
         // data needed for the repaint
         emit q->aboutToChangeTool(canvasData->canvas);
         canvasData->activeTool->deactivate();
-        disconnect(canvasData->activeTool, SIGNAL(cursorChanged(const QCursor&)),
-                   q, SLOT(updateCursor(const QCursor&)));
-        disconnect(canvasData->activeTool, SIGNAL(activateTool(const QString &)),
-                   q, SLOT(switchToolRequested(const QString &)));
-        disconnect(canvasData->activeTool, SIGNAL(activateTemporary(const QString &)),
-                   q, SLOT(switchToolTemporaryRequested(const QString &)));
+        disconnect(canvasData->activeTool, SIGNAL(cursorChanged(QCursor)),
+                   q, SLOT(updateCursor(QCursor)));
+        disconnect(canvasData->activeTool, SIGNAL(activateTool(QString)),
+                   q, SLOT(switchToolRequested(QString)));
+        disconnect(canvasData->activeTool, SIGNAL(activateTemporary(QString)),
+                   q, SLOT(switchToolTemporaryRequested(QString)));
         disconnect(canvasData->activeTool, SIGNAL(done()), q, SLOT(switchBackRequested()));
-        disconnect(canvasData->activeTool, SIGNAL(statusTextChanged(const QString &)),
-                   q, SIGNAL(changedStatusText(const QString &)));
+        disconnect(canvasData->activeTool, SIGNAL(statusTextChanged(QString)),
+                   q, SIGNAL(changedStatusText(QString)));
     }
 
     // emit a empty status text to clear status text from last active tool
     emit q->changedStatusText(QString());
 }
 
 
 void KoToolManager::Private::switchTool(KoToolBase *tool, bool temporary)
 {
 
     Q_ASSERT(tool);
     if (canvasData == 0)
         return;
 
     if (canvasData->activeTool == tool && tool->toolId() != KoInteractionTool_ID)
         return;
 
     disconnectActiveTool();
     canvasData->activeTool = tool;
     connectActiveTool();
     postSwitchTool(temporary);
 }
 
 
 
 void KoToolManager::Private::switchTool(const QString &id, bool temporary)
 {
     Q_ASSERT(canvasData);
     if (!canvasData) return;
 
     if (canvasData->activeTool && temporary)
         canvasData->stack.push(canvasData->activeToolId);
     canvasData->activeToolId = id;
     KoToolBase *tool = canvasData->allTools.value(id);
     if (! tool) {
         return;
     }
 
     Q_FOREACH (ToolHelper *th, tools) {
         if (th->id() == id) {
             canvasData->activationShapeId = th->activationShapeId();
             break;
         }
     }
 
     switchTool(tool, temporary);
 }
 
 void KoToolManager::Private::postSwitchTool(bool temporary)
 {
 #ifndef NDEBUG
     int canvasCount = 1;
     Q_FOREACH (QList<CanvasData*> list, canvasses) {
         bool first = true;
         Q_FOREACH (CanvasData *data, list) {
             if (first) {
                 debugFlake << "Canvas" << canvasCount++;
             }
             debugFlake << "  +- Tool:" << data->activeToolId  << (data == canvasData ? " *" : "");
             first = false;
         }
     }
 #endif
     Q_ASSERT(canvasData);
     if (!canvasData) return;
 
     KoToolBase::ToolActivation toolActivation;
     if (temporary)
         toolActivation = KoToolBase::TemporaryActivation;
     else
         toolActivation = KoToolBase::DefaultActivation;
     QSet<KoShape*> shapesToOperateOn;
     if (canvasData->activeTool
             && canvasData->activeTool->canvas()
             && canvasData->activeTool->canvas()->shapeManager()) {
         KoSelection *selection = canvasData->activeTool->canvas()->shapeManager()->selection();
         Q_ASSERT(selection);
 
         shapesToOperateOn = QSet<KoShape*>::fromList(selection->selectedEditableShapesAndDelegates());
     }
 
     if (canvasData->canvas->canvas()) {
         // Caller of postSwitchTool expect this to be called to update the selected tool
         updateToolForProxy();
         canvasData->activeTool->activate(toolActivation, shapesToOperateOn);
         KoCanvasBase *canvas = canvasData->canvas->canvas();
         canvas->updateInputMethodInfo();
     } else {
         canvasData->activeTool->activate(toolActivation, shapesToOperateOn);
     }
 
     QList<QPointer<QWidget> > optionWidgetList = canvasData->activeTool->optionWidgets();
     if (optionWidgetList.empty()) { // no option widget.
         QWidget *toolWidget;
         QString title;
         Q_FOREACH (ToolHelper *tool, tools) {
             if (tool->id() == canvasData->activeTool->toolId()) {
                 title = tool->toolTip();
                 break;
             }
         }
         toolWidget = canvasData->dummyToolWidget;
         if (toolWidget == 0) {
             toolWidget = new QWidget();
             toolWidget->setObjectName("DummyToolWidget");
             QVBoxLayout *layout = new QVBoxLayout(toolWidget);
             layout->setMargin(3);
             canvasData->dummyToolLabel = new QLabel(toolWidget);
             layout->addWidget(canvasData->dummyToolLabel);
             layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Expanding));
             toolWidget->setLayout(layout);
             canvasData->dummyToolWidget = toolWidget;
         }
         canvasData->dummyToolLabel->setText(i18n("Active tool: %1", title));
         optionWidgetList.append(toolWidget);
     }
 
     // Activate the actions for the currently active tool
     canvasData->activateToolActions();
 
     emit q->changedTool(canvasData->canvas, uniqueToolIds.value(canvasData->activeTool));
 
     emit q->toolOptionWidgetsChanged(canvasData->canvas, optionWidgetList);
 }
 
 
 void KoToolManager::Private::switchCanvasData(CanvasData *cd)
 {
     Q_ASSERT(cd);
 
     KoCanvasBase *oldCanvas = 0;
     KoInputDevice oldInputDevice;
 
     if (canvasData) {
         oldCanvas = canvasData->canvas->canvas();
         oldInputDevice = canvasData->inputDevice;
 
         if (canvasData->activeTool) {
             disconnectActiveTool();
         }
 
         KoToolProxy *proxy = proxies.value(oldCanvas);
         Q_ASSERT(proxy);
         proxy->setActiveTool(0);
     }
 
     canvasData = cd;
     inputDevice = canvasData->inputDevice;
 
     if (canvasData->activeTool) {
         connectActiveTool();
         postSwitchTool(false);
     }
 
     if (oldInputDevice != canvasData->inputDevice) {
         emit q->inputDeviceChanged(canvasData->inputDevice);
     }
 
     if (oldCanvas != canvasData->canvas->canvas()) {
         emit q->changedCanvas(canvasData->canvas->canvas());
     }
 }
 
 
 void KoToolManager::Private::toolActivated(ToolHelper *tool)
 {
     Q_ASSERT(tool);
 
     Q_ASSERT(canvasData);
     if (!canvasData) return;
     KoToolBase *t = canvasData->allTools.value(tool->id());
     Q_ASSERT(t);
 
     canvasData->activeToolId = tool->id();
     canvasData->activationShapeId = tool->activationShapeId();
 
     switchTool(t, false);
 }
 
 void KoToolManager::Private::detachCanvas(KoCanvasController *controller)
 {
     Q_ASSERT(controller);
     // check if we are removing the active canvas controller
     if (canvasData && canvasData->canvas == controller) {
         KoCanvasController *newCanvas = 0;
         // try to find another canvas controller beside the one we are removing
         Q_FOREACH (KoCanvasController* canvas, canvasses.keys()) {
             if (canvas != controller) {
                 // yay found one
                 newCanvas = canvas;
                 break;
             }
         }
         if (newCanvas) {
             switchCanvasData(canvasses.value(newCanvas).first());
         } else {
             emit q->toolOptionWidgetsChanged(controller, QList<QPointer<QWidget> >());
             // as a last resort just set a blank one
             canvasData = 0;
         }
     }
 
     KoToolProxy *proxy = proxies.value(controller->canvas());
     if (proxy)
         proxy->setActiveTool(0);
 
     QList<KoToolBase *> tools;
     Q_FOREACH (CanvasData *canvasData, canvasses.value(controller)) {
         Q_FOREACH (KoToolBase *tool, canvasData->allTools) {
             if (! tools.contains(tool)) {
                 tools.append(tool);
             }
         }
         delete canvasData;
     }
     Q_FOREACH (KoToolBase *tool, tools) {
         uniqueToolIds.remove(tool);
         delete tool;
     }
     canvasses.remove(controller);
     emit q->changedCanvas(canvasData ? canvasData->canvas->canvas() : 0);
 }
 
 void KoToolManager::Private::attachCanvas(KoCanvasController *controller)
 {
     Q_ASSERT(controller);
     CanvasData *cd = createCanvasData(controller, KoInputDevice::mouse());
 
     // switch to new canvas as the active one.
     switchCanvasData(cd);
 
     inputDevice = cd->inputDevice;
     QList<CanvasData*> canvasses_;
     canvasses_.append(cd);
     canvasses[controller] = canvasses_;
 
     KoToolProxy *tp = proxies[controller->canvas()];
     if (tp)
         tp->priv()->setCanvasController(controller);
 
     if (cd->activeTool == 0) {
         // no active tool, so we activate the highest priority main tool
         int highestPriority = INT_MAX;
         ToolHelper * helper = 0;
         Q_FOREACH (ToolHelper * th, tools) {
             if (th->section() == KoToolFactoryBase::mainToolType()) {
                 if (th->priority() < highestPriority) {
                     highestPriority = qMin(highestPriority, th->priority());
                     helper = th;
                 }
             }
         }
         if (helper)
             toolActivated(helper);
     }
 
     Connector *connector = new Connector(controller->canvas()->shapeManager());
     connect(connector, SIGNAL(selectionChanged(QList<KoShape*>)), q,
             SLOT(selectionChanged(QList<KoShape*>)));
     connect(controller->canvas()->selectedShapesProxy(),
             SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             q, SLOT(currentLayerChanged(const KoShapeLayer*)));
 
     emit q->changedCanvas(canvasData ? canvasData->canvas->canvas() : 0);
 }
 
 void KoToolManager::Private::movedFocus(QWidget *from, QWidget *to)
 {
     Q_UNUSED(from);
     // no canvas anyway or no focus set anyway?
     if (!canvasData || to == 0) {
         return;
     }
 
     // Check if this app is about QWidget-based KoCanvasControllerWidget canvasses
     // XXX: Focus handling for non-qwidget based canvases!
     KoCanvasControllerWidget *canvasControllerWidget = dynamic_cast<KoCanvasControllerWidget*>(canvasData->canvas);
     if (!canvasControllerWidget) {
         return;
     }
 
     // canvasWidget is set as focusproxy for KoCanvasControllerWidget,
     // so all focus checks are to be done against canvasWidget objects
 
     // focus returned to current canvas?
     if (to == canvasData->canvas->canvas()->canvasWidget()) {
         // nothing to do
         return;
     }
 
     // if the 'to' is one of our canvasWidgets, then switch.
 
     // for code simplicity the current canvas will be checked again,
     // but would have been caught already in the lines above, so no issue
     KoCanvasController *newCanvas = 0;
     Q_FOREACH (KoCanvasController* canvas, canvasses.keys()) {
         if (canvas->canvas()->canvasWidget() == to) {
             newCanvas = canvas;
             break;
         }
     }
 
     // none of our canvasWidgets got focus?
     if (newCanvas == 0) {
         return;
     }
 
     // switch to canvasdata matching inputdevice used last with this app instance
     Q_FOREACH (CanvasData *data, canvasses.value(newCanvas)) {
         if (data->inputDevice == inputDevice) {
             switchCanvasData(data);
             return;
         }
     }
     // if no such inputDevice for this canvas, then simply fallback to first one
     switchCanvasData(canvasses.value(newCanvas).first());
 }
 
 void KoToolManager::Private::updateCursor(const QCursor &cursor)
 {
     Q_ASSERT(canvasData);
     Q_ASSERT(canvasData->canvas);
     Q_ASSERT(canvasData->canvas->canvas());
     canvasData->canvas->canvas()->setCursor(cursor);
 }
 
 void KoToolManager::Private::selectionChanged(const QList<KoShape*> &shapes)
 {
     QList<QString> types;
     Q_FOREACH (KoShape *shape, shapes) {
         QSet<KoShape*> delegates = shape->toolDelegates();
         if (delegates.isEmpty()) { // no delegates, just the orig shape
             delegates << shape;
         }
 
         foreach (KoShape *shape2, delegates) {
             Q_ASSERT(shape2);
             if (! types.contains(shape2->shapeId())) {
                 types.append(shape2->shapeId());
             }
         }
     }
 
     // check if there is still a shape selected the active tool can work on
     // there needs to be at least one shape for a tool without an activationShapeId
     // to work
     // if not change the current tool to the default tool
 
     const QStringList activationShapeIds = canvasData->activationShapeId.split(',');
 
     if (!(canvasData->activationShapeId.isNull() && shapes.size() > 0)
         && !activationShapeIds.contains("flake/always")
         && !activationShapeIds.contains("flake/edit")) {
 
         bool currentToolWorks = false;
         foreach (const QString &type, types) {
             if (activationShapeIds.contains(type)) {
                 currentToolWorks = true;
                 break;
             }
         }
         if (!currentToolWorks) {
             switchTool(KoInteractionTool_ID, false);
         }
     }
 
     emit q->toolCodesSelected(types);
 }
 
 void KoToolManager::Private::currentLayerChanged(const KoShapeLayer *layer)
 {
     emit q->currentLayerChanged(canvasData->canvas, layer);
     layerExplicitlyDisabled = layer && !layer->isShapeEditable();
     updateToolForProxy();
 
     debugFlake << "Layer changed to" << layer << "explicitly disabled:" << layerExplicitlyDisabled;
 }
 
 void KoToolManager::Private::updateToolForProxy()
 {
     KoToolProxy *proxy = proxies.value(canvasData->canvas->canvas());
     if(!proxy) return;
 
     bool canUseTool = !layerExplicitlyDisabled || canvasData->activationShapeId.endsWith(QLatin1String("/always"));
     proxy->setActiveTool(canUseTool ? canvasData->activeTool : 0);
 }
 
 void KoToolManager::Private::switchInputDevice(const KoInputDevice &device)
 {
     Q_ASSERT(canvasData);
     if (!canvasData) return;
     if (inputDevice == device) return;
     if (inputDevice.isMouse() && device.isMouse()) return;
     if (device.isMouse() && !inputDevice.isMouse()) {
         // we never switch back to mouse from a tablet input device, so the user can use the
         // mouse to edit the settings for a tool activated by a tablet. See bugs
         // https://bugs.kde.org/show_bug.cgi?id=283130 and https://bugs.kde.org/show_bug.cgi?id=285501.
         // We do continue to switch between tablet devices, thought.
         return;
     }
 
     QList<CanvasData*> items = canvasses[canvasData->canvas];
 
     // disable all actions for all tools in the all canvasdata objects for this canvas.
     Q_FOREACH (CanvasData *cd, items) {
         Q_FOREACH (KoToolBase* tool, cd->allTools) {
             Q_FOREACH (QAction * action, tool->actions()) {
                 action->setEnabled(false);
             }
         }
     }
 
     // search for a canvasdata object for the current input device
     Q_FOREACH (CanvasData *cd, items) {
         if (cd->inputDevice == device) {
             switchCanvasData(cd);
 
             if (!canvasData->activeTool) {
                 switchTool(KoInteractionTool_ID, false);
             }
 
             return;
         }
     }
 
     // still here?  That means we need to create a new CanvasData instance with the current InputDevice.
     CanvasData *cd = createCanvasData(canvasData->canvas, device);
     // switch to new canvas as the active one.
     QString oldTool = canvasData->activeToolId;
 
     items.append(cd);
     canvasses[cd->canvas] = items;
 
     switchCanvasData(cd);
 
     q->switchToolRequested(oldTool);
 }
 
 void KoToolManager::Private::registerToolProxy(KoToolProxy *proxy, KoCanvasBase *canvas)
 {
     proxies.insert(canvas, proxy);
     Q_FOREACH (KoCanvasController *controller, canvasses.keys()) {
         if (controller->canvas() == canvas) {
             proxy->priv()->setCanvasController(controller);
             break;
         }
     }
 }
 
 //have to include this because of Q_PRIVATE_SLOT
 #include "moc_KoToolManager.cpp"
diff --git a/libs/flake/tests/TestResourceManager.cpp b/libs/flake/tests/TestResourceManager.cpp
index 9d62215b5c..9fcbfbd9b2 100644
--- a/libs/flake/tests/TestResourceManager.cpp
+++ b/libs/flake/tests/TestResourceManager.cpp
@@ -1,430 +1,430 @@
 /* This file is part of the KDE project
    Copyright (C) 2008 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 "TestResourceManager.h"
 
 #include "KoCanvasResourceManager.h"
 #include "KoResourceManager_p.h"
 #include "KoPathShape.h"
 #include "KoUnit.h"
 #include <QSignalSpy>
 #include <QTest>
 
 #include "kis_debug.h"
 
 void TestResourceManager::koShapeResource()
 {
     KoPathShape * shape = new KoPathShape();
     int key = 9001;
 
     KoCanvasResourceManager rp( 0 );
     rp.setResource( key, shape );
     QVERIFY( shape == rp.koShapeResource( key ) );
 }
 
 void TestResourceManager::testUnitChanged()
 {
     KoCanvasResourceManager rm(0);
-    QSignalSpy spy(&rm, SIGNAL(canvasResourceChanged(int, const QVariant &)));
+    QSignalSpy spy(&rm, SIGNAL(canvasResourceChanged(int,QVariant)));
 
     KoUnit a;
     rm.setResource(KoCanvasResourceManager::Unit, a);
     QCOMPARE(spy.count(), 1);
 
     KoUnit b(KoUnit::Millimeter);
     rm.setResource(KoCanvasResourceManager::Unit, b);
     QCOMPARE(spy.count(), 2);
 }
 
 #include "kis_pointer_utils.h"
 
 struct DerivedResource : public KoDerivedResourceConverter
 {
     DerivedResource(int key, int sourceKey) : KoDerivedResourceConverter(key, sourceKey) {}
 
     QVariant fromSource(const QVariant &value) override {
         return value.toInt() + 10;
     }
 
     QVariant toSource(const QVariant &value, const QVariant &sourceValue) override {
         Q_UNUSED(sourceValue);
         return value.toInt() - 10;
     }
 };
 
 void TestResourceManager::testConverters()
 {
     KoResourceManager m;
 
     const int key1 = 1;
     const int key2 = 2;
     const int derivedKey = 3;
 
     m.setResource(key1, 1);
     m.setResource(key2, 2);
 
     QCOMPARE(m.resource(key1).toInt(), 1);
     QCOMPARE(m.resource(key2).toInt(), 2);
     QVERIFY(!m.hasResource(derivedKey));
 
     m.addDerivedResourceConverter(toQShared(new DerivedResource(derivedKey, key2)));
 
     QCOMPARE(m.resource(derivedKey).toInt(), 12);
     QVERIFY(m.hasResource(derivedKey));
 
     m.setResource(derivedKey, 15);
 
     QCOMPARE(m.resource(key2).toInt(), 5);
     QCOMPARE(m.resource(derivedKey).toInt(), 15);
 
     QVERIFY(m.hasResource(derivedKey));
     m.clearResource(derivedKey);
     QVERIFY(m.hasResource(derivedKey));
     m.clearResource(key2);
     QVERIFY(!m.hasResource(derivedKey));
 }
 
 void TestResourceManager::testDerivedChanged()
 {
     // const int key1 = 1;
     const int key2 = 2;
     const int derivedKey = 3;
     const int otherDerivedKey = 4;
 
     KoCanvasResourceManager m(0);
     m.addDerivedResourceConverter(toQShared(new DerivedResource(derivedKey, key2)));
     m.addDerivedResourceConverter(toQShared(new DerivedResource(otherDerivedKey, key2)));
 
     m.setResource(derivedKey, 15);
 
     QCOMPARE(m.resource(key2).toInt(), 5);
     QCOMPARE(m.resource(derivedKey).toInt(), 15);
 
-    QSignalSpy spy(&m, SIGNAL(canvasResourceChanged(int, const QVariant &)));
+    QSignalSpy spy(&m, SIGNAL(canvasResourceChanged(int,QVariant)));
 
     m.setResource(derivedKey, 16);
 
     QCOMPARE(spy.count(), 3);
     QList<QVariant> args;
 
     args = spy[0];
     QCOMPARE(args[0].toInt(), derivedKey);
     QCOMPARE(args[1].toInt(), 16);
 
     args = spy[1];
     QCOMPARE(args[0].toInt(), key2);
     QCOMPARE(args[1].toInt(), 6);
 
     args = spy[2];
     QCOMPARE(args[0].toInt(), otherDerivedKey);
     QCOMPARE(args[1].toInt(), 16);
 
     spy.clear();
 
     m.setResource(key2, 7);
     QCOMPARE(spy.count(), 3);
 
     args = spy[0];
     QCOMPARE(args[0].toInt(), key2);
     QCOMPARE(args[1].toInt(), 7);
 
     args = spy[1];
     QCOMPARE(args[0].toInt(), otherDerivedKey);
     QCOMPARE(args[1].toInt(), 17);
 
     args = spy[2];
     QCOMPARE(args[0].toInt(), derivedKey);
     QCOMPARE(args[1].toInt(), 17);
 }
 
 struct ComplexResource {
     QHash<int, QVariant> m_resources;
 };
 
 typedef QSharedPointer<ComplexResource> ComplexResourceSP;
 Q_DECLARE_METATYPE(ComplexResourceSP);
 
 struct ComplexConverter : public KoDerivedResourceConverter
 {
     ComplexConverter(int key, int sourceKey) : KoDerivedResourceConverter(key, sourceKey) {}
 
     QVariant fromSource(const QVariant &value) override {
         KIS_ASSERT(value.canConvert<ComplexResourceSP>());
         ComplexResourceSP res = value.value<ComplexResourceSP>();
 
         return res->m_resources[key()];
     }
 
     QVariant toSource(const QVariant &value, const QVariant &sourceValue) override {
         KIS_ASSERT(sourceValue.canConvert<ComplexResourceSP>());
         ComplexResourceSP res = sourceValue.value<ComplexResourceSP>();
 
         res->m_resources[key()] = value;
         return QVariant::fromValue(res);
     }
 };
 
 struct ComplexMediator : public KoResourceUpdateMediator
 {
     ComplexMediator(int key) : KoResourceUpdateMediator(key) {}
 
     void connectResource(QVariant sourceResource) override {
         m_res = sourceResource;
     }
 
     void forceNotify() {
         emit sigResourceChanged(key());
     }
 
     QVariant m_res;
 };
 typedef QSharedPointer<ComplexMediator> ComplexMediatorSP;
 
 void TestResourceManager::testComplexResource()
 {
     const int key = 2;
     const int complex1 = 3;
     const int complex2 = 4;
 
     KoCanvasResourceManager m(0);
     m.addDerivedResourceConverter(toQShared(new ComplexConverter(complex1, key)));
     m.addDerivedResourceConverter(toQShared(new ComplexConverter(complex2, key)));
 
     ComplexMediatorSP mediator(new ComplexMediator(key));
     m.addResourceUpdateMediator(mediator);
 
-    QSignalSpy spy(&m, SIGNAL(canvasResourceChanged(int, const QVariant &)));
+    QSignalSpy spy(&m, SIGNAL(canvasResourceChanged(int,QVariant)));
 
     ComplexResourceSP r1(new ComplexResource());
     r1->m_resources[complex1] = 10;
     r1->m_resources[complex2] = 20;
 
     ComplexResourceSP r2(new ComplexResource());
     r2->m_resources[complex1] = 15;
     r2->m_resources[complex2] = 25;
 
 
     // ####################################################
     // Initial assignment
     // ####################################################
     m.setResource(key, QVariant::fromValue(r1));
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(complex1).toInt(), 10);
     QCOMPARE(m.resource(complex2).toInt(), 20);
 
     QCOMPARE(spy[0][0].toInt(), key);
     QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r1);
     QCOMPARE(spy[1][0].toInt(), complex2);
     QCOMPARE(spy[1][1].toInt(), 20);
     QCOMPARE(spy[2][0].toInt(), complex1);
     QCOMPARE(spy[2][1].toInt(), 10);
     spy.clear();
 
     // ####################################################
     // Change the whole resource
     // ####################################################
     m.setResource(key, QVariant::fromValue(r2));
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(complex1).toInt(), 15);
     QCOMPARE(m.resource(complex2).toInt(), 25);
 
     QCOMPARE(spy[0][0].toInt(), key);
     QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r2);
     QCOMPARE(spy[1][0].toInt(), complex2);
     QCOMPARE(spy[1][1].toInt(), 25);
     QCOMPARE(spy[2][0].toInt(), complex1);
     QCOMPARE(spy[2][1].toInt(), 15);
     spy.clear();
 
     // ####################################################
     // Change a derived resource
     // ####################################################
     m.setResource(complex1, 16);
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(complex1).toInt(), 16);
     QCOMPARE(m.resource(complex2).toInt(), 25);
 
     QCOMPARE(spy[0][0].toInt(), complex1);
     QCOMPARE(spy[0][1].toInt(), 16);
     spy.clear();
 
     // ####################################################
     // Change another derived resource
     // ####################################################
     m.setResource(complex2, 26);
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(complex1).toInt(), 16);
     QCOMPARE(m.resource(complex2).toInt(), 26);
 
     QCOMPARE(spy[0][0].toInt(), complex2);
     QCOMPARE(spy[0][1].toInt(), 26);
     spy.clear();
 
     // ####################################################
     // Switch back the whole source resource
     // ####################################################
     m.setResource(key, QVariant::fromValue(r1));
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(complex1).toInt(), 10);
     QCOMPARE(m.resource(complex2).toInt(), 20);
 
     QCOMPARE(spy[0][0].toInt(), key);
     QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r1);
     QCOMPARE(spy[1][0].toInt(), complex2);
     QCOMPARE(spy[1][1].toInt(), 20);
     QCOMPARE(spy[2][0].toInt(), complex1);
     QCOMPARE(spy[2][1].toInt(), 10);
     spy.clear();
 
     // ####################################################
     // The value keep unchanged case!
     // ####################################################
     m.setResource(complex1, 10);
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(complex1).toInt(), 10);
     QCOMPARE(m.resource(complex2).toInt(), 20);
 
     QCOMPARE(spy.size(), 0);
     spy.clear();
 
     // ####################################################
     // While switching a complex resource one derived value
     // is kept unchanged
     // ####################################################
     r2->m_resources[complex1] = 10;
     m.setResource(key, QVariant::fromValue(r2));
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
     QCOMPARE(m.resource(complex1).toInt(), 10);
     QCOMPARE(m.resource(complex2).toInt(), 26);
 
     QCOMPARE(spy[0][0].toInt(), key);
     QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r2);
     QCOMPARE(spy[1][0].toInt(), complex2);
     QCOMPARE(spy[1][1].toInt(), 26);
     spy.clear();
 
     // ####################################################
     // No devived values are changed!
     // ####################################################
     *r1 = *r2;
     m.setResource(key, QVariant::fromValue(r1));
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(complex1).toInt(), 10);
     QCOMPARE(m.resource(complex2).toInt(), 26);
 
     QCOMPARE(spy[0][0].toInt(), key);
     QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r1);
     spy.clear();
 
     // ####################################################
     // Try to set the same pointer. No signals emitted!
     // ####################################################
     m.setResource(key, QVariant::fromValue(r1));
 
     QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
     QCOMPARE(m.resource(complex1).toInt(), 10);
     QCOMPARE(m.resource(complex2).toInt(), 26);
 
     QCOMPARE(spy.size(), 0);
     spy.clear();
 
 
     // ####################################################
     // Internals 'officially' changed, but the values not
     // ####################################################
     mediator->forceNotify();
 
     QCOMPARE(spy.size(), 0);
     spy.clear();
 
     // ####################################################
     // We changed the values, but didn't notify anyone :)
     // ####################################################
     r1->m_resources[complex1] = 11;
     r1->m_resources[complex2] = 21;
 
     mediator->forceNotify();
 
     QCOMPARE(spy[0][0].toInt(), complex2);
     QCOMPARE(spy[0][1].toInt(), 21);
     QCOMPARE(spy[1][0].toInt(), complex1);
     QCOMPARE(spy[1][1].toInt(), 11);
     spy.clear();
 }
 
 struct NeverChangingResource : public KoDerivedResourceConverter
 {
     NeverChangingResource(int key, int sourceKey) : KoDerivedResourceConverter(key, sourceKey) {}
 
     QVariant fromSource(const QVariant &value) override {
         Q_UNUSED(value);
         return 10;
     }
 
     QVariant toSource(const QVariant &value, const QVariant &sourceValue) override {
         Q_UNUSED(value);
         return sourceValue;
     }
 };
 
 void TestResourceManager::testNeverChangingConverters()
 {
     KoResourceManager m;
 
     const int key1 = 1;
     const int key2 = 2;
     const int derivedKey = 3;
 
     m.setResource(key1, 1);
     m.setResource(key2, 2);
 
     QCOMPARE(m.resource(key1).toInt(), 1);
     QCOMPARE(m.resource(key2).toInt(), 2);
     QVERIFY(!m.hasResource(derivedKey));
 
     m.addDerivedResourceConverter(toQShared(new NeverChangingResource(derivedKey, key2)));
 
     QVERIFY(m.hasResource(derivedKey));
     QCOMPARE(m.resource(derivedKey).toInt(), 10);
 
     m.setResource(derivedKey, 150);
 
     QCOMPARE(m.resource(key2).toInt(), 2);
     QCOMPARE(m.resource(derivedKey).toInt(), 10);
 }
 
 
 QTEST_MAIN(TestResourceManager)
diff --git a/libs/global/kis_acyclic_signal_connector.cpp b/libs/global/kis_acyclic_signal_connector.cpp
index 8f8c439103..93b80d037c 100644
--- a/libs/global/kis_acyclic_signal_connector.cpp
+++ b/libs/global/kis_acyclic_signal_connector.cpp
@@ -1,277 +1,277 @@
 /*
  *  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_acyclic_signal_connector.h"
 
 #include "kis_debug.h"
 
 
 KisAcyclicSignalConnector::KisAcyclicSignalConnector(QObject *parent)
     : QObject(parent),
       m_signalsBlocked(0)
 {
 }
 
 KisAcyclicSignalConnector::~KisAcyclicSignalConnector()
 {
 }
 
 void KisAcyclicSignalConnector::connectForwardDouble(QObject *sender, const char *signal,
                                                   QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(forwardSlotDouble(double)));
     connect(this, SIGNAL(forwardSignalDouble(double)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectBackwardDouble(QObject *sender, const char *signal,
                                                    QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(backwardSlotDouble(double)));
     connect(this, SIGNAL(backwardSignalDouble(double)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectForwardInt(QObject *sender, const char *signal,
                                                   QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(forwardSlotInt(int)));
     connect(this, SIGNAL(forwardSignalInt(int)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectBackwardInt(QObject *sender, const char *signal,
                                                    QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(backwardSlotInt(int)));
     connect(this, SIGNAL(backwardSignalInt(int)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectForwardBool(QObject *sender, const char *signal,
                                                   QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(forwardSlotBool(bool)));
     connect(this, SIGNAL(forwardSignalBool(bool)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectBackwardBool(QObject *sender, const char *signal,
                                                    QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(backwardSlotBool(bool)));
     connect(this, SIGNAL(backwardSignalBool(bool)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectForwardVoid(QObject *sender, const char *signal,
                                                   QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(forwardSlotVoid()));
     connect(this, SIGNAL(forwardSignalVoid()), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectBackwardVoid(QObject *sender, const char *signal,
                                                  QObject *receiver, const char *method)
 {
 
     connect(sender, signal, this, SLOT(backwardSlotVoid()));
     connect(this, SIGNAL(backwardSignalVoid()), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectForwardVariant(QObject *sender, const char *signal,
                                                   QObject *receiver, const char *method)
 {
 
-    connect(sender, signal, this, SLOT(forwardSlotVariant(const QVariant&)));
-    connect(this, SIGNAL(forwardSignalVariant(const QVariant&)), receiver, method);
+    connect(sender, signal, this, SLOT(forwardSlotVariant(QVariant)));
+    connect(this, SIGNAL(forwardSignalVariant(QVariant)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectBackwardVariant(QObject *sender, const char *signal,
                                                        QObject *receiver, const char *method)
 {
-    connect(sender, signal, this, SLOT(backwardSlotVariant(const QVariant&)));
-    connect(this, SIGNAL(backwardSignalVariant(const QVariant&)), receiver, method);
+    connect(sender, signal, this, SLOT(backwardSlotVariant(QVariant)));
+    connect(this, SIGNAL(backwardSignalVariant(QVariant)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectForwardResourcePair(QObject *sender, const char *signal, QObject *receiver, const char *method)
 {
     connect(sender, signal, this, SLOT(forwardSlotResourcePair(int,QVariant)));
     connect(this, SIGNAL(forwardSignalResourcePair(int,QVariant)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::connectBackwardResourcePair(QObject *sender, const char *signal, QObject *receiver, const char *method)
 {
     connect(sender, signal, this, SLOT(backwardSlotResourcePair(int,QVariant)));
     connect(this, SIGNAL(backwardSignalResourcePair(int,QVariant)), receiver, method);
 }
 
 void KisAcyclicSignalConnector::lock()
 {
     if (m_parentConnector) {
         m_parentConnector->lock();
     } else {
         coordinatedLock();
 
         Q_FOREACH(QPointer<KisAcyclicSignalConnector> conn, m_coordinatedConnectors) {
             if (!conn) continue;
             conn->coordinatedLock();
         }
     }
 }
 
 void KisAcyclicSignalConnector::unlock()
 {
     if (m_parentConnector) {
         m_parentConnector->unlock();
     } else {
         Q_FOREACH(QPointer<KisAcyclicSignalConnector> conn, m_coordinatedConnectors) {
             if (!conn) continue;
             conn->coordinatedUnlock();
         }
 
         coordinatedUnlock();
     }
 }
 
 void KisAcyclicSignalConnector::coordinatedLock()
 {
     m_signalsBlocked++;
 }
 
 void KisAcyclicSignalConnector::coordinatedUnlock()
 {
     m_signalsBlocked--;
 }
 
 KisAcyclicSignalConnector *KisAcyclicSignalConnector::createCoordinatedConnector()
 {
     KisAcyclicSignalConnector *conn = new KisAcyclicSignalConnector(this);
     conn->m_parentConnector = this;
     m_coordinatedConnectors.append(conn);
     return conn;
 }
 
 void KisAcyclicSignalConnector::forwardSlotDouble(double value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit forwardSignalDouble(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::backwardSlotDouble(double value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit backwardSignalDouble(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::forwardSlotInt(int value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit forwardSignalInt(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::backwardSlotInt(int value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit backwardSignalInt(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::forwardSlotBool(bool value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit forwardSignalBool(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::backwardSlotBool(bool value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit backwardSignalBool(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::forwardSlotVoid()
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit forwardSignalVoid();
     unlock();
 }
 
 void KisAcyclicSignalConnector::backwardSlotVoid()
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit backwardSignalVoid();
     unlock();
 }
 
 void KisAcyclicSignalConnector::forwardSlotVariant(const QVariant &value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit forwardSignalVariant(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::backwardSlotVariant(const QVariant &value)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit backwardSignalVariant(value);
     unlock();
 }
 
 void KisAcyclicSignalConnector::forwardSlotResourcePair(int key, const QVariant &resource)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit forwardSignalResourcePair(key, resource);
     unlock();
 }
 
 void KisAcyclicSignalConnector::backwardSlotResourcePair(int key, const QVariant &resource)
 {
     if (m_signalsBlocked) return;
 
     lock();
     emit backwardSignalResourcePair(key, resource);
     unlock();
 }
diff --git a/libs/image/kis_image_animation_interface.cpp b/libs/image/kis_image_animation_interface.cpp
index 3a0f6a3fe9..b94032f948 100644
--- a/libs/image/kis_image_animation_interface.cpp
+++ b/libs/image/kis_image_animation_interface.cpp
@@ -1,425 +1,425 @@
 /*
  *  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_image_animation_interface.h"
 
 #include <QFileInfo>
 
 #include "kis_global.h"
 #include "kis_image.h"
 #include "kis_regenerate_frame_stroke_strategy.h"
 #include "kis_switch_time_stroke_strategy.h"
 #include "kis_keyframe_channel.h"
 #include "kis_time_range.h"
 
 #include "kis_post_execution_undo_adapter.h"
 #include "commands_new/kis_switch_current_time_command.h"
 #include "kis_layer_utils.h"
 
 
 struct KisImageAnimationInterface::Private
 {
     Private()
         : image(0),
           externalFrameActive(false),
           frameInvalidationBlocked(false),
           cachedLastFrameValue(-1),
           audioChannelMuted(false),
           audioChannelVolume(0.5),
           m_currentTime(0),
           m_currentUITime(0)
     {
     }
 
     Private(const Private &rhs, KisImage *newImage)
         : image(newImage),
           externalFrameActive(false),
           frameInvalidationBlocked(false),
           fullClipRange(rhs.fullClipRange),
           playbackRange(rhs.playbackRange),
           framerate(rhs.framerate),
           cachedLastFrameValue(-1),
           audioChannelFileName(rhs.audioChannelFileName),
           audioChannelMuted(rhs.audioChannelMuted),
           audioChannelVolume(rhs.audioChannelVolume),
           m_currentTime(rhs.m_currentTime),
           m_currentUITime(rhs.m_currentUITime)
     {
     }
 
     KisImage *image;
     bool externalFrameActive;
     bool frameInvalidationBlocked;
 
     KisTimeRange fullClipRange;
     KisTimeRange playbackRange;
     int framerate;
     int cachedLastFrameValue;
     QString audioChannelFileName;
     bool audioChannelMuted;
     qreal audioChannelVolume;
 
     KisSwitchTimeStrokeStrategy::SharedTokenWSP switchToken;
 
     inline int currentTime() const {
         return m_currentTime;
     }
 
     inline int currentUITime() const {
         return m_currentUITime;
     }
     inline void setCurrentTime(int value) {
         m_currentTime = value;
     }
 
     inline void setCurrentUITime(int value) {
         m_currentUITime = value;
     }
 private:
     int m_currentTime;
     int m_currentUITime;
 };
 
 
 KisImageAnimationInterface::KisImageAnimationInterface(KisImage *image)
     : QObject(image),
       m_d(new Private)
 {
     m_d->image = image;
 
     m_d->framerate = 24;
     m_d->fullClipRange = KisTimeRange::fromTime(0, 100);
 
-    connect(this, SIGNAL(sigInternalRequestTimeSwitch(int, bool)), SLOT(switchCurrentTimeAsync(int, bool)));
+    connect(this, SIGNAL(sigInternalRequestTimeSwitch(int,bool)), SLOT(switchCurrentTimeAsync(int,bool)));
 }
 
 KisImageAnimationInterface::KisImageAnimationInterface(const KisImageAnimationInterface &rhs, KisImage *newImage)
     : m_d(new Private(*rhs.m_d, newImage))
 {
-    connect(this, SIGNAL(sigInternalRequestTimeSwitch(int, bool)), SLOT(switchCurrentTimeAsync(int, bool)));
+    connect(this, SIGNAL(sigInternalRequestTimeSwitch(int,bool)), SLOT(switchCurrentTimeAsync(int,bool)));
 }
 
 KisImageAnimationInterface::~KisImageAnimationInterface()
 {
 }
 
 bool KisImageAnimationInterface::hasAnimation() const
 {
     bool hasAnimation = false;
 
     KisLayerUtils::recursiveApplyNodes(
         m_d->image->root(),
         [&hasAnimation](KisNodeSP node) {
             hasAnimation |= node->isAnimated();
         });
 
     return hasAnimation;
 }
 
 int KisImageAnimationInterface::currentTime() const
 {
     return m_d->currentTime();
 }
 
 int KisImageAnimationInterface::currentUITime() const
 {
     return m_d->currentUITime();
 }
 
 const KisTimeRange& KisImageAnimationInterface::fullClipRange() const
 {
     return m_d->fullClipRange;
 }
 
 void KisImageAnimationInterface::setFullClipRange(const KisTimeRange range)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     m_d->fullClipRange = range;
     emit sigFullClipRangeChanged();
 }
 
 void KisImageAnimationInterface::setFullClipRangeStartTime(int column)
 {
     KisTimeRange newRange(column,  m_d->fullClipRange.end(), false);
     setFullClipRange(newRange);
 }
 
 void KisImageAnimationInterface::setFullClipRangeEndTime(int column)
 {
     KisTimeRange newRange(m_d->fullClipRange.start(), column, false);
     setFullClipRange(newRange);
 }
 
 const KisTimeRange& KisImageAnimationInterface::playbackRange() const
 {
     return m_d->playbackRange.isValid() ? m_d->playbackRange : m_d->fullClipRange;
 }
 
 void KisImageAnimationInterface::setPlaybackRange(const KisTimeRange range)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     m_d->playbackRange = range;
     emit sigPlaybackRangeChanged();
 }
 
 int KisImageAnimationInterface::framerate() const
 {
     return m_d->framerate;
 }
 
 QString KisImageAnimationInterface::audioChannelFileName() const
 {
     return m_d->audioChannelFileName;
 }
 
 void KisImageAnimationInterface::setAudioChannelFileName(const QString &fileName)
 {
     QFileInfo info(fileName);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(fileName.isEmpty() || info.isAbsolute());
     m_d->audioChannelFileName = fileName.isEmpty() ? fileName : info.absoluteFilePath();
 
     emit sigAudioChannelChanged();
 }
 
 bool KisImageAnimationInterface::isAudioMuted() const
 {
     return m_d->audioChannelMuted;
 }
 
 void KisImageAnimationInterface::setAudioMuted(bool value)
 {
     m_d->audioChannelMuted = value;
     emit sigAudioChannelChanged();
 }
 
 qreal KisImageAnimationInterface::audioVolume() const
 {
     return m_d->audioChannelVolume;
 }
 
 void KisImageAnimationInterface::setAudioVolume(qreal value)
 {
     m_d->audioChannelVolume = value;
     emit sigAudioVolumeChanged();
 }
 
 void KisImageAnimationInterface::setFramerate(int fps)
 {
     m_d->framerate = fps;
     emit sigFramerateChanged();
 }
 
 KisImageWSP KisImageAnimationInterface::image() const
 {
     return m_d->image;
 }
 
 bool KisImageAnimationInterface::externalFrameActive() const
 {
     return m_d->externalFrameActive;
 }
 
 void KisImageAnimationInterface::requestTimeSwitchWithUndo(int time)
 {
     if (currentUITime() == time) return;
     requestTimeSwitchNonGUI(time, true);
 }
 
 void KisImageAnimationInterface::setDefaultProjectionColor(const KoColor &color)
 {
     int savedTime = 0;
     saveAndResetCurrentTime(currentTime(), &savedTime);
 
     m_d->image->setDefaultProjectionColor(color);
 
     restoreCurrentTime(&savedTime);
 }
 
 void KisImageAnimationInterface::requestTimeSwitchNonGUI(int time, bool useUndo)
 {
     emit sigInternalRequestTimeSwitch(time, useUndo);
 }
 
 void KisImageAnimationInterface::explicitlySetCurrentTime(int frameId)
 {
     m_d->setCurrentTime(frameId);
 }
 
 void KisImageAnimationInterface::switchCurrentTimeAsync(int frameId, bool useUndo)
 {
     if (currentUITime() == frameId) return;
 
     const KisTimeRange range = KisTimeRange::calculateIdenticalFramesRecursive(m_d->image->root(), currentUITime());
     const bool needsRegeneration = !range.contains(frameId);
 
     KisSwitchTimeStrokeStrategy::SharedTokenSP token =
         m_d->switchToken.toStrongRef();
 
     if (!token || !token->tryResetDestinationTime(frameId, needsRegeneration)) {
 
         {
             KisPostExecutionUndoAdapter *undoAdapter = useUndo ?
                 m_d->image->postExecutionUndoAdapter() : 0;
 
             KisSwitchTimeStrokeStrategy *strategy =
                 new KisSwitchTimeStrokeStrategy(frameId, needsRegeneration,
                                                 this, undoAdapter);
 
             m_d->switchToken = strategy->token();
 
             KisStrokeId stroke = m_d->image->startStroke(strategy);
             m_d->image->endStroke(stroke);
         }
 
         if (needsRegeneration) {
             KisStrokeStrategy *strategy =
                 new KisRegenerateFrameStrokeStrategy(this);
 
             KisStrokeId strokeId = m_d->image->startStroke(strategy);
             m_d->image->endStroke(strokeId);
         }
     }
 
     m_d->setCurrentUITime(frameId);
     emit sigUiTimeChanged(frameId);
 }
 
 void KisImageAnimationInterface::requestFrameRegeneration(int frameId, const QRegion &dirtyRegion)
 {
     KisStrokeStrategy *strategy =
         new KisRegenerateFrameStrokeStrategy(frameId,
                                              dirtyRegion,
                                              this);
 
     QList<KisStrokeJobData*> jobs = KisRegenerateFrameStrokeStrategy::createJobsData(m_d->image);
 
     KisStrokeId stroke = m_d->image->startStroke(strategy);
     Q_FOREACH (KisStrokeJobData* job, jobs) {
         m_d->image->addJob(stroke, job);
     }
     m_d->image->endStroke(stroke);
 }
 
 void KisImageAnimationInterface::saveAndResetCurrentTime(int frameId, int *savedValue)
 {
     m_d->externalFrameActive = true;
     *savedValue = m_d->currentTime();
     m_d->setCurrentTime(frameId);
 }
 
 void KisImageAnimationInterface::restoreCurrentTime(int *savedValue)
 {
     m_d->setCurrentTime(*savedValue);
     m_d->externalFrameActive = false;
 }
 
 void KisImageAnimationInterface::notifyFrameReady()
 {
     emit sigFrameReady(m_d->currentTime());
 }
 
 void KisImageAnimationInterface::notifyFrameCancelled()
 {
     emit sigFrameCancelled();
 }
 
 KisUpdatesFacade* KisImageAnimationInterface::updatesFacade() const
 {
     return m_d->image;
 }
 
 void KisImageAnimationInterface::notifyNodeChanged(const KisNode *node,
                                                    const QRect &rect,
                                                    bool recursive)
 {
     notifyNodeChanged(node, QVector<QRect>({rect}), recursive);
 }
 
 void KisImageAnimationInterface::notifyNodeChanged(const KisNode *node,
                                                    const QVector<QRect> &rects,
                                                    bool recursive)
 {
     if (externalFrameActive() || m_d->frameInvalidationBlocked) return;
 
     // even overlay selection masks are not rendered in the cache
     if (node->inherits("KisSelectionMask")) return;
 
     const int currentTime = m_d->currentTime();
     KisTimeRange invalidateRange;
 
     if (recursive) {
         invalidateRange = KisTimeRange::calculateAffectedFramesRecursive(node, currentTime);
     } else {
         invalidateRange = KisTimeRange::calculateNodeAffectedFrames(node, currentTime);
     }
 
     // we compress the updated rect (atm, no one uses it anyway)
     QRect unitedRect;
     Q_FOREACH (const QRect &rc, rects) {
         unitedRect |= rc;
     }
 
     invalidateFrames(invalidateRange, unitedRect);
 }
 
 void KisImageAnimationInterface::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->cachedLastFrameValue = -1;
     emit sigFramesChanged(range, rect);
 }
 
 void KisImageAnimationInterface::blockFrameInvalidation(bool value)
 {
     m_d->frameInvalidationBlocked = value;
 }
 
 int findLastKeyframeTimeRecursive(KisNodeSP node)
 {
     int time = 0;
 
     KisKeyframeChannel *channel;
     Q_FOREACH (channel, node->keyframeChannels()) {
         KisKeyframeSP keyframe = channel->lastKeyframe();
         if (keyframe) {
             time = std::max(time, keyframe->time());
         }
     }
 
     KisNodeSP child = node->firstChild();
     while (child) {
         time = std::max(time, findLastKeyframeTimeRecursive(child));
         child = child->nextSibling();
     }
 
     return time;
 }
 
 int KisImageAnimationInterface::totalLength()
 {
     if (m_d->cachedLastFrameValue < 0) {
         m_d->cachedLastFrameValue = findLastKeyframeTimeRecursive(m_d->image->root());
     }
 
     int lastKey = m_d->cachedLastFrameValue;
 
     lastKey  = std::max(lastKey, m_d->fullClipRange.end());
     lastKey  = std::max(lastKey, m_d->currentUITime());
 
     return lastKey + 1;
 }
diff --git a/libs/image/tests/kis_image_signal_router_test.cpp b/libs/image/tests/kis_image_signal_router_test.cpp
index 17c10aa193..8a74a0711b 100644
--- a/libs/image/tests/kis_image_signal_router_test.cpp
+++ b/libs/image/tests/kis_image_signal_router_test.cpp
@@ -1,68 +1,68 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image_signal_router_test.h"
 
 #include <QTest>
 
 
 inline void KisImageSignalRouterTest::checkNotification(KisImageSignalType notification, const char *signal)
 {
     QSignalSpy *spy = new QSignalSpy(m_image.data(), signal);
     QCOMPARE(spy->count(), 0);
     m_image->signalRouter()->emitNotification(notification);
     QCOMPARE(spy->count(), 1);
     delete spy;
 }
 
 #define checkComplexSignal(method, signal)                      \
     {                                                           \
     QSignalSpy *spy = new QSignalSpy(m_image.data(), signal);   \
     QCOMPARE(spy->count(), 0);                                  \
     m_image->signalRouter()->method;                            \
     QCOMPARE(spy->count(), 1);                                  \
     delete spy;                                                 \
     }
 
 void KisImageSignalRouterTest::init()
 {
     initBase();
     constructImage();
 }
 
 void KisImageSignalRouterTest::cleanup()
 {
     cleanupBase();
 }
 
 void KisImageSignalRouterTest::testSignalForwarding()
 {
     checkNotification(LayersChangedSignal, SIGNAL(sigLayersChangedAsync()));
     checkNotification(ModifiedSignal, SIGNAL(sigImageModified()));
-    checkNotification(SizeChangedSignal, SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)));
-    checkNotification(ComplexSizeChangedSignal(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)));
+    checkNotification(SizeChangedSignal, SIGNAL(sigSizeChanged(QPointF,QPointF)));
+    checkNotification(ComplexSizeChangedSignal(), SIGNAL(sigSizeChanged(QPointF,QPointF)));
     checkNotification(ProfileChangedSignal, SIGNAL(sigProfileChanged(const KoColorProfile*)));
     checkNotification(ColorSpaceChangedSignal, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)));
-    checkNotification(ResolutionChangedSignal, SIGNAL(sigResolutionChanged(double, double)));
+    checkNotification(ResolutionChangedSignal, SIGNAL(sigResolutionChanged(double,double)));
 
     checkComplexSignal(emitNodeChanged(m_layer1.data()), SIGNAL(sigNodeChanged(KisNodeSP)));
     checkComplexSignal(emitNodeHasBeenAdded(m_layer3.data(),0), SIGNAL(sigNodeAddedAsync(KisNodeSP)));
     checkComplexSignal(emitAboutToRemoveANode(m_layer3.data(),0), SIGNAL(sigRemoveNodeAsync(KisNodeSP)));
 }
 
 QTEST_MAIN(KisImageSignalRouterTest)
diff --git a/libs/image/tests/kis_keyframing_test.cpp b/libs/image/tests/kis_keyframing_test.cpp
index 0e1919c516..638493a0cc 100644
--- a/libs/image/tests/kis_keyframing_test.cpp
+++ b/libs/image/tests/kis_keyframing_test.cpp
@@ -1,528 +1,528 @@
 /*
  *  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_keyframing_test.h"
 #include <QTest>
 #include <qsignalspy.h>
 
 #include "kis_paint_device_frames_interface.h"
 #include "kis_keyframe_channel.h"
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_node.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 
 
 #include <KoColorSpaceRegistry.h>
 
 #include "testing_timed_default_bounds.h"
 
 
 void KisKeyframingTest::initTestCase()
 {
     cs = KoColorSpaceRegistry::instance()->rgb8();
 
     red = new quint8[cs->pixelSize()];
     green = new quint8[cs->pixelSize()];
     blue = new quint8[cs->pixelSize()];
 
     cs->fromQColor(Qt::red, red);
     cs->fromQColor(Qt::green, green);
     cs->fromQColor(Qt::blue, blue);
 }
 
 void KisKeyframingTest::cleanupTestCase()
 {
     delete[] red;
     delete[] green;
     delete[] blue;
 }
 
 void KisKeyframingTest::testScalarChannel()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
     KisKeyframeSP key;
     bool ok;
 
     QCOMPARE(channel->hasScalarValue(), true);
     QCOMPARE(channel->minScalarValue(), -17.0);
     QCOMPARE(channel->maxScalarValue(),  31.0);
 
     QVERIFY(channel->keyframeAt(0) == 0);
 
     // Adding new keyframe
 
     key = channel->addKeyframe(42);
     channel->setScalarValue(key, 7.0);
 
     key = channel->keyframeAt(42);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     // Copying a keyframe
 
     KisKeyframeSP key2 = channel->copyKeyframe(key, 13);
     QVERIFY(key2 != 0);
     QVERIFY(channel->keyframeAt(13) == key2);
     QCOMPARE(channel->scalarValue(key2), 7.0);
 
     // Adding a keyframe where one exists
 
     key2 = channel->addKeyframe(13);
     QVERIFY(key2 != key);
     QCOMPARE(channel->keyframeCount(), 2);
 
     // Moving keyframes
 
     ok = channel->moveKeyframe(key, 10);
     QCOMPARE(ok, true);
     QVERIFY(channel->keyframeAt(42) == 0);
 
     key = channel->keyframeAt(10);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     // Moving a keyframe where another one exists
     ok = channel->moveKeyframe(key, 13);
     QCOMPARE(ok, true);
     QVERIFY(channel->keyframeAt(13) != key2);
 
     // Deleting a keyframe
     channel->deleteKeyframe(key);
     QVERIFY(channel->keyframeAt(10) == 0);
     QCOMPARE(channel->keyframeCount(), 0);
 
     delete channel;
 }
 
 void KisKeyframingTest::testScalarChannelUndoRedo()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
     KisKeyframeSP key;
 
     QCOMPARE(channel->hasScalarValue(), true);
     QCOMPARE(channel->minScalarValue(), -17.0);
     QCOMPARE(channel->maxScalarValue(),  31.0);
 
     QVERIFY(channel->keyframeAt(0) == 0);
 
     // Adding new keyframe
 
     KUndo2Command addCmd;
 
     key = channel->addKeyframe(42, &addCmd);
     channel->setScalarValue(key, 7.0, &addCmd);
 
     key = channel->keyframeAt(42);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     addCmd.undo();
 
     KisKeyframeSP newKey;
 
     newKey = channel->keyframeAt(42);
     QVERIFY(!newKey);
 
     addCmd.redo();
 
     newKey = channel->keyframeAt(42);
     QVERIFY(newKey);
 
     QCOMPARE(channel->scalarValue(key), 7.0);
     QCOMPARE(channel->scalarValue(newKey), 7.0);
 
     delete channel;
 }
 
 void KisKeyframingTest::testScalarInterpolation()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), 0, 30, 0);
 
     KisKeyframeSP key1 = channel->addKeyframe(0);
     channel->setScalarValue(key1, 15);
 
     KisKeyframeSP key2 = channel->addKeyframe(10);
     channel->setScalarValue(key2, 30);
 
     // Constant
 
     key1->setInterpolationMode(KisKeyframe::Constant);
 
     QCOMPARE(channel->interpolatedValue(4), 15.0f);
 
     // Bezier
 
     key1->setInterpolationMode(KisKeyframe::Bezier);
     key1->setInterpolationTangents(QPointF(), QPointF(1,4));
     key2->setInterpolationTangents(QPointF(-4,2), QPointF());
 
     QVERIFY(qAbs(channel->interpolatedValue(4) - 24.9812f) < 0.1f);
 
     // Bezier, self-intersecting curve (auto-correct)
 
     channel->setScalarValue(key2, 15);
     key1->setInterpolationTangents(QPointF(), QPointF(13,10));
     key2->setInterpolationTangents(QPointF(-13,10), QPointF());
 
     QVERIFY(qAbs(channel->interpolatedValue(5) - 20.769f) < 0.1f);
 
     // Bezier, result outside allowed range (clamp)
 
     channel->setScalarValue(key2, 15);
     key1->setInterpolationTangents(QPointF(), QPointF(0, 50));
     key2->setInterpolationTangents(QPointF(0, 50), QPointF());
 
     QCOMPARE(channel->interpolatedValue(5), 30.0f);
 
     delete channel;
 }
 
 void KisKeyframingTest::testRasterChannel()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID());
 
     QCOMPARE(channel->hasScalarValue(), false);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QCOMPARE(channel->frameIdAt(0), 0);
     QVERIFY(channel->keyframeAt(0) != 0);
 
     KisKeyframeSP key_0 = channel->keyframeAt(0);
 
     // New keyframe
 
     KisKeyframeSP key_10 = channel->addKeyframe(10);
     QCOMPARE(channel->keyframeCount(), 2);
     QCOMPARE(dev->framesInterface()->frames().count(), 2);
     QVERIFY(channel->frameIdAt(10) != 0);
 
     dev->fill(0, 0, 512, 512, red);
     QImage thumb1a = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
 
     dev->fill(0, 0, 512, 512, green);
     QImage thumb2a = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(0);
     QImage thumb1b = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb2a != thumb1a);
     QVERIFY(thumb1b == thumb1a);
 
     // Duplicate keyframe
 
     KisKeyframeSP key_20 = channel->copyKeyframe(key_0, 20);
     bounds->testingSetTime(20);
     QImage thumb3a = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb3a == thumb1b);
 
     dev->fill(0, 0, 512, 512, blue);
     QImage thumb3b = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(0);
     QImage thumb1c = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb3b != thumb3a);
     QVERIFY(thumb1c == thumb1b);
 
     // Delete keyrame
     QCOMPARE(channel->keyframeCount(), 3);
     QCOMPARE(dev->framesInterface()->frames().count(), 3);
 
     channel->deleteKeyframe(key_20);
     QCOMPARE(channel->keyframeCount(), 2);
     QCOMPARE(dev->framesInterface()->frames().count(), 2);
     QVERIFY(channel->keyframeAt(20) == 0);
 
     channel->deleteKeyframe(key_10);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QVERIFY(channel->keyframeAt(10) == 0);
 
     channel->deleteKeyframe(key_0);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QVERIFY(channel->keyframeAt(0) != 0);
 }
 
 void KisKeyframingTest::testChannelSignals()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
     KisKeyframeSP key;
     KisKeyframeSP resKey;
 
     qRegisterMetaType<KisKeyframeSP>("KisKeyframeSP");
     QSignalSpy spyPreAdd(channel, SIGNAL(sigKeyframeAboutToBeAdded(KisKeyframeSP)));
     QSignalSpy spyPostAdd(channel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)));
 
     QSignalSpy spyPreRemove(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframeSP)));
     QSignalSpy spyPostRemove(channel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)));
 
     QSignalSpy spyPreMove(channel, SIGNAL(sigKeyframeAboutToBeMoved(KisKeyframeSP,int)));
-    QSignalSpy spyPostMove(channel, SIGNAL(sigKeyframeMoved(KisKeyframeSP, int)));
+    QSignalSpy spyPostMove(channel, SIGNAL(sigKeyframeMoved(KisKeyframeSP,int)));
 
     QVERIFY(spyPreAdd.isValid());
     QVERIFY(spyPostAdd.isValid());
     QVERIFY(spyPreRemove.isValid());
     QVERIFY(spyPostRemove.isValid());
     QVERIFY(spyPreMove.isValid());
     QVERIFY(spyPostMove.isValid());
 
     // Adding a keyframe
 
     QCOMPARE(spyPreAdd.count(), 0);
     QCOMPARE(spyPostAdd.count(), 0);
 
     key = channel->addKeyframe(10);
 
     QCOMPARE(spyPreAdd.count(), 1);
     QCOMPARE(spyPostAdd.count(), 1);
 
     resKey = spyPreAdd.at(0).at(0).value<KisKeyframeSP>();
     QVERIFY(resKey == key);
     resKey = spyPostAdd.at(0).at(0).value<KisKeyframeSP>();
     QVERIFY(resKey == key);
 
     // Moving a keyframe
 
     QCOMPARE(spyPreMove.count(), 0);
     QCOMPARE(spyPostMove.count(), 0);
     channel->moveKeyframe(key, 15);
     QCOMPARE(spyPreMove.count(), 1);
     QCOMPARE(spyPostMove.count(), 1);
 
     resKey = spyPreMove.at(0).at(0).value<KisKeyframeSP>();
     QVERIFY(resKey == key);
     QCOMPARE(spyPreMove.at(0).at(1).toInt(), 15);
     resKey = spyPostMove.at(0).at(0).value<KisKeyframeSP>();
     QVERIFY(resKey == key);
 
     // No-op move (no signals)
 
     channel->moveKeyframe(key, 15);
     QCOMPARE(spyPreMove.count(), 1);
     QCOMPARE(spyPostMove.count(), 1);
 
     // Deleting a keyframe
 
     QCOMPARE(spyPreRemove.count(), 0);
     QCOMPARE(spyPostRemove.count(), 0);
     channel->deleteKeyframe(key);
     QCOMPARE(spyPreRemove.count(), 1);
     QCOMPARE(spyPostRemove.count(), 1);
 
     delete channel;
 }
 
 void KisKeyframingTest::testRasterFrameFetching()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     KisPaintDeviceSP devTarget = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID());
 
     channel->addKeyframe(0);
     channel->addKeyframe(10);
     channel->addKeyframe(50);
 
     bounds->testingSetTime(0);
     dev->fill(0, 0, 512, 512, red);
     QImage frame1 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
     dev->fill(0, 256, 512, 512, green);
     QImage frame2 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(50);
     dev->fill(0, 0, 256, 512, blue);
     QImage frame3 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
 
     KisKeyframeSP keyframe = channel->activeKeyframeAt(0);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched1 = devTarget->createThumbnail(50, 50);
 
     keyframe = channel->activeKeyframeAt(10);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched2 = devTarget->createThumbnail(50, 50);
 
     keyframe = channel->activeKeyframeAt(50);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched3 = devTarget->createThumbnail(50, 50);
 
     QVERIFY(fetched1 == frame1);
     QVERIFY(fetched2 == frame2);
     QVERIFY(fetched3 == frame3);
 }
 
 void KisKeyframingTest::testDeleteFirstRasterChannel()
 {
     // Test Plan:
     // 
     // delete
     // undo delete
     // move
     // undo move
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID());
 
     QCOMPARE(channel->hasScalarValue(), false);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QCOMPARE(channel->frameIdAt(0), 0);
     QVERIFY(channel->keyframeAt(0) != 0);
 
     KisKeyframeSP key_0 = channel->keyframeAt(0);
 
     {
         KUndo2Command cmd;
         bool deleteResult = channel->deleteKeyframe(key_0, &cmd);
         QVERIFY(deleteResult);
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) != 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) != key_0);
 
         cmd.undo();
 
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) == key_0);
     }
 
     {
         KUndo2Command cmd;
         bool moveResult = channel->moveKeyframe(key_0, 1, &cmd);
         QVERIFY(moveResult);
         QCOMPARE(dev->framesInterface()->frames().count(), 2);
         QVERIFY(channel->frameIdAt(0) != 0);
         QVERIFY(channel->frameIdAt(1) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(1));
         QVERIFY(channel->keyframeAt(0) != key_0);
         QVERIFY(channel->keyframeAt(1) == key_0);
 
         cmd.undo();
 
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) == key_0);
     }
 }
 
 void KisKeyframingTest::testAffectedFrames()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
     KisTimeRange range;
 
     channel->addKeyframe(10);
     channel->addKeyframe(20);
     channel->addKeyframe(30);
 
     // At a keyframe
     range = channel->affectedFrames(20);
     QCOMPARE(range.start(), 20);
     QCOMPARE(range.end(), 29);
     QCOMPARE(range.isInfinite(), false);
 
     // Between frames
     range = channel->affectedFrames(25);
     QCOMPARE(range.start(), 20);
     QCOMPARE(range.end(), 29);
     QCOMPARE(range.isInfinite(), false);
 
     // Before first frame
     range = channel->affectedFrames(5);
     QCOMPARE(range.start(), 0);
     QCOMPARE(range.end(), 9);
     QCOMPARE(range.isInfinite(), false);
 
     // After last frame
     range = channel->affectedFrames(35);
     QCOMPARE(range.start(), 30);
     QCOMPARE(range.isInfinite(), true);
 
 }
 
 void KisKeyframingTest::testMovingFrames()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * srcChannel = dev->createKeyframeChannel(KoID());
 
     srcChannel->addKeyframe(0);
     srcChannel->addKeyframe(10);
     srcChannel->addKeyframe(50);
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(*dev, KritaUtils::CopyAllFrames);
     KisRasterKeyframeChannel * dstChannel = dev->keyframeChannel();
 
 
     for (int i = 0; i < 1000; i++) {
 
         const int srcTime = 50 + i;
         const int dstTime = 60 + i;
         const int src2Time = 51 + i;
 
         {
             KUndo2Command parentCommand;
             KisKeyframeSP srcKeyframe = srcChannel->keyframeAt(srcTime);
             KIS_ASSERT(srcKeyframe);
             dstChannel->copyExternalKeyframe(srcChannel, srcTime, dstTime, &parentCommand);
             srcChannel->deleteKeyframe(srcKeyframe, &parentCommand);
         }
 
         for (int j = qMax(0, i-15); j < i+5; ++j) {
             bounds->testingSetTime(j);
             QRect rc1 = dev->extent();
             QRect rc2 = dev2->extent();
             Q_UNUSED(rc1);
             Q_UNUSED(rc2);
         }
 
         {
             KUndo2Command parentCommand;
             KisKeyframeSP dstKeyframe = dstChannel->keyframeAt(dstTime);
             KIS_ASSERT(dstKeyframe);
             srcChannel->copyExternalKeyframe(dstChannel, dstTime, src2Time, &parentCommand);
             dstChannel->deleteKeyframe(dstKeyframe, &parentCommand);
         }
     }
 }
 
 QTEST_MAIN(KisKeyframingTest)
diff --git a/libs/image/tests/kis_processing_applicator_test.cpp b/libs/image/tests/kis_processing_applicator_test.cpp
index b18f58772a..3f9462d0a2 100644
--- a/libs/image/tests/kis_processing_applicator_test.cpp
+++ b/libs/image/tests/kis_processing_applicator_test.cpp
@@ -1,210 +1,210 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_processing_applicator_test.h"
 
 #include <QTest>
 
 #include <KoColor.h>
 #include <KoColorSpaceRegistry.h>
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_paint_device.h"
 
 #include "kis_undo_stores.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "kis_image.h"
 
 #include "testutil.h"
 
 /*
   +----------+
   |root      |
   | paint 2  |
   | paint 1  |
   +----------+
 */
 
 KisImageSP createImage(KisUndoStore *undoStore,
                        KisPaintLayerSP &paintLayer1,
                        KisPaintLayerSP &paintLayer2)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(undoStore, 300, 300, cs, "test");
 
     QRect fillRect1(50,50,100,100);
     QRect fillRect2(75,75,50,50);
 
     paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
     paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8);
 
     paintLayer1->paintDevice()->fill(fillRect1, KoColor(Qt::white, cs));
     paintLayer2->paintDevice()->fill(fillRect2, KoColor(Qt::red, cs));
 
     image->addNode(paintLayer1, image->rootLayer());
     image->addNode(paintLayer2, image->rootLayer());
 
     image->initialRefreshGraph();
 
     return image;
 }
 
 bool checkLayers(KisImageWSP image,
                  const QString &prefix)
 {
     KisNodeSP layer1 = image->rootLayer()->firstChild();
     KisNodeSP layer2 = layer1->nextSibling();
 
     QVector<QImage> images(3);
     images[0] = image->projection()->convertToQImage(0, 0, 0, 300, 300);
     images[1] = layer1->paintDevice()->convertToQImage(0, 0, 0, 300, 300);
     images[2] = layer2->paintDevice()->convertToQImage(0, 0, 0, 300, 300);
 
     QVector<QString> names(3);
     names[0] = QString("applicator_") + prefix + "_projection.png";
     names[1] = QString("applicator_") + prefix + "_layer1.png";
     names[2] = QString("applicator_") + prefix + "_layer2.png";
 
     bool valid = true;
     for(int i = 0; i < 3; i++) {
         QImage ref(QString(FILES_DATA_DIR) + QDir::separator() +
                    "applicator" + QDir::separator() + names[i]);
 
         QPoint temp;
 
         if(!TestUtil::compareQImages(temp, ref, images[i], 1)) {
             dbgKrita << "--- Wrong image:" << names[i];
             valid = false;
             images[i].save(QString(FILES_OUTPUT_DIR) + QDir::separator() + names[i]);
         }
     }
 
     return valid;
 }
 
 
 void KisProcessingApplicatorTest::testNonRecursiveProcessing()
 {
     KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
     KisPaintLayerSP paintLayer1;
     KisPaintLayerSP paintLayer2;
     KisImageSP image = createImage(undoStore, paintLayer1, paintLayer2);
 
     QRect cropRect1(25,25,75,75);
     QRect cropRect2(100,100,50,50);
 
     QVERIFY(checkLayers(image, "initial"));
 
     {
         KisProcessingApplicator applicator(image, paintLayer1,
                                            KisProcessingApplicator::NONE);
 
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(cropRect1, true, false);
         applicator.applyVisitor(visitor);
         applicator.end();
         image->waitForDone();
     }
 
     QVERIFY(checkLayers(image, "crop_l1"));
 
     {
         KisProcessingApplicator applicator(image, paintLayer2,
                                            KisProcessingApplicator::NONE);
 
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(cropRect2, true, false);
         applicator.applyVisitor(visitor);
         applicator.end();
         image->waitForDone();
     }
 
     QVERIFY(checkLayers(image, "crop_l2"));
 
     undoStore->undo();
     image->waitForDone();
     QVERIFY(checkLayers(image, "crop_l1"));
 
     undoStore->undo();
     image->waitForDone();
     QVERIFY(checkLayers(image, "initial"));
 }
 
 void KisProcessingApplicatorTest::testRecursiveProcessing()
 {
     KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
     KisPaintLayerSP paintLayer1;
     KisPaintLayerSP paintLayer2;
     KisImageSP image = createImage(undoStore, paintLayer1, paintLayer2);
 
     QRect cropRect1(40,40,86,86);
 
     QVERIFY(checkLayers(image, "recursive_initial"));
 
     {
         KisProcessingApplicator applicator(image, image->rootLayer(),
                                            KisProcessingApplicator::RECURSIVE);
 
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(cropRect1, true, true);
         applicator.applyVisitor(visitor);
         applicator.end();
         image->waitForDone();
     }
 
     QVERIFY(checkLayers(image, "recursive_crop"));
 
     undoStore->undo();
     image->waitForDone();
     QVERIFY(checkLayers(image, "recursive_initial"));
 }
 
 void KisProcessingApplicatorTest::testNoUIUpdates()
 {
     KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
     KisPaintLayerSP paintLayer1;
     KisPaintLayerSP paintLayer2;
     KisImageSP image = createImage(undoStore, paintLayer1, paintLayer2);
-    QSignalSpy uiSignalsCounter(image.data(), SIGNAL(sigImageUpdated(const QRect&)));
+    QSignalSpy uiSignalsCounter(image.data(), SIGNAL(sigImageUpdated(QRect)));
 
     QRect cropRect1(40,40,86,86);
 
     {
         KisProcessingApplicator applicator(image, image->rootLayer(),
                                            KisProcessingApplicator::RECURSIVE |
                                            KisProcessingApplicator::NO_UI_UPDATES);
 
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(cropRect1, true, true);
         applicator.applyVisitor(visitor);
         applicator.end();
         image->waitForDone();
     }
 
     QCOMPARE(uiSignalsCounter.size(), 0);
 
     uiSignalsCounter.clear();
 
     undoStore->undo();
     image->waitForDone();
 
     QCOMPARE(uiSignalsCounter.size(), 0);
 }
 
 QTEST_MAIN(KisProcessingApplicatorTest)
diff --git a/libs/libqml/plugins/kritasketchplugin/models/CompositeOpModel.cpp b/libs/libqml/plugins/kritasketchplugin/models/CompositeOpModel.cpp
index 00713b23f0..919f1d8f45 100644
--- a/libs/libqml/plugins/kritasketchplugin/models/CompositeOpModel.cpp
+++ b/libs/libqml/plugins/kritasketchplugin/models/CompositeOpModel.cpp
@@ -1,482 +1,482 @@
 /*
     Copyright (C) 2012  Dan Leinir Turthra Jensen <admin@leinir.dk>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 
 #include "CompositeOpModel.h"
 #include <kis_composite_ops_model.h>
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_tool.h>
 #include <kis_canvas2.h>
 #include <input/kis_input_manager.h>
 #include <kis_node_manager.h>
 #include <kis_node.h>
 #include <kis_layer.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoColorSpace.h>
 #include <KoToolManager.h>
 
 class CompositeOpModel::Private
 {
 public:
     Private(CompositeOpModel* qq)
         : q(qq)
         , model(new KisCompositeOpListModel())
         , view(0)
         , eraserMode(0)
         , opacity(0)
         , opacityEnabled(false)
         , flow(0)
         , flowEnabled(false)
         , size(0)
         , sizeEnabled(false)
         , presetsEnabled(true)
     {};
 
     CompositeOpModel* q;
     KisCompositeOpListModel* model;
     KisViewManager* view;
     QString currentCompositeOpID;
     QString prevCompositeOpID;
     bool eraserMode;
     QMap<KisPaintOpPreset*, KisPaintOpConfigWidget*> settingsWidgets;
 
     qreal opacity;
     bool opacityEnabled;
     qreal flow;
     bool flowEnabled;
     qreal size;
     bool sizeEnabled;
     bool presetsEnabled;
     KisPaintOpPresetSP currentPreset;
 
     void updateCompositeOp(QString compositeOpID)
     {
         if (!view)
             return;
 
         KisNodeSP node = view->resourceProvider()->currentNode();
 
         if (node && node->paintDevice())
         {
             if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
                 compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
             if (compositeOpID != currentCompositeOpID)
             {
                 q->setEraserMode(compositeOpID == COMPOSITE_ERASE);
                 currentPreset->settings()->setProperty("CompositeOp", compositeOpID);
                 //m_optionWidget->setConfiguration(m_activePreset->settings().data());
                 view->resourceProvider()->setCurrentCompositeOp(compositeOpID);
                 prevCompositeOpID = currentCompositeOpID;
                 currentCompositeOpID = compositeOpID;
             }
         }
         emit q->currentCompositeOpIDChanged();
     }
 
     void ofsChanged()
     {
         if (presetsEnabled && !currentPreset.isNull() && !currentPreset->settings().isNull())
         {
             // IMPORTANT: set the PaintOp size before setting the other properties
             //            it wont work the other way
             //qreal sizeDiff = size - currentPreset->settings()->paintOpSize();
             //currentPreset->settings()->changePaintOpSize(sizeDiff, 0);
 
             if (currentPreset->settings()->hasProperty("OpacityValue"))
                 currentPreset->settings()->setProperty("OpacityValue", opacity);
 
             if (currentPreset->settings()->hasProperty("FlowValue"))
                 currentPreset->settings()->setProperty("FlowValue", flow);
 
             //m_optionWidget->setConfiguration(d->currentPreset->settings().data());
         }
         if (view)
         {
             view->resourceProvider()->setOpacity(opacity);
         }
     }
 };
 
 CompositeOpModel::CompositeOpModel(QObject* parent)
     : QAbstractListModel(parent)
     , d(new Private(this))
 {
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
             this, SLOT(slotToolChanged(KoCanvasController*,int)));
 
 }
 
 CompositeOpModel::~CompositeOpModel()
 {
     delete d;
 }
 
 QHash<int, QByteArray> CompositeOpModel::roleNames() const
 {
     QHash<int,QByteArray> roles;
     roles[TextRole] = "text";
     roles[IsCategoryRole] = "isCategory";
     return roles;
 }
 
 QVariant CompositeOpModel::data(const QModelIndex& index, int role) const
 {
     QVariant data;
     if (index.isValid())
     {
         QModelIndex otherIndex = d->model->index(index.row(), index.column(), QModelIndex());
         switch(role)
         {
             case TextRole:
                 data = d->model->data(otherIndex, Qt::DisplayRole);
                 break;
             case IsCategoryRole:
                 data = d->model->data(otherIndex, __CategorizedListModelBase::IsHeaderRole);
                 break;
             default:
                 break;
         }
     }
     return data;
 }
 
 int CompositeOpModel::rowCount(const QModelIndex& parent) const
 {
     if (parent.isValid())
         return 0;
     return d->model->rowCount(QModelIndex());
 }
 
 void CompositeOpModel::activateItem(int index)
 {
     if (index > -1 && index < d->model->rowCount(QModelIndex()))
     {
         KoID compositeOp;
         if (d->model->entryAt(compositeOp, d->model->index(index)))
             d->updateCompositeOp(compositeOp.id());
     }
 }
 
 QObject* CompositeOpModel::view() const
 {
     return d->view;
 }
 
 void CompositeOpModel::setView(QObject* newView)
 {
     if (d->view)
     {
         d->view->canvasBase()->disconnect(this);
         d->view->canvasBase()->globalInputManager()->disconnect(this);
         d->view->nodeManager()->disconnect(this);
     }
     d->view = qobject_cast<KisViewManager*>( newView );
     if (d->view)
     {
         if (d->view->canvasBase() && d->view->canvasBase()->resourceManager()) {
-            connect(d->view->canvasBase()->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
-                    this, SLOT(resourceChanged(int, const QVariant&)));
+            connect(d->view->canvasBase()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+                    this, SLOT(resourceChanged(int,QVariant)));
         }
         if (d->view->nodeManager()) {
             connect(d->view->nodeManager(), SIGNAL(sigLayerActivated(KisLayerSP)),
                     this, SLOT(currentNodeChanged(KisLayerSP)));
         }
         slotToolChanged(0, 0);
     }
     emit viewChanged();
 }
 
 bool CompositeOpModel::eraserMode() const
 {
     return d->eraserMode;
 }
 
 void CompositeOpModel::setEraserMode(bool newEraserMode)
 {
     if (d->eraserMode != newEraserMode)
     {
         d->eraserMode = newEraserMode;
         if (d->eraserMode)
             d->updateCompositeOp(COMPOSITE_ERASE);
         else
             d->updateCompositeOp(d->prevCompositeOpID);
         emit eraserModeChanged();
     }
 }
 
 qreal CompositeOpModel::flow() const
 {
     return d->flow;
 }
 
 void CompositeOpModel::setFlow(qreal newFlow)
 {
     if (d->flow != newFlow)
     {
         d->flow = newFlow;
         d->ofsChanged();
         emit flowChanged();
     }
 }
 
 bool CompositeOpModel::flowEnabled() const
 {
     return d->flowEnabled;
 }
 
 void CompositeOpModel::setFlowEnabled(bool newFlowEnabled)
 {
     d->flowEnabled = newFlowEnabled;
     emit flowEnabledChanged();
 }
 
 qreal CompositeOpModel::opacity() const
 {
     return d->opacity;
 }
 
 void CompositeOpModel::setOpacity(qreal newOpacity)
 {
     if (d->opacity != newOpacity)
     {
         d->opacity = newOpacity;
         d->ofsChanged();
         emit opacityChanged();
     }
 }
 
 bool CompositeOpModel::opacityEnabled() const
 {
     return d->opacityEnabled;
 }
 
 void CompositeOpModel::setOpacityEnabled(bool newOpacityEnabled)
 {
     d->opacityEnabled = newOpacityEnabled;
     emit opacityEnabledChanged();
 }
 
 qreal CompositeOpModel::size() const
 {
     return d->size;
 }
 
 void CompositeOpModel::setSize(qreal newSize)
 {
     if (d->size != newSize)
     {
         d->size = newSize;
         d->ofsChanged();
         emit sizeChanged();
     }
 }
 
 bool CompositeOpModel::sizeEnabled() const
 {
     return d->sizeEnabled;
 }
 
 void CompositeOpModel::setSizeEnabled(bool newSizeEnabled)
 {
     d->sizeEnabled = newSizeEnabled;
     emit sizeEnabledChanged();
 }
 
 void CompositeOpModel::changePaintopValue(QString propertyName, QVariant value)
 {
     if (propertyName == "size" && value.toReal() != d->size)
         setSize(value.toReal());
     else if (propertyName == "opacity" && value.toReal() != d->opacity)
         setOpacity(value.toReal());
     else if (propertyName == "flow" && value.toReal() != d->flow)
         setFlow(value.toReal());
 }
 
 bool CompositeOpModel::mirrorHorizontally() const
 {
     if (d->view)
         return d->view->resourceProvider()->mirrorHorizontal();
     return false;
 }
 
 void CompositeOpModel::setMirrorHorizontally(bool newMirrorHorizontally)
 {
     if (d->view && d->view->resourceProvider()->mirrorHorizontal() != newMirrorHorizontally)
     {
         d->view->resourceProvider()->setMirrorHorizontal(newMirrorHorizontally);
         emit mirrorHorizontallyChanged();
     }
 }
 
 bool CompositeOpModel::mirrorVertically() const
 {
     if (d->view)
         return d->view->resourceProvider()->mirrorVertical();
     return false;
 }
 
 void CompositeOpModel::setMirrorVertically(bool newMirrorVertically)
 {
     if (d->view && d->view->resourceProvider()->mirrorVertical() != newMirrorVertically)
     {
         d->view->resourceProvider()->setMirrorVertical(newMirrorVertically);
         emit mirrorVerticallyChanged();
     }
 }
 
 void CompositeOpModel::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!d->view) return;
     if (!d->view->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(d->view->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             //setWidgetState(ENABLE_COMPOSITEOP|ENABLE_OPACITY);
             d->opacityEnabled = true;
         }
         else {
             //setWidgetState(DISABLE_COMPOSITEOP|DISABLE_OPACITY);
             d->opacityEnabled = false;
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             d->flowEnabled = true;
             d->sizeEnabled = true;
             d->presetsEnabled = true;
         }
         else {
             d->flowEnabled = false;
             d->sizeEnabled = false;
             d->presetsEnabled = false;
         }
     }
     else {
         d->opacityEnabled = false;
         d->flowEnabled = false;
         d->sizeEnabled = false;
     }
     emit opacityEnabledChanged();
     emit flowEnabledChanged();
     emit sizeEnabledChanged();
 }
 
 void CompositeOpModel::resourceChanged(int key, const QVariant& /*v*/)
 {
     if (d->view && d->view->canvasBase() && d->view->canvasBase()->resourceManager() && d->view->resourceProvider()) {
 
         if (key == KisCanvasResourceProvider::MirrorHorizontal) {
             emit mirrorHorizontallyChanged();
             return;
         }
         else if(key == KisCanvasResourceProvider::MirrorVertical) {
             emit mirrorVerticallyChanged();
             return;
         }
 
         KisPaintOpPresetSP preset = d->view->canvasBase()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 
         if (preset && d->currentPreset.data() != preset.data()) {
             d->currentPreset = preset;
             if (!d->settingsWidgets.contains(preset.data())) {
                 d->settingsWidgets[preset.data()] = KisPaintOpRegistry::instance()->get(preset->paintOp().id())->createConfigWidget(0);
                 d->settingsWidgets[preset.data()]->setImage(d->view->image());
                 d->settingsWidgets[preset.data()]->setConfiguration(preset->settings());
             }
 
             if (d->settingsWidgets[preset.data()]) {
                 preset->settings()->setOptionsWidget(d->settingsWidgets[preset.data()]);
             }
 
             d->size = preset->settings()->paintOpSize();
             emit sizeChanged();
 
             if (preset->settings()->hasProperty("OpacityValue"))  {
                 d->opacityEnabled = true;
                 d->opacity = preset->settings()->getProperty("OpacityValue").toReal();
             }
             else {
                 d->opacityEnabled = false;
                 d->opacity = 1;
             }
 
             d->view->resourceProvider()->setOpacity(d->opacity);
             emit opacityChanged();
             emit opacityEnabledChanged();
 
             if (preset->settings()->hasProperty("FlowValue")) {
                 d->flowEnabled = true;
                 d->flow = preset->settings()->getProperty("FlowValue").toReal();
             }
             else {
                 d->flowEnabled = false;
                 d->flow = 1;
             }
             emit flowChanged();
             emit flowEnabledChanged();
 
             QString compositeOp = preset->settings()->getString("CompositeOp");
 
             // This is a little odd, but the logic here is that the opposite of an eraser is a normal composite op (so we just select over, aka normal)
             // This means that you can switch your eraser over to being a painting tool by turning off the eraser again.
             if (compositeOp == COMPOSITE_ERASE) {
                 d->currentCompositeOpID = COMPOSITE_OVER;
                 d->eraserMode = true;
             }
             else {
                 d->eraserMode = false;
             }
             emit eraserModeChanged();
             d->updateCompositeOp(compositeOp);
         }
     }
 }
 
 void CompositeOpModel::currentNodeChanged(KisLayerSP newNode)
 {
     Q_UNUSED(newNode);
     if (d->eraserMode) {
         d->eraserMode = false;
         d->updateCompositeOp(d->prevCompositeOpID);
         emit eraserModeChanged();
     }
 }
 
 int CompositeOpModel::indexOf(QString compositeOpId)
 {
     return d->model->indexOf(KoID(compositeOpId)).row();
 }
 
 QString CompositeOpModel::currentCompositeOpID() const
 {
     return d->currentCompositeOpID;
 }
 
diff --git a/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp b/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp
index c6beaa1428..a081409cbb 100644
--- a/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp
+++ b/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp
@@ -1,984 +1,984 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Dan Leinir Turthra Jensen <admin@leinir.dk>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "LayerModel.h"
 #include "LayerThumbProvider.h"
 #include <PropertyContainer.h>
 #include <kis_node_model.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_node_manager.h>
 #include <kis_dummies_facade_base.h>
 #include <KisDocument.h>
 #include <kis_composite_ops_model.h>
 #include <kis_node.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_shape_controller.h>
 #include <kis_adjustment_layer.h>
 #include <kis_selection_manager.h>
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <filter/kis_filter_registry.h>
 #include <KoShapeControllerBase.h>
 #include <KoProperties.h>
 #include <QQmlEngine>
 #include <kis_base_node.h>
 #include "KisSelectionActionsAdapter.h"
 
 struct LayerModelMetaInfo {
     LayerModelMetaInfo()
     : canMoveUp(false)
     , canMoveRight(false)
     , canMoveDown(false)
     , canMoveLeft(false)
     , depth(-1)
     {}
     bool canMoveUp;
     bool canMoveRight;
     bool canMoveDown;
     bool canMoveLeft;
     int depth;
 };
 
 class LayerModel::Private {
 public:
     Private(LayerModel* qq)
         : q(qq)
         , nodeModel(new KisNodeModel(qq))
         , aboutToRemoveRoots(false)
         , canvas(0)
         , nodeManager(0)
         , image(0)
         , activeNode(0)
         , declarativeEngine(0)
         , thumbProvider(0)
         , updateActiveLayerWithNewFilterConfigTimer(new QTimer(qq))
         , imageChangedTimer(new QTimer(qq))
     {
         QList<KisFilterSP> tmpFilters = KisFilterRegistry::instance()->values();
         Q_FOREACH (const KisFilterSP& filter, tmpFilters)
         {
             filters[filter.data()->id()] = filter.data();
         }
         updateActiveLayerWithNewFilterConfigTimer->setInterval(0);
         updateActiveLayerWithNewFilterConfigTimer->setSingleShot(true);
         connect(updateActiveLayerWithNewFilterConfigTimer, SIGNAL(timeout()), qq, SLOT(updateActiveLayerWithNewFilterConfig()));
 
         imageChangedTimer->setInterval(250);
         imageChangedTimer->setSingleShot(true);
         connect(imageChangedTimer, SIGNAL(timeout()), qq, SLOT(imageHasChanged()));
     }
 
     LayerModel* q;
     QList<KisNodeSP> layers;
     QHash<const KisNode*, LayerModelMetaInfo> layerMeta;
     KisNodeModel* nodeModel;
     bool aboutToRemoveRoots;
     KisViewManager* view;
     KisCanvas2* canvas;
     QScopedPointer<KisSelectionActionsAdapter> selectionActionsAdapter;
     QPointer<KisNodeManager> nodeManager;
     KisImageWSP image;
     KisNodeSP activeNode;
     QQmlEngine* declarativeEngine;
     LayerThumbProvider* thumbProvider;
     QHash<QString, const KisFilter*> filters;
 
     KisFilterConfigurationSP newConfig;
     QTimer* updateActiveLayerWithNewFilterConfigTimer;
 
     QTimer* imageChangedTimer;
     static int counter()
     {
         static int count = 0;
         return count++;
     }
 
     static QStringList layerClassNames()
     {
         QStringList list;
         list << "KisGroupLayer";
         list << "KisPaintLayer";
         list << "KisFilterMask";
         list << "KisAdjustmentLayer";
         return list;
     }
 
     int deepChildCount(KisNodeSP layer)
     {
         quint32 childCount = layer->childCount();
         QList<KisNodeSP> children = layer->childNodes(layerClassNames(), KoProperties());
         for(quint32 i = 0; i < childCount; ++i)
             childCount += deepChildCount(children.at(i));
         return childCount;
     }
 
     void rebuildLayerList(KisNodeSP layer = 0)
     {
         bool refreshingFromRoot = false;
         if (!image)
         {
             layers.clear();
             return;
         }
         if (layer == 0)
         {
             refreshingFromRoot = true;
             layers.clear();
             layer = image->rootLayer();
         }
         // implementation node: The root node is not a visible node, and so
         // is never added to the list of layers
         QList<KisNodeSP> children = layer->childNodes(layerClassNames(), KoProperties());
         if (children.count() == 0)
             return;
         for(quint32 i = children.count(); i > 0; --i)
         {
             layers << children.at(i-1);
             rebuildLayerList(children.at(i-1));
         }
 
         if (refreshingFromRoot)
             refreshLayerMovementAbilities();
     }
 
     void refreshLayerMovementAbilities()
     {
         layerMeta.clear();
         if (layers.count() == 0)
             return;
         for(int i = 0; i < layers.count(); ++i)
         {
             const KisNodeSP layer = layers.at(i);
             LayerModelMetaInfo ability;
 
             if (i > 0)
                 ability.canMoveUp = true;
 
             if (i < layers.count() - 1)
                 ability.canMoveDown = true;
 
             KisNodeSP parent = layer;
             while(parent)
             {
                 ++ability.depth;
                 parent = parent->parent();
             }
 
             if (ability.depth > 1)
                 ability.canMoveLeft = true;
 
             if (i < layers.count() - 1 && qobject_cast<const KisGroupLayer*>(layers.at(i + 1).constData()))
                 ability.canMoveRight = true;
 
             layerMeta[layer] = ability;
         }
     }
 };
 
 LayerModel::LayerModel(QObject* parent)
     : QAbstractListModel(parent)
     , d(new Private(this))
 {
 
-    connect(d->nodeModel, SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)),
-            this, SLOT(source_rowsAboutToBeInserted(QModelIndex, int, int)));
-    connect(d->nodeModel, SIGNAL(rowsInserted(QModelIndex, int, int)),
-            this, SLOT(source_rowsInserted(QModelIndex, int, int)));
-
-    connect(d->nodeModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)),
-            this, SLOT(source_rowsAboutToBeRemoved(QModelIndex, int, int)));
-    connect(d->nodeModel, SIGNAL(rowsRemoved(QModelIndex, int, int)),
-            this, SLOT(source_rowsRemoved(QModelIndex, int, int)));
+    connect(d->nodeModel, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
+            this, SLOT(source_rowsAboutToBeInserted(QModelIndex,int,int)));
+    connect(d->nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
+            this, SLOT(source_rowsInserted(QModelIndex,int,int)));
+
+    connect(d->nodeModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+            this, SLOT(source_rowsAboutToBeRemoved(QModelIndex,int,int)));
+    connect(d->nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+            this, SLOT(source_rowsRemoved(QModelIndex,int,int)));
 
     connect(d->nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(source_dataChanged(QModelIndex,QModelIndex)));
     connect(d->nodeModel, SIGNAL(modelReset()),
             this, SLOT(source_modelReset()));
 
     connect(d->nodeModel, SIGNAL(layoutAboutToBeChanged()), this, SIGNAL(layoutAboutToBeChanged()));
     connect(d->nodeModel, SIGNAL(layoutChanged()), this, SIGNAL(layoutChanged()));
 }
 
 LayerModel::~LayerModel()
 {
     delete d;
 }
 
 QHash<int, QByteArray> LayerModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
     roles[IconRole] = "icon";
     roles[NameRole] = "name";
     roles[ActiveLayerRole] = "activeLayer";
     roles[OpacityRole] = "opacity";
     roles[PercentOpacityRole] = "percentOpacity";
     roles[VisibleRole] = "visible";
     roles[CompositeDetailsRole] = "compositeDetails";
     roles[FilterRole] = "filter";
     roles[ChildCountRole] = "childCount";
     roles[DeepChildCountRole] = "deepChildCount";
     roles[DepthRole] = "depth";
     roles[PreviousItemDepthRole] = "previousItemDepth";
     roles[NextItemDepthRole] = "nextItemDepth";
     roles[CanMoveDownRole] = "canMoveDown";
     roles[CanMoveLeftRole] = "canMoveLeft";
     roles[CanMoveRightRole] = "canMoveRight";
     roles[CanMoveUpRole] = "canMoveUp";
 
     return roles;
 }
 
 QObject* LayerModel::view() const
 {
     return d->view;
 }
 
 void LayerModel::setView(QObject *newView)
 {
     KisViewManager* view = qobject_cast<KisViewManager*>(newView);
     // This has to happen very early, and we will be filling it back up again soon anyway...
     if (d->canvas) {
         d->canvas->disconnectCanvasObserver(this);
         disconnect(d->image, 0, this, 0);
         disconnect(d->nodeManager, 0, this, 0);
         disconnect(d->nodeModel, 0, d->nodeManager, 0);
         disconnect(d->nodeModel, SIGNAL(nodeActivated(KisNodeSP)), this, SLOT(currentNodeChanged(KisNodeSP)));
         d->image = 0;
         d->nodeManager = 0;
         d->layers.clear();
         d->activeNode.clear();
         d->canvas = 0;
         d->nodeModel->setDummiesFacade(0, 0, 0, 0, 0, 0, 0);
         d->selectionActionsAdapter.reset();
 
     }
 
     d->view = view;
     if (!d->view) {
         return;
     }
 
     d->canvas = view->canvasBase();
     d->thumbProvider = new LayerThumbProvider();
     d->thumbProvider->setLayerModel(this);
     d->thumbProvider->setLayerID(Private::counter());
 // QT5TODO: results in a crash
      d->declarativeEngine->addImageProvider(QString("layerthumb%1").arg(d->thumbProvider->layerID()), d->thumbProvider);
 
     if (d->canvas) {
         d->image = d->canvas->imageView()->image();
         d->nodeManager = d->canvas->viewManager()->nodeManager();
 
         KisDummiesFacadeBase *kritaDummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(d->canvas->imageView()->document()->shapeController());
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(d->canvas->imageView()->document()->shapeController());
 
         d->selectionActionsAdapter.reset(new KisSelectionActionsAdapter(d->canvas->viewManager()->selectionManager()));
         d->nodeModel->setDummiesFacade(kritaDummiesFacade,
                                        d->image,
                                        shapeController,
                                        d->nodeManager->nodeSelectionAdapter(),
                                        d->nodeManager->nodeInsertionAdapter(),
                                        d->selectionActionsAdapter.data(),
                                        d->nodeManager->nodeDisplayModeAdapter());
 
         connect(d->image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(d->image, SIGNAL(sigNodeChanged(KisNodeSP)), SLOT(nodeChanged(KisNodeSP)));
         connect(d->image, SIGNAL(sigImageUpdated(QRect)), SLOT(imageChanged()));
         connect(d->image, SIGNAL(sigRemoveNodeAsync(KisNodeSP)), SLOT(aboutToRemoveNode(KisNodeSP)));
 
         // cold start
         currentNodeChanged(d->nodeManager->activeNode());
 
         // Connection KisNodeManager -> KisLayerBox
         connect(d->nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)), this, SLOT(currentNodeChanged(KisNodeSP)));
 
         d->rebuildLayerList();
         beginResetModel();
         endResetModel();
     }
 }
 
 QObject* LayerModel::engine() const
 {
     return d->declarativeEngine;
 }
 
 void LayerModel::setEngine(QObject* newEngine)
 {
     d->declarativeEngine = qobject_cast<QQmlEngine*>(newEngine);
     emit engineChanged();
 }
 
 QString LayerModel::fullImageThumbUrl() const
 {
     return QString("image://layerthumb%1/fullimage/%2").arg(d->thumbProvider->layerID()).arg(QDateTime::currentMSecsSinceEpoch());
 }
 
 void LayerModel::currentNodeChanged(KisNodeSP newActiveNode)
 {
     if (!d->activeNode.isNull()) {
         QModelIndex oldIndex = d->nodeModel->indexFromNode(d->activeNode);
         source_dataChanged(oldIndex, oldIndex);
     }
     d->activeNode = newActiveNode;
     emitActiveChanges();
     if (!d->activeNode.isNull()) {
         QModelIndex oldIndex = d->nodeModel->indexFromNode(d->activeNode);
         source_dataChanged(oldIndex, oldIndex);
     }
 }
 
 QVariant LayerModel::data(const QModelIndex& index, int role) const
 {
     QVariant data;
     if (index.isValid()) {
         index.internalPointer();
         KisNodeSP node = d->layers.at(index.row());
         if (node.isNull())
             return data;
         KisNodeSP parent;
         switch(role)
         {
         case IconRole:
             if (dynamic_cast<const KisGroupLayer*>(node.constData()))
                 data = QLatin1String("../images/svg/icon-layer_group-black.svg");
             else if (dynamic_cast<const KisFilterMask*>(node.constData()))
                 data = QLatin1String("../images/svg/icon-layer_filter-black.svg");
             else if (dynamic_cast<const KisAdjustmentLayer*>(node.constData()))
                 data = QLatin1String("../images/svg/icon-layer_filter-black.svg");
             else
                 // We add the currentMSecsSinceEpoch to ensure we force an update (even with cache turned
                 // off, we still apparently get some caching behaviour on delegates in QML)
                 data = QString("image://layerthumb%1/%2/%3").arg(d->thumbProvider->layerID()).arg(index.row()).arg(QDateTime::currentMSecsSinceEpoch());
             break;
         case NameRole:
             data = node->name();
             break;
         case ActiveLayerRole:
             data = (node == d->activeNode);
             break;
         case OpacityRole:
             data = node->opacity();
             break;
         case PercentOpacityRole:
             data = node->percentOpacity();
             break;
         case VisibleRole:
             data = node->visible();
             break;
         case CompositeDetailsRole:
             // composite op goes here...
             if (node->compositeOp())
                 data = node->compositeOp()->description();
             break;
         case FilterRole:
             break;
         case ChildCountRole:
             data = node->childNodes(d->layerClassNames(), KoProperties()).count();
             break;
         case DeepChildCountRole:
             data = d->deepChildCount(d->layers.at(index.row()));
             break;
         case DepthRole:
             data = d->layerMeta[node.data()].depth;
             break;
         case PreviousItemDepthRole:
             if (index.row() == 0)
                 data = -1;
             else
                 data = d->layerMeta[d->layers[index.row() - 1].data()].depth;
             break;
         case NextItemDepthRole:
             if (index.row() == d->layers.count() - 1)
                 data = -1;
             else
                 data = d->layerMeta[d->layers[index.row() + 1].data()].depth;
             break;
         case CanMoveDownRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveDown;
             break;
         case CanMoveLeftRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveLeft;
             break;
         case CanMoveRightRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveRight;
             break;
         case CanMoveUpRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveUp;
             break;
         default:
             break;
         }
     }
     return data;
 }
 
 int LayerModel::rowCount(const QModelIndex& parent) const
 {
     if ( parent.isValid() ) {
         return 0;
     }
     return d->layers.count();
 }
 
 QVariant LayerModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     return QAbstractItemModel::headerData(section, orientation, role);
 }
 
 void LayerModel::setActive(int index)
 {
     if (index > -1 && index < d->layers.count()) {
         KisNodeSP newNode = d->layers.at(index);
         d->nodeManager->slotUiActivatedNode(newNode);
         currentNodeChanged(newNode);
     }
 }
 
 void LayerModel::moveUp()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!d->nodeManager->activeNode()->nextSibling()) {
         //dbgKrita << "Active node apparently has no next sibling, however that has happened...";
         if (!grandParent)
             return;
         //dbgKrita << "Node has grandparent";
         if (!grandParent->parent() && node->inherits("KisMask"))
             return;
         //dbgKrita << "Node isn't a mask";
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
     }
     else {
         //dbgKrita << "Move node directly";
         d->nodeManager->lowerNode();
     }
 }
 
 void LayerModel::moveDown()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!d->nodeManager->activeNode()->prevSibling()) {
         //dbgKrita << "Active node apparently has no previous sibling, however that has happened...";
         if (!grandParent)
             return;
         //dbgKrita << "Node has grandparent";
         if (!grandParent->parent() && node->inherits("KisMask"))
             return;
         //dbgKrita << "Node isn't a mask";
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
     } else
     {
         //dbgKrita << "Move node directly";
         d->nodeManager->raiseNode();
     }
 }
 
 void LayerModel::moveLeft()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
     quint16 nodeIndex = parent->index(node);
 
     if (!grandParent)
         return;
     if (!grandParent->parent() && node->inherits("KisMask"))
         return;
 
     if (nodeIndex <= parent->childCount() / 2) {
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
     }
     else {
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
     }
 }
 
 void LayerModel::moveRight()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = d->nodeManager->activeNode()->parent();
     KisNodeSP newParent;
     int nodeIndex = parent->index(node);
     int indexAbove = nodeIndex + 1;
     int indexBelow = nodeIndex - 1;
 
     if (parent->at(indexBelow) && parent->at(indexBelow)->allowAsChild(node)) {
         newParent = parent->at(indexBelow);
         d->nodeManager->moveNodeAt(node, newParent, newParent->childCount());
     }
     else if (parent->at(indexAbove) && parent->at(indexAbove)->allowAsChild(node)) {
         newParent = parent->at(indexAbove);
         d->nodeManager->moveNodeAt(node, newParent, 0);
     }
     else {
         return;
     }
 }
 
 void LayerModel::clear()
 {
     d->canvas->viewManager()->selectionManager()->clear();
 }
 
 void LayerModel::clone()
 {
     d->nodeManager->duplicateActiveNode();
 }
 
 void LayerModel::setLocked(int index, bool newLocked)
 {
     if (index > -1 && index < d->layers.count()) {
         if(d->layers[index]->userLocked() == newLocked)
             return;
         d->layers[index]->setUserLocked(newLocked);
         QModelIndex idx = createIndex(index, 0);
         dataChanged(idx, idx);
     }
 }
 
 void LayerModel::setOpacity(int index, float newOpacity)
 {
     if (index > -1 && index < d->layers.count()) {
         if(qFuzzyCompare(d->layers[index]->opacity() + 1, newOpacity + 1))
             return;
         d->layers[index]->setOpacity(newOpacity);
         d->layers[index]->setDirty();
         QModelIndex idx = createIndex(index, 0);
         dataChanged(idx, idx);
     }
 }
 
 void LayerModel::setVisible(int index, bool newVisible)
 {
     if (index > -1 && index < d->layers.count()) {
         KisBaseNode::PropertyList props = d->layers[index]->sectionModelProperties();
         if(props[0].state == newVisible)
             return;
         KisBaseNode::Property prop = props[0];
         prop.state = newVisible;
         props[0] = prop;
         d->nodeModel->setData( d->nodeModel->indexFromNode(d->layers[index]), QVariant::fromValue<KisBaseNode::PropertyList>(props), KisNodeModel::PropertiesRole );
         d->layers[index]->setDirty(d->layers[index]->extent());
         QModelIndex idx = createIndex(index, 0);
         dataChanged(idx, idx);
     }
 }
 
 QImage LayerModel::layerThumbnail(QString layerID) const
 {
     // So, yeah, this is a complete cheatery hack. However, it ensures
     // we actually get updates when we want them (every time the image is supposed
     // to be changed). Had hoped we could avoid it, but apparently not.
     int index = layerID.section(QChar('/'), 0, 0).toInt();
     QImage thumb;
     if (index > -1 && index < d->layers.count()) {
         if (d->thumbProvider)
             thumb = d->layers[index]->createThumbnail(120, 120);
     }
     return thumb;
 }
 
 void LayerModel::deleteCurrentLayer()
 {
     d->activeNode.clear();
     d->nodeManager->removeNode();
 }
 
 void LayerModel::deleteLayer(int index)
 {
     if (index > -1 && index < d->layers.count()) {
         if (d->activeNode == d->layers.at(index))
             d->activeNode.clear();
         d->nodeManager->slotUiActivatedNode(d->layers.at(index));
         d->nodeManager->removeNode();
         d->rebuildLayerList();
         beginResetModel();
         endResetModel();
     }
 }
 
 void LayerModel::addLayer(int layerType)
 {
     switch(layerType) {
         case 0:
             d->nodeManager->createNode("KisPaintLayer");
             break;
         case 1:
             d->nodeManager->createNode("KisGroupLayer");
             break;
         case 2:
             d->nodeManager->createNode("KisFilterMask", true);
             break;
         default:
             break;
     }
 }
 
 void LayerModel::source_rowsAboutToBeInserted(QModelIndex /*p*/, int /*from*/, int /*to*/)
 {
     beginResetModel();
 }
 
 void LayerModel::source_rowsInserted(QModelIndex /*p*/, int, int)
 {
     d->rebuildLayerList();
     emit countChanged();
     endResetModel();
 }
 
 void LayerModel::source_rowsAboutToBeRemoved(QModelIndex /*p*/, int /*from*/, int /*to*/)
 {
     beginResetModel();
 }
 
 void LayerModel::source_rowsRemoved(QModelIndex, int, int)
 {
     d->rebuildLayerList();
     emit countChanged();
     endResetModel();
 }
 
 void LayerModel::source_dataChanged(QModelIndex /*tl*/, QModelIndex /*br*/)
 {
         QModelIndex top = createIndex(0, 0);
         QModelIndex bottom = createIndex(d->layers.count() - 1, 0);
         dataChanged(top, bottom);
 }
 
 void LayerModel::source_modelReset()
 {
     beginResetModel();
     d->rebuildLayerList();
     d->activeNode.clear();
     if (d->layers.count() > 0)
     {
         d->nodeManager->slotUiActivatedNode(d->layers.at(0));
         currentNodeChanged(d->layers.at(0));
     }
     emit countChanged();
     endResetModel();
 }
 
 void LayerModel::notifyImageDeleted()
 {
 }
 
 void LayerModel::nodeChanged(KisNodeSP node)
 {
     QModelIndex index = createIndex(d->layers.indexOf(node), 0);
     dataChanged(index, index);
 }
 
 void LayerModel::imageChanged()
 {
     d->imageChangedTimer->start();
 }
 
 void LayerModel::imageHasChanged()
 {
     QModelIndex top = createIndex(0, 0);
     QModelIndex bottom = createIndex(d->layers.count() - 1, 0);
     dataChanged(top, bottom);
 }
 
 void LayerModel::aboutToRemoveNode(KisNodeSP node)
 {
     Q_UNUSED(node)
     QTimer::singleShot(0, this, SLOT(source_modelReset()));
 }
 
 void LayerModel::emitActiveChanges()
 {
     emit activeFilterConfigChanged();
     emit activeNameChanged();
     emit activeTypeChanged();
     emit activeCompositeOpChanged();
     emit activeOpacityChanged();
     emit activeVisibleChanged();
     emit activeLockedChanged();
     emit activeRChannelActiveChanged();
     emit activeGChannelActiveChanged();
     emit activeBChannelActiveChanged();
     emit activeAChannelActiveChanged();
 }
 
 QString LayerModel::activeName() const
 {
     if (d->activeNode.isNull())
         return QString();
     return d->activeNode->name();
 }
 
 void LayerModel::setActiveName(QString newName)
 {
     if (d->activeNode.isNull())
         return;
     d->activeNode->setName(newName);
     emit activeNameChanged();
 }
 
 QString LayerModel::activeType() const
 {
     return d->activeNode->metaObject()->className();
 }
 
 int LayerModel::activeCompositeOp() const
 {
     if (d->activeNode.isNull())
         return 0;
     KoID entry(d->activeNode->compositeOp()->id());
     QModelIndex idx = KisCompositeOpListModel::sharedInstance()->indexOf(entry);
     if (idx.isValid())
         return idx.row();
     return 0;
 }
 
 void LayerModel::setActiveCompositeOp(int newOp)
 {
     if (d->activeNode.isNull())
         return;
     KoID entry;
     if (KisCompositeOpListModel::sharedInstance()->entryAt(entry, KisCompositeOpListModel::sharedInstance()->index(newOp)))
     {
         d->activeNode->setCompositeOpId(entry.id());
         d->activeNode->setDirty();
         emit activeCompositeOpChanged();
     }
 }
 
 int LayerModel::activeOpacity() const
 {
     if (d->activeNode.isNull())
         return 0;
     return d->activeNode->opacity();
 }
 
 void LayerModel::setActiveOpacity(int newOpacity)
 {
     d->activeNode->setOpacity(newOpacity);
     d->activeNode->setDirty();
     emit activeOpacityChanged();
 }
 
 bool LayerModel::activeVisible() const
 {    if (d->activeNode.isNull())
         return false;
     return d->activeNode->visible();
 }
 
 void LayerModel::setActiveVisible(bool newVisible)
 {
     if (d->activeNode.isNull())
         return;
     setVisible(d->layers.indexOf(d->activeNode), newVisible);
     emit activeVisibleChanged();
 }
 
 bool LayerModel::activeLocked() const
 {
     if (d->activeNode.isNull())
         return false;
     return d->activeNode->userLocked();
 }
 
 void LayerModel::setActiveLocked(bool newLocked)
 {
     if (d->activeNode.isNull())
         return;
     d->activeNode->setUserLocked(newLocked);
     emit activeLockedChanged();
 }
 
 bool LayerModel::activeAChannelActive() const
 {
     KisLayer* layer = qobject_cast<KisLayer*>(d->activeNode.data());
     bool state = false;
     if (layer)
         state = !layer->alphaChannelDisabled();
     return state;
 }
 
 void LayerModel::setActiveAChannelActive(bool newActive)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(d->activeNode.data());
     if (layer)
     {
         layer->disableAlphaChannel(!newActive);
         layer->setDirty();
         emit activeAChannelActiveChanged();
     }
 }
 
 
 bool getActiveChannel(KisNodeSP node, int channelIndex)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(node.data());
     bool flag = false;
     if (layer)
     {
         QBitArray flags = layer->channelFlags();
         if (channelIndex < flags.size()) {
             flag = flags[channelIndex];
         }
     }
     return flag;
 }
 
 void setChannelActive(KisNodeSP node, int channelIndex, bool newActive)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(node.data());
     if (layer) {
         QBitArray flags = layer->channelFlags();
         flags.setBit(channelIndex, newActive);
         layer->setChannelFlags(flags);
         layer->setDirty();
     }
 }
 
 bool LayerModel::activeBChannelActive() const
 {
     return getActiveChannel(d->activeNode, 2);
 }
 
 void LayerModel::setActiveBChannelActive(bool newActive)
 {
     setChannelActive(d->activeNode, 2, newActive);
     emit activeBChannelActiveChanged();
 }
 
 bool LayerModel::activeGChannelActive() const
 {
     return getActiveChannel(d->activeNode, 1);
 }
 
 void LayerModel::setActiveGChannelActive(bool newActive)
 {
     setChannelActive(d->activeNode, 1, newActive);
     emit activeGChannelActiveChanged();
 }
 
 bool LayerModel::activeRChannelActive() const
 {
     return getActiveChannel(d->activeNode, 0);
 }
 
 void LayerModel::setActiveRChannelActive(bool newActive)
 {
     setChannelActive(d->activeNode, 0, newActive);
     emit activeRChannelActiveChanged();
 }
 
 QObject* LayerModel::activeFilterConfig() const
 {
     QMap<QString, QVariant> props;
     QString filterId;
     KisFilterMask* filterMask = qobject_cast<KisFilterMask*>(d->activeNode.data());
     if (filterMask) {
         props = filterMask->filter()->getProperties();
         filterId = filterMask->filter()->name();
     }
     else {
         KisAdjustmentLayer* adjustmentLayer = qobject_cast<KisAdjustmentLayer*>(d->activeNode.data());
         if (adjustmentLayer)
         {
             props = adjustmentLayer->filter()->getProperties();
             filterId = adjustmentLayer->filter()->name();
         }
     }
     PropertyContainer* config = new PropertyContainer(filterId, 0);
     QMap<QString, QVariant>::const_iterator i;
     for(i = props.constBegin(); i != props.constEnd(); ++i) {
         config->setProperty(i.key().toLatin1(), i.value());
         //dbgKrita << "Getting active config..." << i.key() << i.value();
     }
     return config;
 }
 
 void LayerModel::setActiveFilterConfig(QObject* newConfig)
 {
     if (d->activeNode.isNull())
         return;
     PropertyContainer* config = qobject_cast<PropertyContainer*>(newConfig);
     if (!config)
         return;
 
     //dbgKrita << "Attempting to set new config" << config->name();
     KisFilterConfigurationSP realConfig = d->filters.value(config->name())->factoryConfiguration();
     QMap<QString, QVariant>::const_iterator i;
     for(i = realConfig->getProperties().constBegin(); i != realConfig->getProperties().constEnd(); ++i)
     {
         realConfig->setProperty(i.key(), config->property(i.key().toLatin1()));
         //dbgKrita << "Creating config..." << i.key() << i.value();
     }
 // The following code causes sporadic crashes, and disabling causes leaks. So, leaks it must be, for now.
 // The cause is the lack of a smart pointer interface for passing filter configs around
 // Must be remedied, but for now...
 //    if (d->newConfig)
 //        delete(d->newConfig);
     d->newConfig = realConfig;
     //d->updateActiveLayerWithNewFilterConfigTimer->start();
     updateActiveLayerWithNewFilterConfig();
 }
 
 void LayerModel::updateActiveLayerWithNewFilterConfig()
 {
     if (!d->newConfig)
         return;
     //dbgKrita << "Setting new config..." << d->newConfig->name();
     KisFilterMask* filterMask = qobject_cast<KisFilterMask*>(d->activeNode.data());
     if (filterMask)
     {
         //dbgKrita << "Filter mask";
         if (filterMask->filter() == d->newConfig)
             return;
         //dbgKrita << "Setting filter mask";
         filterMask->setFilter(d->newConfig);
     }
     else
     {
         KisAdjustmentLayer* adjustmentLayer = qobject_cast<KisAdjustmentLayer*>(d->activeNode.data());
         if (adjustmentLayer)
         {
             //dbgKrita << "Adjustment layer";
             if (adjustmentLayer->filter() == d->newConfig)
                 return;
             //dbgKrita << "Setting filter on adjustment layer";
             adjustmentLayer->setFilter(d->newConfig);
         }
         else
         {
             //dbgKrita << "UNKNOWN, BAIL OUT!";
         }
     }
     d->newConfig = 0;
     d->activeNode->setDirty(d->activeNode->extent());
     d->image->setModified();
     QTimer::singleShot(100, this, SIGNAL(activeFilterConfigChanged()));
 }
 
diff --git a/libs/libqml/plugins/kritasketchplugin/models/PresetModel.cpp b/libs/libqml/plugins/kritasketchplugin/models/PresetModel.cpp
index 424ba9ccef..fdbedcec42 100644
--- a/libs/libqml/plugins/kritasketchplugin/models/PresetModel.cpp
+++ b/libs/libqml/plugins/kritasketchplugin/models/PresetModel.cpp
@@ -1,217 +1,217 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Dan Leinir Turthra Jensen <admin@leinir.dk>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "PresetModel.h"
 
 #include <KoResourceServerAdapter.h>
 #include <KisResourceServerProvider.h>
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_canvas2.h>
 #include <kis_paintop_box.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_factory.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <kis_node.h>
 #include <kis_image.h>
 
 class PresetModel::Private {
 public:
     Private()
         : view(0)
     {
          rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     }
 
     KisPaintOpPresetResourceServer * rserver;
     QString currentPreset;
     KisViewManager* view;
 
     KisPaintOpPresetSP 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;
     }
 
     void setCurrentPaintop(const KoID& paintop, KisPaintOpPresetSP preset)
     {
         preset = (!preset) ? defaultPreset(paintop) : preset;
 
         Q_ASSERT(preset && preset->settings());
 
         // handle the settings and expose it through a a simple QObject property
         //m_optionWidget->setConfiguration(preset->settings());
 #if 0
         preset->settings()->setNode(view->resourceProvider()->currentNode());
 #endif
 
         view->resourceProvider()->setPaintOpPreset(preset);
     }
 };
 
 PresetModel::PresetModel(QObject *parent)
     : QAbstractListModel(parent)
     , d(new Private)
 {
 }
 
 PresetModel::~PresetModel()
 {
     delete d;
 }
 
 QHash<int, QByteArray> PresetModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
     roles[ImageRole] = "image";
     roles[TextRole] = "text";
     roles[NameRole] = "name";
 
     return roles;
 }
 
 int PresetModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid())
         return 0;
     return d->rserver->resources().count();
 }
 
 QVariant PresetModel::data(const QModelIndex &index, int role) const
 {
     QVariant result;
     if (index.isValid())
     {
         switch(role)
         {
         case ImageRole:
             result = QString("image://presetthumb/%1").arg(index.row());
             break;
         case TextRole:
             result = d->rserver->resources().at(index.row())->name().replace(QLatin1String("_"), QLatin1String(" "));
             break;
         case NameRole:
             result = d->rserver->resources().at(index.row())->name();
             break;
         default:
             result = "";
             break;
         }
     }
     return result;
 }
 
 QVariant PresetModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(orientation);
     QVariant result;
     if (section == 0)
     {
         switch(role)
         {
         case ImageRole:
             result = QString("Thumbnail");
             break;
         case TextRole:
             result = QString("Name");
             break;
         default:
             result = "";
             break;
         }
     }
     return result;
 }
 
 QObject* PresetModel::view() const
 {
     return d->view;
 }
 
 void PresetModel::setView(QObject* newView)
 {
     d->view = qobject_cast<KisViewManager*>( newView );
     if (d->view && d->view->canvasBase()) {
-        connect(d->view->canvasBase()->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
-                this, SLOT(resourceChanged(int, const QVariant&)));
+        connect(d->view->canvasBase()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+                this, SLOT(resourceChanged(int,QVariant)));
     }
     emit viewChanged();
 }
 
 QString PresetModel::currentPreset() const
 {
     return d->currentPreset;
 }
 
 void PresetModel::setCurrentPreset(QString presetName)
 {
     activatePreset(nameToIndex(presetName));
     // not emitting here, as that happens when the resource changes... this is more
     // a polite request than an actual setter, due to the nature of the resource system.
 }
 
 int PresetModel::nameToIndex(QString presetName) const
 {
     int index = 0;
     QList<KisPaintOpPresetSP> resources = d->rserver->resources();
     for(int i = 0; i < resources.count(); ++i)
     {
         if (resources.at(i)->name() == presetName || resources.at(i)->name().replace(QLatin1String("_"), QLatin1String(" ")) == presetName)
         {
             index = i;
             break;
         }
     }
     return index;
 }
 
 void PresetModel::activatePreset(int index)
 {
     if ( !d->view )
         return;
 
     QList<KisPaintOpPresetSP> resources = d->rserver->resources();
     if (index >= 0 && index < resources.count())  {
         KisPaintOpPresetSP preset = resources.at( index );
         d->setCurrentPaintop(preset->paintOp(), preset);
     }
 }
 
 void PresetModel::resourceChanged(int /*key*/, const QVariant& /*v*/)
 {
     if (d->view)
     {
         KisPaintOpPresetSP preset = d->view->canvasBase()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && d->currentPreset != preset->name())
         {
             d->currentPreset = preset->name();
             emit currentPresetChanged();
         }
     }
 }
 
diff --git a/libs/ui/KisAutoSaveRecoveryDialog.cpp b/libs/ui/KisAutoSaveRecoveryDialog.cpp
index 2ae547230a..10b33fb1e4 100644
--- a/libs/ui/KisAutoSaveRecoveryDialog.cpp
+++ b/libs/ui/KisAutoSaveRecoveryDialog.cpp
@@ -1,279 +1,279 @@
 /* This file is part of the KDE project
    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 "KisAutoSaveRecoveryDialog.h"
 
 #include <KoStore.h>
 
 #include <kwidgetitemdelegate.h>
 #include <klocalizedstring.h>
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QListView>
 #include <QAbstractTableModel>
 #include <QLabel>
 #include <QDir>
 #include <QFileInfo>
 #include <QDateTime>
 #include <QImage>
 #include <QPixmap>
 #include <QHeaderView>
 #include <QStyledItemDelegate>
 #include <QPainter>
 #include <QCheckBox>
 #include <kis_debug.h>
 
 
 struct FileItem {
 
     FileItem() : checked(true) {}
 
     QImage thumbnail;
     QString name;
     QString date;
     bool checked;
 };
 
 class FileItemDelegate : public KWidgetItemDelegate
 {
 public:
 
     FileItemDelegate(QAbstractItemView *itemView, KisAutoSaveRecoveryDialog *dlg)
         : KWidgetItemDelegate(itemView, dlg)
         , m_parent(dlg)
     {
     }
 
     QList<QWidget*> createItemWidgets(const QModelIndex& index) const override
     {
         // a lump of coal and a piece of elastic will get you through the world
         QWidget *page = new QWidget;
         QHBoxLayout *layout = new QHBoxLayout(page);
 
         QCheckBox *checkBox = new QCheckBox;
         checkBox->setProperty("fileitem", index.data());
 
         connect(checkBox, SIGNAL(toggled(bool)), m_parent, SLOT(toggleFileItem(bool)));
         QLabel *thumbnail = new QLabel;
         QLabel *filename = new QLabel;
         QLabel *dateModified = new QLabel;
 
         layout->addWidget(checkBox);
         layout->addWidget(thumbnail);
         layout->addWidget(filename);
         layout->addWidget(dateModified);
 
         page->setFixedSize(600, 200);
 
         return QList<QWidget*>() << page;
     }
 
     void updateItemWidgets(const QList<QWidget*> widgets,
                            const QStyleOptionViewItem &option,
                            const QPersistentModelIndex &index) const override
     {
         FileItem *fileItem = (FileItem*)index.data().value<void*>();
 
         QWidget* page= widgets[0];
         QHBoxLayout* layout = qobject_cast<QHBoxLayout*>(page->layout());
         QCheckBox *checkBox = qobject_cast<QCheckBox*>(layout->itemAt(0)->widget());
         QLabel *thumbnail = qobject_cast<QLabel*>(layout->itemAt(1)->widget());
         QLabel *filename = qobject_cast<QLabel*>(layout->itemAt(2)->widget());
         QLabel *modified = qobject_cast<QLabel*>(layout->itemAt(3)->widget());
 
         checkBox->setChecked(fileItem->checked);
         thumbnail->setPixmap(QPixmap::fromImage(fileItem->thumbnail));
         filename->setText(fileItem->name);
         modified->setText(fileItem->date);
 
         // move the page _up_ otherwise it will draw relative to the actual position
         page->setGeometry(option.rect.translated(0, -option.rect.y()));
     }
 
     void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &/*index*/) const override
     {
         //paint background for selected or hovered item
         QStyleOptionViewItem opt = option;
         itemView()->style()->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, painter, 0);
     }
 
     QSize sizeHint(const QStyleOptionViewItem&, const QModelIndex&) const override
     {
         return QSize(600, 200);
     }
 
 
     KisAutoSaveRecoveryDialog *m_parent;
 };
 
 class KisAutoSaveRecoveryDialog::FileItemModel : public QAbstractListModel
 {
 public:
     FileItemModel(QList<FileItem*> fileItems, QObject *parent)
         : QAbstractListModel(parent)
         , m_fileItems(fileItems){}
 
     ~FileItemModel() override
     {
         qDeleteAll(m_fileItems);
         m_fileItems.clear();
     }
 
     int rowCount(const QModelIndex &/*parent*/) const override { return m_fileItems.size(); }
 
     Qt::ItemFlags flags(const QModelIndex& /*index*/) const override
     {
         Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
         return flags;
     }
 
     QVariant data(const QModelIndex& index, int role) const override
     {
         if (index.isValid() && index.row() < m_fileItems.size()) {
 
             FileItem *item = m_fileItems.at(index.row());
 
             switch (role) {
             case Qt::DisplayRole:
             {
                 return QVariant::fromValue<void*>((void*)item);
             }
             case Qt::SizeHintRole:
                 return QSize(600, 200);
             }
         }
         return QVariant();
     }
 
     bool setData(const QModelIndex& index, const QVariant& /*value*/, int role) override
     {
         if (index.isValid() && index.row() < m_fileItems.size()) {
             if (role == Qt::CheckStateRole) {
                 m_fileItems.at(index.row())->checked = !m_fileItems.at(index.row())->checked;
                 return true;
             }
         }
         return false;
     }
     QList<FileItem *> m_fileItems;
 };
 
 KisAutoSaveRecoveryDialog::KisAutoSaveRecoveryDialog(const QStringList &filenames, QWidget *parent) :
     KoDialog(parent)
 {
     setCaption(i18nc("@title:window", "Recover Files"));
     setButtons( KoDialog::Ok | KoDialog::Cancel | KoDialog::User1 );
     setButtonText(KoDialog::User1, i18n("Discard All"));
     setMinimumSize(650, 500);
     QWidget *page = new QWidget(this);
     QVBoxLayout *layout = new QVBoxLayout(page);
     if (filenames.size() == 1) {
         layout->addWidget(new QLabel(i18n("The following autosave file can be recovered:")));
     }
     else {
         layout->addWidget(new QLabel(i18n("The following autosave files can be recovered:")));
     }
 
     m_listView = new QListView();
     m_listView->setAcceptDrops(false);
     KWidgetItemDelegate *delegate = new FileItemDelegate(m_listView, this);
     m_listView->setItemDelegate(delegate);
 
     QList<FileItem*> fileItems;
     Q_FOREACH (const QString &filename, filenames) {
 
         FileItem *file = new FileItem();
         file->name = filename;
 
 #ifdef Q_OS_WIN
         QString path = QDir::tempPath() + "/" + filename;
 #else
         QString path = QDir::homePath() + "/" + filename;
 #endif
 
         // get thumbnail -- almost all Krita-supported formats save a thumbnail
         KoStore* store = KoStore::createStore(path, KoStore::Read);
 
         if (store) {
             if (store->open(QString("Thumbnails/thumbnail.png"))
                || store->open(QString("preview.png"))) {
                 // Hooray! No long delay for the user...
                 QByteArray bytes = store->read(store->size());
                 store->close();
                 QImage img;
                 img.loadFromData(bytes);
                 file->thumbnail = img.scaled(QSize(200,200), Qt::KeepAspectRatio, Qt::SmoothTransformation);
             }
 
             delete store;
         }
 
         // get the date
         QDateTime date = QFileInfo(path).lastModified();
         file->date = "(" + date.toString(Qt::LocalDate) + ")";
 
         fileItems.append(file);
     }
 
     m_model = new FileItemModel(fileItems, m_listView);
     m_listView->setModel(m_model);
     layout->addWidget(m_listView);
     layout->addWidget(new QLabel(i18n("If you select Cancel, all recoverable files will be kept.\nIf you press OK, selected files will be recovered, the unselected files discarded.")));
     setMainWidget(page);
     
     setAttribute(Qt::WA_DeleteOnClose, false);
-    connect( this, SIGNAL( user1Clicked() ), this, SLOT( slotDeleteAll() ) );
+    connect( this, SIGNAL(user1Clicked()), this, SLOT(slotDeleteAll()) );
 }
 
 KisAutoSaveRecoveryDialog::~KisAutoSaveRecoveryDialog()
 {
     delete m_listView->itemDelegate();
     delete m_model;
     delete m_listView;
 }
 
 void KisAutoSaveRecoveryDialog::slotDeleteAll()
 {
     foreach(FileItem* fileItem, m_model->m_fileItems) {
         fileItem->checked = false;
     }
     accept();
 }
 
 QStringList KisAutoSaveRecoveryDialog::recoverableFiles()
 {
     QStringList files;
     Q_FOREACH (FileItem* fileItem, m_model->m_fileItems) {
         if (fileItem->checked) {
             files << fileItem->name;
         }
     }
     return files;
 }
 
 void KisAutoSaveRecoveryDialog::toggleFileItem(bool toggle)
 {
     // I've made better man from a piece of putty and matchstick!
     QVariant v = sender()->property("fileitem") ;
     if (v.isValid()) {
         FileItem *fileItem = (FileItem*)v.value<void*>();
         fileItem->checked = toggle;
     }
 }
diff --git a/libs/ui/KisDetailsPane.cpp b/libs/ui/KisDetailsPane.cpp
index 2ec85d47dc..8b450772da 100644
--- a/libs/ui/KisDetailsPane.cpp
+++ b/libs/ui/KisDetailsPane.cpp
@@ -1,113 +1,113 @@
 /* This file is part of the KDE project
    Copyright (C) 2005 Peter Simonsson <psn@linux.se>
 
    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 "KisDetailsPane.h"
 
 #include <QStandardItemModel>
 #include <QKeyEvent>
 
 ////////////////////////////////////
 // class KisDetailsPane
 ///////////////////////////////////
 
 struct KisDetailsPanePrivate
 {
     QStandardItemModel m_model;
 };
 
 KisDetailsPane::KisDetailsPane(QWidget* parent, const QString& header)
         : QWidget(parent),
         Ui_KisDetailsPaneBase(),
         d(new KisDetailsPanePrivate())
 {
     d->m_model.setHorizontalHeaderItem(0, new QStandardItem(header));
 
     setupUi(this);
 
     m_previewLabel->installEventFilter(this);
     m_documentList->installEventFilter(this);
     m_documentList->setIconSize(QSize(IconExtent, IconExtent));
     m_documentList->setModel(&d->m_model);
     m_splitter->setSizes(QList<int>() << 2 << 1);
 
     changePalette();
 
-    connect(m_documentList->selectionModel(), SIGNAL(currentChanged(const QModelIndex&, const QModelIndex&)),
-            this, SLOT(selectionChanged(const QModelIndex&)));
-    connect(m_documentList, SIGNAL(doubleClicked(const QModelIndex&)),
-            this, SLOT(openFile(const QModelIndex&)));
+    connect(m_documentList->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
+            this, SLOT(selectionChanged(QModelIndex)));
+    connect(m_documentList, SIGNAL(doubleClicked(QModelIndex)),
+            this, SLOT(openFile(QModelIndex)));
     connect(m_openButton, SIGNAL(clicked()), this, SLOT(openFile()));
 }
 
 KisDetailsPane::~KisDetailsPane()
 {
     delete d;
 }
 
 bool KisDetailsPane::eventFilter(QObject* watched, QEvent* e)
 {
     if (watched == m_previewLabel) {
         if (e->type() == QEvent::MouseButtonDblClick) {
             openFile();
         }
     }
 
     if (watched == m_documentList) {
         if ((e->type() == QEvent::Resize) && isVisible()) {
             emit splitterResized(this, m_splitter->sizes());
         }
 
         if ((e->type() == QEvent::KeyPress)) {
             QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
 
             if (keyEvent->key() == Qt::Key_Enter || keyEvent->key() == Qt::Key_Return) {
                 openFile();
             }
         }
     }
 
     return false;
 }
 
 void KisDetailsPane::resizeSplitter(KisDetailsPane* sender, const QList<int>& sizes)
 {
     if (sender == this)
         return;
 
     m_splitter->setSizes(sizes);
 }
 
 void KisDetailsPane::openFile()
 {
     QModelIndex index = m_documentList->selectionModel()->currentIndex();
     openFile(index);
 }
 
 void KisDetailsPane::changePalette()
 {
     QPalette p = palette();
     p.setBrush(QPalette::Base, QColor(Qt::transparent));
     p.setColor(QPalette::Text, p.color(QPalette::Normal, QPalette::Foreground));
     m_detailsLabel->setPalette(p);
 }
 
 QStandardItemModel* KisDetailsPane::model() const
 {
     return &d->m_model;
 }
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index e2673a81fd..2e94e94e89 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1844 +1,1844 @@
-/* This file is part of the Krita project
+/* 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_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.h"
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include "KisReferenceImagesLayer.h"
 
 #include <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.h"
 
 
 // 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)),
+                                   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)) {
             const QString existingAutoSaveBaseName = localFilePath();
             const bool wasRecovered = isRecovered();
 
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 /**
                  * If undo stack is alreado clean/empty, it doesn't emit any
                  * signals, so we might forget update document modified state
                  * (which was set, e.g. while recovering an autosave file)
                  */
 
                 if (d->undoStack->isClean()) {
                     setModified(false);
                 } else {
                     d->undoStack->setClean();
                 }
             }
             setRecovered(false);
             removeAutoSaveFiles(existingAutoSaveBaseName, wasRecovered);
         }
 
         emit completed();
         emit sigSavingFinished();
 
         emit statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
     }
 }
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->batchMode;
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->batchMode = batchMode;
 }
 
 KisDocument* KisDocument::lockAndCloneForSaving()
 {
     // force update of all the asynchronous nodes before cloning
     QApplication::processEvents();
     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&)),
+            SIGNAL(sigBackgroundSavingFinished(KisImportExportFilter::ConversionStatus,QString)),
             this,
-            SLOT(slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus, const QString&)));
+            SLOT(slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus,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&)),
+                                             this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,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(const QString &autosaveBaseName, bool wasRecovered)
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(autosaveBaseName);   // 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);
     }
 
     QRegularExpression autosavePattern("^\\..+-autosave.kra$");
 
     if (wasRecovered &&
         !autosaveBaseName.isEmpty() &&
         autosavePattern.match(QFileInfo(autosaveBaseName).fileName()).hasMatch() &&
         QFile::exists(autosaveBaseName)) {
 
         QFile::remove(autosaveBaseName);
     }
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackCleanChanged(bool value)
 {
     setModified(!value);
 }
 
 void KisDocument::slotConfigChanged()
 {
     KisConfig cfg(true);
     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&)),
+        connect(d->referenceImagesLayer, SIGNAL(sigUpdateCanvas(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->setUndoStore(new KisDumbUndoStore());
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->image->setUndoStore(new KisDocumentUndoStore(this));
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
 
     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/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index 245f31b190..022e6c5e9b 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2668 +1,2668 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QStandardPaths>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDialog>
 #include <QDockWidget>
 #include <QIcon>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QToolButton>
 #include <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 <QProxyStyle>
 
 
 #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"
 #include "kis_icon_utils.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 <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> >)));
+    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);
 
 
     // Tab close button override
     // Windows just has a black X, and Ubuntu has a dark x that is hard to read
     // just switch this icon out for all OSs so it is easier to see
     d->mdiArea->setStyleSheet("QTabBar::close-button { image: url(:/pics/broken-preset.png) }");
 
 
 
     setCentralWidget(d->widgetStack);
     d->widgetStack->setCurrentIndex(0);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));    connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     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 &)));
+    connect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
     KisDocument::OpenFlags openFlags = KisDocument::None;
     if (flags & RecoveryFile) {
         openFlags |= KisDocument::RecoveryFile;
     }
 
     bool openRet = !(flags & Import) ? newdoc->openUrl(url, openFlags) : newdoc->importDocument(url);
 
 
     if (!openRet) {
         delete newdoc;
         return false;
     }
 
     KisPart::instance()->addDocument(newdoc);
     updateReloadFileAction(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
     return true;
 }
 
 void KisMainWindow::showDocument(KisDocument *document) {
     Q_FOREACH(QMdiSubWindow *subwindow, d->mdiArea->subWindowList()) {
         KisView *view = qobject_cast<KisView*>(subwindow->widget());
         KIS_SAFE_ASSERT_RECOVER_NOOP(view);
 
         if (view) {
             if (view->document() == document) {
                 setActiveSubWindow(subwindow);
                 return;
             }
         }
     }
 
     addViewAndNotifyLoadingCompleted(document);
 }
 
 KisView* KisMainWindow::addViewAndNotifyLoadingCompleted(KisDocument *document)
 {
     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 &)));
+        disconnect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
-    disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
+    disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
-    disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
+    disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::installBundle(const QString &fileName) const
 {
     QFileInfo from(fileName);
     QFileInfo to(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
     if (to.exists()) {
         QFile::remove(to.canonicalFilePath());
     }
     return QFile::copy(fileName, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas, bool isExporting)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     }
     else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     if (document->isRecovered()) {
         saveas = true;
     }
 
     if (document->url().isEmpty()) {
         saveas = true;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
-    connect(document, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
+    connect(document, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     QByteArray nativeFormat = document->nativeFormatMimeType();
     QByteArray oldMimeFormat = document->mimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     if (!mimeFilter.contains(oldMimeFormat)) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).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!";
                     }
                 }
                 else { // Export
                     ret = document->exportDocument(newURL, outputFormat);
 
                     if (ret) {
                         d->lastExportLocation = newURL.toLocalFile();
                         d->lastExportedFormat = outputFormat;
                     }
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
         // We cannot "export" into the currently
         // opened document. We are not Gimp.
         KIS_ASSERT_RECOVER_NOOP(!isExporting);
 
         // be sure document has the correct outputMimeType!
         if (document->isModified()) {
             ret = document->save(true, 0);
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
         }
     }
 
     updateReloadFileAction(document);
     updateCaption();
 
     return ret;
 }
 
 void KisMainWindow::undo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->undo();
     }
 }
 
 void KisMainWindow::redo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->redo();
     }
 }
 
 void KisMainWindow::closeEvent(QCloseEvent *e)
 {
     if (!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&)));
+    connect(startupWidget, SIGNAL(openTemplate(QUrl)), KisPart::instance(), SLOT(openTemplate(QUrl)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
     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);
         }
     }
 
     /**
      * Qt has a weirdness, it has hardcoded shortcuts added to an action
      * in the window menu. We need to reset the shortcuts for that menu
      * to nothing, otherwise the shortcuts cannot be made configurable.
      *
      * See: https://bugs.kde.org/show_bug.cgi?id=352205
      *      https://bugs.kde.org/show_bug.cgi?id=375524
      *      https://bugs.kde.org/show_bug.cgi?id=398729
      */
     QMdiSubWindow *subWindow = d->mdiArea->currentSubWindow();
     if (subWindow) {
         QMenu *menu = subWindow->systemMenu();
         if (menu) {
             Q_FOREACH (QAction *action, menu->actions()) {
                 action->setShortcut(QKeySequence());
             }
         }
     }
 
     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()
 {
     if (d->mdiArea->currentSubWindow()) {
         d->mdiArea->currentSubWindow()->close();
         d->actionManager()->updateGUI();
     }
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
         m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->resources().isEmpty()) {
         m_errorMessage = i18n("Krita cannot find any brush presets! Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 }
 
 void KisMainWindow::showErrorAndDie()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Installation error"), m_errorMessage);
     if (m_dieOnError) {
         exit(10);
     }
 }
 
 void KisMainWindow::showAboutApplication()
 {
     KisAboutApplication dlg(this);
     dlg.exec();
 }
 
 QPointer<KisView> KisMainWindow::activeKisView()
 {
     if (!d->mdiArea) return 0;
     QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
     //dbgKrita << "activeKisView" << activeSubWindow;
     if (!activeSubWindow) return 0;
     return qobject_cast<KisView*>(activeSubWindow->widget());
 }
 
 void KisMainWindow::newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > &optionWidgetList)
 {
     KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
     bool isOurOwnView = false;
 
     Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->canvasController() == controller) {
             isOurOwnView = view->mainWindow() == this;
         }
     }
 
     if (!isOurOwnView) return;
 
     Q_FOREACH (QWidget *w, optionWidgetList) {
 #ifdef Q_OS_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->createStandardAction(KStandardAction::Close, this, SLOT(closeCurrentWindow()));
 
     d->showSessionManager = actionManager->createAction("file_sessions");
     connect(d->showSessionManager, SIGNAL(triggered(bool)), this, SLOT(slotShowSessionManager()));
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg = d->windowStateConfig;
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = 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/KisNodeView.cpp b/libs/ui/KisNodeView.cpp
index ef6b3dbc90..8ea0ab0ce9 100644
--- a/libs/ui/KisNodeView.cpp
+++ b/libs/ui/KisNodeView.cpp
@@ -1,573 +1,573 @@
 /*
   Copyright (c) 2006 Gábor Lehel <illissius@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 "KisNodeView.h"
 #include "KisNodePropertyAction_p.h"
 #include "KisNodeDelegate.h"
 #include "kis_node_view_visibility_delegate.h"
 #include "kis_node_model.h"
 #include "kis_signals_blocker.h"
 
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <kis_icon.h>
 #include <ksharedconfig.h>
 
 #include <QtDebug>
 #include <QContextMenuEvent>
 #include <QHeaderView>
 #include <QHelpEvent>
 #include <QMenu>
 #include <QDrag>
 #include <QMouseEvent>
 #include <QPersistentModelIndex>
 #include <QApplication>
 #include <QPainter>
 #include <QScrollBar>
 
 #include "kis_node_view_color_scheme.h"
 
 
 #ifdef HAVE_X11
 #define DRAG_WHILE_DRAG_WORKAROUND
 #endif
 
 #ifdef DRAG_WHILE_DRAG_WORKAROUND
 #define DRAG_WHILE_DRAG_WORKAROUND_START() d->isDragging = true
 #define DRAG_WHILE_DRAG_WORKAROUND_STOP() d->isDragging = false
 #else
 #define DRAG_WHILE_DRAG_WORKAROUND_START()
 #define DRAG_WHILE_DRAG_WORKAROUND_STOP()
 #endif
 
 
 class Q_DECL_HIDDEN KisNodeView::Private
 {
 public:
     Private(KisNodeView* _q)
         : delegate(_q, _q)
     , mode(DetailedMode)
 #ifdef DRAG_WHILE_DRAG_WORKAROUND
         , isDragging(false)
 #endif
     {
         KSharedConfigPtr config =  KSharedConfig::openConfig();
         KConfigGroup group = config->group("NodeView");
         mode = (DisplayMode) group.readEntry("NodeViewMode", (int)MinimalMode);
     }
     KisNodeDelegate delegate;
     DisplayMode mode;
     QPersistentModelIndex hovered;
     QPoint lastPos;
 
 #ifdef DRAG_WHILE_DRAG_WORKAROUND
     bool isDragging;
 #endif
 };
 
 
 KisNodeView::KisNodeView(QWidget *parent)
     : QTreeView(parent)
     , m_draggingFlag(false)
     , d(new Private(this))
 {
     setItemDelegateForColumn(0, &d->delegate);
 
     setMouseTracking(true);
     setSelectionBehavior(SelectRows);
     setDefaultDropAction(Qt::MoveAction);
     setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     header()->hide();
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
 
     setDropIndicatorShown(true);
 }
 
 KisNodeView::~KisNodeView()
 {
     delete d;
 }
 
 void KisNodeView::setDisplayMode(DisplayMode mode)
 {
     if (d->mode != mode) {
         d->mode = mode;
         KSharedConfigPtr config =  KSharedConfig::openConfig();
         KConfigGroup group = config->group("NodeView");
         group.writeEntry("NodeViewMode", (int)mode);
         scheduleDelayedItemsLayout();
     }
 }
 
 KisNodeView::DisplayMode KisNodeView::displayMode() const
 {
     return d->mode;
 }
 
 void KisNodeView::addPropertyActions(QMenu *menu, const QModelIndex &index)
 {
     KisBaseNode::PropertyList list = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     for (int i = 0, n = list.count(); i < n; ++i) {
         if (list.at(i).isMutable) {
             PropertyAction *a = new PropertyAction(i, list.at(i), index, menu);
-            connect(a, SIGNAL(toggled(bool, const QPersistentModelIndex&, int)),
-                    this, SLOT(slotActionToggled(bool, const QPersistentModelIndex&, int)));
+            connect(a, SIGNAL(toggled(bool,QPersistentModelIndex,int)),
+                    this, SLOT(slotActionToggled(bool,QPersistentModelIndex,int)));
             menu->addAction(a);
         }
     }
 }
 
 void KisNodeView::updateNode(const QModelIndex &index)
 {
     dataChanged(index, index);
 }
 
 QItemSelectionModel::SelectionFlags KisNodeView::selectionCommand(const QModelIndex &index,
                                                                   const QEvent *event) const
 {
     /**
      * Qt has a bug: when we Ctrl+click on an item, the item's
      * selections gets toggled on mouse *press*, whereas usually it is
      * done on mouse *release*.  Therefore the user cannot do a
      * Ctrl+D&D with the default configuration. This code fixes the
      * problem by manually returning QItemSelectionModel::NoUpdate
      * flag when the user clicks on an item and returning
      * QItemSelectionModel::Toggle on release.
      */
 
     if (event &&
         (event->type() == QEvent::MouseButtonPress ||
          event->type() == QEvent::MouseButtonRelease) &&
         index.isValid()) {
 
         const QMouseEvent *mevent = static_cast<const QMouseEvent*>(event);
 
         if (mevent->button() == Qt::RightButton &&
             selectionModel()->selectedIndexes().contains(index)) {
 
             // Allow calling context menu for multiple layers
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonPress &&
             (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonRelease &&
             (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::Toggle;
         }
     }
 
     /**
      * Qt 5.6 has a bug: it reads global modifiers, not the ones
      * passed from event.  So if you paste an item using Ctrl+V it'll
      * select multiple layers for you
      */
     Qt::KeyboardModifiers globalModifiers = QApplication::keyboardModifiers();
     if (!event && globalModifiers != Qt::NoModifier) {
         return QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows;
     }
 
     return QAbstractItemView::selectionCommand(index, event);
 }
 QRect KisNodeView::visualRect(const QModelIndex &index) const
 {
     QRect rc = QTreeView::visualRect(index);
     rc.setLeft(0);
     return rc;
 }
 
 QRect KisNodeView::originalVisualRect(const QModelIndex &index) const
 {
     return QTreeView::visualRect(index);
 }
 
 QModelIndex KisNodeView::indexAt(const QPoint &point) const
 {
     KisNodeViewColorScheme scm;
 
     QModelIndex index = QTreeView::indexAt(point);
     if (!index.isValid() && point.x() < scm.visibilityColumnWidth()) {
         index = QTreeView::indexAt(point + QPoint(scm.visibilityColumnWidth(), 0));
     }
 
     return index;
 }
 
 bool KisNodeView::viewportEvent(QEvent *e)
 {
     if (model()) {
         switch(e->type()) {
         case QEvent::MouseButtonPress: {
             DRAG_WHILE_DRAG_WORKAROUND_STOP();
 
             const QPoint pos = static_cast<QMouseEvent*>(e)->pos();
             d->lastPos = pos;
 
             if (!indexAt(pos).isValid()) {
                 return QTreeView::viewportEvent(e);
             }
             QModelIndex index = model()->buddy(indexAt(pos));
             if (d->delegate.editorEvent(e, model(), optionForIndex(index), index)) {
                 return true;
             }
         } break;
         case QEvent::Leave: {
             QEvent e(QEvent::Leave);
             d->delegate.editorEvent(&e, model(), optionForIndex(d->hovered), d->hovered);
             d->hovered = QModelIndex();
         } break;
         case QEvent::MouseMove: {
 #ifdef DRAG_WHILE_DRAG_WORKAROUND
             if (d->isDragging) {
                 return false;
             }
 #endif
 
             const QPoint pos = static_cast<QMouseEvent*>(e)->pos();
             QModelIndex hovered = indexAt(pos);
             if (hovered != d->hovered) {
                 if (d->hovered.isValid()) {
                     QEvent e(QEvent::Leave);
                     d->delegate.editorEvent(&e, model(), optionForIndex(d->hovered), d->hovered);
                 }
                 if (hovered.isValid()) {
                     QEvent e(QEvent::Enter);
                     d->delegate.editorEvent(&e, model(), optionForIndex(hovered), hovered);
                 }
                 d->hovered = hovered;
             }
             /* This is a workaround for a bug in QTreeView that immediately begins a dragging action
             when the mouse lands on the decoration/icon of a different index and moves 1 pixel or more */
             Qt::MouseButtons buttons = static_cast<QMouseEvent*>(e)->buttons();
             if ((Qt::LeftButton | Qt::MidButton) & buttons) {
                 if ((pos - d->lastPos).manhattanLength() > qApp->startDragDistance()) {
                     return QTreeView::viewportEvent(e);
                 }
                 return true;
             }
         } break;
         case QEvent::ToolTip: {
             const QPoint pos = static_cast<QHelpEvent*>(e)->pos();
             if (!indexAt(pos).isValid()) {
                 return QTreeView::viewportEvent(e);
             }
             QModelIndex index = model()->buddy(indexAt(pos));
             return d->delegate.editorEvent(e, model(), optionForIndex(index), index);
         } break;
         case QEvent::Resize: {
             scheduleDelayedItemsLayout();
             break;
         }
         default: break;
         }
     }
     return QTreeView::viewportEvent(e);
 }
 
 void KisNodeView::contextMenuEvent(QContextMenuEvent *e)
 {
     QTreeView::contextMenuEvent(e);
     QModelIndex i = indexAt(e->pos());
     if (model())
         i = model()->buddy(i);
     showContextMenu(e->globalPos(), i);
 }
 
 void KisNodeView::showContextMenu(const QPoint &globalPos, const QModelIndex &index)
 {
     emit contextMenuRequested(globalPos, index);
 }
 
 void KisNodeView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTreeView::currentChanged(current, previous);
     if (current != previous) {
         Q_ASSERT(!current.isValid() || current.model() == model());
         model()->setData(current, true, KisNodeModel::ActiveRole);
     }
 }
 
 void KisNodeView::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &/*roles*/)
 {
     QTreeView::dataChanged(topLeft, bottomRight);
     for (int x = topLeft.row(); x <= bottomRight.row(); ++x) {
         for (int y = topLeft.column(); y <= bottomRight.column(); ++y) {
             QModelIndex index = topLeft.sibling(x, y);
             if (index.data(KisNodeModel::ActiveRole).toBool()) {
                 if (currentIndex() != index) {
                     setCurrentIndex(index);
                 }
                 return;
             }
         }
     }
 }
 
 void KisNodeView::selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
 {
     QTreeView::selectionChanged(selected, deselected);
     emit selectionChanged(selectedIndexes());
 }
 
 void KisNodeView::slotActionToggled(bool on, const QPersistentModelIndex &index, int num)
 {
     KisBaseNode::PropertyList list = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
     list[num].state = on;
     const_cast<QAbstractItemModel*>(index.model())->setData(index, QVariant::fromValue(list), KisNodeModel::PropertiesRole);
 }
 
 QStyleOptionViewItem KisNodeView::optionForIndex(const QModelIndex &index) const
 {
     QStyleOptionViewItem option = viewOptions();
     option.rect = visualRect(index);
     if (index == currentIndex())
         option.state |= QStyle::State_HasFocus;
     return option;
 }
 
 void KisNodeView::startDrag(Qt::DropActions supportedActions)
 {
     DRAG_WHILE_DRAG_WORKAROUND_START();
 
     if (displayMode() == KisNodeView::ThumbnailMode) {
         const QModelIndexList indexes = selectionModel()->selectedIndexes();
         if (!indexes.isEmpty()) {
             QMimeData *data = model()->mimeData(indexes);
             if (!data) {
                 return;
             }
             QDrag *drag = new QDrag(this);
             drag->setPixmap(createDragPixmap());
             drag->setMimeData(data);
             //m_dragSource = this;
             drag->exec(supportedActions);
         }
     }
     else {
         QTreeView::startDrag(supportedActions);
     }
 }
 
 QPixmap KisNodeView::createDragPixmap() const
 {
     const QModelIndexList selectedIndexes = selectionModel()->selectedIndexes();
     Q_ASSERT(!selectedIndexes.isEmpty());
 
     const int itemCount = selectedIndexes.count();
 
     // If more than one item is dragged, align the items inside a
     // rectangular grid. The maximum grid size is limited to 4 x 4 items.
     int xCount = 2;
     int size = 96;
     if (itemCount > 9) {
         xCount = 4;
         size = KisIconUtils::SizeLarge;
     }
     else if (itemCount > 4) {
         xCount = 3;
         size = KisIconUtils::SizeHuge;
     }
     else if (itemCount < xCount) {
         xCount = itemCount;
     }
 
     int yCount = itemCount / xCount;
     if (itemCount % xCount != 0) {
         ++yCount;
     }
 
     if (yCount > xCount) {
         yCount = xCount;
     }
 
     // Draw the selected items into the grid cells
     QPixmap dragPixmap(xCount * size + xCount - 1, yCount * size + yCount - 1);
     dragPixmap.fill(Qt::transparent);
 
     QPainter painter(&dragPixmap);
     int x = 0;
     int y = 0;
     Q_FOREACH (const QModelIndex &selectedIndex, selectedIndexes) {
         const QImage img = selectedIndex.data(int(KisNodeModel::BeginThumbnailRole) + size).value<QImage>();
         painter.drawPixmap(x, y, QPixmap().fromImage(img.scaled(QSize(size, size), Qt::KeepAspectRatio, Qt::SmoothTransformation)));
 
         x += size + 1;
         if (x >= dragPixmap.width()) {
             x = 0;
             y += size + 1;
         }
         if (y >= dragPixmap.height()) {
             break;
         }
     }
 
     return dragPixmap;
 }
 
 void KisNodeView::resizeEvent(QResizeEvent * event)
 {
     KisNodeViewColorScheme scm;
     header()->setStretchLastSection(false);
     header()->setOffset(-scm.visibilityColumnWidth());
     header()->resizeSection(0, event->size().width() - scm.visibilityColumnWidth());
     setIndentation(scm.indentation());
     QTreeView::resizeEvent(event);
 }
 
 void KisNodeView::paintEvent(QPaintEvent *event)
 {
     event->accept();
     QTreeView::paintEvent(event);
 
     // Paint the line where the slide should go
     if (isDragging() && (displayMode() == KisNodeView::ThumbnailMode)) {
         QSize size(visualRect(model()->index(0, 0, QModelIndex())).width(), visualRect(model()->index(0, 0, QModelIndex())).height());
         int numberRow = cursorPageIndex();
         int scrollBarValue = verticalScrollBar()->value();
 
         QPoint point1(0, numberRow * size.height() - scrollBarValue);
         QPoint point2(size.width(), numberRow * size.height() - scrollBarValue);
         QLineF line(point1, point2);
 
         QPainter painter(this->viewport());
         QPen pen = QPen(palette().brush(QPalette::Highlight), 8);
         pen.setCapStyle(Qt::RoundCap);
         painter.setPen(pen);
         painter.setOpacity(0.8);
         painter.drawLine(line);
     }
 }
 
 void KisNodeView::drawBranches(QPainter *painter, const QRect &rect,
                                const QModelIndex &index) const
 {
     Q_UNUSED(painter);
     Q_UNUSED(rect);
     Q_UNUSED(index);
 
     /**
      * Noop... Everything is going to be painted by KisNodeDelegate.
      * So this override basically disables painting of Qt's branch-lines.
      */
 }
 
 void KisNodeView::dropEvent(QDropEvent *ev)
 {
     if (displayMode() == KisNodeView::ThumbnailMode) {
         setDraggingFlag(false);
         ev->accept();
         clearSelection();
 
         if (!model()) {
             return;
         }
 
         int newIndex = cursorPageIndex();
         model()->dropMimeData(ev->mimeData(), ev->dropAction(), newIndex, -1, QModelIndex());
         return;
     }
     QTreeView::dropEvent(ev);
 
     DRAG_WHILE_DRAG_WORKAROUND_STOP();
 }
 
 int KisNodeView::cursorPageIndex() const
 {
     QSize size(visualRect(model()->index(0, 0, QModelIndex())).width(), visualRect(model()->index(0, 0, QModelIndex())).height());
     int scrollBarValue = verticalScrollBar()->value();
 
     QPoint cursorPosition = QWidget::mapFromGlobal(QCursor::pos());
 
     int numberRow = (cursorPosition.y() + scrollBarValue) / size.height();
 
     //If cursor is at the half button of the page then the move action is performed after the slide, otherwise it is
     //performed before the page
     if (abs((cursorPosition.y() + scrollBarValue) - size.height()*numberRow) > (size.height()/2)) {
         numberRow++;
     }
 
     if (numberRow > model()->rowCount(QModelIndex())) {
         numberRow = model()->rowCount(QModelIndex());
     }
 
     return numberRow;
 }
 
 void KisNodeView::dragEnterEvent(QDragEnterEvent *ev)
 {
     DRAG_WHILE_DRAG_WORKAROUND_START();
 
     QVariant data = qVariantFromValue(
         static_cast<void*>(const_cast<QMimeData*>(ev->mimeData())));
     model()->setData(QModelIndex(), data, KisNodeModel::DropEnabled);
 
     QTreeView::dragEnterEvent(ev);
 }
 
 void KisNodeView::dragMoveEvent(QDragMoveEvent *ev)
 {
     DRAG_WHILE_DRAG_WORKAROUND_START();
 
     if (displayMode() == KisNodeView::ThumbnailMode) {
         ev->accept();
         if (!model()) {
             return;
         }
         QTreeView::dragMoveEvent(ev);
         setDraggingFlag();
         viewport()->update();
         return;
     }
     QTreeView::dragMoveEvent(ev);
 }
 
 void KisNodeView::dragLeaveEvent(QDragLeaveEvent *e)
 {
     if (displayMode() == KisNodeView::ThumbnailMode) {
         setDraggingFlag(false);
     } else {
         QTreeView::dragLeaveEvent(e);
     }
 
     DRAG_WHILE_DRAG_WORKAROUND_STOP();
 }
 
 bool KisNodeView::isDragging() const
 {
     return m_draggingFlag;
 }
 
 void KisNodeView::setDraggingFlag(bool flag)
 {
     m_draggingFlag = flag;
 }
 
 void KisNodeView::slotUpdateIcons()
 {
     d->delegate.slotUpdateIcon();
 }
diff --git a/libs/ui/KisOpenPane.cpp b/libs/ui/KisOpenPane.cpp
index 75eb16a1de..a075b9f4fa 100644
--- a/libs/ui/KisOpenPane.cpp
+++ b/libs/ui/KisOpenPane.cpp
@@ -1,355 +1,355 @@
 /* This file is part of the KDE project
    Copyright (C) 2005 Peter Simonsson <psn@linux.se>
 
    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 "KisOpenPane.h"
 
 #include <QLayout>
 #include <QLabel>
 #include <QImage>
 #include <QPainter>
 #include <QPen>
 #include <QPixmap>
 #include <QSize>
 #include <QString>
 #include <QTreeWidget>
 #include <QTreeWidgetItem>
 #include <QStyledItemDelegate>
 #include <QLinearGradient>
 #include <QStandardPaths>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QMimeData>
 
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 #include <kis_debug.h>
 #include <QUrl>
 
 
 #include <KoFileDialog.h>
 #include <KoIcon.h>
 #include "KisTemplateTree.h"
 #include "KisTemplateGroup.h"
 #include "KisTemplate.h"
 #include "KisDetailsPane.h"
 #include "KisTemplatesPane.h"
 #include "ui_KisOpenPaneBase.h"
 
 #include <limits.h>
 #include <kconfiggroup.h>
 
 #include <kis_icon.h>
 
 class KoSectionListItem : public QTreeWidgetItem
 {
 public:
     KoSectionListItem(QTreeWidget* treeWidget, const QString& name, int sortWeight, int widgetIndex = -1)
         : QTreeWidgetItem(treeWidget, QStringList() << name), m_sortWeight(sortWeight), m_widgetIndex(widgetIndex) {
         Qt::ItemFlags newFlags = Qt::NoItemFlags;
 
         if(m_widgetIndex >= 0)
             newFlags |= Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 
         setFlags(newFlags);
     }
 
     bool operator<(const QTreeWidgetItem & other) const override {
         const KoSectionListItem* item = dynamic_cast<const KoSectionListItem*>(&other);
 
         if (!item)
             return 0;
 
         return ((item->sortWeight() - sortWeight()) < 0);
     }
 
     int sortWeight() const {
         return m_sortWeight;
     }
 
     int widgetIndex() const {
         return m_widgetIndex;
     }
 
 private:
     int m_sortWeight;
     int m_widgetIndex;
 };
 
 class KisOpenPanePrivate : public Ui_KisOpenPaneBase
 {
 public:
     KisOpenPanePrivate() :
         Ui_KisOpenPaneBase() {
         m_templatesSeparator = 0;
     }
 
     int m_freeCustomWidgetIndex;
     KoSectionListItem* m_templatesSeparator;
 
 
 };
 
 KisOpenPane::KisOpenPane(QWidget *parent, const QStringList& mimeFilter, const QString& templatesResourcePath)
     : QDialog(parent)
     , d(new KisOpenPanePrivate)
 {
     d->setupUi(this);
 
     m_mimeFilter = mimeFilter;
 
     QStyledItemDelegate* delegate = new QStyledItemDelegate(d->m_sectionList);
     d->m_sectionList->setItemDelegate(delegate);
 
     connect(d->m_sectionList, SIGNAL(itemSelectionChanged()),
             this, SLOT(updateSelectedWidget()));
-    connect(d->m_sectionList, SIGNAL(itemClicked(QTreeWidgetItem*, int)),
+    connect(d->m_sectionList, SIGNAL(itemClicked(QTreeWidgetItem*,int)),
             this, SLOT(itemClicked(QTreeWidgetItem*)));
-    connect(d->m_sectionList, SIGNAL(itemActivated(QTreeWidgetItem*, int)),
+    connect(d->m_sectionList, SIGNAL(itemActivated(QTreeWidgetItem*,int)),
             this, SLOT(itemClicked(QTreeWidgetItem*)));
 
     initTemplates(templatesResourcePath);
 
     d->m_freeCustomWidgetIndex = 4;
 
     if (!d->m_sectionList->selectedItems().isEmpty())
     {
         KoSectionListItem* selectedItem = static_cast<KoSectionListItem*>(d->m_sectionList->selectedItems().first());
 
         if (selectedItem) {
             d->m_widgetStack->widget(selectedItem->widgetIndex())->setFocus();
         }
     }
 
     QList<int> sizes;
 
     // Set the sizes of the details pane splitters
     KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog"); sizes = cfgGrp.readEntry("DetailsPaneSplitterSizes", sizes);
 
     if (!sizes.isEmpty())
         emit splitterResized(0, sizes);
 
-    connect(this, SIGNAL(splitterResized(KisDetailsPane*, const QList<int>&)),
-            this, SLOT(saveSplitterSizes(KisDetailsPane*, const QList<int>&)));
+    connect(this, SIGNAL(splitterResized(KisDetailsPane*,QList<int>)),
+            this, SLOT(saveSplitterSizes(KisDetailsPane*,QList<int>)));
 
     setAcceptDrops(true);
 }
 
 KisOpenPane::~KisOpenPane()
 {
     if (!d->m_sectionList->selectedItems().isEmpty()) {
         KoSectionListItem* item = dynamic_cast<KoSectionListItem*>(d->m_sectionList->selectedItems().first());
 
         if (item) {
             if (!qobject_cast<KisDetailsPane*>(d->m_widgetStack->widget(item->widgetIndex()))) {
                 KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog");
                 cfgGrp.writeEntry("LastReturnType", item->text(0));
             }
         }
     }
 
     delete d;
 }
 
 
 
 void KisOpenPane::openFileDialog()
 {
 
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocument");
     dialog.setCaption(i18n("Open Existing Document"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(m_mimeFilter);
     Q_FOREACH (const QString &filename, dialog.filenames()) {
         emit openExistingFile(QUrl::fromUserInput(filename));
     }
 }
 
 void KisOpenPane::initTemplates(const QString& templatesResourcePath)
 {
     QTreeWidgetItem* selectItem = 0;
     QTreeWidgetItem* firstItem = 0;
     const int templateOffset = 1000;
 
     if (!templatesResourcePath.isEmpty()) {
         KisTemplateTree templateTree(templatesResourcePath, true);
 
         Q_FOREACH (KisTemplateGroup *group, templateTree.groups()) {
             if (group->isHidden()) {
                 continue;
             }
 
             if (!d->m_templatesSeparator) {
                 d->m_templatesSeparator = new KoSectionListItem(d->m_sectionList, "", 999);
             }
 
             KisTemplatesPane* pane = new KisTemplatesPane(this, group->name(),
                                                           group, templateTree.defaultTemplate());
-            connect(pane, SIGNAL(openUrl(const QUrl&)), this, SIGNAL(openTemplate(const QUrl&)));
-            connect(pane, SIGNAL(alwaysUseChanged(KisTemplatesPane*, const QString&)),
-                    this, SIGNAL(alwaysUseChanged(KisTemplatesPane*, const QString&)));
-            connect(this, SIGNAL(alwaysUseChanged(KisTemplatesPane*, const QString&)),
-                    pane, SLOT(changeAlwaysUseTemplate(KisTemplatesPane*, const QString&)));
-            connect(pane, SIGNAL(splitterResized(KisDetailsPane*, const QList<int>&)),
-                    this, SIGNAL(splitterResized(KisDetailsPane*, const QList<int>&)));
-            connect(this, SIGNAL(splitterResized(KisDetailsPane*, const QList<int>&)),
-                    pane, SLOT(resizeSplitter(KisDetailsPane*, const QList<int>&)));
+            connect(pane, SIGNAL(openUrl(QUrl)), this, SIGNAL(openTemplate(QUrl)));
+            connect(pane, SIGNAL(alwaysUseChanged(KisTemplatesPane*,QString)),
+                    this, SIGNAL(alwaysUseChanged(KisTemplatesPane*,QString)));
+            connect(this, SIGNAL(alwaysUseChanged(KisTemplatesPane*,QString)),
+                    pane, SLOT(changeAlwaysUseTemplate(KisTemplatesPane*,QString)));
+            connect(pane, SIGNAL(splitterResized(KisDetailsPane*,QList<int>)),
+                    this, SIGNAL(splitterResized(KisDetailsPane*,QList<int>)));
+            connect(this, SIGNAL(splitterResized(KisDetailsPane*,QList<int>)),
+                    pane, SLOT(resizeSplitter(KisDetailsPane*,QList<int>)));
             QTreeWidgetItem* item = addPane(group->name(), group->templates().first()->loadPicture(),
                                             pane, group->sortingWeight() + templateOffset);
 
 
 
             if (!firstItem) {
                 firstItem = item;
             }
 
             if (group == templateTree.defaultGroup()) {
                 firstItem = item;
             }
 
             if (pane->isSelected()) {
                 selectItem = item;
             }
         }
     } else {
         firstItem = d->m_sectionList->topLevelItem(0);
     }
 
     KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog");
 
     if (selectItem && (cfgGrp.readEntry("LastReturnType") == "Template")) {
         d->m_sectionList->setCurrentItem(selectItem, 0, QItemSelectionModel::ClearAndSelect);
     } else if (d->m_sectionList->selectedItems().isEmpty() && firstItem) {
         d->m_sectionList->setCurrentItem(firstItem, 0, QItemSelectionModel::ClearAndSelect);
     }
 }
 
 void KisOpenPane::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasUrls()) {
         event->accept();
     }
 }
 
 void KisOpenPane::dropEvent(QDropEvent *event)
 {
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         // XXX: when the MVC refactoring is done, this can open a bunch of
         //      urls, but since the part/document combination is still 1:1
         //      that won't work for now.
         emit openExistingFile(event->mimeData()->urls().first());
 
     }
 }
 
 void KisOpenPane::addCustomDocumentWidget(QWidget *widget, const QString& title, const QString& icon)
 {
     Q_ASSERT(widget);
 
     QString realtitle = title;
 
     if (realtitle.isEmpty())
         realtitle = i18n("Custom Document");
 
     QTreeWidgetItem* item = addPane(realtitle, icon, widget, d->m_freeCustomWidgetIndex);
     ++d->m_freeCustomWidgetIndex;
     KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog");
 
     QString lastActiveItem = cfgGrp.readEntry("LastReturnType");
     bool showCustomItemByDefault = cfgGrp.readEntry("ShowCustomDocumentWidgetByDefault", false);
     if (lastActiveItem == realtitle || (lastActiveItem.isEmpty() && showCustomItemByDefault)) {
         d->m_sectionList->setCurrentItem(item, 0, QItemSelectionModel::ClearAndSelect);
         KoSectionListItem* selectedItem = static_cast<KoSectionListItem*>(item);
         d->m_widgetStack->widget(selectedItem->widgetIndex())->setFocus();
     }
 }
 
 QTreeWidgetItem* KisOpenPane::addPane(const QString &title, const QString &iconName, QWidget *widget, int sortWeight)
 {
     if (!widget) {
         return 0;
     }
 
     int id = d->m_widgetStack->addWidget(widget);
     KoSectionListItem* listItem = new KoSectionListItem(d->m_sectionList, title, sortWeight, id);
 
     // resizes icons so they are a bit smaller
     QIcon icon = KisIconUtils::loadIcon(iconName);
     QPixmap iconPixmap = icon.pixmap(32, 32);
 
     QIcon finalIcon(iconPixmap);
     listItem->setIcon(0, finalIcon);
 
     return listItem;
 }
 
 QTreeWidgetItem* KisOpenPane::addPane(const QString& title, const QPixmap& icon, QWidget* widget, int sortWeight)
 {
     if (!widget) {
         return 0;
     }
 
     int id = d->m_widgetStack->addWidget(widget);
 
     int iconSize = 32;
 
     KoSectionListItem* listItem = new KoSectionListItem(d->m_sectionList, title, sortWeight, id);
 
     if (!icon.isNull()) {
         QImage image = icon.toImage();
 
         if ((image.width() > iconSize) || (image.height() > iconSize)) {
             image = image.scaled(iconSize, iconSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
         }
 
         image = image.convertToFormat(QImage::Format_ARGB32);
         image = image.copy((image.width() - iconSize) / 2, (image.height() - iconSize) / 2, iconSize, iconSize);
         listItem->setIcon(0, QIcon(QPixmap::fromImage(image)));
     }
 
     return listItem;
 }
 
 void KisOpenPane::updateSelectedWidget()
 {
     if(!d->m_sectionList->selectedItems().isEmpty())
     {
         KoSectionListItem* section = dynamic_cast<KoSectionListItem*>(d->m_sectionList->selectedItems().first());
 
         if (!section)
             return;
 
         d->m_widgetStack->setCurrentIndex(section->widgetIndex());
     }
 }
 
 void KisOpenPane::saveSplitterSizes(KisDetailsPane* sender, const QList<int>& sizes)
 {
     Q_UNUSED(sender);
     KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog");
     cfgGrp.writeEntry("DetailsPaneSplitterSizes", sizes);
 }
 
 void KisOpenPane::itemClicked(QTreeWidgetItem* item)
 {
     KoSectionListItem* selectedItem = static_cast<KoSectionListItem*>(item);
 
     if (selectedItem && selectedItem->widgetIndex() >= 0) {
         d->m_widgetStack->widget(selectedItem->widgetIndex())->setFocus();
     }
 }
diff --git a/libs/ui/KisReferenceImagesDecoration.cpp b/libs/ui/KisReferenceImagesDecoration.cpp
index 2ac834dbee..b3d7e2ce1c 100644
--- a/libs/ui/KisReferenceImagesDecoration.cpp
+++ b/libs/ui/KisReferenceImagesDecoration.cpp
@@ -1,173 +1,173 @@
 /*
  * 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 "KisReferenceImagesDecoration.h"
 
 #include "KoShapeManager.h"
 
 #include "kis_algebra_2d.h"
 #include "KisDocument.h"
 #include "KisReferenceImagesLayer.h"
 
 struct KisReferenceImagesDecoration::Private {
     struct Buffer
     {
         /// Top left corner of the buffer relative to the viewport
         QPointF position;
         QImage image;
 
         QRectF bounds() const
         {
             return QRectF(position, image.size());
         }
     };
 
     KisReferenceImagesDecoration *q;
 
     KisWeakSharedPtr<KisReferenceImagesLayer> layer;
     Buffer buffer;
     QTransform previousTransform;
     QSizeF previousViewSize;
 
     explicit Private(KisReferenceImagesDecoration *q)
         : q(q)
     {}
 
     void updateBufferByImageCoordinates(const QRectF &dirtyImageRect)
     {
         QRectF dirtyWidgetRect = q->view()->viewConverter()->imageToWidget(dirtyImageRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
     void updateBufferByWidgetCoordinates(const QRectF &dirtyWidgetRect)
     {
         QRectF dirtyImageRect = q->view()->viewConverter()->widgetToImage(dirtyWidgetRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
 private:
     void updateBuffer(QRectF widgetRect, QRectF imageRect)
     {
         KisCoordinatesConverter *viewConverter = q->view()->viewConverter();
         QTransform transform = viewConverter->imageToWidgetTransform();
 
         if (buffer.image.isNull() || !buffer.bounds().contains(widgetRect)) {
             const QRectF boundingImageRect = layer->boundingImageRect();
             const QRectF boundingWidgetRect = q->view()->viewConverter()->imageToWidget(boundingImageRect);
             widgetRect = boundingWidgetRect.intersected(q->view()->rect());
 
             if (widgetRect.isNull()) return;
 
             buffer.position = widgetRect.topLeft();
             buffer.image = QImage(widgetRect.size().toSize(), QImage::Format_ARGB32);
             buffer.image.fill(Qt::transparent);
 
             imageRect = q->view()->viewConverter()->widgetToImage(widgetRect);
         }
 
         QPainter gc(&buffer.image);
 
         gc.translate(-buffer.position);
         gc.setTransform(transform, true);
 
         gc.save();
         gc.setCompositionMode(QPainter::CompositionMode_Source);
         gc.fillRect(imageRect, Qt::transparent);
         gc.restore();
 
         gc.setClipRect(imageRect);
         layer->paintReferences(gc);
     }
 };
 
 KisReferenceImagesDecoration::KisReferenceImagesDecoration(QPointer<KisView> parent, KisDocument *document)
     : KisCanvasDecoration("referenceImagesDecoration", parent)
     , d(new Private(this))
 {
     connect(document->image().data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)), this, SLOT(slotNodeAdded(KisNodeSP)));
 
     auto referenceImageLayer = document->referenceImagesLayer();
     if (referenceImageLayer) {
         setReferenceImageLayer(referenceImageLayer);
     }
 }
 
 KisReferenceImagesDecoration::~KisReferenceImagesDecoration()
 {}
 
 void KisReferenceImagesDecoration::addReferenceImage(KisReferenceImage *referenceImage)
 {
     KisDocument *document = view()->document();
     KUndo2Command *cmd = KisReferenceImagesLayer::addReferenceImages(document, {referenceImage});
     document->addCommand(cmd);
 }
 
 bool KisReferenceImagesDecoration::documentHasReferenceImages() const
 {
     return view()->document()->referenceImagesLayer() != nullptr;
 }
 
 void KisReferenceImagesDecoration::drawDecoration(QPainter &gc, const QRectF &/*updateRect*/, const KisCoordinatesConverter *converter, KisCanvas2 */*canvas*/)
 {
     // TODO: can we use partial updates here?
 
     KisSharedPtr<KisReferenceImagesLayer> layer = d->layer.toStrongRef();
 
     if (!layer.isNull()) {
         QSizeF viewSize = view()->size();
 
         QTransform transform = converter->imageToWidgetTransform();
         if (d->previousViewSize != viewSize || !KisAlgebra2D::fuzzyMatrixCompare(transform, d->previousTransform, 1e-4)) {
             d->previousViewSize = viewSize;
             d->previousTransform = transform;
             d->buffer.image = QImage();
             d->updateBufferByWidgetCoordinates(QRectF(QPointF(0,0), viewSize));
         }
 
         if (!d->buffer.image.isNull()) {
             gc.drawImage(d->buffer.position, d->buffer.image);
         }
     }
 }
 
 void KisReferenceImagesDecoration::slotNodeAdded(KisNodeSP node)
 {
     auto *referenceImagesLayer = dynamic_cast<KisReferenceImagesLayer*>(node.data());
 
     if (referenceImagesLayer) {
         setReferenceImageLayer(referenceImagesLayer);
     }
 }
 
 void KisReferenceImagesDecoration::slotReferenceImagesChanged(const QRectF &dirtyRect)
 {
     d->updateBufferByImageCoordinates(dirtyRect);
 
     QRectF documentRect = view()->viewConverter()->imageToDocument(dirtyRect);
     view()->canvasBase()->updateCanvas(documentRect);
 }
 
 void KisReferenceImagesDecoration::setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
 {
     d->layer = layer;
     connect(
-            layer.data(), SIGNAL(sigUpdateCanvas(const QRectF&)),
-            this, SLOT(slotReferenceImagesChanged(const QRectF&))
+            layer.data(), SIGNAL(sigUpdateCanvas(QRectF)),
+            this, SLOT(slotReferenceImagesChanged(QRectF))
     );
 }
diff --git a/libs/ui/KisTemplateCreateDia.cpp b/libs/ui/KisTemplateCreateDia.cpp
index 8616be2856..f8dc808f88 100644
--- a/libs/ui/KisTemplateCreateDia.cpp
+++ b/libs/ui/KisTemplateCreateDia.cpp
@@ -1,529 +1,529 @@
 /*
    This file is part of the KDE project
    Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
                  2000 Werner Trobin <trobin@kde.org>
    Copyright (C) 2004 Nicolas GOUTTE <goutte@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 <KisTemplateCreateDia.h>
 
 #include <QFile>
 #include <QLabel>
 #include <QRadioButton>
 #include <QPushButton>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QHBoxLayout>
 #include <QTreeWidget>
 #include <QTreeWidgetItem>
 #include <QGroupBox>
 #include <QInputDialog>
 #include <QTemporaryFile>
 #include <QLineEdit>
 #include <QDir>
 
 #include <klocalizedstring.h>
 #include <kis_icon.h>
 #include <KisDocument.h>
 #include <KisTemplates.h>
 #include <KisTemplateTree.h>
 #include <KisTemplateGroup.h>
 #include <KisTemplate.h>
 #include <QMessageBox>
 #include <KoResourcePaths.h>
 #include <kis_debug.h>
 #include <kconfiggroup.h>
 #include <QUrl>
 #include <KoFileDialog.h>
 
 #include <ksharedconfig.h>
 
 // ODF thumbnail extent
 static const int thumbnailExtent = 128;
 
 class KisTemplateCreateDiaPrivate {
 public:
     KisTemplateCreateDiaPrivate(const QString &templatesResourcePath,
                                 const QString &filePath, const QPixmap &thumbnail)
         : m_tree(templatesResourcePath, true)
         , m_filePath(filePath)
         , m_thumbnail(thumbnail)
     { }
 
     KisTemplateTree m_tree;
     QLineEdit *m_name;
     QRadioButton *m_default;
     QRadioButton *m_custom;
     QPushButton *m_select;
     QLabel *m_preview;
     QString m_customFile;
     QPixmap m_customPixmap;
     QTreeWidget *m_groups;
     QPushButton *m_add;
     QPushButton *m_remove;
     QCheckBox *m_defaultTemplate;
     QString m_filePath;
     QPixmap m_thumbnail;
     bool m_changed;
 };
 
 
 /****************************************************************************
  *
  * Class: KisTemplateCreateDia
  *
  ****************************************************************************/
 
 KisTemplateCreateDia::KisTemplateCreateDia(const QString &templatesResourcePath,
                                            const QString &filePath, const QPixmap &thumbnail, QWidget *parent)
     : KoDialog(parent)
     , d(new KisTemplateCreateDiaPrivate(templatesResourcePath, filePath, thumbnail))
 {
     setButtons( KoDialog::Ok|KoDialog::Cancel );
     setDefaultButton( KoDialog::Ok );
     setCaption( i18n( "Create Template" ) );
     setModal( true );
     setObjectName( "template create dia" );
 
     QWidget *mainwidget = mainWidget();
     QHBoxLayout *mbox=new QHBoxLayout( mainwidget );
     QVBoxLayout* leftbox = new QVBoxLayout();
     mbox->addLayout( leftbox );
 
     QLabel *label=new QLabel(i18nc("Template name", "Name:"), mainwidget);
     QHBoxLayout *namefield=new QHBoxLayout();
     leftbox->addLayout( namefield );
     namefield->addWidget(label);
     d->m_name=new QLineEdit(mainwidget);
     d->m_name->setFocus();
-    connect(d->m_name, SIGNAL(textChanged(const QString &)),
-            this, SLOT(slotNameChanged(const QString &)));
+    connect(d->m_name, SIGNAL(textChanged(QString)),
+            this, SLOT(slotNameChanged(QString)));
     namefield->addWidget(d->m_name);
 
     label=new QLabel(i18n("Group:"), mainwidget);
     leftbox->addWidget(label);
     d->m_groups = new QTreeWidget(mainwidget);
     leftbox->addWidget(d->m_groups);
     d->m_groups->setColumnCount(1);
     d->m_groups->setHeaderHidden(true);
     d->m_groups->setRootIsDecorated(true);
     d->m_groups->setSortingEnabled(true);
 
     fillGroupTree();
     d->m_groups->sortItems(0, Qt::AscendingOrder);
 
     QHBoxLayout *bbox=new QHBoxLayout();
     leftbox->addLayout( bbox );
     d->m_add=new QPushButton(i18n("&Add Group..."), mainwidget);
     connect(d->m_add, SIGNAL(clicked()), this, SLOT(slotAddGroup()));
     bbox->addWidget(d->m_add);
     d->m_remove=new QPushButton(i18n("&Remove"), mainwidget);
     connect(d->m_remove, SIGNAL(clicked()), this, SLOT(slotRemove()));
     bbox->addWidget(d->m_remove);
 
     QVBoxLayout *rightbox=new QVBoxLayout();
     mbox->addLayout( rightbox );
     QGroupBox *pixbox = new QGroupBox(i18n("Picture"), mainwidget);
     rightbox->addWidget(pixbox);
     QVBoxLayout *pixlayout=new QVBoxLayout(pixbox );
     d->m_default=new QRadioButton(i18n("&Preview"), pixbox);
     d->m_default->setChecked(true);
     connect(d->m_default, SIGNAL(clicked()), this, SLOT(slotDefault()));
     pixlayout->addWidget(d->m_default);
     QHBoxLayout *custombox=new QHBoxLayout();
     d->m_custom=new QRadioButton(i18n("Custom:"), pixbox);
     d->m_custom->setChecked(false);
     connect(d->m_custom, SIGNAL(clicked()), this, SLOT(slotCustom()));
     custombox->addWidget(d->m_custom);
     d->m_select=new QPushButton(i18n("&Select..."), pixbox);
     connect(d->m_select, SIGNAL(clicked()), this, SLOT(slotSelect()));
     custombox->addWidget(d->m_select);
     custombox->addStretch(1);
     pixlayout->addLayout(custombox);
     d->m_preview=new QLabel(pixbox); // setPixmap() -> auto resize?
     pixlayout->addWidget(d->m_preview, 0, Qt::AlignCenter);
     pixlayout->addStretch(1);
 
     d->m_defaultTemplate = new QCheckBox( i18n("Use the new template as default"), mainwidget );
     d->m_defaultTemplate->setChecked( true );
     d->m_defaultTemplate->setVisible( false );
     d->m_defaultTemplate->setToolTip(i18n("Use the new template every time Krita starts"));
     rightbox->addWidget( d->m_defaultTemplate );
 
     enableButtonOk(false);
     d->m_changed=false;
     updatePixmap();
 
     connect(d->m_groups, SIGNAL(itemSelectionChanged()), this, SLOT(slotSelectionChanged()));
 
     d->m_remove->setEnabled(d->m_groups->currentItem());
     connect(this, SIGNAL(okClicked()), this, SLOT(slotOk()));
 }
 
 KisTemplateCreateDia::~KisTemplateCreateDia() {
     delete d;
 }
 
 void KisTemplateCreateDia::slotSelectionChanged()
 {
     const QTreeWidgetItem* item = d->m_groups->currentItem();
     d->m_remove->setEnabled( item );
     if ( ! item )
         return;
 
     if ( item->parent() != 0 )
     {
         d->m_name->setText( item->text( 0 ) );
     }
 }
 
 void KisTemplateCreateDia::createTemplate(const QString &templatesResourcePath,
                                           const char *suffix,
                                           KisDocument *document, QWidget *parent)
 {
     Q_UNUSED(suffix);
     QString fileName;
     {
         QTemporaryFile tempFile;
         if (!tempFile.open()) {
             qWarning("Creation of temporary file to store template failed.");
             return;
         }
         fileName = tempFile.fileName();
     }
 
     bool retval = document->exportDocumentSync(QUrl::fromLocalFile(fileName), KisDocument::nativeFormatMimeType());
     if (!retval) {
         qWarning("Could not save template");
         return;
     }
     const QPixmap thumbnail = document->generatePreview(QSize(thumbnailExtent, thumbnailExtent));
     KisTemplateCreateDia *dia = new KisTemplateCreateDia(templatesResourcePath, fileName, thumbnail, parent);
     dia->exec();
     delete dia;
 
     QDir d;
     d.remove(fileName);
 }
 
 static void saveAsQuadraticPng(const QPixmap &pixmap, const QString &fileName)
 {
     QImage icon = pixmap.toImage();
     icon = icon.convertToFormat(QImage::Format_ARGB32);
     const int iconExtent = qMax(icon.width(), icon.height());
     icon = icon.copy((icon.width() - iconExtent) / 2, (icon.height() - iconExtent) / 2, iconExtent, iconExtent);
     icon.save(fileName, "PNG");
 }
 
 void KisTemplateCreateDia::slotOk() {
 
     // get the current item, if there is one...
     QTreeWidgetItem *item = d->m_groups->currentItem();
     if (!item)
         item = d->m_groups->topLevelItem(0);
     if (!item) {    // safe :)
         d->m_tree.writeTemplateTree();
         slotButtonClicked( KoDialog::Cancel );
         return;
     }
     // is it a group or a template? anyway - get the group :)
     if (item->parent() != 0)
         item=item->parent();
     if (!item) {    // *very* safe :P
         d->m_tree.writeTemplateTree();
         slotButtonClicked( KoDialog::Cancel );
         return;
     }
 
     KisTemplateGroup *group=d->m_tree.find(item->text(0));
     if (!group) {    // even safer
         d->m_tree.writeTemplateTree();
         slotButtonClicked( KoDialog::Cancel );
         return;
     }
 
     if (d->m_name->text().isEmpty()) {
         d->m_tree.writeTemplateTree();
         slotButtonClicked( KoDialog::Cancel );
         return;
     }
 
     // copy the tmp file and the picture the app provides
     QString dir = KoResourcePaths::saveLocation("data", d->m_tree.templatesResourcePath());
     dir += group->name();
     QString templateDir = dir+"/.source/";
     QString iconDir = dir+"/.icon/";
 
     QString file = KisTemplates::trimmed(d->m_name->text());
     QString tmpIcon = ".icon/"+file;
     tmpIcon += ".png";
     QString icon=iconDir+file;
     icon += ".png";
 
     QString ext = ".kra";
 
     QString dest = templateDir + file + ext;
     if (QFile::exists(dest)) {
         do {
             file = file.prepend( '_' );
             dest = templateDir + file + ext;
             tmpIcon=".icon/" + file + ".png";
             icon=iconDir + file + ".png";
         }
         while (QFile(dest).exists());
     }
     bool ignore = false;
     KisTemplate *t = new KisTemplate(d->m_name->text(), QString(), ".source/"+ file + ext, tmpIcon, "", "", false, true);
     if (!group->add(t)) {
         KisTemplate *existingTemplate=group->find(d->m_name->text());
         if (existingTemplate && !existingTemplate->isHidden()) {
             if (QMessageBox::warning(this,
                                      i18nc("@title:window", "Krita"),
                                      i18n("Do you really want to overwrite the existing '%1' template?", existingTemplate->name()),
                                      QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes) {
                 group->add(t, true);
             }
             else {
                 delete t;
                 return;
             }
         }
         else {
             ignore = true;
         }
     }
 
     QDir path;
     if (!path.mkpath(templateDir) || !path.mkpath(iconDir)) {
         d->m_tree.writeTemplateTree();
         slotButtonClicked( KoDialog::Cancel );
         return;
     }
 
     QString orig;
     orig = d->m_filePath;
     // don't overwrite the hidden template file with a new non-hidden one
     if (!ignore) {
         if (!QFile::copy(d->m_filePath, dest)) {
             qWarning() << "Could not copy" << d->m_filePath << "to" << dest;
         }
 
         // save the picture as icon
         if (d->m_default->isChecked() && !d->m_thumbnail.isNull()) {
             saveAsQuadraticPng(d->m_thumbnail, icon);
         } else if (!d->m_customPixmap.isNull()) {
             saveAsQuadraticPng(d->m_customPixmap, icon);
         } else {
             warnUI << "Could not save the preview picture!";
         }
     }
 
     // if there's a .directory file, we copy this one, too
     bool ready=false;
     QStringList tmp=group->dirs();
     for(QStringList::ConstIterator it=tmp.constBegin(); it!=tmp.constEnd() && !ready; ++it) {
         if ((*it).contains(dir)==0) {
             orig = (*it) + ".directory";
             // Check if we can read the file
             if (QFile(orig).exists()) {
                 dest = dir + "/.directory";
                 // We copy the file with overwrite
                 if (!QFile(orig).copy(dest)) {
                     warnKrita << "Failed to copy from" << orig << "to" << dest;
                 }
                 ready = true;
             }
         }
     }
 
     d->m_tree.writeTemplateTree();
 
     if ( d->m_defaultTemplate->isChecked() )
     {
 
         KConfigGroup grp( KSharedConfig::openConfig(), "TemplateChooserDialog");
         grp.writeEntry( "LastReturnType", "Template" );
         grp.writePathEntry( "FullTemplateName", dir + '/' + t->file() );
         grp.writePathEntry( "AlwaysUseTemplate", dir + '/' + t->file() );
     }
 }
 
 void KisTemplateCreateDia::slotDefault() {
 
     d->m_default->setChecked(true);
     d->m_custom->setChecked(false);
     updatePixmap();
 }
 
 void KisTemplateCreateDia::slotCustom() {
 
     d->m_default->setChecked(false);
     d->m_custom->setChecked(true);
     if (d->m_customFile.isEmpty())
         slotSelect();
     else
         updatePixmap();
 }
 
 void KisTemplateCreateDia::slotSelect() {
 
     d->m_default->setChecked(false);
     d->m_custom->setChecked(true);
 
     KoFileDialog dlg(this, KoFileDialog::OpenFile, "TemplateImages");
     dlg.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dlg.setImageFilters();
     dlg.setCaption(i18n("Select an image"));
     QString fn = dlg.filename();
     if (fn.isEmpty()) {
         if (d->m_customFile.isEmpty()) {
             d->m_default->setChecked(true);
             d->m_custom->setChecked(false);
         }
         return;
     }
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     d->m_customFile = fn;
     d->m_customPixmap = QPixmap();
     updatePixmap();
 }
 
 void KisTemplateCreateDia::slotNameChanged(const QString &name) {
 
     if ( ( name.trimmed().isEmpty() || !d->m_groups->topLevelItem(0) ) && !d->m_changed )
         enableButtonOk(false);
     else
         enableButtonOk(true);
 }
 
 void KisTemplateCreateDia::slotAddGroup() {
 
     const QString name = QInputDialog::getText(this, i18n("Add Group"), i18n("Enter group name:"));
     KisTemplateGroup *group = d->m_tree.find(name);
     if (group && !group->isHidden()) {
         QMessageBox::information( this, i18n("This name is already used."), i18n("Add Group") );
         return;
     }
     QString dir = KoResourcePaths::saveLocation("data", d->m_tree.templatesResourcePath());
     dir+=name;
     KisTemplateGroup *newGroup=new KisTemplateGroup(name, dir, 0, true);
     d->m_tree.add(newGroup);
     QTreeWidgetItem *item = new QTreeWidgetItem(d->m_groups, QStringList() << name);
     d->m_groups->setCurrentItem(item);
     d->m_groups->sortItems(0, Qt::AscendingOrder);
     d->m_name->setFocus();
     enableButtonOk(true);
     d->m_changed=true;
 }
 
 void KisTemplateCreateDia::slotRemove() {
 
     QTreeWidgetItem *item = d->m_groups->currentItem();
     if (!item)
         return;
 
     QString what;
     QString removed;
     if (item->parent() == 0) {
         what =  i18n("Do you really want to remove that group?");
         removed = i18nc("@title:window", "Remove Group");
     } else {
         what =  i18n("Do you really want to remove that template?");
         removed = i18nc("@title:window", "Remove Template");
     }
 
     if (QMessageBox::warning(this,
                              removed,
                              what,
                              QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox:: No) {
         d->m_name->setFocus();
         return;
     }
 
     if (item->parent() == 0) {
         KisTemplateGroup *group=d->m_tree.find(item->text(0));
         if (group)
             group->setHidden(true);
     }
     else {
         bool done=false;
         QList<KisTemplateGroup*> groups = d->m_tree.groups();
         QList<KisTemplateGroup*>::const_iterator it = groups.constBegin();
         for(; it != groups.constEnd() && !done; ++it) {
             KisTemplate *t = (*it)->find(item->text(0));
 
             if (t) {
                 t->setHidden(true);
                 done=true;
             }
         }
     }
     delete item;
     item=0;
     enableButtonOk(true);
     d->m_name->setFocus();
     d->m_changed=true;
 }
 
 void KisTemplateCreateDia::updatePixmap() {
 
     if (d->m_default->isChecked() && !d->m_thumbnail.isNull()) {
         d->m_preview->setPixmap(d->m_thumbnail);
     }
     else if (d->m_custom->isChecked() && !d->m_customFile.isEmpty()) {
 
         if (d->m_customPixmap.isNull()) {
             dbgUI <<"Trying to load picture" << d->m_customFile;
             // use the code in KisTemplate to load the image... hacky, I know :)
             KisTemplate t("foo", "bar", QString(), d->m_customFile);
             d->m_customPixmap = t.loadPicture();
         }
         else {
             warnUI << "Trying to load picture";
         }
 
         if (!d->m_customPixmap.isNull()) {
             d->m_preview->setPixmap(d->m_customPixmap);
         }
         else {
             d->m_preview->setText(i18n("Could not load picture."));
         }
     }
     else {
         d->m_preview->setText(i18n("No picture available."));
     }
 }
 
 void KisTemplateCreateDia::fillGroupTree() {
 
     Q_FOREACH (KisTemplateGroup *group, d->m_tree.groups()) {
         if (group->isHidden())
             continue;
         QTreeWidgetItem *groupItem=new QTreeWidgetItem(d->m_groups, QStringList() << group->name());
 
         Q_FOREACH (KisTemplate *t, group->templates()) {
             if (t->isHidden())
                 continue;
             (void)new QTreeWidgetItem(groupItem, QStringList() << t->name());
         }
     }
 }
diff --git a/libs/ui/KisView.cpp b/libs/ui/KisView.cpp
index 34b7026323..4f26c4f5ac 100644
--- a/libs/ui/KisView.cpp
+++ b/libs/ui/KisView.cpp
@@ -1,1024 +1,1024 @@
 /*
  * 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 "KisView.h"
 
 #include "KisView_p.h"
 
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 #include <KoDocumentInfo.h>
 #include "KoPageLayout.h"
 #include <KoToolManager.h>
 
 #include <kis_icon.h>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kselectaction.h>
 #include <kconfiggroup.h>
 
 #include <QMenu>
 #include <QMessageBox>
 #include <QUrl>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QImage>
 #include <QList>
 #include <QPrintDialog>
 #include <QToolBar>
 #include <QStatusBar>
 #include <QMoveEvent>
 #include <QMdiSubWindow>
 
 #include <kis_image.h>
 #include <kis_node.h>
 
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_selection.h>
 
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_config.h"
 #include "KisDocument.h"
 #include "kis_image_manager.h"
 #include "KisMainWindow.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_axis.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_shape_controller.h"
 #include "kis_tool_freehand.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "kis_statusbar.h"
 #include "kis_painting_assistants_decoration.h"
 #include "KisReferenceImagesDecoration.h"
 #include "kis_progress_widget.h"
 #include "kis_signal_compressor.h"
 #include "kis_filter_manager.h"
 #include "kis_file_layer.h"
 #include "krita_utils.h"
 #include "input/kis_input_manager.h"
 #include "KisRemoteFileFetcher.h"
 #include "kis_selection_manager.h"
 
 //static
 QString KisView::newObjectName()
 {
     static int s_viewIFNumber = 0;
     QString name; name.setNum(s_viewIFNumber++); name.prepend("view_");
     return name;
 }
 
 bool KisView::s_firstView = true;
 
 class Q_DECL_HIDDEN KisView::Private
 {
 public:
     Private(KisView *_q,
             KisDocument *document,
             KoCanvasResourceManager *resourceManager,
             KActionCollection *actionCollection)
         : actionCollection(actionCollection)
         , viewConverter()
         , canvasController(_q, actionCollection)
         , canvas(&viewConverter, resourceManager, _q, document->shapeController())
         , zoomManager(_q, &this->viewConverter, &this->canvasController)
         , paintingAssistantsDecoration(new KisPaintingAssistantsDecoration(_q))
         , referenceImagesDecoration(new KisReferenceImagesDecoration(_q, document))
         , floatingMessageCompressor(100, KisSignalCompressor::POSTPONE)
     {
     }
 
     bool inOperation; //in the middle of an operation (no screen refreshing)?
 
     QPointer<KisDocument> document; // our KisDocument
     QWidget *tempActiveWidget = 0;
 
     /**
      * Signals the document has been deleted. Can't use document==0 since this
      * only happens in ~QObject, and views get deleted by ~KisDocument.
      * XXX: either provide a better justification to do things this way, or
      * rework the mechanism.
      */
     bool documentDeleted = false;
 
     KActionCollection* actionCollection;
     KisCoordinatesConverter viewConverter;
     KisCanvasController canvasController;
     KisCanvas2 canvas;
     KisZoomManager zoomManager;
     KisViewManager *viewManager = 0;
     KisNodeSP currentNode;
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration;
     KisReferenceImagesDecorationSP referenceImagesDecoration;
     bool isCurrent = false;
     bool showFloatingMessage = false;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     KisSignalCompressor floatingMessageCompressor;
     QMdiSubWindow *subWindow{nullptr};
 
     bool softProofing = false;
     bool gamutCheck = false;
 
     // Hmm sorry for polluting the private class with such a big inner class.
     // At the beginning it was a little struct :)
     class StatusBarItem
     {
     public:
 
         StatusBarItem(QWidget * widget, int stretch, bool permanent)
             : m_widget(widget),
               m_stretch(stretch),
               m_permanent(permanent),
               m_connected(false),
               m_hidden(false) {}
 
         bool operator==(const StatusBarItem& rhs) {
             return m_widget == rhs.m_widget;
         }
 
         bool operator!=(const StatusBarItem& rhs) {
             return m_widget != rhs.m_widget;
         }
 
         QWidget * widget() const {
             return m_widget;
         }
 
         void ensureItemShown(QStatusBar * sb) {
             Q_ASSERT(m_widget);
             if (!m_connected) {
                 if (m_permanent)
                     sb->addPermanentWidget(m_widget, m_stretch);
                 else
                     sb->addWidget(m_widget, m_stretch);
 
                 if(!m_hidden)
                     m_widget->show();
 
                 m_connected = true;
             }
         }
         void ensureItemHidden(QStatusBar * sb) {
             if (m_connected) {
                 m_hidden = m_widget->isHidden();
                 sb->removeWidget(m_widget);
                 m_widget->hide();
                 m_connected = false;
             }
         }
     private:
         QWidget * m_widget = 0;
         int m_stretch;
         bool m_permanent;
         bool m_connected = false;
         bool m_hidden = false;
 
     };
 
 };
 
 KisView::KisView(KisDocument *document, KoCanvasResourceManager *resourceManager, KActionCollection *actionCollection, QWidget *parent)
     : QWidget(parent)
     , d(new Private(this, document, resourceManager, actionCollection))
 {
     Q_ASSERT(document);
     connect(document, SIGNAL(titleModified(QString,bool)), this, SIGNAL(titleModified(QString,bool)));
     setObjectName(newObjectName());
 
     d->document = document;
 
     setFocusPolicy(Qt::StrongFocus);
 
     QStatusBar * sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
-        connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
-                this, SLOT(slotSavingStatusMessage(const QString&, int)));
+        connect(d->document, SIGNAL(statusBarMessage(QString,int)),
+                this, SLOT(slotSavingStatusMessage(QString,int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 
     d->canvas.setup();
 
     KisConfig cfg(false);
 
     d->canvasController.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVastScrolling(cfg.vastScrolling());
     d->canvasController.setCanvas(&d->canvas);
 
     d->zoomManager.setup(d->actionCollection);
 
 
     connect(&d->canvasController, SIGNAL(documentSizeChanged()), &d->zoomManager, SLOT(slotScrollAreaSizeChanged()));
     setAcceptDrops(true);
 
     connect(d->document, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     connect(d->document, SIGNAL(sigSavingFinished()), this, SLOT(slotSavingFinished()));
 
     d->canvas.addDecoration(d->referenceImagesDecoration);
     d->referenceImagesDecoration->setVisible(true);
 
     d->canvas.addDecoration(d->paintingAssistantsDecoration);
     d->paintingAssistantsDecoration->setVisible(true);
 
     d->showFloatingMessage = cfg.showCanvasMessages();
 }
 
 KisView::~KisView()
 {
     if (d->viewManager) {
         if (d->viewManager->filterManager()->isStrokeRunning()) {
             d->viewManager->filterManager()->cancel();
         }
 
         d->viewManager->mainWindow()->notifyChildViewDestroyed(this);
     }
 
     KoToolManager::instance()->removeCanvasController(&d->canvasController);
     d->canvasController.setCanvas(0);
 
     KisPart::instance()->removeView(this);
     delete d;
 }
 
 void KisView::notifyCurrentStateChanged(bool isCurrent)
 {
     d->isCurrent = isCurrent;
 
     if (!d->isCurrent && d->savedFloatingMessage) {
         d->savedFloatingMessage->removeMessage();
     }
 
     KisInputManager *inputManager = globalInputManager();
     if (d->isCurrent) {
         inputManager->attachPriorityEventFilter(&d->canvasController);
     } else {
         inputManager->detachPriorityEventFilter(&d->canvasController);
     }
 
     /**
      * When current view is changed, currently selected node is also changed,
      * therefore we should update selection overlay mask
      */
     viewManager()->selectionManager()->selectionChanged();
 }
 
 bool KisView::isCurrent() const
 {
     return d->isCurrent;
 }
 
 void KisView::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisView::showFloatingMessageImpl(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->viewManager) return;
 
     if(d->isCurrent && d->showFloatingMessage && d->viewManager->qtMainWindow()) {
         if (d->savedFloatingMessage) {
             d->savedFloatingMessage->tryOverrideMessage(message, icon, timeout, priority, alignment);
         } else {
             d->savedFloatingMessage = new KisFloatingMessage(message, this->canvasBase()->canvasWidget(), false, timeout, priority, alignment);
             d->savedFloatingMessage->setShowOverParent(true);
             d->savedFloatingMessage->setIcon(icon);
 
             connect(&d->floatingMessageCompressor, SIGNAL(timeout()), d->savedFloatingMessage, SLOT(showMessage()));
             d->floatingMessageCompressor.start();
         }
     }
 }
 
 bool KisView::canvasIsMirrored() const
 {
     return d->canvas.xAxisMirrored() || d->canvas.yAxisMirrored();
 }
 
 void KisView::setViewManager(KisViewManager *view)
 {
     d->viewManager = view;
 
     KoToolManager::instance()->addController(&d->canvasController);
     KoToolManager::instance()->registerToolActions(d->actionCollection, &d->canvasController);
     dynamic_cast<KisShapeController*>(d->document->shapeController())->setInitialShapeForCanvas(&d->canvas);
 
     if (resourceProvider()) {
         resourceProvider()->slotImageSizeChanged();
     }
 
     if (d->viewManager && d->viewManager->nodeManager()) {
         d->viewManager->nodeManager()->nodesUpdated();
     }
 
-    connect(image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), this, SLOT(slotImageSizeChanged(const QPointF&, const QPointF&)));
+    connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SLOT(slotImageSizeChanged(QPointF,QPointF)));
     connect(image(), SIGNAL(sigResolutionChanged(double,double)), this, SLOT(slotImageResolutionChanged()));
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)),
             SLOT(slotImageNodeAdded(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueAddNode(KisNodeSP)),
             SLOT(slotContinueAddNode(KisNodeSP)),
             Qt::AutoConnection);
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
             SLOT(slotImageNodeRemoved(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueRemoveNode(KisNodeSP)),
             SLOT(slotContinueRemoveNode(KisNodeSP)),
             Qt::AutoConnection);
 
     d->viewManager->updateGUI();
 
     KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 }
 
 KisViewManager* KisView::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisView::slotImageNodeAdded(KisNodeSP node)
 {
     emit sigContinueAddNode(node);
 }
 
 void KisView::slotContinueAddNode(KisNodeSP newActiveNode)
 {
     /**
      * When deleting the last layer, root node got selected. We should
      * fix it when the first layer is added back.
      *
      * Here we basically reimplement what Qt's view/model do. But
      * since they are not connected, we should do it manually.
      */
 
     if (!d->isCurrent &&
             (!d->currentNode || !d->currentNode->parent())) {
 
         d->currentNode = newActiveNode;
     }
 }
 
 
 void KisView::slotImageNodeRemoved(KisNodeSP node)
 {
     emit sigContinueRemoveNode(KritaUtils::nearestNodeAfterRemoval(node));
 }
 
 void KisView::slotContinueRemoveNode(KisNodeSP newActiveNode)
 {
     if (!d->isCurrent) {
         d->currentNode = newActiveNode;
     }
 }
 
 KoZoomController *KisView::zoomController() const
 {
     return d->zoomManager.zoomController();
 }
 
 KisZoomManager *KisView::zoomManager() const
 {
     return &d->zoomManager;
 }
 
 KisCanvasController *KisView::canvasController() const
 {
     return &d->canvasController;
 }
 
 KisCanvasResourceProvider *KisView::resourceProvider() const
 {
     if (d->viewManager) {
         return d->viewManager->resourceProvider();
     }
     return 0;
 }
 
 KisInputManager* KisView::globalInputManager() const
 {
     return d->viewManager ? d->viewManager->inputManager() : 0;
 }
 
 KisCanvas2 *KisView::canvasBase() const
 {
     return &d->canvas;
 }
 
 KisImageWSP KisView::image() const
 {
     if (d->document) {
         return d->document->image();
     }
     return 0;
 }
 
 KisCoordinatesConverter *KisView::viewConverter() const
 {
     return &d->viewConverter;
 }
 
 void KisView::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasImage()
             || event->mimeData()->hasUrls()
             || event->mimeData()->hasFormat("application/x-krita-node")) {
         event->accept();
 
         // activate view if it should accept the drop
         this->setFocus();
     } else {
         event->ignore();
     }
 }
 
 void KisView::dropEvent(QDropEvent *event)
 {
     KisImageWSP kisimage = image();
     Q_ASSERT(kisimage);
 
     QPoint cursorPos = canvasBase()->coordinatesConverter()->widgetToImage(event->pos()).toPoint();
     QRect imageBounds = kisimage->bounds();
     QPoint pasteCenter;
     bool forceRecenter;
 
     if (event->keyboardModifiers() & Qt::ShiftModifier &&
             imageBounds.contains(cursorPos)) {
 
         pasteCenter = cursorPos;
         forceRecenter = true;
     } else {
         pasteCenter = imageBounds.center();
         forceRecenter = false;
     }
     if (event->mimeData()->hasFormat("application/x-krita-node") ||
             event->mimeData()->hasImage())
     {
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(d->document->shapeController());
 
         QList<KisNodeSP> nodes =
                 KisMimeData::loadNodes(event->mimeData(), imageBounds,
                                        pasteCenter, forceRecenter,
                                        kisimage, kritaShapeController);
 
         Q_FOREACH (KisNodeSP node, nodes) {
             if (node) {
                 KisNodeCommandsAdapter adapter(viewManager());
                 if (!viewManager()->nodeManager()->activeLayer()) {
                     adapter.addNode(node, kisimage->rootLayer() , 0);
                 } else {
                     adapter.addNode(node,
                                     viewManager()->nodeManager()->activeLayer()->parent(),
                                     viewManager()->nodeManager()->activeLayer());
                 }
             }
         }
     }
     else if (event->mimeData()->hasUrls()) {
 
         QList<QUrl> urls = event->mimeData()->urls();
         if (urls.length() > 0) {
 
             QMenu popup;
             popup.setObjectName("drop_popup");
 
             QAction *insertAsNewLayer = new QAction(i18n("Insert as New Layer"), &popup);
             QAction *insertManyLayers = new QAction(i18n("Insert Many Layers"), &popup);
 
             QAction *insertAsNewFileLayer = new QAction(i18n("Insert as New File Layer"), &popup);
             QAction *insertManyFileLayers = new QAction(i18n("Insert Many File Layers"), &popup);
 
             QAction *openInNewDocument = new QAction(i18n("Open in New Document"), &popup);
             QAction *openManyDocuments = new QAction(i18n("Open Many Documents"), &popup);
 
             QAction *insertAsReferenceImage = new QAction(i18n("Insert as Reference Image"), &popup);
             QAction *insertAsReferenceImages = new QAction(i18n("Insert as Reference Images"), &popup);
 
             QAction *cancel = new QAction(i18n("Cancel"), &popup);
 
             popup.addAction(insertAsNewLayer);
             popup.addAction(insertAsNewFileLayer);
             popup.addAction(openInNewDocument);
             popup.addAction(insertAsReferenceImage);
 
             popup.addAction(insertManyLayers);
             popup.addAction(insertManyFileLayers);
             popup.addAction(openManyDocuments);
             popup.addAction(insertAsReferenceImages);
 
             insertAsNewLayer->setEnabled(image() && urls.count() == 1);
             insertAsNewFileLayer->setEnabled(image() && urls.count() == 1);
             openInNewDocument->setEnabled(urls.count() == 1);
             insertAsReferenceImage->setEnabled(image() && urls.count() == 1);
 
             insertManyLayers->setEnabled(image() && urls.count() > 1);
             insertManyFileLayers->setEnabled(image() && urls.count() > 1);
             openManyDocuments->setEnabled(urls.count() > 1);
             insertAsReferenceImages->setEnabled(image() && urls.count() > 1);
 
             popup.addSeparator();
             popup.addAction(cancel);
 
             QAction *action = popup.exec(QCursor::pos());
             if (action != 0 && action != cancel) {
                 QTemporaryFile *tmp = 0;
                 for (QUrl url : urls) {
 
                     if (!url.isLocalFile()) {
                         // download the file and substitute the url
                         KisRemoteFileFetcher fetcher;
                         tmp = new QTemporaryFile();
                         tmp->setAutoRemove(true);
                         if (!fetcher.fetchFile(url, tmp)) {
                             qDebug() << "Fetching" << url << "failed";
                             continue;
                         }
                         url = url.fromLocalFile(tmp->fileName());
                     }
                     if (url.isLocalFile()) {
                         if (action == insertAsNewLayer || action == insertManyLayers) {
                             d->viewManager->imageManager()->importImage(url);
                             activateWindow();
                         }
                         else if (action == insertAsNewFileLayer || action == insertManyFileLayers) {
                             KisNodeCommandsAdapter adapter(viewManager());
                             KisFileLayer *fileLayer = new KisFileLayer(image(), "", url.toLocalFile(),
                                                                        KisFileLayer::None, image()->nextLayerName(), OPACITY_OPAQUE_U8);
                             adapter.addNode(fileLayer, viewManager()->activeNode()->parent(), viewManager()->activeNode());
                         }
                         else if (action == openInNewDocument || action == openManyDocuments) {
                             if (mainWindow()) {
                                 mainWindow()->openDocument(url, KisMainWindow::None);
                             }
                         }
                         else if (action == insertAsReferenceImage || action == insertAsReferenceImages) {
                             auto *reference = KisReferenceImage::fromFile(url.toLocalFile(), d->viewConverter, this);
 
                             if (reference) {
                                 reference->setPosition(d->viewConverter.imageToDocument(cursorPos));
                                 d->referenceImagesDecoration->addReferenceImage(reference);
 
                                 KoToolManager::instance()->switchToolRequested("ToolReferenceImages");
                             }
                         }
 
                     }
                     delete tmp;
                     tmp = 0;
                 }
             }
         }
     }
 
 }
 
 KisDocument *KisView::document() const
 {
     return d->document;
 }
 
 void KisView::setDocument(KisDocument *document)
 {
     d->document->disconnect(this);
     d->document = document;
     QStatusBar *sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
-        connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
-                this, SLOT(slotSavingStatusMessage(const QString&, int)));
+        connect(d->document, SIGNAL(statusBarMessage(QString,int)),
+                this, SLOT(slotSavingStatusMessage(QString,int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 }
 
 void KisView::setDocumentDeleted()
 {
     d->documentDeleted = true;
 }
 
 QPrintDialog *KisView::createPrintDialog(KisPrintJob *printJob, QWidget *parent)
 {
     Q_UNUSED(parent);
     QPrintDialog *printDialog = new QPrintDialog(&printJob->printer(), this);
     printDialog->setMinMax(printJob->printer().fromPage(), printJob->printer().toPage());
     printDialog->setEnabledOptions(printJob->printDialogOptions());
     return printDialog;
 }
 
 
 KisMainWindow * KisView::mainWindow() const
 {
     return dynamic_cast<KisMainWindow *>(window());
 }
 
 void KisView::setSubWindow(QMdiSubWindow *subWindow)
 {
     d->subWindow = subWindow;
 }
 
 QStatusBar * KisView::statusBar() const
 {
     KisMainWindow *mw = mainWindow();
     return mw ? mw->statusBar() : 0;
 }
 
 void KisView::slotSavingStatusMessage(const QString &text, int timeout, bool isAutoSaving)
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->showMessage(text, timeout);
     }
 
     KisConfig cfg(true);
 
     if (!sb || sb->isHidden() ||
         (!isAutoSaving && cfg.forceShowSaveMessages()) ||
         (cfg.forceShowAutosaveMessages() && isAutoSaving)) {
 
         viewManager()->showFloatingMessage(text, QIcon());
     }
 }
 
 void KisView::slotClearStatusText()
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->clearMessage();
     }
 }
 
 QList<QAction*> KisView::createChangeUnitActions(bool addPixelUnit)
 {
     UnitActionGroup* unitActions = new UnitActionGroup(d->document, addPixelUnit, this);
     return unitActions->actions();
 }
 
 void KisView::closeEvent(QCloseEvent *event)
 {
     // Check whether we're the last (user visible) view
     int viewCount = KisPart::instance()->viewCount(document());
     if (viewCount > 1 || !isVisible()) {
         // there are others still, so don't bother the user
         event->accept();
         return;
     }
 
     if (queryClose()) {
         d->viewManager->statusBar()->setView(0);
         event->accept();
         return;
     }
 
     event->ignore();
 
 }
 
 bool KisView::queryClose()
 {
     if (!document())
         return true;
 
     document()->waitForSavingToComplete();
 
     if (document()->isModified()) {
         QString name;
         if (document()->documentInfo()) {
             name = document()->documentInfo()->aboutInfo("title");
         }
         if (name.isEmpty())
             name = document()->url().fileName();
 
         if (name.isEmpty())
             name = i18n("Untitled");
 
         int res = QMessageBox::warning(this,
                                        i18nc("@title:window", "Krita"),
                                        i18n("<p>The document <b>'%1'</b> has been modified.</p><p>Do you want to save it?</p>", name),
                                        QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
 
         switch (res) {
         case QMessageBox::Yes : {
             bool isNative = (document()->mimeType() == document()->nativeFormatMimeType());
             if (!viewManager()->mainWindow()->saveDocument(document(), !isNative, false))
                 return false;
             break;
         }
         case QMessageBox::No : {
             KisImageSP image = document()->image();
             image->requestStrokeCancellation();
             viewManager()->blockUntilOperationsFinishedForced(image);
 
             document()->removeAutoSaveFiles(document()->localFilePath(), document()->isRecovered());
             document()->setModified(false);   // Now when queryClose() is called by closeEvent it won't do anything.
             break;
         }
         default : // case QMessageBox::Cancel :
             return false;
         }
     }
 
     return true;
 
 }
 
 void KisView::resetImageSizeAndScroll(bool changeCentering,
                                       const QPointF &oldImageStillPoint,
                                       const QPointF &newImageStillPoint)
 {
     const KisCoordinatesConverter *converter = d->canvas.coordinatesConverter();
 
     QPointF oldPreferredCenter = d->canvasController.preferredCenter();
 
     /**
      * Calculating the still point in old coordinates depending on the
      * parameters given
      */
 
     QPointF oldStillPoint;
 
     if (changeCentering) {
         oldStillPoint =
                 converter->imageToWidget(oldImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize oldDocumentSize = d->canvasController.documentSize();
         oldStillPoint = QPointF(0.5 * oldDocumentSize.width(), 0.5 * oldDocumentSize.height());
     }
 
     /**
      * Updating the document size
      */
 
     QSizeF size(image()->width() / image()->xRes(), image()->height() / image()->yRes());
     KoZoomController *zc = d->zoomManager.zoomController();
     zc->setZoom(KoZoomMode::ZOOM_CONSTANT, zc->zoomAction()->effectiveZoom());
     zc->setPageSize(size);
     zc->setDocumentSize(size, true);
 
     /**
      * Calculating the still point in new coordinates depending on the
      * parameters given
      */
 
     QPointF newStillPoint;
 
     if (changeCentering) {
         newStillPoint =
                 converter->imageToWidget(newImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize newDocumentSize = d->canvasController.documentSize();
         newStillPoint = QPointF(0.5 * newDocumentSize.width(), 0.5 * newDocumentSize.height());
     }
 
     d->canvasController.setPreferredCenter(oldPreferredCenter - oldStillPoint + newStillPoint);
 }
 
 void KisView::syncLastActiveNodeToDocument()
 {
     KisDocument *doc = document();
     if (doc) {
         doc->setPreActivatedNode(d->currentNode);
     }
 }
 
 void KisView::saveViewState(KisPropertiesConfiguration &config) const
 {
     config.setProperty("file", d->document->url());
     config.setProperty("window", mainWindow()->windowStateConfig().name());
 
     if (d->subWindow) {
         config.setProperty("geometry", d->subWindow->saveGeometry().toBase64());
     }
 
     config.setProperty("zoomMode", (int)zoomController()->zoomMode());
     config.setProperty("zoom", d->canvas.coordinatesConverter()->zoom());
 
     d->canvasController.saveCanvasState(config);
 }
 
 void KisView::restoreViewState(const KisPropertiesConfiguration &config)
 {
     if (d->subWindow) {
         QByteArray geometry = QByteArray::fromBase64(config.getString("geometry", "").toLatin1());
         d->subWindow->restoreGeometry(QByteArray::fromBase64(geometry));
     }
 
     qreal zoom = config.getFloat("zoom", 1.0f);
     int zoomMode = config.getInt("zoomMode", (int)KoZoomMode::ZOOM_PAGE);
     d->zoomManager.zoomController()->setZoom((KoZoomMode::Mode)zoomMode, zoom);
     d->canvasController.restoreCanvasState(config);
 }
 
 void KisView::setCurrentNode(KisNodeSP node)
 {
     d->currentNode = node;
     d->canvas.slotTrySwitchShapeManager();
 
     syncLastActiveNodeToDocument();
 }
 
 KisNodeSP KisView::currentNode() const
 {
     return d->currentNode;
 }
 
 KisLayerSP KisView::currentLayer() const
 {
     KisNodeSP node;
     KisMaskSP mask = currentMask();
     if (mask) {
         node = mask->parent();
     }
     else {
         node = d->currentNode;
     }
     return qobject_cast<KisLayer*>(node.data());
 }
 
 KisMaskSP KisView::currentMask() const
 {
     return dynamic_cast<KisMask*>(d->currentNode.data());
 }
 
 KisSelectionSP KisView::selection()
 {
     KisLayerSP layer = currentLayer();
     if (layer)
         return layer->selection(); // falls through to the global
     // selection, or 0 in the end
     if (image()) {
         return image()->globalSelection();
     }
     return 0;
 }
 
 void KisView::slotSoftProofing(bool softProofing)
 {
     d->softProofing = softProofing;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Soft Proofing doesn't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
     if (softProofing){
         message = i18n("Soft Proofing turned on.");
     } else {
         message = i18n("Soft Proofing turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotSoftProofing(softProofing);
 }
 
 void KisView::slotGamutCheck(bool gamutCheck)
 {
     d->gamutCheck = gamutCheck;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Gamut Warnings don't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
 
     if (gamutCheck){
         message = i18n("Gamut Warnings turned on.");
         if (!d->softProofing){
             message += "\n "+i18n("But Soft Proofing is still off.");
         }
     } else {
         message = i18n("Gamut Warnings turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotGamutCheck(gamutCheck);
 }
 
 bool KisView::softProofing()
 {
     return d->softProofing;
 }
 
 bool KisView::gamutCheck()
 {
     return d->gamutCheck;
 }
 
 void KisView::slotLoadingFinished()
 {
     if (!document()) return;
 
     /**
      * Cold-start of image size/resolution signals
      */
     slotImageResolutionChanged();
 
     if (image()->locked()) {
         // If this is the first view on the image, the image will have been locked
         // so unlock it.
         image()->blockSignals(false);
         image()->unlock();
     }
 
     canvasBase()->initializeImage();
 
     /**
      * Dirty hack alert
      */
     d->zoomManager.zoomController()->setAspectMode(true);
 
     if (viewConverter()) {
         viewConverter()->setZoomMode(KoZoomMode::ZOOM_PAGE);
     }
     connect(image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), this, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)));
     connect(image(), SIGNAL(sigProfileChanged(const KoColorProfile*)), this, SIGNAL(sigProfileChanged(const KoColorProfile*)));
     connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SIGNAL(sigSizeChanged(QPointF,QPointF)));
 
     KisNodeSP activeNode = document()->preActivatedNode();
 
     if (!activeNode) {
         activeNode = image()->rootLayer()->lastChild();
     }
 
     while (activeNode && !activeNode->inherits("KisLayer")) {
         activeNode = activeNode->prevSibling();
     }
 
     setCurrentNode(activeNode);
     zoomManager()->updateImageBoundsSnapping();
 }
 
 void KisView::slotSavingFinished()
 {
     if (d->viewManager && d->viewManager->mainWindow()) {
         d->viewManager->mainWindow()->updateCaption();
     }
 }
 
 KisPrintJob * KisView::createPrintJob()
 {
     return new KisPrintJob(image());
 }
 
 void KisView::slotImageResolutionChanged()
 {
     resetImageSizeAndScroll(false);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 
     // update KoUnit value for the document
     if (resourceProvider()) {
         resourceProvider()->resourceManager()->
                 setResource(KoCanvasResourceManager::Unit, d->canvas.unit());
     }
 }
 
 void KisView::slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint)
 {
     resetImageSizeAndScroll(true, oldStillPoint, newStillPoint);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 }
 
 void KisView::closeView()
 {
     d->subWindow->close();
 }
diff --git a/libs/ui/KisViewManager.cpp b/libs/ui/KisViewManager.cpp
index 49f340d0e9..3260d8504d 100644
--- a/libs/ui/KisViewManager.cpp
+++ b/libs/ui/KisViewManager.cpp
@@ -1,1392 +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 <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&)),
+                    image(), SIGNAL(sigSizeChanged(QPointF,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 &)));
+    connect(d->actionAuthor, SIGNAL(triggered(QString)), this, SLOT(changeAuthorProfile(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() && cfg.useOpenGL());
 }
diff --git a/libs/ui/KisWindowLayoutManager.cpp b/libs/ui/KisWindowLayoutManager.cpp
index 80bd18ac61..26e7ccdc58 100644
--- a/libs/ui/KisWindowLayoutManager.cpp
+++ b/libs/ui/KisWindowLayoutManager.cpp
@@ -1,243 +1,243 @@
 /*
  *  Copyright (c) 2018 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 "KisWindowLayoutManager.h"
 
 #include <QWidget>
 #include <QDesktopWidget>
 #include <QScreen>
 
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <KisApplication.h>
 #include <KisMainWindow.h>
 #include <KisPart.h>
 #include <kis_dom_utils.h>
 #include <KisResourceServerProvider.h>
 #include <KisSessionResource.h>
 
 Q_GLOBAL_STATIC(KisWindowLayoutManager, s_instance)
 
 struct KisWindowLayoutManager::Private {
     bool showImageInAllWindows{false};
     bool primaryWorkspaceFollowsFocus{false};
     QUuid primaryWindow;
 
     QVector<DisplayLayout*> displayLayouts;
 
     void loadDisplayLayouts() {
         KConfigGroup layoutsCfg(KSharedConfig::openConfig(), "DisplayLayouts");
         QStringList groups = layoutsCfg.groupList();
 
         Q_FOREACH(QString name, groups) {
             loadDisplayLayout(name, layoutsCfg.group(name));
         }
     }
 
     void loadDisplayLayout(const QString &name, KConfigGroup layoutCfg) {
         DisplayLayout *layout = new DisplayLayout();
         layout->name = name;
 
         int displayNumber = 1;
 
         while (true) {
             const QString displayDefinition = layoutCfg.readEntry(QString("Display%1").arg(displayNumber++), QString());
             if (displayDefinition.isEmpty()) break;
 
             // Just the resolution for now. Later we might want to split by a separator and include things like serial number, etc.
             const QString &resolutionStr = displayDefinition;
 
             QStringList dimensions = resolutionStr.split('x');
             if (dimensions.size() != 2) {
                 qWarning() << "Invalid display definition: " << displayDefinition;
                 break;
             }
 
             QSize resolution = QSize(
                 KisDomUtils::toInt(dimensions[0]),
                 KisDomUtils::toInt(dimensions[1])
             );
 
             layout->displays.append(Display{resolution});
         }
 
         layout->preferredWindowLayout = layoutCfg.readEntry("PreferredLayout", "");
 
         displayLayouts.append(layout);
     }
 
     void saveDisplayLayout(const DisplayLayout &layout) {
         KConfigGroup layoutsCfg(KSharedConfig::openConfig(), "DisplayLayouts");
         KConfigGroup layoutCfg = layoutsCfg.group(layout.name);
         layoutCfg.writeEntry("PreferredLayout", layout.preferredWindowLayout);
     }
 };
 
 bool KisWindowLayoutManager::Display::matches(QScreen* screen) const
 {
     return resolution == screen->geometry().size();
 }
 
 bool KisWindowLayoutManager::DisplayLayout::matches(QList<QScreen*> screens) const
 {
     if (screens.size() != displays.size()) return false;
 
     QVector<bool> matchedScreens(screens.size());
     Q_FOREACH(auto &expectedDisplay, displays) {
         int i;
         for (i = 0; i < screens.size(); i++) {
             if (matchedScreens[i]) continue;
 
             if (expectedDisplay.matches(screens[i])) {
                 matchedScreens[i] = true;
                 break;
             }
         }
 
         if (i == screens.size()) {
             return false;
         }
     }
 
     return true;
 }
 
 KisWindowLayoutManager * KisWindowLayoutManager::instance()
 {
     return s_instance;
 }
 
 KisWindowLayoutManager::KisWindowLayoutManager()
     : d(new Private)
 {
     d->loadDisplayLayouts();
 
     connect(qobject_cast<KisApplication*>(KisApplication::instance()),
-            SIGNAL(focusChanged(QWidget*, QWidget*)),
-            this, SLOT(slotFocusChanged(QWidget*, QWidget*)));
+            SIGNAL(focusChanged(QWidget*,QWidget*)),
+            this, SLOT(slotFocusChanged(QWidget*,QWidget*)));
 
     connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(slotScreensChanged()));
     connect(QApplication::desktop(), SIGNAL(screenCountChanged(int)), this, SLOT(slotScreensChanged()));
 }
 
 KisWindowLayoutManager::~KisWindowLayoutManager() {
     Q_FOREACH(DisplayLayout *layout, d->displayLayouts) {
         delete layout;
     }
 }
 
 void KisWindowLayoutManager::setShowImageInAllWindowsEnabled(bool showInAll)
 {
     bool wasEnabled = d->showImageInAllWindows;
 
     d->showImageInAllWindows = showInAll;
 
     if (!wasEnabled && showInAll) {
         KisMainWindow *currentMainWindow = KisPart::instance()->currentMainwindow();
         if (currentMainWindow) {
             KisView *activeView = currentMainWindow->activeView();
             if (activeView) {
                 KisDocument *document = activeView->document();
                 if (document) {
                    activeDocumentChanged(document);
                 }
             }
         }
     }
 }
 
 bool KisWindowLayoutManager::isShowImageInAllWindowsEnabled() const
 {
     return d->showImageInAllWindows;
 }
 
 bool KisWindowLayoutManager::primaryWorkspaceFollowsFocus() const
 {
     return d->primaryWorkspaceFollowsFocus;
 }
 
 void KisWindowLayoutManager::setPrimaryWorkspaceFollowsFocus(bool enabled, QUuid primaryWindow)
 {
     d->primaryWorkspaceFollowsFocus = enabled;
     d->primaryWindow = primaryWindow;
 }
 
 QUuid KisWindowLayoutManager::primaryWindowId() const
 {
     return d->primaryWindow;
 }
 
 void KisWindowLayoutManager::activeDocumentChanged(KisDocument *document)
 {
     if (d->showImageInAllWindows) {
         Q_FOREACH(QPointer<KisMainWindow> window, KisPart::instance()->mainWindows()) {
             if (window->isHidden()) continue;
 
             const auto view = window->activeView();
             if (!view || view->document() != document) {
                 window->showDocument(document);
             }
         }
     }
 }
 
 void KisWindowLayoutManager::slotFocusChanged(QWidget *old, QWidget *now)
 {
     Q_UNUSED(old);
 
     if (!now) return;
     KisMainWindow *newMainWindow = qobject_cast<KisMainWindow*>(now->window());
     if (!newMainWindow) return;
 
     newMainWindow->windowFocused();
 }
 
 void KisWindowLayoutManager::setLastUsedLayout(const KisWindowLayoutResource *layout)
 {
     // For automatic switching, only allow a window layout proper
     auto *session = dynamic_cast<const KisSessionResource*>(layout);
     if (session) return;
 
     QList<QScreen*> screens = QGuiApplication::screens();
     Q_FOREACH(DisplayLayout *displayLayout, d->displayLayouts) {
         if (displayLayout->matches(screens)) {
             displayLayout->preferredWindowLayout = layout->name();
             d->saveDisplayLayout(*displayLayout);
             break;
         }
     }
 }
 
 void KisWindowLayoutManager::slotScreensChanged()
 {
     QList<QScreen*> screens = QGuiApplication::screens();
 
     Q_FOREACH(const DisplayLayout *displayLayout, d->displayLayouts) {
         if (displayLayout->matches(screens)) {
             KoResourceServer<KisWindowLayoutResource> *windowLayoutServer = KisResourceServerProvider::instance()->windowLayoutServer();
             KisWindowLayoutResource *layout = windowLayoutServer->resourceByName(displayLayout->preferredWindowLayout);
 
             if (layout) {
                 setLastUsedLayout(layout);
                 layout->applyLayout();
                 return;
             }
         }
     }
 }
diff --git a/libs/ui/brushhud/kis_brush_hud.cpp b/libs/ui/brushhud/kis_brush_hud.cpp
index 60fa77a7ec..93a40399bd 100644
--- a/libs/ui/brushhud/kis_brush_hud.cpp
+++ b/libs/ui/brushhud/kis_brush_hud.cpp
@@ -1,286 +1,286 @@
 /*
  *  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_brush_hud.h"
 
 #include <QGuiApplication>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QPointer>
 #include <QLabel>
 #include <QPainter>
 #include <QPaintEvent>
 #include <QScrollArea>
 #include <QEvent>
 #include <QToolButton>
 
 
 #include "kis_uniform_paintop_property.h"
 #include "kis_slider_based_paintop_property.h"
 #include "kis_uniform_paintop_property_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_paintop_settings_update_proxy.h"
 #include "kis_icon_utils.h"
 #include "kis_dlg_brush_hud_config.h"
 #include "kis_brush_hud_properties_config.h"
 #include "kis_elided_label.h"
 
 #include "kis_debug.h"
 
 
 struct KisBrushHud::Private
 {
     QPointer<KisElidedLabel> lblPresetName;
     QPointer<QLabel> lblPresetIcon;
     QPointer<QWidget> wdgProperties;
     QPointer<QScrollArea> wdgPropertiesArea;
     QPointer<QVBoxLayout> propertiesLayout;
     QPointer<QToolButton> btnConfigure;
 
     KisCanvasResourceProvider *provider;
 
     KisSignalAutoConnectionsStore connections;
     KisSignalAutoConnectionsStore presetConnections;
 
     KisPaintOpPresetSP currentPreset;
 };
 
 KisBrushHud::KisBrushHud(KisCanvasResourceProvider *provider, QWidget *parent)
     : QWidget(parent, Qt::FramelessWindowHint),
       m_d(new Private)
 {
     m_d->provider = provider;
 
     QVBoxLayout *layout = new QVBoxLayout();
 
     QHBoxLayout *labelLayout = new QHBoxLayout();
     m_d->lblPresetIcon = new QLabel(this);
     const QSize iconSize = QSize(22,22);
     m_d->lblPresetIcon->setMinimumSize(iconSize);
     m_d->lblPresetIcon->setMaximumSize(iconSize);
     m_d->lblPresetIcon->setScaledContents(true);
 
     m_d->lblPresetName = new KisElidedLabel("<Preset Name>", Qt::ElideMiddle, this);
 
     m_d->btnConfigure = new QToolButton(this);
     m_d->btnConfigure->setAutoRaise(true);
 
 
 
     connect(m_d->btnConfigure, SIGNAL(clicked()), SLOT(slotConfigBrushHud()));
 
     labelLayout->addWidget(m_d->lblPresetIcon);
     labelLayout->addWidget(m_d->lblPresetName);
     labelLayout->addWidget(m_d->btnConfigure);
 
     layout->addLayout(labelLayout);
 
     m_d->wdgPropertiesArea = new QScrollArea(this);
     m_d->wdgPropertiesArea->setAlignment(Qt::AlignLeft | Qt::AlignTop);
     m_d->wdgPropertiesArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
     m_d->wdgPropertiesArea->setWidgetResizable(true);
 
     m_d->wdgProperties = new QWidget(this);
     m_d->propertiesLayout = new QVBoxLayout(this);
     m_d->propertiesLayout->setSpacing(0);
     m_d->propertiesLayout->setContentsMargins(0, 0, 22, 0);
     m_d->propertiesLayout->setSizeConstraint(QLayout::SetMinimumSize);
 
     // not adding any widgets until explicitly requested
 
     m_d->wdgProperties->setLayout(m_d->propertiesLayout);
     m_d->wdgPropertiesArea->setWidget(m_d->wdgProperties);
     layout->addWidget(m_d->wdgPropertiesArea);
 
     updateIcons();
 
     setLayout(layout);
     setCursor(Qt::ArrowCursor);
 
     // Prevent tablet events from being captured by the canvas
     setAttribute(Qt::WA_NoMousePropagation, true);
 }
 
 
 
 KisBrushHud::~KisBrushHud()
 {
 }
 
 QSize KisBrushHud::sizeHint() const
 {
     QSize size = QWidget::sizeHint();
     return QSize(size.width(), parentWidget()->height());
 }
 
 void KisBrushHud::updateIcons()
 {
     m_d->btnConfigure->setIcon(KisIconUtils::loadIcon("applications-system"));
 }
 
 void KisBrushHud::slotReloadProperties()
 {
     m_d->presetConnections.clear();
     clearProperties();
     updateProperties();
 }
 
 void KisBrushHud::clearProperties() const
 {
     while (m_d->propertiesLayout->count()) {
         QLayoutItem *item = m_d->propertiesLayout->takeAt(0);
 
         QWidget *w = item->widget();
         if (w) {
             w->deleteLater();
         }
 
         delete item;
     }
 
     m_d->currentPreset.clear();
 }
 
 void KisBrushHud::updateProperties()
 {
     KisPaintOpPresetSP preset = m_d->provider->currentPreset();
 
     if (preset == m_d->currentPreset) return;
 
     m_d->presetConnections.clear();
     clearProperties();
 
     m_d->currentPreset = preset;
     m_d->presetConnections.addConnection(
         m_d->currentPreset->updateProxy(), SIGNAL(sigUniformPropertiesChanged()),
         this, SLOT(slotReloadProperties()));
 
     m_d->lblPresetIcon->setPixmap(QPixmap::fromImage(preset->image()));
     m_d->lblPresetName->setLongText(preset->name());
 
     QList<KisUniformPaintOpPropertySP> properties;
 
     {
         QList<KisUniformPaintOpPropertySP> allProperties = preset->uniformProperties();
         QList<KisUniformPaintOpPropertySP> discardedProperties;
 
         KisBrushHudPropertiesConfig cfg;
         cfg.filterProperties(preset->paintOp().id(),
                              allProperties,
                              &properties,
                              &discardedProperties);
     }
 
     Q_FOREACH(auto property, properties) {
         QWidget *w = 0;
 
         if (!property->isVisible()) continue;
 
         if (property->type() == KisUniformPaintOpProperty::Int) {
             w = new KisUniformPaintOpPropertyIntSlider(property, m_d->wdgProperties);
         } else if (property->type() == KisUniformPaintOpProperty::Double) {
             w = new KisUniformPaintOpPropertyDoubleSlider(property, m_d->wdgProperties);
         } else if (property->type() == KisUniformPaintOpProperty::Bool) {
             w = new KisUniformPaintOpPropertyCheckBox(property, m_d->wdgProperties);
         } else if (property->type() == KisUniformPaintOpProperty::Combo) {
             w = new KisUniformPaintOpPropertyComboBox(property, m_d->wdgProperties);
         }
 
         if (w) {
             w->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
             m_d->propertiesLayout->addWidget(w);
         }
     }
 
     m_d->propertiesLayout->addStretch();
 }
 
 void KisBrushHud::showEvent(QShowEvent *event)
 {
     m_d->connections.clear();
     m_d->connections.addUniqueConnection(
-        m_d->provider->resourceManager(), SIGNAL(canvasResourceChanged(int, QVariant)),
-        this, SLOT(slotCanvasResourceChanged(int, QVariant)));
+        m_d->provider->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+        this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     updateProperties();
 
     QWidget::showEvent(event);
 }
 
 void KisBrushHud::hideEvent(QHideEvent *event)
 {
     m_d->connections.clear();
     QWidget::hideEvent(event);
 
     clearProperties();
 }
 
 void KisBrushHud::slotCanvasResourceChanged(int key, const QVariant &resource)
 {
     Q_UNUSED(resource);
 
     if (key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
         updateProperties();
     }
 }
 
 void KisBrushHud::paintEvent(QPaintEvent *event)
 {
     QColor bgColor = palette().color(QPalette::Window);
 
     QPainter painter(this);
     painter.fillRect(rect() & event->rect(), bgColor);
     painter.end();
 
     QWidget::paintEvent(event);
 }
 
 bool KisBrushHud::event(QEvent *event)
 {
     switch (event->type()) {
     case QEvent::TabletPress:
     case QEvent::TabletMove:
     case QEvent::TabletRelease:
         // Allow the tablet event to be translated to a mouse event on certain platforms
         break;
     case QEvent::MouseButtonPress:
     case QEvent::MouseMove:
     case QEvent::MouseButtonRelease:
     case QEvent::Wheel:
         event->accept();
         return true;
     default:
         break;
     }
 
     return QWidget::event(event);
 }
 
 void KisBrushHud::slotConfigBrushHud()
 {
     if (!m_d->currentPreset) return;
 
     KisDlgConfigureBrushHud dlg(m_d->currentPreset);
     dlg.exec();
 
     slotReloadProperties();
 }
diff --git a/libs/ui/brushhud/kis_uniform_paintop_property_widget.cpp b/libs/ui/brushhud/kis_uniform_paintop_property_widget.cpp
index 06736238af..c531494ba0 100644
--- a/libs/ui/brushhud/kis_uniform_paintop_property_widget.cpp
+++ b/libs/ui/brushhud/kis_uniform_paintop_property_widget.cpp
@@ -1,225 +1,225 @@
 /*
  *  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_uniform_paintop_property_widget.h"
 
 #include <QVBoxLayout>
 #include <QCheckBox>
 #include <QComboBox>
 
 #include "kis_slider_spin_box.h"
 #include "kis_acyclic_signal_connector.h"
 #include "kis_slider_based_paintop_property.h"
 #include "kis_combo_based_paintop_property.h"
 #include "kis_debug.h"
 
 /****************************************************************/
 /*      KisUniformPaintOpPropertyWidget                         */
 /****************************************************************/
 
 struct KisUniformPaintOpPropertyWidget::Private
 {
     Private(KisUniformPaintOpPropertySP _property)
         : property(_property) {}
 
     typedef KisUniformPaintOpProperty::Type Type;
     KisUniformPaintOpPropertySP property;
 };
 
 KisUniformPaintOpPropertyWidget::KisUniformPaintOpPropertyWidget(KisUniformPaintOpPropertySP property, QWidget *parent)
     : QWidget(parent),
       m_d(new Private(property))
 {
     KisAcyclicSignalConnector *conn = new KisAcyclicSignalConnector(this);
-    conn->connectForwardVariant(property.data(), SIGNAL(valueChanged(const QVariant&)),
-                                this, SLOT(setValue(const QVariant&)));
+    conn->connectForwardVariant(property.data(), SIGNAL(valueChanged(QVariant)),
+                                this, SLOT(setValue(QVariant)));
 
-    conn->connectBackwardVariant(this, SIGNAL(valueChanged(const QVariant&)),
-                                 property.data(), SLOT(setValue(const QVariant&)));
+    conn->connectBackwardVariant(this, SIGNAL(valueChanged(QVariant)),
+                                 property.data(), SLOT(setValue(QVariant)));
 }
 
 KisUniformPaintOpPropertyWidget::~KisUniformPaintOpPropertyWidget()
 {
 }
 
 KisUniformPaintOpPropertySP KisUniformPaintOpPropertyWidget::property() const
 {
     return m_d->property;
 }
 
 /****************************************************************/
 /*      KisUniformPaintOpPropertyIntSlider                      */
 /****************************************************************/
 
 KisUniformPaintOpPropertyIntSlider::KisUniformPaintOpPropertyIntSlider(KisUniformPaintOpPropertySP property, QWidget *parent)
     : KisUniformPaintOpPropertyWidget(property, parent)
 {
     const QString prefix = QString("%1: ").arg(property->name());
     QVBoxLayout *layout = new QVBoxLayout(this);
 
     KisIntSliderBasedPaintOpProperty *sliderProperty =
         dynamic_cast<KisIntSliderBasedPaintOpProperty*>(property.data());
     KIS_ASSERT_RECOVER_RETURN(sliderProperty);
 
     m_slider = new KisSliderSpinBox(this);
     m_slider->setBlockUpdateSignalOnDrag(true);
     m_slider->setRange(sliderProperty->min(), sliderProperty->max());
     m_slider->setSingleStep(sliderProperty->singleStep());
     m_slider->setPageStep(sliderProperty->pageStep());
     m_slider->setPrefix(prefix);
     m_slider->setSuffix(sliderProperty->suffix());
     m_slider->setExponentRatio(sliderProperty->exponentRatio());
 
     m_slider->setValue(sliderProperty->value().toInt());
     connect(m_slider, SIGNAL(valueChanged(int)), SLOT(slotSliderChanged(int)));
 
     layout->addWidget(m_slider);
     setLayout(layout);
 }
 
 void KisUniformPaintOpPropertyIntSlider::setValue(const QVariant &value)
 {
     m_slider->setValue(value.toInt());
 }
 
 void KisUniformPaintOpPropertyIntSlider::slotSliderChanged(int value)
 {
     emit valueChanged(value);
 }
 
 /****************************************************************/
 /*      KisUniformPaintOpPropertyDoubleSlider                   */
 /****************************************************************/
 
 KisUniformPaintOpPropertyDoubleSlider::KisUniformPaintOpPropertyDoubleSlider(KisUniformPaintOpPropertySP property, QWidget *parent)
     : KisUniformPaintOpPropertyWidget(property, parent)
 {
     const QString prefix = QString("%1: ").arg(property->name());
     QVBoxLayout *layout = new QVBoxLayout(this);
 
     KisDoubleSliderBasedPaintOpProperty *sliderProperty =
         dynamic_cast<KisDoubleSliderBasedPaintOpProperty*>(property.data());
     KIS_ASSERT_RECOVER_RETURN(sliderProperty);
 
     m_slider = new KisDoubleSliderSpinBox(this);
     m_slider->setBlockUpdateSignalOnDrag(true);
     m_slider->setRange(sliderProperty->min(), sliderProperty->max(), sliderProperty->decimals());
     m_slider->setSingleStep(sliderProperty->singleStep());
     m_slider->setPrefix(prefix);
     m_slider->setSuffix(sliderProperty->suffix());
     m_slider->setExponentRatio(sliderProperty->exponentRatio());
 
     m_slider->setValue(sliderProperty->value().toReal());
     connect(m_slider, SIGNAL(valueChanged(qreal)), SLOT(slotSliderChanged(qreal)));
 
     layout->addWidget(m_slider);
     setLayout(layout);
 }
 
 void KisUniformPaintOpPropertyDoubleSlider::setValue(const QVariant &value)
 {
     m_slider->setValue(value.toReal());
 }
 
 void KisUniformPaintOpPropertyDoubleSlider::slotSliderChanged(qreal value)
 {
     emit valueChanged(value);
 }
 
 /****************************************************************/
 /*      KisUniformPaintOpPropertyCheckBox                       */
 /****************************************************************/
 
 KisUniformPaintOpPropertyCheckBox::KisUniformPaintOpPropertyCheckBox(KisUniformPaintOpPropertySP property, QWidget *parent)
     : KisUniformPaintOpPropertyWidget(property, parent)
 {
     QVBoxLayout *layout = new QVBoxLayout(this);
 
     m_checkBox = new QCheckBox(property->name(), this);
     m_checkBox->setChecked(property->value().toBool());
     connect(m_checkBox, SIGNAL(toggled(bool)), SLOT(slotCheckBoxChanged(bool)));
 
     layout->addWidget(m_checkBox);
     setLayout(layout);
 }
 
 void KisUniformPaintOpPropertyCheckBox::setValue(const QVariant &value)
 {
     m_checkBox->setChecked(value.toBool());
 }
 
 void KisUniformPaintOpPropertyCheckBox::slotCheckBoxChanged(bool value)
 {
     emit valueChanged(value);
 }
 
 /****************************************************************/
 /*      KisUniformPaintOpPropertyComboBox                       */
 /****************************************************************/
 
 KisUniformPaintOpPropertyComboBox::KisUniformPaintOpPropertyComboBox(KisUniformPaintOpPropertySP property, QWidget *parent)
     : KisUniformPaintOpPropertyWidget(property, parent)
 {
     QVBoxLayout *layout = new QVBoxLayout(this);
 
     KisComboBasedPaintOpProperty *comboProperty =
         dynamic_cast<KisComboBasedPaintOpProperty*>(property.data());
     KIS_ASSERT_RECOVER_RETURN(comboProperty);
 
     const QList<QString> items = comboProperty->items();
     const QList<QIcon> icons = comboProperty->icons();
 
     m_comboBox = new QComboBox(this);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(icons.isEmpty() ||
                                    items.size() == icons.size());
 
     if (!icons.isEmpty()) {
         auto itemIt = items.constBegin();
         auto iconIt = icons.constBegin();
 
         while (itemIt != items.constEnd() &&
                iconIt != icons.constEnd()) {
 
             m_comboBox->addItem(*iconIt, *itemIt);
 
             ++itemIt;
             ++iconIt;
         }
     } else {
         Q_FOREACH (const QString &item, items) {
             m_comboBox->addItem(item);
         }
     }
 
     m_comboBox->setCurrentIndex(property->value().toInt());
     connect(m_comboBox, SIGNAL(currentIndexChanged(int)), SLOT(slotComboBoxChanged(int)));
 
     layout->addWidget(m_comboBox);
     setLayout(layout);
 }
 
 void KisUniformPaintOpPropertyComboBox::setValue(const QVariant &value)
 {
     m_comboBox->setCurrentIndex(value.toInt());
 }
 
 void KisUniformPaintOpPropertyComboBox::slotComboBoxChanged(int value)
 {
     emit valueChanged(value);
 }
diff --git a/libs/ui/canvas/kis_animation_player.cpp b/libs/ui/canvas/kis_animation_player.cpp
index f1dd6ac1b5..1895609ae7 100644
--- a/libs/ui/canvas/kis_animation_player.cpp
+++ b/libs/ui/canvas/kis_animation_player.cpp
@@ -1,588 +1,588 @@
 /*
  *  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_player.h"
 
 #include <QElapsedTimer>
 #include <QTimer>
 #include <QtMath>
 
 //#define PLAYER_DEBUG_FRAMERATE
 
 #include "kis_global.h"
 #include "kis_algebra_2d.h"
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_image.h"
 #include "kis_canvas2.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_signal_compressor.h"
 #include <KisDocument.h>
 #include <QFileInfo>
 #include "KisSyncedAudioPlayback.h"
 #include "kis_signal_compressor_with_param.h"
 
 #include "kis_image_config.h"
 #include <limits>
 
 #include "KisViewManager.h"
 #include "kis_icon_utils.h"
 
 #include "KisPart.h"
 #include "dialogs/KisAsyncAnimationCacheRenderDialog.h"
 #include "KisRollingMeanAccumulatorWrapper.h"
 
 
 struct KisAnimationPlayer::Private
 {
 public:
     Private(KisAnimationPlayer *_q)
         : q(_q),
           realFpsAccumulator(24),
           droppedFpsAccumulator(24),
           droppedFramesPortion(24),
           dropFramesMode(true),
           nextFrameExpectedTime(0),
           expectedInterval(0),
           expectedFrame(0),
           lastTimerInterval(0),
           lastPaintedFrame(0),
           playbackStatisticsCompressor(1000, KisSignalCompressor::FIRST_INACTIVE),
           stopAudioOnScrubbingCompressor(100, KisSignalCompressor::POSTPONE),
           audioOffsetTolerance(-1)
           {}
 
     KisAnimationPlayer *q;
 
     bool useFastFrameUpload;
     bool playing;
 
     QTimer *timer;
 
     int initialFrame;
     int firstFrame;
     int lastFrame;
     qreal playbackSpeed;
 
     KisCanvas2 *canvas;
 
     KisSignalAutoConnectionsStore cancelStrokeConnections;
 
     QElapsedTimer realFpsTimer;
     KisRollingMeanAccumulatorWrapper realFpsAccumulator;
     KisRollingMeanAccumulatorWrapper droppedFpsAccumulator;
     KisRollingMeanAccumulatorWrapper droppedFramesPortion;
 
 
     bool dropFramesMode;
 
     QElapsedTimer playbackTime;
     int nextFrameExpectedTime;
     int expectedInterval;
     int expectedFrame;
     int lastTimerInterval;
     int lastPaintedFrame;
 
     KisSignalCompressor playbackStatisticsCompressor;
 
     QScopedPointer<KisSyncedAudioPlayback> syncedAudio;
     QScopedPointer<KisSignalCompressorWithParam<int> > audioSyncScrubbingCompressor;
     KisSignalCompressor stopAudioOnScrubbingCompressor;
 
     int audioOffsetTolerance;
 
     void stopImpl(bool doUpdates);
 
     int incFrame(int frame, int inc) {
         frame += inc;
         if (frame > lastFrame) {
             frame = firstFrame + frame - lastFrame - 1;
         }
         return frame;
     }
 
     qint64 frameToMSec(int value, int fps) {
         return qreal(value) / fps * 1000.0;
     }
     int msecToFrame(qint64 value, int fps) {
         return qreal(value) * fps / 1000.0;
     }
 };
 
 KisAnimationPlayer::KisAnimationPlayer(KisCanvas2 *canvas)
     : QObject(canvas)
     , m_d(new Private(this))
 {
     m_d->useFastFrameUpload = false;
     m_d->playing = false;
     m_d->canvas = canvas;
     m_d->playbackSpeed = 1.0;
 
     m_d->timer = new QTimer(this);
     connect(m_d->timer, SIGNAL(timeout()), this, SLOT(slotUpdate()));
     m_d->timer->setSingleShot(true);
 
     connect(KisConfigNotifier::instance(),
             SIGNAL(dropFramesModeChanged()),
             SLOT(slotUpdateDropFramesMode()));
     slotUpdateDropFramesMode();
 
     connect(&m_d->playbackStatisticsCompressor, SIGNAL(timeout()),
             this, SIGNAL(sigPlaybackStatisticsUpdated()));
 
     using namespace std::placeholders;
     std::function<void (int)> callback(
         std::bind(&KisAnimationPlayer::slotSyncScrubbingAudio, this, _1));
 
     const int defaultScrubbingUdpatesDelay = 40; /* 40 ms == 25 fps */
 
     m_d->audioSyncScrubbingCompressor.reset(
         new KisSignalCompressorWithParam<int>(defaultScrubbingUdpatesDelay, callback, KisSignalCompressor::FIRST_ACTIVE));
 
     m_d->stopAudioOnScrubbingCompressor.setDelay(defaultScrubbingUdpatesDelay);
     connect(&m_d->stopAudioOnScrubbingCompressor, SIGNAL(timeout()), SLOT(slotTryStopScrubbingAudio()));
 
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigFramerateChanged()), SLOT(slotUpdateAudioChunkLength()));
     slotUpdateAudioChunkLength();
 
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigAudioChannelChanged()), SLOT(slotAudioChannelChanged()));
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigAudioVolumeChanged()), SLOT(slotAudioVolumeChanged()));
 
     slotAudioChannelChanged();
 }
 
 KisAnimationPlayer::~KisAnimationPlayer()
 {}
 
 void KisAnimationPlayer::slotUpdateDropFramesMode()
 {
     KisConfig cfg(true);
     m_d->dropFramesMode = cfg.animationDropFrames();
 }
 
 void KisAnimationPlayer::slotSyncScrubbingAudio(int msecTime)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->syncedAudio);
 
     if (!m_d->syncedAudio->isPlaying()) {
         m_d->syncedAudio->play(msecTime);
     } else {
         m_d->syncedAudio->syncWithVideo(msecTime);
     }
 
     if (!isPlaying()) {
         m_d->stopAudioOnScrubbingCompressor.start();
     }
 }
 
 void KisAnimationPlayer::slotTryStopScrubbingAudio()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->syncedAudio);
     if (m_d->syncedAudio && !isPlaying()) {
         m_d->syncedAudio->stop();
     }
 }
 
 void KisAnimationPlayer::slotAudioChannelChanged()
 {
 
     KisImageAnimationInterface *interface = m_d->canvas->image()->animationInterface();
     QString fileName = interface->audioChannelFileName();
     QFileInfo info(fileName);
     if (info.exists() && !interface->isAudioMuted()) {
         m_d->syncedAudio.reset(new KisSyncedAudioPlayback(info.absoluteFilePath()));
         m_d->syncedAudio->setVolume(interface->audioVolume());
         m_d->syncedAudio->setSoundOffsetTolerance(m_d->audioOffsetTolerance);
 
-        connect(m_d->syncedAudio.data(), SIGNAL(error(const QString &, const QString &)), SLOT(slotOnAudioError(const QString &, const QString &)));
+        connect(m_d->syncedAudio.data(), SIGNAL(error(QString,QString)), SLOT(slotOnAudioError(QString,QString)));
     } else {
         m_d->syncedAudio.reset();
     }
 }
 
 void KisAnimationPlayer::slotAudioVolumeChanged()
 {
     KisImageAnimationInterface *interface = m_d->canvas->image()->animationInterface();
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setVolume(interface->audioVolume());
     }
 }
 
 void KisAnimationPlayer::slotOnAudioError(const QString &fileName, const QString &message)
 {
     QString errorMessage(i18nc("floating on-canvas message", "Cannot open audio: \"%1\"\nError: %2", fileName, message));
     m_d->canvas->viewManager()->showFloatingMessage(errorMessage, KisIconUtils::loadIcon("warning"));
 }
 
 void KisAnimationPlayer::connectCancelSignals()
 {
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigUndoDuringStrokeRequested()),
         this, SLOT(slotCancelPlayback()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigStrokeCancellationRequested()),
         this, SLOT(slotCancelPlayback()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigStrokeEndRequested()),
         this, SLOT(slotCancelPlaybackSafe()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigFramerateChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigFullClipRangeChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigPlaybackRangeChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 }
 
 void KisAnimationPlayer::disconnectCancelSignals()
 {
     m_d->cancelStrokeConnections.clear();
 }
 
 void KisAnimationPlayer::slotUpdateAudioChunkLength()
 {
     const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
     const int animationFramePeriod = qMax(1, 1000 / animation->framerate());
 
     KisConfig cfg(true);
     int scrubbingAudioUdpatesDelay = cfg.scrubbingAudioUpdatesDelay();
 
     if (scrubbingAudioUdpatesDelay < 0) {
 
         scrubbingAudioUdpatesDelay = qMax(1, animationFramePeriod);
     }
 
     m_d->audioSyncScrubbingCompressor->setDelay(scrubbingAudioUdpatesDelay);
     m_d->stopAudioOnScrubbingCompressor.setDelay(scrubbingAudioUdpatesDelay);
 
     m_d->audioOffsetTolerance = cfg.audioOffsetTolerance();
     if (m_d->audioOffsetTolerance < 0) {
         m_d->audioOffsetTolerance = animationFramePeriod;
     }
 
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setSoundOffsetTolerance(m_d->audioOffsetTolerance);
     }
 }
 
 void KisAnimationPlayer::slotUpdatePlaybackTimer()
 {
     m_d->timer->stop();
 
     const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
     const KisTimeRange &playBackRange = animation->playbackRange();
     if (!playBackRange.isValid()) return;
 
     const int fps = animation->framerate();
 
     m_d->initialFrame = animation->currentUITime();
     m_d->firstFrame = playBackRange.start();
     m_d->lastFrame = playBackRange.end();
     m_d->expectedFrame = qBound(m_d->firstFrame, m_d->expectedFrame, m_d->lastFrame);
 
 
     m_d->expectedInterval = qreal(1000) / fps / m_d->playbackSpeed;
     m_d->lastTimerInterval = m_d->expectedInterval;
 
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setSpeed(m_d->playbackSpeed);
     }
 
     m_d->timer->start(m_d->expectedInterval);
 
     if (m_d->playbackTime.isValid()) {
         m_d->playbackTime.restart();
     } else {
         m_d->playbackTime.start();
     }
 
     m_d->nextFrameExpectedTime = m_d->playbackTime.elapsed() + m_d->expectedInterval;
 }
 
 void KisAnimationPlayer::play()
 {
     {
         const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
         const KisTimeRange &range = animation->playbackRange();
         if (!range.isValid()) return;
 
         // when openGL is disabled, there is no animation cache
         if (m_d->canvas->frameCache()) {
             KisImageConfig cfg(true);
 
             const int dimensionLimit =
                 cfg.useAnimationCacheFrameSizeLimit() ?
                 cfg.animationCacheFrameSizeLimit() :
                 std::numeric_limits<int>::max();
 
             const int maxImageDimension = KisAlgebra2D::maxDimension(m_d->canvas->image()->bounds());
 
             const QRect regionOfInterest =
                 cfg.useAnimationCacheRegionOfInterest() && maxImageDimension > dimensionLimit ?
                 m_d->canvas->regionOfInterest() :
                 m_d->canvas->coordinatesConverter()->imageRectInImagePixels();
 
             const QRect minimalNeedRect =
                 m_d->canvas->coordinatesConverter()->widgetRectInImagePixels().toAlignedRect() &
                 m_d->canvas->coordinatesConverter()->imageRectInImagePixels();
 
             m_d->canvas->frameCache()->dropLowQualityFrames(range, regionOfInterest, minimalNeedRect);
 
             KisAsyncAnimationCacheRenderDialog dlg(m_d->canvas->frameCache(),
                                                    range,
                                                    200);
 
             dlg.setRegionOfInterest(regionOfInterest);
 
             KisAsyncAnimationCacheRenderDialog::Result result =
                 dlg.regenerateRange(m_d->canvas->viewManager());
 
             if (result != KisAsyncAnimationCacheRenderDialog::RenderComplete) {
                 return;
             }
 
             m_d->canvas->setRenderingLimit(regionOfInterest);
         }
     }
 
     m_d->playing = true;
 
     slotUpdatePlaybackTimer();
     m_d->expectedFrame = m_d->firstFrame;
     m_d->lastPaintedFrame = -1;
 
     connectCancelSignals();
 
     if (m_d->syncedAudio) {
         KisImageAnimationInterface *animationInterface = m_d->canvas->image()->animationInterface();
         m_d->syncedAudio->play(m_d->frameToMSec(m_d->firstFrame, animationInterface->framerate()));
     }
 
     emit sigPlaybackStarted();
 }
 
 void KisAnimationPlayer::Private::stopImpl(bool doUpdates)
 {
     if (syncedAudio) {
         syncedAudio->stop();
     }
 
     q->disconnectCancelSignals();
 
     timer->stop();
     playing = false;
     canvas->setRenderingLimit(QRect());
 
     if (doUpdates) {
         KisImageAnimationInterface *animation = canvas->image()->animationInterface();
         if (animation->currentUITime() == initialFrame) {
             canvas->refetchDataFromImage();
         } else {
             animation->switchCurrentTimeAsync(initialFrame);
         }
     }
 
     emit q->sigPlaybackStopped();
 }
 
 void KisAnimationPlayer::stop()
 {
     m_d->stopImpl(true);
 }
 
 void KisAnimationPlayer::forcedStopOnExit()
 {
     m_d->stopImpl(false);
 }
 
 bool KisAnimationPlayer::isPlaying()
 {
     return m_d->playing;
 }
 
 int KisAnimationPlayer::currentTime()
 {
     return m_d->lastPaintedFrame;
 }
 
 void KisAnimationPlayer::displayFrame(int time)
 {
     uploadFrame(time);
 }
 
 void KisAnimationPlayer::slotUpdate()
 {
     uploadFrame(-1);
 }
 
 void KisAnimationPlayer::uploadFrame(int frame)
 {
     KisImageAnimationInterface *animationInterface = m_d->canvas->image()->animationInterface();
 
     if (frame < 0) {
         const int currentTime = m_d->playbackTime.elapsed();
         const int framesDiff = currentTime - m_d->nextFrameExpectedTime;
         const qreal framesDiffNorm = qreal(framesDiff) / m_d->expectedInterval;
 
         // qDebug() << ppVar(framesDiff)
         //          << ppVar(m_d->expectedFrame)
         //          << ppVar(framesDiffNorm)
         //          << ppVar(m_d->lastTimerInterval);
 
         if (m_d->dropFramesMode) {
             const int numDroppedFrames = qMax(0, qRound(framesDiffNorm));
             frame = m_d->incFrame(m_d->expectedFrame, numDroppedFrames);
         } else {
             frame = m_d->expectedFrame;
         }
 
         m_d->nextFrameExpectedTime = currentTime + m_d->expectedInterval;
 
         m_d->lastTimerInterval = qMax(0.0, m_d->lastTimerInterval - 0.5 * framesDiff);
         m_d->expectedFrame = m_d->incFrame(frame,  1);
 
         m_d->timer->start(m_d->lastTimerInterval);
 
         m_d->playbackStatisticsCompressor.start();
     }
 
     if (m_d->syncedAudio) {
         const int msecTime = m_d->frameToMSec(frame, animationInterface->framerate());
         if (isPlaying()) {
             slotSyncScrubbingAudio(msecTime);
         } else {
             m_d->audioSyncScrubbingCompressor->start(msecTime);
         }
     }
 
 
     bool useFallbackUploadMethod = !m_d->canvas->frameCache();
 
     if (m_d->canvas->frameCache() &&
         m_d->canvas->frameCache()->shouldUploadNewFrame(frame, m_d->lastPaintedFrame)) {
 
 
         if (m_d->canvas->frameCache()->uploadFrame(frame)) {
             m_d->canvas->updateCanvas();
 
             m_d->useFastFrameUpload = true;
         } else {
             useFallbackUploadMethod = true;
         }
     }
 
     if (useFallbackUploadMethod) {
         m_d->useFastFrameUpload = false;
 
         m_d->canvas->image()->barrierLock(true);
         m_d->canvas->image()->unlock();
 
         // no OpenGL cache or the frame just not cached yet
         animationInterface->switchCurrentTimeAsync(frame);
     }
 
     if (!m_d->realFpsTimer.isValid()) {
         m_d->realFpsTimer.start();
     } else {
         const int elapsed = m_d->realFpsTimer.restart();
         m_d->realFpsAccumulator(elapsed);
 
         if (m_d->lastPaintedFrame >= 0) {
             int numFrames = frame - m_d->lastPaintedFrame;
             if (numFrames < 0) {
                 numFrames += m_d->lastFrame - m_d->firstFrame + 1;
             }
 
             m_d->droppedFramesPortion(qreal(int(numFrames != 1)));
 
             if (numFrames > 0) {
                 m_d->droppedFpsAccumulator(qreal(elapsed) / numFrames);
             }
 
 #ifdef PLAYER_DEBUG_FRAMERATE
             qDebug() << "    RFPS:" << 1000.0 / m_d->realFpsAccumulator.rollingMean()
                      << "DFPS:" << 1000.0 / m_d->droppedFpsAccumulator.rollingMean() << ppVar(numFrames);
 #endif /* PLAYER_DEBUG_FRAMERATE */
         }
     }
 
     m_d->lastPaintedFrame = frame;
     emit sigFrameChanged();
 }
 
 qreal KisAnimationPlayer::effectiveFps() const
 {
     return 1000.0 / m_d->droppedFpsAccumulator.rollingMean();
 }
 
 qreal KisAnimationPlayer::realFps() const
 {
     return 1000.0 / m_d->realFpsAccumulator.rollingMean();
 }
 
 qreal KisAnimationPlayer::framesDroppedPortion() const
 {
     return m_d->droppedFramesPortion.rollingMean();
 }
 
 void KisAnimationPlayer::slotCancelPlayback()
 {
     stop();
 }
 
 void KisAnimationPlayer::slotCancelPlaybackSafe()
 {
     /**
      * If there is no openGL support, then we have no (!) cache at
      * all. Therefore we should regenerate frame on every time switch,
      * which, yeah, can be very slow.  What is more important, when
      * regenerating a frame animation interface will emit a
      * sigStrokeEndRequested() signal and we should ignore it. That is
      * not an ideal solution, because the user will be able to paint
      * on random frames while playing, but it lets users with faulty
      * GPUs see at least some preview of their animation.
      */
 
     if (m_d->useFastFrameUpload) {
         stop();
     }
 }
 
 qreal KisAnimationPlayer::playbackSpeed()
 {
     return m_d->playbackSpeed;
 }
 
 void KisAnimationPlayer::slotUpdatePlaybackSpeed(double value)
 {
     m_d->playbackSpeed = value;
     if (m_d->playing) {
         slotUpdatePlaybackTimer();
     }
 }
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index 53cdf60421..f93ecfe916 100644
--- a/libs/ui/canvas/kis_canvas2.cpp
+++ b/libs/ui/canvas/kis_canvas2.cpp
@@ -1,1229 +1,1229 @@
 /* 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 "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_selection_mask.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"
 #include "kis_image_signal_router.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;
     int isBatchUpdateActive = 0;
 
     bool effectiveLodAllowedInImage() {
         return lodAllowedInImage && !bootstrapLodBlocked;
     }
 
     void setActiveShapeManager(KoShapeManager *shapeManager);
 };
 
 namespace {
 KoShapeManager* fetchShapeManagerFromNode(KisNodeSP node)
 {
     KoShapeManager *shapeManager = 0;
     KisSelectionSP selection;
 
     if (KisLayer *layer = dynamic_cast<KisLayer*>(node.data())) {
         KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer);
         if (shapeLayer) {
             shapeManager = shapeLayer->shapeManager();
 
         }
     } else if (KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(node.data())) {
         selection = mask->selection();
     }
 
     if (!shapeManager && 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
 {
     KoShapeManager *localShapeManager = this->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;
 }
 
 KoShapeManager *KisCanvas2::localShapeManager() const
 {
     KisNodeSP node = m_d->view->currentNode();
     KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
     if (localShapeManager != m_d->currentlyActiveShapeManager) {
         m_d->setActiveShapeManager(localShapeManager);
     }
 
     return localShapeManager;
 }
 
 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->signalRouter(), SIGNAL(sigNotifyBatchUpdateStarted()), SLOT(slotBeginUpdatesBatch()), Qt::DirectConnection);
     connect(image->signalRouter(), SIGNAL(sigNotifyBatchUpdateEnded()), SLOT(slotEndUpdatesBatch()), Qt::DirectConnection);
     connect(image->signalRouter(), SIGNAL(sigRequestLodPlanesSyncBlocked(bool)), SLOT(slotSetLodUpdatesBlocked(bool)), Qt::DirectConnection);
 
     connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
-    connect(image, SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), SLOT(startResizingImage()), Qt::DirectConnection);
+    connect(image, SIGNAL(sigSizeChanged(QPointF,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()
 {
     auto tryIssueCanvasUpdates = [this](const QRect &vRect) {
         if (!m_d->isBatchUpdateActive) {
             // 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();
             }
         }
     };
 
     auto uploadData = [this, tryIssueCanvasUpdates](const QVector<KisUpdateInfoSP> &infoObjects) {
         QVector<QRect> viewportRects = m_d->canvasWidget->updateCanvasProjection(infoObjects);
         const QRect vRect = std::accumulate(viewportRects.constBegin(), viewportRects.constEnd(),
                                             QRect(), std::bit_or<QRect>());
 
         tryIssueCanvasUpdates(vRect);
     };
 
     bool shouldExplicitlyIssueUpdates = false;
 
     QVector<KisUpdateInfoSP> infoObjects;
     while (KisUpdateInfoSP info = m_d->projectionUpdatesCompressor.takeUpdateInfo()) {
         const KisMarkerUpdateInfo *batchInfo = dynamic_cast<const KisMarkerUpdateInfo*>(info.data());
         if (batchInfo) {
             if (!infoObjects.isEmpty()) {
                 uploadData(infoObjects);
                 infoObjects.clear();
             }
 
             if (batchInfo->type() == KisMarkerUpdateInfo::StartBatch) {
                 m_d->isBatchUpdateActive++;
             } else if (batchInfo->type() == KisMarkerUpdateInfo::EndBatch) {
                 m_d->isBatchUpdateActive--;
                 KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->isBatchUpdateActive >= 0);
                 if (m_d->isBatchUpdateActive == 0) {
                     shouldExplicitlyIssueUpdates = true;
                 }
             } else if (batchInfo->type() == KisMarkerUpdateInfo::BlockLodUpdates) {
                 m_d->canvasWidget->setLodResetInProgress(true);
             } else if (batchInfo->type() == KisMarkerUpdateInfo::UnblockLodUpdates) {
                 m_d->canvasWidget->setLodResetInProgress(false);
                 shouldExplicitlyIssueUpdates = true;
             }
         } else {
             infoObjects << info;
         }
     }
 
     if (!infoObjects.isEmpty()) {
         uploadData(infoObjects);
     } else if (shouldExplicitlyIssueUpdates) {
         tryIssueCanvasUpdates(m_d->coordinatesConverter->imageRectInImagePixels());
     }
 }
 
 void KisCanvas2::slotBeginUpdatesBatch()
 {
     KisUpdateInfoSP info =
         new KisMarkerUpdateInfo(KisMarkerUpdateInfo::StartBatch,
                                       m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
 void KisCanvas2::slotEndUpdatesBatch()
 {
     KisUpdateInfoSP info =
         new KisMarkerUpdateInfo(KisMarkerUpdateInfo::EndBatch,
                                       m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
 void KisCanvas2::slotSetLodUpdatesBlocked(bool value)
 {
     KisUpdateInfoSP info =
         new KisMarkerUpdateInfo(value ?
                                 KisMarkerUpdateInfo::BlockLodUpdates :
                                 KisMarkerUpdateInfo::UnblockLodUpdates,
                                 m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
 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_display_color_converter.cpp b/libs/ui/canvas/kis_display_color_converter.cpp
index 4a6ab18268..25d1f3b8b6 100644
--- a/libs/ui/canvas/kis_display_color_converter.cpp
+++ b/libs/ui/canvas/kis_display_color_converter.cpp
@@ -1,645 +1,645 @@
 /*
  *  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_display_color_converter.h"
 
 #include <QGlobalStatic>
 #include <QPointer>
 
 #include <KoColor.h>
 #include <KoColorDisplayRendererInterface.h>
 #include <KoColorSpaceMaths.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorConversions.h>
 
 #include <KoCanvasResourceManager.h>
 #include "kis_config_notifier.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_image.h"
 #include "kis_node.h"
 
 #include "kundo2command.h"
 #include "kis_config.h"
 #include "kis_paint_device.h"
 #include "kis_iterator_ng.h"
 
 Q_GLOBAL_STATIC(KisDisplayColorConverter, s_instance)
 
 
 struct KisDisplayColorConverter::Private
 {
     Private(KisDisplayColorConverter *_q, KoCanvasResourceManager *_resourceManager)
         : q(_q),
           resourceManager(_resourceManager),
           nodeColorSpace(0),
           paintingColorSpace(0),
           monitorColorSpace(0),
           monitorProfile(0),
           renderingIntent(KoColorConversionTransformation::internalRenderingIntent()),
           conversionFlags(KoColorConversionTransformation::internalConversionFlags()),
           displayFilter(0),
           intermediateColorSpace(0),
           displayRenderer(new DisplayRenderer(_q, _resourceManager))
     {
     }
 
     KisDisplayColorConverter *const q;
 
     KoCanvasResourceManager *resourceManager;
 
     const KoColorSpace *nodeColorSpace;
     const KoColorSpace *paintingColorSpace;
     const KoColorSpace *monitorColorSpace;
 
     const KoColorProfile *monitorProfile;
 
     KoColorConversionTransformation::Intent renderingIntent;
     KoColorConversionTransformation::ConversionFlags conversionFlags;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
     const KoColorSpace *intermediateColorSpace;
 
     KoColor intermediateFgColor;
     KisNodeSP connectedNode;
 
     inline KoColor approximateFromQColor(const QColor &qcolor);
     inline QColor approximateToQColor(const KoColor &color);
 
     void slotCanvasResourceChanged(int key, const QVariant &v);
     void slotUpdateCurrentNodeColorSpace();
     void selectPaintingColorSpace();
 
     void updateIntermediateFgColor(const KoColor &color);
     void setCurrentNode(KisNodeSP node);
     bool useOcio() const;
 
     bool finalIsRgba(const KoColorSpace *cs) const;
 
     template <bool flipToBgra>
     QColor floatArrayToQColor(const float *p);
 
     template <bool flipToBgra>
     QImage convertToQImageDirect(KisPaintDeviceSP device);
 
     class DisplayRenderer : public KoColorDisplayRendererInterface {
     public:
         DisplayRenderer(KisDisplayColorConverter *displayColorConverter, KoCanvasResourceManager *resourceManager)
             : m_displayColorConverter(displayColorConverter),
               m_resourceManager(resourceManager)
         {
             displayColorConverter->connect(displayColorConverter, SIGNAL(displayConfigurationChanged()),
                             this, SIGNAL(displayConfigurationChanged()));
         }
 
         QImage convertToQImage(const KoColorSpace *srcColorSpace, const quint8 *data, qint32 width, qint32 height) const override {
             KisPaintDeviceSP dev = new KisPaintDevice(srcColorSpace);
             dev->writeBytes(data, 0, 0, width, height);
             return m_displayColorConverter->toQImage(dev);
         }
 
         QColor toQColor(const KoColor &c) const override {
             return m_displayColorConverter->toQColor(c);
         }
 
         KoColor approximateFromRenderedQColor(const QColor &c) const override {
             return m_displayColorConverter->approximateFromRenderedQColor(c);
         }
 
         KoColor fromHsv(int h, int s, int v, int a) const override {
             return m_displayColorConverter->fromHsv(h, s, v, a);
         }
 
         void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const override {
             m_displayColorConverter->getHsv(srcColor, h, s, v, a);
         }
 
         qreal minVisibleFloatValue(const KoChannelInfo *chaninfo) const override {
             return chaninfo->getUIMin();
         }
 
         qreal maxVisibleFloatValue(const KoChannelInfo *chaninfo) const override {
             qreal maxValue = chaninfo->getUIMax();
 
             if (m_resourceManager) {
                 qreal exposure = m_resourceManager->resource(KisCanvasResourceProvider::HdrExposure).value<qreal>();
                 // not sure if *= is what we want
                 maxValue *= std::pow(2.0, -exposure);
             }
 
             return maxValue;
         }
 
         const KoColorSpace* getPaintingColorSpace() const override {
             return m_displayColorConverter->paintingColorSpace();
         }
 
     private:
         KisDisplayColorConverter *m_displayColorConverter;
         QPointer<KoCanvasResourceManager> m_resourceManager;
     };
 
     QScopedPointer<KoColorDisplayRendererInterface> displayRenderer;
 };
 
 KisDisplayColorConverter::KisDisplayColorConverter(KoCanvasResourceManager *resourceManager, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, resourceManager))
 {
 
-    connect(m_d->resourceManager, SIGNAL(canvasResourceChanged(int, const QVariant&)),
-            SLOT(slotCanvasResourceChanged(int, const QVariant&)));
+    connect(m_d->resourceManager, SIGNAL(canvasResourceChanged(int,QVariant)),
+            SLOT(slotCanvasResourceChanged(int,QVariant)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(selectPaintingColorSpace()));
 
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 }
 
 KisDisplayColorConverter::KisDisplayColorConverter()
     : m_d(new Private(this, 0))
 {
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 
     m_d->paintingColorSpace = KoColorSpaceRegistry::instance()->rgb8();
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
 
 }
 
 KisDisplayColorConverter::~KisDisplayColorConverter()
 {
 }
 
 KisDisplayColorConverter* KisDisplayColorConverter::dumbConverterInstance()
 {
     return s_instance;
 }
 
 KoColorDisplayRendererInterface* KisDisplayColorConverter::displayRendererInterface() const
 {
     return m_d->displayRenderer.data();
 }
 
 bool KisDisplayColorConverter::Private::useOcio() const
 {
     return displayFilter && paintingColorSpace->colorModelId() == RGBAColorModelID;
 }
 
 void KisDisplayColorConverter::Private::updateIntermediateFgColor(const KoColor &srcColor)
 {
     KIS_ASSERT_RECOVER_RETURN(displayFilter);
 
     KoColor color = srcColor;
     color.convertTo(intermediateColorSpace);
     displayFilter->approximateForwardTransformation(color.data(), 1);
     intermediateFgColor = color;
 }
 
 void KisDisplayColorConverter::Private::slotCanvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KisCanvasResourceProvider::CurrentKritaNode) {
         KisNodeSP currentNode = v.value<KisNodeWSP>();
         setCurrentNode(currentNode);
     } else if (useOcio() && key == KoCanvasResourceManager::ForegroundColor) {
         updateIntermediateFgColor(v.value<KoColor>());
     }
 }
 
 void KisDisplayColorConverter::Private::slotUpdateCurrentNodeColorSpace()
 {
     setCurrentNode(connectedNode);
 }
 
 inline KisPaintDeviceSP findValidDevice(KisNodeSP node) {
     return node->paintDevice() ? node->paintDevice() : node->original();
 }
 
 void KisDisplayColorConverter::Private::setCurrentNode(KisNodeSP node)
 {
     if (connectedNode) {
         KisPaintDeviceSP device = findValidDevice(connectedNode);
 
         if (device) {
             q->disconnect(device, 0);
         }
     }
 
     nodeColorSpace = 0;
 
     if (node) {
         KisPaintDeviceSP device = findValidDevice(node);
 
         nodeColorSpace = device ?
             device->compositionSourceColorSpace() :
             node->colorSpace();
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(nodeColorSpace);
 
         if (device) {
             q->connect(device, SIGNAL(profileChanged(const KoColorProfile*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
             q->connect(device, SIGNAL(colorSpaceChanged(const KoColorSpace*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
         }
 
     }
 
     if (!nodeColorSpace) {
         nodeColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     }
 
     connectedNode = node;
     selectPaintingColorSpace();
 }
 
 void KisDisplayColorConverter::Private::selectPaintingColorSpace()
 {
     KisConfig cfg(true);
     paintingColorSpace = cfg.customColorSelectorColorSpace();
 
     if (!paintingColorSpace || displayFilter) {
         paintingColorSpace = nodeColorSpace;
     }
 
     emit q->displayConfigurationChanged();
 }
 
 const KoColorSpace* KisDisplayColorConverter::paintingColorSpace() const
 {
     KIS_ASSERT_RECOVER(m_d->paintingColorSpace) {
         return KoColorSpaceRegistry::instance()->rgb8();
     }
 
     return m_d->paintingColorSpace;
 }
 
 void KisDisplayColorConverter::setMonitorProfile(const KoColorProfile *monitorProfile)
 {
     m_d->monitorColorSpace = KoColorSpaceRegistry::instance()->rgb8(monitorProfile);
     m_d->monitorProfile = monitorProfile;
 
     m_d->renderingIntent = renderingIntent();
     m_d->conversionFlags = conversionFlags();
 
     emit displayConfigurationChanged();
 }
 
 void KisDisplayColorConverter::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     if (m_d->displayFilter && displayFilter &&
         displayFilter->lockCurrentColorVisualRepresentation()) {
 
         KoColor color(m_d->intermediateFgColor);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(m_d->paintingColorSpace);
         m_d->resourceManager->setForegroundColor(color);
     }
 
     m_d->displayFilter = displayFilter;
     m_d->intermediateColorSpace = 0;
 
     if (m_d->displayFilter) {
         // choosing default profile, which is scRGB
         const KoColorProfile *intermediateProfile = 0;
         m_d->intermediateColorSpace =
             KoColorSpaceRegistry::instance()->
             colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), intermediateProfile);
 
         KIS_ASSERT_RECOVER(m_d->intermediateColorSpace) {
             m_d->intermediateColorSpace = m_d->monitorColorSpace;
         }
 
         m_d->updateIntermediateFgColor(
             m_d->resourceManager->foregroundColor());
     }
 
 
     { // sanity check
         // KisConfig cfg;
         // KIS_ASSERT_RECOVER_NOOP(cfg.useOcio() == (bool) m_d->displayFilter);
     }
 
     m_d->selectPaintingColorSpace();
 }
 
 
 KoColorConversionTransformation::Intent
 KisDisplayColorConverter::renderingIntent()
 {
     KisConfig cfg(true);
     return (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 }
 
 KoColorConversionTransformation::ConversionFlags
 KisDisplayColorConverter::conversionFlags()
 {
     KoColorConversionTransformation::ConversionFlags conversionFlags =
         KoColorConversionTransformation::HighQuality;
 
     KisConfig cfg(true);
 
     if (cfg.useBlackPointCompensation()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
 
     return conversionFlags;
 }
 
 QSharedPointer<KisDisplayFilter> KisDisplayColorConverter::displayFilter() const
 {
     return m_d->displayFilter;
 }
 
 const KoColorProfile* KisDisplayColorConverter::monitorProfile() const
 {
     return m_d->monitorProfile;
 }
 
 bool KisDisplayColorConverter::Private::finalIsRgba(const KoColorSpace *cs) const
 {
     /**
      * In Krita RGB color spaces differ: 8/16bit are BGRA, 16f/32f-bit RGBA
      */
     KoID colorDepthId = cs->colorDepthId();
     return colorDepthId == Float16BitsColorDepthID ||
         colorDepthId == Float32BitsColorDepthID;
 }
 
 template <bool flipToBgra>
 QColor KisDisplayColorConverter::Private::floatArrayToQColor(const float *p) {
     if (flipToBgra) {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     } else {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     }
 }
 
 QColor KisDisplayColorConverter::toQColor(const KoColor &srcColor) const
 {
     KoColor c(srcColor);
     c.convertTo(m_d->paintingColorSpace);
 
     if (!m_d->useOcio()) {
         // we expect the display profile is rgb8, which is BGRA here
         KIS_ASSERT_RECOVER(m_d->monitorColorSpace->pixelSize() == 4) { return Qt::red; };
 
         c.convertTo(m_d->monitorColorSpace, m_d->renderingIntent, m_d->conversionFlags);
 
         const quint8 *p = c.data();
         return QColor(p[2], p[1], p[0], p[3]);
     } else {
         const KoColorSpace *srcCS = c.colorSpace();
 
         if (m_d->displayFilter->useInternalColorManagement()) {
             srcCS = KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Float32BitsColorDepthID.id(),
                 m_d->monitorProfile);
             c.convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
         }
 
         int numChannels = srcCS->channelCount();
         QVector<float> normalizedChannels(numChannels);
         srcCS->normalisedChannelsValue(c.data(), normalizedChannels);
         m_d->displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = (const float *)normalizedChannels.constData();
 
         return m_d->finalIsRgba(srcCS) ?
             m_d->floatArrayToQColor<true>(p) :
             m_d->floatArrayToQColor<false>(p);
     }
 }
 
 KoColor KisDisplayColorConverter::approximateFromRenderedQColor(const QColor &c) const
 {
     return m_d->approximateFromQColor(c);
 }
 
 template <bool flipToBgra>
 QImage
 KisDisplayColorConverter::Private::convertToQImageDirect(KisPaintDeviceSP device)
 {
     QRect bounds = device->exactBounds();
     if (bounds.isEmpty()) return QImage();
 
     QImage image(bounds.size(), QImage::Format_ARGB32);
 
     KisSequentialConstIterator it(device, bounds);
     quint8 *dstPtr = image.bits();
 
     const KoColorSpace *cs = device->colorSpace();
     int numChannels = cs->channelCount();
     QVector<float> normalizedChannels(numChannels);
 
     while (it.nextPixel()) {
         cs->normalisedChannelsValue(it.rawDataConst(), normalizedChannels);
         displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = normalizedChannels.constData();
 
         if (flipToBgra) {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         } else {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         }
 
         dstPtr += 4;
     }
 
     return image;
 }
 
 QImage KisDisplayColorConverter::toQImage(KisPaintDeviceSP srcDevice) const
 {
     KisPaintDeviceSP device = srcDevice;
     if (*device->colorSpace() != *m_d->paintingColorSpace) {
         device = new KisPaintDevice(*srcDevice);
 
         KUndo2Command *cmd = device->convertTo(m_d->paintingColorSpace);
         delete cmd;
     }
 
     if (!m_d->useOcio()) {
         return device->convertToQImage(m_d->monitorProfile, m_d->renderingIntent, m_d->conversionFlags);
     } else {
         if (m_d->displayFilter->useInternalColorManagement()) {
             if (device == srcDevice) {
                 device = new KisPaintDevice(*srcDevice);
             }
 
             const KoColorSpace *srcCS =
                 KoColorSpaceRegistry::instance()->colorSpace(
                     RGBAColorModelID.id(),
                     Float32BitsColorDepthID.id(),
                     m_d->monitorProfile);
 
             KUndo2Command *cmd = device->convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
             delete cmd;
         }
 
         return m_d->finalIsRgba(device->colorSpace()) ?
             m_d->convertToQImageDirect<true>(device) :
             m_d->convertToQImageDirect<false>(device);
     }
 
     return QImage();
 }
 
 KoColor KisDisplayColorConverter::Private::approximateFromQColor(const QColor &qcolor)
 {
     if (!useOcio()) {
         return KoColor(qcolor, paintingColorSpace);
     } else {
         KoColor color(qcolor, intermediateColorSpace);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(paintingColorSpace);
         return color;
     }
 
     qFatal("Must not be reachable");
     return KoColor();
 }
 
 QColor KisDisplayColorConverter::Private::approximateToQColor(const KoColor &srcColor)
 {
     KoColor color(srcColor);
 
     if (useOcio()) {
         color.convertTo(intermediateColorSpace);
         displayFilter->approximateForwardTransformation(color.data(), 1);
     }
 
     return color.toQColor();
 }
 
 
 KoColor KisDisplayColorConverter::fromHsv(int h, int s, int v, int a) const
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsv(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsv(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsvF(qreal h, qreal s, qreal v, qreal a)
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsvF(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsvF(const KoColor &srcColor, qreal *h, qreal *s, qreal *v, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsvF(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHslF(qreal h, qreal s, qreal l, qreal a)
 {
     // generate HSL from sRGB!
     QColor qcolor(QColor::fromHslF(h, s, l, a));
     if (!qcolor.isValid()) {
         warnKrita << "Could not construct valid color from h" << h << "s" << s << "l" << l << "a" << a;
         qcolor = Qt::black;
     }
     return m_d->approximateFromQColor(qcolor);
 
 }
 
 void KisDisplayColorConverter::getHslF(const KoColor &srcColor, qreal *h, qreal *s, qreal *l, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHslF(h, s, l, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsiF(qreal h, qreal s, qreal i)
 {
     // generate HSI from sRGB!
     qreal r=0.0;
     qreal g=0.0;
     qreal b=0.0;
     qreal a=1.0;
     HSIToRGB(h, s, i, &r, &g, &b);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,r,1.0), qBound(0.0,g,1.0), qBound(0.0,b,1.0), a);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsiF(const KoColor &srcColor, qreal *h, qreal *s, qreal *i)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     qreal r=color.redF();
     qreal g=color.greenF();
     qreal b=color.blueF();
     RGBToHSI(r, g, b, h, s, i);
 }
 
 KoColor KisDisplayColorConverter::fromHsyF(qreal h, qreal s, qreal y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // generate HSL from sRGB!
     QVector <qreal> channelValues(3);
     y = pow(y, gamma);
     HSYToRGB(h, s, y, &channelValues[0], &channelValues[1], &channelValues[2], R, G, B);
     KoColorSpaceRegistry::instance()->rgb8()->profile()->delinearizeFloatValueFast(channelValues);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,channelValues[0],1.0), qBound(0.0,channelValues[1],1.0), qBound(0.0,channelValues[2],1.0), 1.0);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsyF(const KoColor &srcColor, qreal *h, qreal *s, qreal *y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     QVector <qreal> channelValues(3);
     channelValues[0]=color.redF();
     channelValues[1]=color.greenF();
     channelValues[2]=color.blueF();
     //TODO: if we're going to have KoColor here, remember to check whether the TRC of the profile exists...
     KoColorSpaceRegistry::instance()->rgb8()->profile()->linearizeFloatValueFast(channelValues);
     RGBToHSY(channelValues[0], channelValues[1], channelValues[2], h, s, y, R, G, B);
     *y = pow(*y, 1/gamma);
 }
 
 #include "moc_kis_display_color_converter.cpp"
diff --git a/libs/ui/canvas/kis_guides_manager.cpp b/libs/ui/canvas/kis_guides_manager.cpp
index aaac373af5..87033f440c 100644
--- a/libs/ui/canvas/kis_guides_manager.cpp
+++ b/libs/ui/canvas/kis_guides_manager.cpp
@@ -1,802 +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_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->view->zoomManager()->horizontalRuler(), SIGNAL(guideCreationInProgress(Qt::Orientation,QPoint)),
+            this, SLOT(slotGuideCreationInProgress(Qt::Orientation,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->view->zoomManager()->horizontalRuler(), SIGNAL(guideCreationFinished(Qt::Orientation,QPoint)),
+            this, SLOT(slotGuideCreationFinished(Qt::Orientation,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->view->zoomManager()->verticalRuler(), SIGNAL(guideCreationInProgress(Qt::Orientation,QPoint)),
+            this, SLOT(slotGuideCreationInProgress(Qt::Orientation,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->view->zoomManager()->verticalRuler(), SIGNAL(guideCreationFinished(Qt::Orientation,QPoint)),
+            this, SLOT(slotGuideCreationFinished(Qt::Orientation,QPoint)));
 
         m_d->viewConnections.addUniqueConnection(
-            m_d->view->document(), SIGNAL(sigGuidesConfigChanged(const KisGuidesConfig &)),
-            this, SLOT(slotDocumentRequestedConfig(const KisGuidesConfig &)));
+            m_d->view->document(), SIGNAL(sigGuidesConfigChanged(KisGuidesConfig)),
+            this, SLOT(slotDocumentRequestedConfig(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_paintop_transformation_connector.cpp b/libs/ui/canvas/kis_paintop_transformation_connector.cpp
index f708b9b83e..bf93986495 100644
--- a/libs/ui/canvas/kis_paintop_transformation_connector.cpp
+++ b/libs/ui/canvas/kis_paintop_transformation_connector.cpp
@@ -1,58 +1,58 @@
 /*
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_transformation_connector.h"
 
 #include "kis_canvas_resource_provider.h"
 #include "kis_canvas2.h"
 #include "kis_coordinates_converter.h"
 #include "brushengine/kis_paintop_preset.h"
 #include "brushengine/kis_paintop_settings.h"
 
 
 KisPaintopTransformationConnector::KisPaintopTransformationConnector(KisCanvas2 *canvas, QObject *parent)
     : QObject(parent),
       m_canvas(canvas)
 {
     connect(m_canvas->resourceManager(),
-            SIGNAL(canvasResourceChanged(int, const QVariant&)),
-            SLOT(slotCanvasResourceChanged(int, const QVariant&)));
+            SIGNAL(canvasResourceChanged(int,QVariant)),
+            SLOT(slotCanvasResourceChanged(int,QVariant)));
 }
 
 void KisPaintopTransformationConnector::notifyTransformationChanged()
 {
     KisPaintOpPresetSP preset =
         m_canvas->resourceManager()->
         resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 
     if (preset) {
         const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
         preset->settings()->setCanvasRotation(converter->rotationAngle());
         preset->settings()->setCanvasMirroring(converter->xAxisMirrored(),
                                                converter->yAxisMirrored());
     }
 }
 
 void KisPaintopTransformationConnector::slotCanvasResourceChanged(int key, const QVariant &resource)
 {
     Q_UNUSED(resource);
 
     if (key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
         notifyTransformationChanged();
     }
 }
diff --git a/libs/ui/dialogs/kis_dlg_file_layer.cpp b/libs/ui/dialogs/kis_dlg_file_layer.cpp
index a0be8a89cb..040bd84484 100644
--- a/libs/ui/dialogs/kis_dlg_file_layer.cpp
+++ b/libs/ui/dialogs/kis_dlg_file_layer.cpp
@@ -1,120 +1,120 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2013
  *
  * 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_dlg_file_layer.h"
 
 #include <QLineEdit>
 #include <QCheckBox>
 #include <QStandardPaths>
 
 #include <klocalizedstring.h>
 
 #include <KoFileDialog.h>
 #include <KisApplication.h>
 #include <KisImportExportManager.h>
 #include <kis_file_name_requester.h>
 #include <kis_config_widget.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_node.h>
 #include <kis_file_layer.h>
 
 KisDlgFileLayer::KisDlgFileLayer(const QString &basePath, const QString & name, QWidget * parent)
     : KoDialog(parent)
     , m_basePath(basePath)
 {
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     QWidget * page = new QWidget(this);
     dlgWidget.setupUi(page);
     QStringList mimes = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
     // Nesting .kra files is not supported, so do not offer that option. See https://bugs.kde.org/show_bug.cgi?id=386515
     mimes.removeAll("application/x-krita");
     dlgWidget.wdgUrlRequester->setMimeTypeFilters(mimes);
     setMainWidget(page);
 
     //dlgWidget.wdgUrlRequester->setBasePath(m_basePath);
     dlgWidget.wdgUrlRequester->setStartDir(m_basePath);
 
     dlgWidget.txtLayerName->setText(name);
 
-    connect(dlgWidget.wdgUrlRequester, SIGNAL(textChanged(const QString &)),
-            SLOT(slotNameChanged(const QString &)));
+    connect(dlgWidget.wdgUrlRequester, SIGNAL(textChanged(QString)),
+            SLOT(slotNameChanged(QString)));
 
     enableButtonOk(false);
 }
 
 void KisDlgFileLayer::slotNameChanged(const QString & text)
 {
     enableButtonOk(!text.isEmpty());
 }
 
 QString KisDlgFileLayer::layerName() const
 {
     return dlgWidget.txtLayerName->text();
 }
 
 KisFileLayer::ScalingMethod KisDlgFileLayer::scaleToImageResolution() const
 {
     if (dlgWidget.radioDontScale->isChecked()) {
         return KisFileLayer::None;
     }
     else if (dlgWidget.radioScaleToImageSize->isChecked()) {
         return KisFileLayer::ToImageSize;
     }
     else {
         return KisFileLayer::ToImagePPI;
     }
 }
 
 void KisDlgFileLayer::setFileName(QString fileName)
 {
     dlgWidget.wdgUrlRequester->setFileName(fileName);
 }
 
 void KisDlgFileLayer::setScalingMethod(KisFileLayer::ScalingMethod method)
 {
     dlgWidget.radioDontScale->setChecked(false);
     dlgWidget.radioScaleToImageSize->setChecked(false);
     dlgWidget.radioScalePPI->setChecked(false);
     if (method == KisFileLayer::None) {
         dlgWidget.radioDontScale->setChecked(true);
     } else if (method == KisFileLayer::ToImageSize) {
         dlgWidget.radioScaleToImageSize->setChecked(true);
     } else {
         dlgWidget.radioScalePPI->setChecked(true);
     }
 }
 
 QString KisDlgFileLayer::fileName() const
 {
     QString path = dlgWidget.wdgUrlRequester->fileName();
     QFileInfo fi(path);
     if (fi.isSymLink()) {
         path = fi.symLinkTarget();
         fi = QFileInfo(path);
     }
     if (!m_basePath.isEmpty() && fi.isAbsolute()) {
         QDir directory(m_basePath);
         path = directory.relativeFilePath(path);
     }
 
     return path;
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp b/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp
index 2084b67f6a..643b1d837e 100644
--- a/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp
+++ b/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp
@@ -1,397 +1,397 @@
 /*
  *  Copyright (c) 2016 Kapustin Alexey <akapust1n@yandex.ru>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_stroke_selection_properties.h"
 
 #include <QPushButton>
 #include <QRadioButton>
 #include <QLayout>
 #include <QLabel>
 #include <QSpinBox>
 #include <QSlider>
 #include <QCheckBox>
 #include <QPlainTextEdit>
 #include <QTextEdit>
 
 #include <klocalizedstring.h>
 
 #include <KoColorSpace.h>
 #include "KoColorProfile.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorConversionTransformation.h"
 #include "KoColorPopupAction.h"
 #include "kis_icon_utils.h"
 #include "KoID.h"
 #include "kis_image.h"
 #include "kis_annotation.h"
 #include "kis_config.h"
 #include "kis_signal_compressor.h"
 #include "widgets/kis_cmb_idlist.h"
 #include <squeezedcombobox.h>
 #include "kis_layer_utils.h"
 #include <kis_ls_utils.h>
 #include "kis_canvas_resource_provider.h"
 #include "KoUnit.h"
 #include "kis_display_color_converter.h"
 
 KisDlgStrokeSelection::KisDlgStrokeSelection(KisImageWSP image, KisViewManager *view, bool isVectorLayer)
     : KoDialog(view->mainWindow())
 {
     m_resourceManager = view->mainWindow()->resourceManager();
 
     converter = view->canvasBase()->displayColorConverter();
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setCaption(i18nc("@title:window", "Stroke Selection Properties"));
     m_page = new WdgStrokeSelection(this);
 
     m_image = image;
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
     QString filterConfig = KisConfig(true).exportConfiguration("StrokeSelection");
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
     cfg->fromXML(filterConfig);
 
     auto &m_options = m_page->m_options;
     m_options.color = cfg->getColor("color");
     m_options.lineColorSource = cfg->getInt("lineColorSource");
     m_page->lineColorBox->setCurrentIndex(m_options.lineColorSource);
 
     m_page->colorSelector->setColor(getSelectedColor().toQColor());
 
     m_options.brushSelected = cfg->getBool("useBrush", 0);
     m_page->typeBox->setCurrentIndex(m_options.brushSelected? 0 : 1);
 
     m_options._colorFillSource = cfg->getInt("colorFillSource", 0);
     m_page->fillBox->setCurrentIndex(m_options._colorFillSource);
     m_options.customColor = cfg->getColor("customColor");
     if (m_options._colorFillSource == static_cast<int>(colorFillSource::CustomColor)) {
         m_page->colorFillSelector->setColor(m_options.customColor.toQColor());
     }
     else {
         m_page->colorFillSelector->setColor(getFillSelectedColor().toQColor());
     }
 
     m_options.fillColor = cfg->getColor("fillColor");
     if (m_options._colorFillSource == static_cast<int>(colorFillSource::None)) {
         m_page->colorFillSelector->setDisabled(true);
     }
     else {
         m_page->colorFillSelector->setDisabled(false);    }
 
     m_options.lineSize = cfg->getInt("lineSize", 1);
     m_page->lineSize->setValue(m_options.lineSize);
     if (m_options.brushSelected) {
         m_page->lineSize->setDisabled(true);
         m_page->fillBox->setDisabled(true);
         m_page->colorFillSelector->setDisabled(true);
         m_page->sizeBox->setDisabled(true);
     }
 
     m_options.lineDimension = cfg->getInt("lineDimension", 0);
     m_page->sizeBox->setCurrentIndex(m_options.lineDimension);
 
     connect(m_page, SIGNAL(colorSelectorChanged()), SLOT(setColorButton()));
     connect(m_page, SIGNAL(colorFillSelectorChanged()), SLOT(setColorFillButton()));
-    connect(m_page->colorFillSelector, SIGNAL(changed(const QColor&)), SLOT(colorFillChanged(const QColor&)));
-    connect(m_page->colorSelector, SIGNAL(changed(const QColor&)), SLOT(colorChanged(const QColor&)));
+    connect(m_page->colorFillSelector, SIGNAL(changed(QColor)), SLOT(colorFillChanged(QColor)));
+    connect(m_page->colorSelector, SIGNAL(changed(QColor)), SLOT(colorChanged(QColor)));
 
     if (isVectorLayer) {
         lockVectorLayerFunctions();
     }
 }
 
 KisDlgStrokeSelection::~KisDlgStrokeSelection()
 {
     auto &m_options = m_page->m_options;
     m_options.lineSize = m_page->lineSize->value();
 
     m_options.lineDimension = m_page->sizeBox->currentIndex();
     m_options.lineColorSource = m_page->lineColorBox->currentIndex();
 
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
     cfg->setProperty("lineSize", m_options.lineSize);
     cfg->setProperty("colorFillSource", m_options._colorFillSource);
     cfg->setProperty("useBrush", m_options.brushSelected);
     cfg->setProperty("lineDimension", m_options.lineDimension);
     cfg->setProperty("lineColorSource", m_options.lineColorSource);
 
     QVariant colorVariant("KoColor");
     colorVariant.setValue(m_options.customColor);
     cfg->setProperty("customColor", colorVariant);
 
     QVariant  _colorVariant("KoColor");
     _colorVariant.setValue(m_options.color);
     cfg->setProperty("color", _colorVariant);
 
     QVariant _cVariant("KoColor");
     _cVariant.setValue(m_options.fillColor);
     cfg->setProperty("fillColor", _cVariant);
 
     KisConfig(false).setExportConfiguration("StrokeSelection", cfg);
 
     delete m_page;
 }
 
 KoColor KisDlgStrokeSelection::getSelectedColor() const
 {
     KoColor color;
 
     QString currentSource = m_page->lineColorBox->currentText();
 
     if (currentSource == "Foreground color") {
         color = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     }
     else  if (currentSource == "Background color") {
               color = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
           }
           else  {
               color = m_page->m_options.color;
            }
 
     return color;
 }
 
 KoColor KisDlgStrokeSelection::getFillSelectedColor() const
 {
     KoColor color;
 
     colorFillSource currentSource = static_cast<colorFillSource>(m_page->fillBox->currentIndex());
 
     if (currentSource == colorFillSource::FGColor) {
         color = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     }
     else  if (currentSource == colorFillSource::BGColor) {
               color = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
           }
           else  if (currentSource == colorFillSource::PaintColor) {
                     color = converter->approximateFromRenderedQColor(m_page->colorSelector->color());
                 }
                 else  {
                     color = m_page->m_options.customColor;
                 }
 
     return color;
 }
 
 
 bool KisDlgStrokeSelection::isBrushSelected() const
 {
      int index = m_page->typeBox->currentIndex();
      drawType type = static_cast<drawType>(index);
 
      if (type == drawType::brushDraw){
          return true;
      }
      else {
          return false;
      }
 }
 
 StrokeSelectionOptions KisDlgStrokeSelection::getParams() const
  {
      StrokeSelectionOptions params;
 
      params.lineSize = getLineSize();
      params.color = getSelectedColor();
      params.brushSelected = isBrushSelected();
      params.fillColor = getFillSelectedColor();
      params._colorFillSource = m_page->m_options._colorFillSource;
      return params;
 
 }
 
 void KisDlgStrokeSelection::lockVectorLayerFunctions()
 {
     m_page->colorFillSelector->setEnabled(false);
     m_page->lineSize->setEnabled(false);
     m_page->sizeBox->setEnabled(false);
     m_page->fillBox->setEnabled(false);
     m_page->typeBox->setEnabled(false);
 }
 
 void KisDlgStrokeSelection::unlockVectorLayerFunctions()
 {
     m_page->colorFillSelector->setEnabled(true);
     m_page->lineSize->setEnabled(true);
     m_page->sizeBox->setEnabled(true);
     m_page->fillBox->setEnabled(true);
     m_page->typeBox->setEnabled(true);
 }
 
 void KisDlgStrokeSelection::setColorFillButton()
 {
     m_page->colorFillSelector->setColor(getFillSelectedColor().toQColor());
 }
 
 void KisDlgStrokeSelection::setColorButton()
 {
     m_page->colorSelector->setColor(getSelectedColor().toQColor());
 }
 
 
 int KisDlgStrokeSelection::getLineSize() const
 {
     int value = m_page->lineSize->value();
 
     if (m_page->sizeBox->currentText() == "px") {
         return value;
     }
     else if (m_page->sizeBox->currentText() == "mm"){
              int pixels =  static_cast<int>(KoUnit::convertFromUnitToUnit(value,KoUnit(KoUnit::Millimeter), KoUnit(KoUnit::Pixel)));
              return pixels;
     }
          else {
              int  pixels = static_cast<int>(KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Pixel)));
              return pixels;
     }
 }
 
 linePosition KisDlgStrokeSelection::getLinePosition() const
 {/* TODO
    int index = m_page->linePosition->currentIndex();
    switch(index)
    {
    case(0):
        return linePosition::OUTSIDE;
    case(1):
        return linePosition::INSIDE;
    case(2):
        return linePosition::CENTER;
    default:
        return linePosition::CENTER;
    }*/
     return linePosition::CENTER;
 }
 
 void KisDlgStrokeSelection::colorChanged(const QColor &newColor)
 {
     if (m_page->fillBox->currentText() == "Paint color") {
         m_page->colorFillSelector->setColor(newColor);
     }
     QColor BGColor = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>().toQColor();
     QColor FGColor = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>().toQColor();
     KoColor tempColor= converter->approximateFromRenderedQColor(newColor);
 
 
      if (!(newColor == BGColor) && !(newColor == FGColor)) {
         m_page->m_options.color = tempColor;
         m_page->lineColorBox->setCurrentIndex(2);  //custom color
      }
 }
 
 void KisDlgStrokeSelection::colorFillChanged(const QColor &newColor)
 {
     QColor PaintColor = m_page->colorSelector->color();
     QColor BGcolor = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>().toQColor();
     QColor FGColor = m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>().toQColor();
     KoColor tempColor= converter->approximateFromRenderedQColor(newColor);
 
     if (!(newColor == FGColor) && !(newColor == BGcolor) && !(newColor == PaintColor)) {
         m_page->m_options.customColor = tempColor;
         m_page->fillBox->setCurrentIndex(static_cast<int>(colorFillSource::CustomColor));
     }
     m_page->m_options.fillColor = tempColor;
 }
 
 
 
 WdgStrokeSelection::WdgStrokeSelection(QWidget *parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 void WdgStrokeSelection::on_fillBox_currentIndexChanged(int index)
 {
     if (index == static_cast<int>(colorFillSource::None)) {
         colorFillSelector->setDisabled(true);
     }
     else {
         colorFillSelector->setDisabled(false);
         emit colorFillSelectorChanged();
     }
     m_options._colorFillSource = index;
 }
 
 void WdgStrokeSelection::on_typeBox_currentIndexChanged(const QString &arg1)
 {
   if (arg1 == "Current Brush") {
       m_options.brushSelected = true;
       lineSize->setDisabled(true);
       fillBox->setDisabled(true);
       colorFillSelector->setDisabled(true);
       sizeBox->setDisabled(true);
   }
   else {
       m_options.brushSelected = false;
       lineSize->setDisabled(false);
       fillBox->setDisabled(false);
       colorFillSelector->setDisabled(false);
       sizeBox->setDisabled(false);
       }
 }
 
 void WdgStrokeSelection::on_lineColorBox_currentIndexChanged(const QString &/*arg1*/)
 {
     emit colorSelectorChanged();
 }
 
 
 StrokeSelectionOptions ::StrokeSelectionOptions():
     lineSize(1),
     brushSelected(false),
     _colorFillSource(0),
     lineColorSource(0),
     lineDimension(0)
 {
     color.fromQColor(Qt::black);
     fillColor.fromQColor(Qt::black);
     customColor.fromQColor(Qt::black);
 }
 
 KisPainter::FillStyle StrokeSelectionOptions::fillStyle() const
 {
     colorFillSource tempColor = static_cast<colorFillSource>(_colorFillSource);
     KisPainter::FillStyle style;
 
     switch (tempColor) {
     case colorFillSource::PaintColor:
         style = KisPainter::FillStyleForegroundColor;
         break;
     case colorFillSource::BGColor:
         style = KisPainter::FillStyleBackgroundColor;
         break;
     case colorFillSource::CustomColor:
         style = KisPainter::FillStyleBackgroundColor;
         break;
     case colorFillSource::None:
         style = KisPainter::FillStyleNone;
         break;
     case colorFillSource::FGColor:
         style = KisPainter::FillStyleBackgroundColor;
         break;
     default:
         style = KisPainter::FillStyleBackgroundColor;
     }
     return style;
 }
 
 
diff --git a/libs/ui/flake/kis_shape_layer_canvas.cpp b/libs/ui/flake/kis_shape_layer_canvas.cpp
index 9ada10879c..e59062f89c 100644
--- a/libs/ui/flake/kis_shape_layer_canvas.cpp
+++ b/libs/ui/flake/kis_shape_layer_canvas.cpp
@@ -1,350 +1,350 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_shape_layer_canvas.h"
 
 #include <QPainter>
 #include <QMutexLocker>
 
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxySimple.h>
 #include <KoViewConverter.h>
 #include <KoColorSpace.h>
 
 #include <kis_paint_device.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_painter.h>
 #include <flake/kis_shape_layer.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include "kis_image_view_converter.h"
 
 #include <kis_debug.h>
 
 #include <QThread>
 #include <QApplication>
 
 #include <kis_spontaneous_job.h>
 #include "kis_global.h"
 
 //#define DEBUG_REPAINT
 
 KisShapeLayerCanvasBase::KisShapeLayerCanvasBase(KisShapeLayer *parent, KisImageWSP image)
     : KoCanvasBase(0)
     , m_viewConverter(new KisImageViewConverter(image))
     , m_shapeManager(new KoShapeManager(this))
     , m_selectedShapesProxy(new KoSelectedShapesProxySimple(m_shapeManager.data()))
 {
     m_shapeManager->selection()->setActiveLayer(parent);
 }
 
 KoShapeManager *KisShapeLayerCanvasBase::shapeManager() const
 {
     return m_shapeManager.data();
 }
 
 KoSelectedShapesProxy *KisShapeLayerCanvasBase::selectedShapesProxy() const
 {
     return m_selectedShapesProxy.data();
 }
 
 KoViewConverter* KisShapeLayerCanvasBase::viewConverter() const
 {
     return m_viewConverter.data();
 }
 
 void KisShapeLayerCanvasBase::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     Q_UNUSED(offset);
     Q_UNUSED(spacing);
 }
 
 bool KisShapeLayerCanvasBase::snapToGrid() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return false;
 }
 
 void KisShapeLayerCanvasBase::addCommand(KUndo2Command *)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
 }
 
 
 KoToolProxy * KisShapeLayerCanvasBase::toolProxy() const
 {
 //     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return 0;
 }
 
 QWidget* KisShapeLayerCanvasBase::canvasWidget()
 {
     return 0;
 }
 
 const QWidget* KisShapeLayerCanvasBase::canvasWidget() const
 {
     return 0;
 }
 
 KoUnit KisShapeLayerCanvasBase::unit() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(false); // This should never be called as this canvas should have no tools.
     return KoUnit(KoUnit::Point);
 }
 
 void KisShapeLayerCanvasBase::prepareForDestroying()
 {
     m_isDestroying = true;
 }
 
 bool KisShapeLayerCanvasBase::hasChangedWhileBeingInvisible()
 {
     return m_hasChangedWhileBeingInvisible;
 }
 
 
 KisShapeLayerCanvas::KisShapeLayerCanvas(KisShapeLayer *parent, KisImageWSP image)
         : KisShapeLayerCanvasBase(parent, image)
         , m_projection(0)
         , m_parentLayer(parent)
         , m_asyncUpdateSignalCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     /**
      * The layour should also add itself to its own shape manager, so that the canvas
      * would track its changes/transformations
      */
     m_shapeManager->addShape(parent, KoShapeManager::AddWithoutRepaint);
     m_shapeManager->selection()->setActiveLayer(parent);
 
     connect(this, SIGNAL(forwardRepaint()), SLOT(repaint()), Qt::QueuedConnection);
     connect(&m_asyncUpdateSignalCompressor, SIGNAL(timeout()), SLOT(slotStartAsyncRepaint()));
 
     setImage(image);
 }
 
 KisShapeLayerCanvas::~KisShapeLayerCanvas()
 {
     m_shapeManager->remove(m_parentLayer);
 }
 
 void KisShapeLayerCanvas::setImage(KisImageWSP image)
 {
     if (m_image) {
         disconnect(m_image, 0, this, 0);
     }
 
     m_viewConverter->setImage(image);
     m_image = image;
 
     if (image) {
-        connect(m_image, SIGNAL(sigSizeChanged(const QPointF &, const QPointF &)), SLOT(slotImageSizeChanged()));
+        connect(m_image, SIGNAL(sigSizeChanged(QPointF,QPointF)), SLOT(slotImageSizeChanged()));
         m_cachedImageRect = m_image->bounds();
     }
 }
 
 
 #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/kis_gui_context_command.cpp b/libs/ui/kis_gui_context_command.cpp
index 58aea14cdf..a83c10fd83 100644
--- a/libs/ui/kis_gui_context_command.cpp
+++ b/libs/ui/kis_gui_context_command.cpp
@@ -1,50 +1,50 @@
 /*
  *  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_gui_context_command.h"
 #include "kis_gui_context_command_p.h"
 
 
 KisGuiContextCommand::KisGuiContextCommand(KUndo2Command *command, QObject *guiObject)
     : m_command(command),
       m_delegate(new KisGuiContextCommandDelegate(0))
 {
     /**
      * We owe the delegate ourselves, so don't assign a parent to it,
      * but just move it to the GUI thread
      */
     m_delegate->moveToThread(guiObject->thread());
 
-    connect(this, SIGNAL(sigExecuteCommand(KUndo2Command*, bool)),
-            m_delegate.data(), SLOT(executeCommand(KUndo2Command*, bool)),
+    connect(this, SIGNAL(sigExecuteCommand(KUndo2Command*,bool)),
+            m_delegate.data(), SLOT(executeCommand(KUndo2Command*,bool)),
             Qt::BlockingQueuedConnection);
 }
 
 KisGuiContextCommand::~KisGuiContextCommand()
 {
 }
 
 void KisGuiContextCommand::undo()
 {
     emit sigExecuteCommand(m_command.data(), true);
 }
 
 void KisGuiContextCommand::redo()
 {
     emit sigExecuteCommand(m_command.data(), false);
 }
diff --git a/libs/ui/kis_node_manager.cpp b/libs/ui/kis_node_manager.cpp
index 45acb4cf79..694c3f74ac 100644
--- a/libs/ui/kis_node_manager.cpp
+++ b/libs/ui/kis_node_manager.cpp
@@ -1,1519 +1,1519 @@
 /*
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_node_manager.h"
 
 #include <QStandardPaths>
 #include <QMessageBox>
 #include <QSignalMapper>
 #include <QApplication>
 
 #include <kactioncollection.h>
 
 #include <QKeySequence>
 
 #include <kis_icon.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoShape.h>
 #include <KoShapeLayer.h>
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KoToolManager.h>
 #include <KoProperties.h>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_image.h>
 #include <kis_painter.h>
 #include <kis_paint_layer.h>
 #include <KisMimeDatabase.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "KisPart.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_shape_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_mask_manager.h"
 #include "kis_group_layer.h"
 #include "kis_layer_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_processing_applicator.h"
 #include "kis_sequential_iterator.h"
 #include "kis_transaction.h"
 #include "kis_node_selection_adapter.h"
 #include "kis_node_insertion_adapter.h"
 #include "kis_node_juggler_compressed.h"
 #include "KisNodeDisplayModeAdapter.h"
 #include "kis_clipboard.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_mimedata.h"
 #include "kis_layer_utils.h"
 #include "krita_utils.h"
 #include "kis_shape_layer.h"
 
 #include "processing/kis_mirror_processing_visitor.h"
 #include "KisView.h"
 
 #include <kis_signals_blocker.h>
 
 struct KisNodeManager::Private {
 
     Private(KisNodeManager *_q, KisViewManager *v)
         : q(_q)
         , view(v)
         , imageView(0)
         , layerManager(v)
         , maskManager(v)
         , commandsAdapter(v)
         , nodeSelectionAdapter(new KisNodeSelectionAdapter(q))
         , nodeInsertionAdapter(new KisNodeInsertionAdapter(q))
         , nodeDisplayModeAdapter(new KisNodeDisplayModeAdapter())
     {
     }
 
     KisNodeManager * q;
     KisViewManager * view;
     QPointer<KisView>imageView;
     KisLayerManager layerManager;
     KisMaskManager maskManager;
     KisNodeCommandsAdapter commandsAdapter;
     QScopedPointer<KisNodeSelectionAdapter> nodeSelectionAdapter;
     QScopedPointer<KisNodeInsertionAdapter> nodeInsertionAdapter;
     QScopedPointer<KisNodeDisplayModeAdapter> nodeDisplayModeAdapter;
 
     KisAction *showInTimeline;
 
     KisNodeList selectedNodes;
     QPointer<KisNodeJugglerCompressed> nodeJuggler;
 
     KisNodeWSP previouslyActiveNode;
 
     bool activateNodeImpl(KisNodeSP node);
 
     QSignalMapper nodeCreationSignalMapper;
     QSignalMapper nodeConversionSignalMapper;
 
     void saveDeviceAsImage(KisPaintDeviceSP device,
                            const QString &defaultName,
                            const QRect &bounds,
                            qreal xRes,
                            qreal yRes,
                            quint8 opacity);
 
     void mergeTransparencyMaskAsAlpha(bool writeToLayers);
     KisNodeJugglerCompressed* lazyGetJuggler(const KUndo2MagicString &actionName);
 };
 
 bool KisNodeManager::Private::activateNodeImpl(KisNodeSP node)
 {
     Q_ASSERT(view);
     Q_ASSERT(view->canvasBase());
     Q_ASSERT(view->canvasBase()->globalShapeManager());
     Q_ASSERT(imageView);
     if (node && node == q->activeNode()) {
         return false;
     }
 
     // Set the selection on the shape manager to the active layer
     // and set call KoSelection::setActiveLayer( KoShapeLayer* layer )
     // with the parent of the active layer.
     KoSelection *selection = view->canvasBase()->globalShapeManager()->selection();
     Q_ASSERT(selection);
     selection->deselectAll();
 
     if (!node) {
         selection->setActiveLayer(0);
         imageView->setCurrentNode(0);
         maskManager.activateMask(0);
         layerManager.activateLayer(0);
         previouslyActiveNode = q->activeNode();
     } else {
 
         previouslyActiveNode = q->activeNode();
 
         KoShape * shape = view->document()->shapeForNode(node);
 
         //if (!shape) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape, false);
 
         selection->select(shape);
         KoShapeLayer * shapeLayer = dynamic_cast<KoShapeLayer*>(shape);
 
         //if (!shapeLayer) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shapeLayer, false);
 
 //         shapeLayer->setGeometryProtected(node->userLocked());
 //         shapeLayer->setVisible(node->visible());
         selection->setActiveLayer(shapeLayer);
 
         imageView->setCurrentNode(node);
         if (KisLayerSP layer = qobject_cast<KisLayer*>(node.data())) {
             maskManager.activateMask(0);
             layerManager.activateLayer(layer);
         } else if (KisMaskSP mask = dynamic_cast<KisMask*>(node.data())) {
             maskManager.activateMask(mask);
             // XXX_NODE: for now, masks cannot be nested.
             layerManager.activateLayer(static_cast<KisLayer*>(node->parent().data()));
         }
     }
     return true;
 }
 
 KisNodeManager::KisNodeManager(KisViewManager *view)
     : m_d(new Private(this, view))
 {
 
     connect(&m_d->layerManager, SIGNAL(sigLayerActivated(KisLayerSP)), SIGNAL(sigLayerActivated(KisLayerSP)));
 }
 
 KisNodeManager::~KisNodeManager()
 {
     delete m_d;
 }
 
 void KisNodeManager::setView(QPointer<KisView>imageView)
 {
     m_d->maskManager.setView(imageView);
     m_d->layerManager.setView(imageView);
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         shapeController->disconnect(SIGNAL(sigActivateNode(KisNodeSP)), this);
         m_d->imageView->image()->disconnect(this);
     }
 
     m_d->imageView = imageView;
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         connect(shapeController, SIGNAL(sigActivateNode(KisNodeSP)), SLOT(slotNonUiActivatedNode(KisNodeSP)));
         connect(m_d->imageView->image(), SIGNAL(sigIsolatedModeChanged()),this, SLOT(slotUpdateIsolateModeAction()));
-        connect(m_d->imageView->image(), SIGNAL(sigRequestNodeReselection(KisNodeSP, const KisNodeList&)),this, SLOT(slotImageRequestNodeReselection(KisNodeSP, const KisNodeList&)));
+        connect(m_d->imageView->image(), SIGNAL(sigRequestNodeReselection(KisNodeSP,KisNodeList)),this, SLOT(slotImageRequestNodeReselection(KisNodeSP,KisNodeList)));
         m_d->imageView->resourceProvider()->slotNodeActivated(m_d->imageView->currentNode());
     }
 
 }
 
 #define NEW_LAYER_ACTION(id, layerType)                                 \
     {                                                                   \
         action = actionManager->createAction(id);                       \
         m_d->nodeCreationSignalMapper.setMapping(action, layerType);    \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeCreationSignalMapper, SLOT(map()));           \
     }
 
 #define CONVERT_NODE_ACTION_2(id, layerType, exclude)                   \
     {                                                                   \
         action = actionManager->createAction(id);                       \
         action->setExcludedNodeTypes(QStringList(exclude));             \
         actionManager->addAction(id, action);                           \
         m_d->nodeConversionSignalMapper.setMapping(action, layerType);  \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeConversionSignalMapper, SLOT(map()));         \
     }
 
 #define CONVERT_NODE_ACTION(id, layerType)              \
     CONVERT_NODE_ACTION_2(id, layerType, layerType)
 
 void KisNodeManager::setup(KActionCollection * actionCollection, KisActionManager* actionManager)
 {
     m_d->layerManager.setup(actionManager);
     m_d->maskManager.setup(actionCollection, actionManager);
 
     KisAction * action = 0;
 
     action = actionManager->createAction("mirrorNodeX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeX()));
 
     action  = actionManager->createAction("mirrorNodeY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeY()));
 
     action = actionManager->createAction("mirrorAllNodesX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorAllNodesX()));
 
     action  = actionManager->createAction("mirrorAllNodesY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorAllNodesY()));
 
     action = actionManager->createAction("activateNextLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activateNextNode()));
 
     action = actionManager->createAction("activatePreviousLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activatePreviousNode()));
 
     action = actionManager->createAction("switchToPreviouslyActiveNode");
     connect(action, SIGNAL(triggered()), this, SLOT(switchToPreviouslyActiveNode()));
 
     action  = actionManager->createAction("save_node_as_image");
     connect(action, SIGNAL(triggered()), this, SLOT(saveNodeAsImage()));
 
     action  = actionManager->createAction("save_vector_node_to_svg");
     connect(action, SIGNAL(triggered()), this, SLOT(saveVectorLayerAsImage()));
     action->setActivationFlags(KisAction::ACTIVE_SHAPE_LAYER);
 
     action = actionManager->createAction("duplicatelayer");
     connect(action, SIGNAL(triggered()), this, SLOT(duplicateActiveNode()));
 
     action = actionManager->createAction("copy_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(copyLayersToClipboard()));
 
     action = actionManager->createAction("cut_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(cutLayersToClipboard()));
 
     action = actionManager->createAction("paste_layer_from_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(pasteLayersFromClipboard()));
 
     action = actionManager->createAction("create_quick_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickGroup()));
 
     action = actionManager->createAction("create_quick_clipping_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickClippingGroup()));
 
     action = actionManager->createAction("quick_ungroup");
     connect(action, SIGNAL(triggered()), this, SLOT(quickUngroup()));
 
     action = actionManager->createAction("select_all_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectAllNodes()));
 
     action = actionManager->createAction("select_visible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectVisibleNodes()));
 
     action = actionManager->createAction("select_locked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectLockedNodes()));
 
     action = actionManager->createAction("select_invisible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectInvisibleNodes()));
 
     action = actionManager->createAction("select_unlocked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectUnlockedNodes()));
 
     action = actionManager->createAction("new_from_visible");
     connect(action, SIGNAL(triggered()), this, SLOT(createFromVisible()));
 
     action = actionManager->createAction("show_in_timeline");
     action->setCheckable(true);
     connect(action, SIGNAL(toggled(bool)), this, SLOT(slotShowHideTimeline(bool)));
     m_d->showInTimeline = action;
 
     NEW_LAYER_ACTION("add_new_paint_layer", "KisPaintLayer");
 
     NEW_LAYER_ACTION("add_new_group_layer", "KisGroupLayer");
 
     NEW_LAYER_ACTION("add_new_clone_layer", "KisCloneLayer");
 
     NEW_LAYER_ACTION("add_new_shape_layer", "KisShapeLayer");
 
     NEW_LAYER_ACTION("add_new_adjustment_layer", "KisAdjustmentLayer");
 
     NEW_LAYER_ACTION("add_new_fill_layer", "KisGeneratorLayer");
 
     NEW_LAYER_ACTION("add_new_file_layer", "KisFileLayer");
 
     NEW_LAYER_ACTION("add_new_transparency_mask", "KisTransparencyMask");
 
     NEW_LAYER_ACTION("add_new_filter_mask", "KisFilterMask");
 
     NEW_LAYER_ACTION("add_new_colorize_mask", "KisColorizeMask");
 
     NEW_LAYER_ACTION("add_new_transform_mask", "KisTransformMask");
 
     NEW_LAYER_ACTION("add_new_selection_mask", "KisSelectionMask");
 
-    connect(&m_d->nodeCreationSignalMapper, SIGNAL(mapped(const QString &)),
-            this, SLOT(createNode(const QString &)));
+    connect(&m_d->nodeCreationSignalMapper, SIGNAL(mapped(QString)),
+            this, SLOT(createNode(QString)));
 
     CONVERT_NODE_ACTION("convert_to_paint_layer", "KisPaintLayer");
 
     CONVERT_NODE_ACTION_2("convert_to_selection_mask", "KisSelectionMask", QStringList() << "KisSelectionMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_filter_mask", "KisFilterMask", QStringList() << "KisFilterMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_transparency_mask", "KisTransparencyMask", QStringList() << "KisTransparencyMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION("convert_to_animated", "animated");
 
     CONVERT_NODE_ACTION_2("convert_layer_to_file_layer", "KisFileLayer", QStringList()<< "KisFileLayer" << "KisCloneLayer");
 
-    connect(&m_d->nodeConversionSignalMapper, SIGNAL(mapped(const QString &)),
-            this, SLOT(convertNode(const QString &)));
+    connect(&m_d->nodeConversionSignalMapper, SIGNAL(mapped(QString)),
+            this, SLOT(convertNode(QString)));
 
     action = actionManager->createAction("isolate_layer");
     connect(action, SIGNAL(triggered(bool)), this, SLOT(toggleIsolateMode(bool)));
 
     action = actionManager->createAction("toggle_layer_visibility");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleVisibility()));
 
     action = actionManager->createAction("toggle_layer_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleLock()));
 
     action = actionManager->createAction("toggle_layer_inherit_alpha");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleInheritAlpha()));
 
     action = actionManager->createAction("toggle_layer_alpha_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleAlphaLock()));
 
     action  = actionManager->createAction("split_alpha_into_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaIntoMask()));
 
     action  = actionManager->createAction("split_alpha_write");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaWrite()));
 
     // HINT: we can save even when the nodes are not editable
     action  = actionManager->createAction("split_alpha_save_merged");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaSaveMerged()));
 
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotUpdateIsolateModeAction()));
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotTryRestartIsolatedMode()));
 }
 
 void KisNodeManager::updateGUI()
 {
     // enable/disable all relevant actions
     m_d->layerManager.updateGUI();
     m_d->maskManager.updateGUI();
 }
 
 KisNodeSP KisNodeManager::activeNode()
 {
     if (m_d->imageView) {
         return m_d->imageView->currentNode();
     }
     return 0;
 }
 
 KisLayerSP KisNodeManager::activeLayer()
 {
     return m_d->layerManager.activeLayer();
 }
 
 const KoColorSpace* KisNodeManager::activeColorSpace()
 {
     if (m_d->maskManager.activeDevice()) {
         return m_d->maskManager.activeDevice()->colorSpace();
     } else {
         Q_ASSERT(m_d->layerManager.activeLayer());
         if (m_d->layerManager.activeLayer()->parentLayer())
             return m_d->layerManager.activeLayer()->parentLayer()->colorSpace();
         else
             return m_d->view->image()->colorSpace();
     }
 }
 
 void KisNodeManager::moveNodeAt(KisNodeSP node, KisNodeSP parent, int index)
 {
     if (parent->allowAsChild(node)) {
         if (node->inherits("KisSelectionMask") && parent->inherits("KisLayer")) {
             KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data());
             KisLayer *l = qobject_cast<KisLayer*>(parent.data());
             if (m && m->active() && l && l->selectionMask()) {
                 l->selectionMask()->setActive(false);
             }
         }
         m_d->commandsAdapter.moveNode(node, parent, index);
     }
 }
 
 void KisNodeManager::moveNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Move Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->moveNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::copyNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Copy Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->copyNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::addNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Add Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->addNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::toggleIsolateActiveNode()
 {
     KisImageWSP image = m_d->view->image();
     KisNodeSP activeNode = this->activeNode();
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     if (activeNode == image->isolatedModeRoot()) {
         toggleIsolateMode(false);
     } else {
         toggleIsolateMode(true);
     }
 }
 
 void KisNodeManager::toggleIsolateMode(bool checked)
 {
     KisImageWSP image = m_d->view->image();
 
     KisNodeSP activeNode = this->activeNode();
     if (checked && activeNode) {
 
         // Transform and colorize masks don't have pixel data...
         if (activeNode->inherits("KisTransformMask") ||
             activeNode->inherits("KisColorizeMask")) return;
 
         if (!image->startIsolatedMode(activeNode)) {
             KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
             action->setChecked(false);
         }
     } else {
         image->stopIsolatedMode();
     }
 }
 
 void KisNodeManager::slotUpdateIsolateModeAction()
 {
     KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
     Q_ASSERT(action);
 
     KisNodeSP activeNode = this->activeNode();
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
 
     action->setChecked(isolatedRootNode && isolatedRootNode == activeNode);
 }
 
 void KisNodeManager::slotTryRestartIsolatedMode()
 {
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (!isolatedRootNode) return;
 
     this->toggleIsolateMode(true);
 }
 
 void KisNodeManager::createNode(const QString & nodeType, bool quiet, KisPaintDeviceSP copyFrom)
 {
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) {
         return;
     }
 
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     // XXX: make factories for this kind of stuff,
     //      with a registry
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.addLayer(activeNode);
     } else if (nodeType == "KisGroupLayer") {
         m_d->layerManager.addGroupLayer(activeNode);
     } else if (nodeType == "KisAdjustmentLayer") {
         m_d->layerManager.addAdjustmentLayer(activeNode);
     } else if (nodeType == "KisGeneratorLayer") {
         m_d->layerManager.addGeneratorLayer(activeNode);
     } else if (nodeType == "KisShapeLayer") {
         m_d->layerManager.addShapeLayer(activeNode);
     } else if (nodeType == "KisCloneLayer") {
         m_d->layerManager.addCloneLayer(activeNode);
     } else if (nodeType == "KisTransparencyMask") {
         m_d->maskManager.createTransparencyMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFilterMask") {
         m_d->maskManager.createFilterMask(activeNode, copyFrom, quiet, false);
     } else if (nodeType == "KisColorizeMask") {
         m_d->maskManager.createColorizeMask(activeNode);
     } else if (nodeType == "KisTransformMask") {
         m_d->maskManager.createTransformMask(activeNode);
     } else if (nodeType == "KisSelectionMask") {
         m_d->maskManager.createSelectionMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFileLayer") {
         m_d->layerManager.addFileLayer(activeNode);
     }
 }
 
 void KisNodeManager::createFromVisible()
 {
     KisLayerUtils::newLayerFromVisible(m_d->view->image(), m_d->view->image()->root()->lastChild());
 }
 
 void KisNodeManager::slotShowHideTimeline(bool value)
 {
     Q_FOREACH (KisNodeSP node, selectedNodes()) {
         node->setUseInTimeline(value);
     }
 }
 
 KisLayerSP KisNodeManager::createPaintLayer()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     return m_d->layerManager.addLayer(activeNode);
 }
 
 void KisNodeManager::convertNode(const QString &nodeType)
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.convertNodeToPaintLayer(activeNode);
     } else if (nodeType == "KisSelectionMask" ||
                nodeType == "KisFilterMask" ||
                nodeType == "KisTransparencyMask") {
 
         KisPaintDeviceSP copyFrom = activeNode->paintDevice() ?
             activeNode->paintDevice() : activeNode->projection();
 
         m_d->commandsAdapter.beginMacro(kundo2_i18n("Convert to a Selection Mask"));
 
         bool result = false;
 
         if (nodeType == "KisSelectionMask") {
             result = m_d->maskManager.createSelectionMask(activeNode, copyFrom, true);
         } else if (nodeType == "KisFilterMask") {
             result = m_d->maskManager.createFilterMask(activeNode, copyFrom, false, true);
         } else if (nodeType == "KisTransparencyMask") {
             result = m_d->maskManager.createTransparencyMask(activeNode, copyFrom, true);
         }
 
         m_d->commandsAdapter.endMacro();
 
         if (!result) {
             m_d->view->blockUntilOperationsFinishedForced(m_d->imageView->image());
             m_d->commandsAdapter.undoLastCommand();
         }
 
     } else if (nodeType == "KisFileLayer") {
             m_d->layerManager.convertLayerToFileLayer(activeNode);
     } else {
         warnKrita << "Unsupported node conversion type:" << nodeType;
     }
 }
 
 void KisNodeManager::slotSomethingActivatedNodeImpl(KisNodeSP node)
 {
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     KIS_SAFE_ASSERT_RECOVER_RETURN(dummiesFacade);
 
     const bool nodeVisible = !isNodeHidden(node, !m_d->nodeDisplayModeAdapter->showGlobalSelectionMask());
     if (!nodeVisible) {
         return;
     }
 
     KIS_ASSERT_RECOVER_RETURN(node != activeNode());
     if (m_d->activateNodeImpl(node)) {
         emit sigUiNeedChangeActiveNode(node);
         emit sigNodeActivated(node);
         nodesUpdated();
         if (node) {
             bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
             if (toggled) {
                 m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
             }
         }
     }
 }
 
 void KisNodeManager::slotNonUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 
     if (node) {
         bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
         if (toggled) {
             m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
         }
     }
 }
 
 void KisNodeManager::slotUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node) {
         QStringList vectorTools = QStringList()
                 << "InteractionTool"
                 << "KarbonPatternTool"
                 << "KarbonGradientTool"
                 << "KarbonCalligraphyTool"
                 << "CreateShapesTool"
                 << "PathTool";
 
         QStringList pixelTools = QStringList()
                 << "KritaShape/KisToolBrush"
                 << "KritaShape/KisToolDyna"
                 << "KritaShape/KisToolMultiBrush"
                 << "KritaFill/KisToolFill"
                 << "KritaFill/KisToolGradient";
 
 
         KisSelectionMask *selectionMask = dynamic_cast<KisSelectionMask*>(node.data());
         const bool nodeHasVectorAbilities = node->inherits("KisShapeLayer") ||
             (selectionMask && selectionMask->selection()->hasShapeSelection());
 
         if (nodeHasVectorAbilities) {
             if (pixelTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("InteractionTool");
             }
         }
         else {
             if (vectorTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
             }
         }
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 }
 
 void KisNodeManager::nodesUpdated()
 {
     KisNodeSP node = activeNode();
     if (!node) return;
 
     m_d->layerManager.layersUpdated();
     m_d->maskManager.masksUpdated();
 
     m_d->view->updateGUI();
     m_d->view->selectionManager()->selectionChanged();
 
     {
         KisSignalsBlocker b(m_d->showInTimeline);
         m_d->showInTimeline->setChecked(node->useInTimeline());
     }
 }
 
 KisPaintDeviceSP KisNodeManager::activePaintDevice()
 {
     return m_d->maskManager.activeMask() ?
         m_d->maskManager.activeDevice() :
         m_d->layerManager.activeDevice();
 }
 
 void KisNodeManager::nodeProperties(KisNodeSP node)
 {
     if ((selectedNodes().size() > 1 && node->inherits("KisLayer")) || node->inherits("KisLayer")) {
         m_d->layerManager.layerProperties();
     }
     else if (node->inherits("KisMask")) {
         m_d->maskManager.maskProperties();
     }
 }
 
 qint32 KisNodeManager::convertOpacityToInt(qreal opacity)
 {
     /**
      * Scales opacity from the range 0...100
      * to the integer range 0...255
      */
 
     return qMin(255, int(opacity * 2.55 + 0.5));
 }
 
 void KisNodeManager::setNodeOpacity(KisNodeSP node, qint32 opacity,
                                     bool finalChange)
 {
     if (!node) return;
     if (node->opacity() == opacity) return;
 
     if (!finalChange) {
         node->setOpacity(opacity);
         node->setDirty();
     } else {
         m_d->commandsAdapter.setOpacity(node, opacity);
     }
 }
 
 void KisNodeManager::setNodeCompositeOp(KisNodeSP node,
                                         const KoCompositeOp* compositeOp)
 {
     if (!node) return;
     if (node->compositeOp() == compositeOp) return;
 
     m_d->commandsAdapter.setCompositeOp(node, compositeOp);
 }
 
 void KisNodeManager::slotImageRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes)
 {
     if (activeNode) {
         slotNonUiActivatedNode(activeNode);
     }
     if (!selectedNodes.isEmpty()) {
         slotSetSelectedNodes(selectedNodes);
     }
 }
 
 void KisNodeManager::slotSetSelectedNodes(const KisNodeList &nodes)
 {
     m_d->selectedNodes = nodes;
     emit sigUiNeedChangeSelectedNodes(nodes);
 }
 
 KisNodeList KisNodeManager::selectedNodes()
 {
     return m_d->selectedNodes;
 }
 
 KisNodeSelectionAdapter* KisNodeManager::nodeSelectionAdapter() const
 {
     return m_d->nodeSelectionAdapter.data();
 }
 
 KisNodeInsertionAdapter* KisNodeManager::nodeInsertionAdapter() const
 {
     return m_d->nodeInsertionAdapter.data();
 }
 
 KisNodeDisplayModeAdapter *KisNodeManager::nodeDisplayModeAdapter() const
 {
     return m_d->nodeDisplayModeAdapter.data();
 }
 
 bool KisNodeManager::isNodeHidden(KisNodeSP node, bool isGlobalSelectionHidden)
 {
     if (dynamic_cast<KisReferenceImagesLayer *>(node.data())) {
         return true;
     }
 
     if (isGlobalSelectionHidden && dynamic_cast<KisSelectionMask *>(node.data()) &&
         (!node->parent() || !node->parent()->parent())) {
         return true;
     }
 
     return false;
 }
 
 void KisNodeManager::nodeOpacityChanged(qreal opacity, bool finalChange)
 {
     KisNodeSP node = activeNode();
 
     setNodeOpacity(node, convertOpacityToInt(opacity), finalChange);
 }
 
 void KisNodeManager::nodeCompositeOpChanged(const KoCompositeOp* op)
 {
     KisNodeSP node = activeNode();
 
     setNodeCompositeOp(node, op);
 }
 
 void KisNodeManager::duplicateActiveNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Duplicate Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->duplicateNode(selectedNodes());
 }
 
 KisNodeJugglerCompressed* KisNodeManager::Private::lazyGetJuggler(const KUndo2MagicString &actionName)
 {
     KisImageWSP image = view->image();
 
     if (!nodeJuggler ||
         (nodeJuggler &&
          (nodeJuggler->isEnded() ||
           !nodeJuggler->canMergeAction(actionName)))) {
 
         nodeJuggler = new KisNodeJugglerCompressed(actionName, image, q, 750);
         nodeJuggler->setAutoDelete(true);
     }
 
     return nodeJuggler;
 }
 
 void KisNodeManager::raiseNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Raise Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->raiseNode(selectedNodes());
 }
 
 void KisNodeManager::lowerNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Lower Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->lowerNode(selectedNodes());
 }
 
 void KisNodeManager::removeSingleNode(KisNodeSP node)
 {
     if (!node || !node->parent()) {
         return;
     }
 
     KisNodeList nodes;
     nodes << node;
     removeSelectedNodes(nodes);
 }
 
 void KisNodeManager::removeSelectedNodes(KisNodeList nodes)
 {
     KUndo2MagicString actionName = kundo2_i18n("Remove Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::removeNode()
 {
     removeSelectedNodes(selectedNodes());
 }
 
 void KisNodeManager::mirrorNodeX()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer X");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask X");
     }
     mirrorNode(node, commandName, Qt::Horizontal, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorNodeY()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer Y");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask Y");
     }
     mirrorNode(node, commandName, Qt::Vertical, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorAllNodesX()
 {
     KisNodeSP node = m_d->view->image()->root();
     mirrorNode(node, kundo2_i18n("Mirror All Layers X"),
                Qt::Vertical, m_d->view->selection());
 }
 
 void KisNodeManager::mirrorAllNodesY()
 {
     KisNodeSP node = m_d->view->image()->root();
     mirrorNode(node, kundo2_i18n("Mirror All Layers Y"),
                Qt::Vertical, m_d->view->selection());
 }
 
 void KisNodeManager::activateNextNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node = activeNode->nextSibling();
 
     while (node && node->childCount() > 0) {
            node = node->firstChild();
     }
 
     if (!node && activeNode->parent() && activeNode->parent()->parent()) {
         node = activeNode->parent();
     }
 
     while(node && isNodeHidden(node, true)) {
         node = node->nextSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::activatePreviousNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node;
 
     if (activeNode->childCount() > 0) {
         node = activeNode->lastChild();
     }
     else {
         node = activeNode->prevSibling();
     }
 
     while (!node && activeNode->parent()) {
         node = activeNode->parent()->prevSibling();
         activeNode = activeNode->parent();
     }
 
     while(node && isNodeHidden(node, true)) {
         node = node->prevSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::switchToPreviouslyActiveNode()
 {
     if (m_d->previouslyActiveNode && m_d->previouslyActiveNode->parent()) {
         slotNonUiActivatedNode(m_d->previouslyActiveNode);
     }
 }
 
 void KisNodeManager::mirrorNode(KisNodeSP node,
                                 const KUndo2MagicString& actionName,
                                 Qt::Orientation orientation,
                                 KisSelectionSP selection)
 {
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(m_d->view->image(), node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor;
 
     if (selection) {
         visitor = new KisMirrorProcessingVisitor(selection, orientation);
     } else {
         visitor = new KisMirrorProcessingVisitor(m_d->view->image()->bounds(), orientation);
     }
 
     if (!selection) {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     applicator.end();
 
     nodesUpdated();
 }
 
 void KisNodeManager::Private::saveDeviceAsImage(KisPaintDeviceSP device,
                                                 const QString &defaultName,
                                                 const QRect &bounds,
                                                 qreal xRes,
                                                 qreal yRes,
                                                 quint8 opacity)
 {
     KoFileDialog dialog(view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18n("Export \"%1\"", defaultName));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export));
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(filename, false);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   device->compositionSourceColorSpace(),
                                   defaultName);
     dst->setResolution(xRes, yRes);
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", opacity);
     paintLayer->paintDevice()->makeCloneFrom(device, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
     dst->initialRefreshGraph();
 
     doc->exportDocumentSync(url, mimefilter.toLatin1());
 }
 
 void KisNodeManager::saveNodeAsImage()
 {
     KisNodeSP node = activeNode();
 
     if (!node) {
         warnKrita << "BUG: Save Node As Image was called without any node selected";
         return;
     }
 
     KisImageWSP image = m_d->view->image();
     QRect saveRect = image->bounds() | node->exactBounds();
 
     KisPaintDeviceSP device = node->paintDevice();
     if (!device) {
         device = node->projection();
     }
 
     m_d->saveDeviceAsImage(device, node->name(),
                            saveRect,
                            image->xRes(), image->yRes(),
                            node->opacity());
 }
 
 #include "SvgWriter.h"
 
 void KisNodeManager::saveVectorLayerAsImage()
 {
     KisShapeLayerSP shapeLayer = qobject_cast<KisShapeLayer*>(activeNode().data());
     if (!shapeLayer) {
         return;
     }
 
     KoFileDialog dialog(m_d->view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18nc("@title:window", "Export to SVG"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "image/svg+xml", "image/svg+xml");
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     const QSizeF sizeInPx = m_d->view->image()->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_d->view->image()->xRes(),
                           sizeInPx.height() / m_d->view->image()->yRes());
 
     QList<KoShape*> shapes = shapeLayer->shapes();
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     SvgWriter writer(shapes);
     if (!writer.save(filename, sizeInPt, true)) {
         QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("Could not save to svg: %1", filename));
     }
 }
 
 void KisNodeManager::slotSplitAlphaIntoMask()
 {
     KisNodeSP node = activeNode();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->hasEditablePaintDevice());
 
     KisPaintDeviceSP srcDevice = node->paintDevice();
     const KoColorSpace *srcCS = srcDevice->colorSpace();
     const QRect processRect =
         srcDevice->exactBounds() |
         srcDevice->defaultBounds()->bounds();
 
     KisPaintDeviceSP selectionDevice =
         new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
     m_d->commandsAdapter.beginMacro(kundo2_i18n("Split Alpha into a Mask"));
     KisTransaction transaction(kundo2_noi18n("__split_alpha_channel__"), srcDevice);
 
     KisSequentialIterator srcIt(srcDevice, processRect);
     KisSequentialIterator dstIt(selectionDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *srcPtr = srcIt.rawData();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->opacityU8(srcPtr);
         srcCS->setOpacity(srcPtr, OPACITY_OPAQUE_U8, 1);
     }
 
     m_d->commandsAdapter.addExtraCommand(transaction.endAndTake());
 
     createNode("KisTransparencyMask", false, selectionDevice);
     m_d->commandsAdapter.endMacro();
 }
 
 void KisNodeManager::Private::mergeTransparencyMaskAsAlpha(bool writeToLayers)
 {
     KisNodeSP node = q->activeNode();
     KisNodeSP parentNode = node->parent();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->inherits("KisTransparencyMask"));
 
     if (writeToLayers && !parentNode->hasEditablePaintDevice()) {
         QMessageBox::information(view->mainWindow(),
                                  i18nc("@title:window", "Layer %1 is not editable", parentNode->name()),
                                  i18n("Cannot write alpha channel of "
                                       "the parent layer \"%1\".\n"
                                       "The operation will be cancelled.", parentNode->name()));
         return;
     }
 
     KisPaintDeviceSP dstDevice;
     if (writeToLayers) {
         KIS_ASSERT_RECOVER_RETURN(parentNode->paintDevice());
         dstDevice = parentNode->paintDevice();
     } else {
         KisPaintDeviceSP copyDevice = parentNode->paintDevice();
         if (!copyDevice) {
             copyDevice = parentNode->original();
         }
         dstDevice = new KisPaintDevice(*copyDevice);
     }
 
     const KoColorSpace *dstCS = dstDevice->colorSpace();
 
     KisPaintDeviceSP selectionDevice = node->paintDevice();
     KIS_ASSERT_RECOVER_RETURN(selectionDevice->colorSpace()->pixelSize() == 1);
 
     const QRect processRect =
         selectionDevice->exactBounds() |
         dstDevice->exactBounds() |
         selectionDevice->defaultBounds()->bounds();
 
     QScopedPointer<KisTransaction> transaction;
 
     if (writeToLayers) {
         commandsAdapter.beginMacro(kundo2_i18n("Write Alpha into a Layer"));
         transaction.reset(new KisTransaction(kundo2_noi18n("__write_alpha_channel__"), dstDevice));
     }
 
     KisSequentialIterator srcIt(selectionDevice, processRect);
     KisSequentialIterator dstIt(dstDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *alpha8Ptr = srcIt.rawData();
         quint8 *dstPtr = dstIt.rawData();
 
         dstCS->setOpacity(dstPtr, *alpha8Ptr, 1);
     }
 
     if (writeToLayers) {
         commandsAdapter.addExtraCommand(transaction->endAndTake());
         commandsAdapter.removeNode(node);
         commandsAdapter.endMacro();
     } else {
         KisImageWSP image = view->image();
         QRect saveRect = image->bounds();
 
         saveDeviceAsImage(dstDevice, parentNode->name(),
                           saveRect,
                           image->xRes(), image->yRes(),
                           OPACITY_OPAQUE_U8);
     }
 }
 
 
 void KisNodeManager::slotSplitAlphaWrite()
 {
     m_d->mergeTransparencyMaskAsAlpha(true);
 }
 
 void KisNodeManager::slotSplitAlphaSaveMerged()
 {
     m_d->mergeTransparencyMaskAsAlpha(false);
 }
 
 void KisNodeManager::toggleLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isLocked = active->userLocked();
 
     for (auto &node : nodes) {
         node->setUserLocked(!isLocked);
     }
 }
 
 void KisNodeManager::toggleVisibility()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isVisible = active->visible();
 
     for (auto &node : nodes) {
         node->setVisible(!isVisible);
         node->setDirty();
     }
 }
 
 void KisNodeManager::toggleAlphaLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisPaintLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaLocked = layer->alphaLocked();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisPaintLayer*>(node.data());
         if (layer) {
             layer->setAlphaLocked(!isAlphaLocked);
         }
     }
 }
 
 void KisNodeManager::toggleInheritAlpha()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaDisabled = layer->alphaChannelDisabled();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisLayer*>(node.data());
         if (layer) {
             layer->disableAlphaChannel(!isAlphaDisabled);
             node->setDirty();
         }
     }
 }
 
 void KisNodeManager::cutLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     if (nodes.isEmpty()) return;
 
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), false);
 
     KUndo2MagicString actionName = kundo2_i18n("Cut Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::copyLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), true);
 }
 
 void KisNodeManager::pasteLayersFromClipboard()
 {
     const QMimeData *data = KisClipboard::instance()->layersMimeData();
     if (!data) return;
 
     KisNodeSP activeNode = this->activeNode();
 
     KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(shapeController);
 
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(dummiesFacade);
 
     const bool copyNode = false;
     KisImageSP image = m_d->view->image();
     KisNodeDummy *parentDummy = dummiesFacade->dummyForNode(activeNode);
     KisNodeDummy *aboveThisDummy = parentDummy ? parentDummy->lastChild() : 0;
 
     KisMimeData::insertMimeLayers(data,
                                   image,
                                   shapeController,
                                   parentDummy,
                                   aboveThisDummy,
                                   copyNode,
                                   nodeInsertionAdapter());
 }
 
 void KisNodeManager::createQuickGroupImpl(KisNodeJugglerCompressed *juggler,
                                           const QString &overrideGroupName,
                                           KisNodeSP *newGroup,
                                           KisNodeSP *newLastChild)
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisImageSP image = m_d->view->image();
     QString groupName = !overrideGroupName.isEmpty() ? overrideGroupName : image->nextLayerName();
     KisGroupLayerSP group = new KisGroupLayer(image.data(), groupName, OPACITY_OPAQUE_U8);
 
     KisNodeList nodes1;
     nodes1 << group;
 
     KisNodeList nodes2;
     nodes2 = KisLayerUtils::sortMergableNodes(image->root(), selectedNodes());
     KisLayerUtils::filterMergableNodes(nodes2);
 
     if (KisLayerUtils::checkIsChildOf(active, nodes2)) {
         active = nodes2.first();
     }
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     juggler->addNode(nodes1, parent, aboveThis);
     juggler->moveNode(nodes2, group, 0);
 
     *newGroup = group;
     *newLastChild = nodes2.last();
 }
 
 void KisNodeManager::createQuickGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     createQuickGroupImpl(juggler, "", &parent, &above);
 }
 
 void KisNodeManager::createQuickClippingGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Clipping Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     KisImageSP image = m_d->view->image();
     createQuickGroupImpl(juggler, image->nextLayerName(i18nc("default name for a clipping group layer", "Clipping Group")), &parent, &above);
 
     KisPaintLayerSP maskLayer = new KisPaintLayer(image.data(), i18nc("default name for quick clip group mask layer", "Mask Layer"), OPACITY_OPAQUE_U8, image->colorSpace());
     maskLayer->disableAlphaChannel(true);
 
     juggler->addNode(KisNodeList() << maskLayer, parent, above);
 }
 
 void KisNodeManager::quickUngroup()
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     KUndo2MagicString actionName = kundo2_i18n("Quick Ungroup");
 
     if (parent && dynamic_cast<KisGroupLayer*>(active.data())) {
         KisNodeList nodes = active->childNodes(QStringList(), KoProperties());
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(nodes, parent, active);
         juggler->removeNode(KisNodeList() << active);
     } else if (parent && parent->parent()) {
         KisNodeSP grandParent = parent->parent();
 
         KisNodeList allChildNodes = parent->childNodes(QStringList(), KoProperties());
         KisNodeList allSelectedNodes = selectedNodes();
 
         const bool removeParent = KritaUtils::compareListsUnordered(allChildNodes, allSelectedNodes);
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(allSelectedNodes, grandParent, parent);
         if (removeParent) {
             juggler->removeNode(KisNodeList() << parent);
         }
     }
 }
 
 void KisNodeManager::selectLayersImpl(const KoProperties &props, const KoProperties &invertedProps)
 {
     KisImageSP image = m_d->view->image();
     KisNodeList nodes = KisLayerUtils::findNodesWithProps(image->root(), props, true);
 
     KisNodeList selectedNodes = this->selectedNodes();
 
     if (KritaUtils::compareListsUnordered(nodes, selectedNodes)) {
         nodes = KisLayerUtils::findNodesWithProps(image->root(), invertedProps, true);
     }
 
     if (!nodes.isEmpty()) {
         slotImageRequestNodeReselection(nodes.last(), nodes);
     }
 }
 
 void KisNodeManager::selectAllNodes()
 {
     KoProperties props;
     selectLayersImpl(props, props);
 }
 
 void KisNodeManager::selectVisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectLockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectInvisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", true);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectUnlockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", true);
 
     selectLayersImpl(props, invertedProps);
 }
diff --git a/libs/ui/kis_paintop_settings_widget.cpp b/libs/ui/kis_paintop_settings_widget.cpp
index 68281cbfcb..901460d958 100644
--- a/libs/ui/kis_paintop_settings_widget.cpp
+++ b/libs/ui/kis_paintop_settings_widget.cpp
@@ -1,247 +1,247 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2008
  * Copyright (C) Silvio Heinrich <plassy@web.de>   , (C) 2011
  *
  * 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_settings_widget.h"
 #include "kis_paintop_option.h"
 #include "kis_paintop_options_model.h"
 
 #include <QHBoxLayout>
 #include <QList>
 #include <QStackedWidget>
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QStyleOptionViewItem>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_cmb_composite.h>
 #include <kis_categorized_item_delegate.h>
 #include <brushengine/kis_locked_properties_server.h>
 #include <brushengine/kis_locked_properties_proxy.h>
 #include <brushengine/kis_locked_properties.h>
 #include <brushengine/kis_paintop_lod_limitations.h>
 
 
 
 struct KisPaintOpSettingsWidget::Private
 {
     QList<KisPaintOpOption*>    paintOpOptions;
     KisCategorizedListView*     optionsList;
     KisPaintOpOptionListModel*  model;
     QStackedWidget*             optionsStack;
 
 };
 
 KisPaintOpSettingsWidget::KisPaintOpSettingsWidget(QWidget * parent)
         : KisPaintOpConfigWidget(parent)
         , m_d(new Private())
 {
     setObjectName("KisPaintOpPresetsWidget");
 
     m_d->model       = new KisPaintOpOptionListModel(this);
     m_d->optionsList = new KisCategorizedListView(this);
     m_d->optionsList->setModel(m_d->model);
     m_d->optionsList->setItemDelegate(new KisCategorizedItemDelegate(m_d->optionsList));
     m_d->optionsList->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContents);
     m_d->optionsList->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
     QSizePolicy policy =  QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     m_d->optionsList->setSizePolicy(policy);
 
     m_d->optionsList->setMinimumWidth(140); // this should be just big enough to show all of the setting names
 
     m_d->optionsStack = new QStackedWidget(this);
     policy = QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     m_d->optionsStack->setSizePolicy(policy);
 
     QHBoxLayout* layout = new QHBoxLayout(this);
     layout->addWidget(m_d->optionsList);
     layout->addWidget(m_d->optionsStack);
 
     layout->setStretch(0, 0);
     layout->setStretch(1, 1);
 
     m_saveLockedOption = false;
 
-    connect(m_d->optionsList, SIGNAL(activated(const QModelIndex&)), this, SLOT(changePage(const QModelIndex&)));
-    connect(m_d->optionsList, SIGNAL(clicked(QModelIndex)), this, SLOT(changePage(const QModelIndex&)));
+    connect(m_d->optionsList, SIGNAL(activated(QModelIndex)), this, SLOT(changePage(QModelIndex)));
+    connect(m_d->optionsList, SIGNAL(clicked(QModelIndex)), this, SLOT(changePage(QModelIndex)));
     connect(m_d->optionsList, SIGNAL(rightClickedMenuDropSettingsTriggered()), this, SLOT(slotLockPropertiesDrop()));
     connect(m_d->optionsList, SIGNAL(rightClickedMenuSaveSettingsTriggered()), this, SLOT(slotLockPropertiesSave()));
     connect(m_d->optionsList, SIGNAL(sigEntryChecked(QModelIndex)), this, SLOT(slotEntryChecked(QModelIndex)));
-    connect (m_d->optionsList, SIGNAL(lockAreaTriggered(QModelIndex)), this, SLOT(lockProperties(const QModelIndex&)));
+    connect (m_d->optionsList, SIGNAL(lockAreaTriggered(QModelIndex)), this, SLOT(lockProperties(QModelIndex)));
 
 }
 
 
 KisPaintOpSettingsWidget::~KisPaintOpSettingsWidget()
 {
     qDeleteAll(m_d->paintOpOptions);
     delete m_d;
 }
 
 void KisPaintOpSettingsWidget::addPaintOpOption(KisPaintOpOption *option, const QString &label)
 {
     addPaintOpOption(option, label, option->category());
 }
 
 void KisPaintOpSettingsWidget::addPaintOpOption(KisPaintOpOption *option, const QString &label, KisPaintOpOption::PaintopCategory category)
 {
     if (!option->configurationPage()) return;
     m_d->model->addPaintOpOption(option, m_d->optionsStack->count(), label, category);
     connect(option, SIGNAL(sigSettingChanged()), SIGNAL(sigConfigurationItemChanged()));
     m_d->optionsStack->addWidget(option->configurationPage());
     m_d->paintOpOptions << option;
 }
 
 void KisPaintOpSettingsWidget::setConfiguration(const KisPropertiesConfigurationSP  config)
 {
     Q_ASSERT(!config->getString("paintop").isEmpty());
     KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(config);
     int indexcount = 0;
     Q_FOREACH (KisPaintOpOption* option, m_d->paintOpOptions) {
         option->startReadOptionSetting(propertiesProxy);
 
         if (KisLockedPropertiesServer::instance()->propertiesFromLocked()) {
             option->setLocked(true);
         }
         else {
             option->setLocked(false);
         }
 
         KisLockedPropertiesServer::instance()->setPropertiesFromLocked(false);
         KisOptionInfo info;
         info.option = option;
         info.index = indexcount;
         m_d->model->categoriesMapper()->itemFromRow(m_d->model->indexOf(info).row())->setLocked(option->isLocked());
         m_d->model->categoriesMapper()->itemFromRow(m_d->model->indexOf(info).row())->setLockable(true);
         m_d->model->signalDataChanged(m_d->model->indexOf(info));
         indexcount++;
     }
 }
 
 void KisPaintOpSettingsWidget::writeConfiguration(KisPropertiesConfigurationSP config) const
 {
     KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(config);
     Q_FOREACH (const KisPaintOpOption* option, m_d->paintOpOptions) {
         option->startWriteOptionSetting(propertiesProxy);
     }
 }
 
 KisPaintopLodLimitations KisPaintOpSettingsWidget::lodLimitations() const
 {
     KisPaintopLodLimitations l;
 
     Q_FOREACH (const KisPaintOpOption* option, m_d->paintOpOptions) {
         if (option->isCheckable() && !option->isChecked()) continue;
         option->lodLimitations(&l);
     }
 
     return l;
 }
 
 void KisPaintOpSettingsWidget::setImage(KisImageWSP image)
 {
     Q_FOREACH (KisPaintOpOption* option, m_d->paintOpOptions) {
         option->setImage(image);
     }
 }
 
 void KisPaintOpSettingsWidget::setNode(KisNodeWSP node)
 {
     Q_FOREACH (KisPaintOpOption* option, m_d->paintOpOptions) {
         option->setNode(node);
     }
 }
 
 void KisPaintOpSettingsWidget::changePage(const QModelIndex& index)
 {
     KisOptionInfo info;
     QPalette palette;
     palette.setColor(QPalette::Base, QColor(255,200,200));
     palette.setColor(QPalette::Text, Qt::black);
 
     if(m_d->model->entryAt(info, index)) {
         m_d->optionsStack->setCurrentIndex(info.index);
 
         // disable the widget if a setting area is not active and not being used
        if (info.option->isCheckable() ) {
             m_d->optionsStack->setEnabled(info.option->isChecked());
        } else {
            m_d->optionsStack->setEnabled(true); // option is not checkable, so always enable
        }
 
 
     }
 
     notifyPageChanged();
 }
 
 void KisPaintOpSettingsWidget::notifyPageChanged()
 {
 }
 
 void KisPaintOpSettingsWidget::lockProperties(const QModelIndex& index)
 {
     KisOptionInfo info;
     if (m_d->model->entryAt(info, index)) {
         m_d->optionsList->setCurrentIndex(index);
         KisPropertiesConfigurationSP p = new KisPropertiesConfiguration();
         info.option->startWriteOptionSetting(p);
 
         if (!info.option->isLocked()){
             KisLockedPropertiesServer::instance()->addToLockedProperties(p);
             info.option->setLocked(true);
             m_d->model->categoriesMapper()->itemFromRow(index.row())->setLocked(true);
 
         }
         else {
             KisLockedPropertiesServer::instance()->removeFromLockedProperties(p);
             info.option->setLocked(false);
             m_d->model->categoriesMapper()->itemFromRow(index.row())->setLocked(false);
 
             if (m_saveLockedOption){
                 emit sigSaveLockedConfig(p);
             }
             else {
                 emit sigDropLockedConfig(p);
             }
             m_saveLockedOption = false;
         }
         m_d->model->signalDataChanged(index);
     }
 
 }
 void KisPaintOpSettingsWidget::slotLockPropertiesDrop()
 {
     m_saveLockedOption = false;
     lockProperties(m_d->optionsList->currentIndex());
 }
 void KisPaintOpSettingsWidget::slotLockPropertiesSave()
 {
     m_saveLockedOption = true;
     lockProperties(m_d->optionsList->currentIndex());
 }
 void KisPaintOpSettingsWidget::slotEntryChecked(const QModelIndex &index)
 {
     Q_UNUSED(index);
     emit sigConfigurationItemChanged();
 }
diff --git a/libs/ui/kis_popup_palette.cpp b/libs/ui/kis_popup_palette.cpp
index 6ac4c219d6..753389adb4 100644
--- a/libs/ui/kis_popup_palette.cpp
+++ b/libs/ui/kis_popup_palette.cpp
@@ -1,913 +1,913 @@
 /* This file is part of the KDE project
    Copyright 2009 Vera Lukman <shicmap@gmail.com>
    Copyright 2011 Sven Langkamp <sven.langkamp@gmail.com>
    Copyright 2016 Scott Petrovic <scottpetrovic@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 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 "kis_canvas2.h"
 #include "kis_config.h"
 #include "kis_popup_palette.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_icon_utils.h"
 #include "KisResourceServerProvider.h"
 #include <kis_canvas_resource_provider.h>
 #include <KoTriangleColorSelector.h>
 #include <KisVisualColorSelector.h>
 #include <kis_config_notifier.h>
 #include <QtGui>
 #include <QMenu>
 #include <QWhatsThis>
 #include <QVBoxLayout>
 #include <QElapsedTimer>
 #include "kis_signal_compressor.h"
 #include "brushhud/kis_brush_hud.h"
 #include "brushhud/kis_round_hud_button.h"
 #include "kis_signals_blocker.h"
 #include "kis_canvas_controller.h"
 
 class PopupColorTriangle : public KoTriangleColorSelector
 {
 public:
     PopupColorTriangle(const KoColorDisplayRendererInterface *displayRenderer, QWidget* parent)
         : KoTriangleColorSelector(displayRenderer, parent)
         , m_dragging(false) {
     }
 
     ~PopupColorTriangle() override {}
 
     void tabletEvent(QTabletEvent* event) override {
         event->accept();
         QMouseEvent* mouseEvent = 0;
         switch (event->type()) {
         case QEvent::TabletPress:
             mouseEvent = new QMouseEvent(QEvent::MouseButtonPress, event->pos(),
                                          Qt::LeftButton, Qt::LeftButton, event->modifiers());
             m_dragging = true;
             mousePressEvent(mouseEvent);
             break;
         case QEvent::TabletMove:
             mouseEvent = new QMouseEvent(QEvent::MouseMove, event->pos(),
                                          (m_dragging) ? Qt::LeftButton : Qt::NoButton,
                                          (m_dragging) ? Qt::LeftButton : Qt::NoButton, event->modifiers());
             mouseMoveEvent(mouseEvent);
             break;
         case QEvent::TabletRelease:
             mouseEvent = new QMouseEvent(QEvent::MouseButtonRelease, event->pos(),
                                          Qt::LeftButton,
                                          Qt::LeftButton,
                                          event->modifiers());
             m_dragging = false;
             mouseReleaseEvent(mouseEvent);
             break;
         default: break;
         }
         delete mouseEvent;
     }
 
 private:
     bool m_dragging;
 };
 
 KisPopupPalette::KisPopupPalette(KisViewManager* viewManager, KisCoordinatesConverter* coordinatesConverter ,KisFavoriteResourceManager* manager,
                                  const KoColorDisplayRendererInterface *displayRenderer, KisCanvasResourceProvider *provider, QWidget *parent)
     : QWidget(parent, Qt::FramelessWindowHint)
     , m_coordinatesConverter(coordinatesConverter)
     , m_viewManager(viewManager)
     , m_actionManager(viewManager->actionManager())
     , m_resourceManager(manager)
     , m_displayRenderer(displayRenderer)
     , m_colorChangeCompressor(new KisSignalCompressor(50, KisSignalCompressor::POSTPONE))
     , m_actionCollection(viewManager->actionCollection())
 {
     // some UI controls are defined and created based off these variables
 
     const int borderWidth = 3;
 
     if (KisConfig(true).readEntry<bool>("popuppalette/usevisualcolorselector", false)) {
         m_triangleColorSelector = new KisVisualColorSelector(this);
     }
     else {
         m_triangleColorSelector  = new PopupColorTriangle(displayRenderer, this);
     }
     m_triangleColorSelector->setDisplayRenderer(displayRenderer);
     m_triangleColorSelector->setConfig(true,false);
     m_triangleColorSelector->move(m_popupPaletteSize/2-m_colorHistoryInnerRadius+borderWidth, m_popupPaletteSize/2-m_colorHistoryInnerRadius+borderWidth);
     m_triangleColorSelector->resize(m_colorHistoryInnerRadius*2-borderWidth*2, m_colorHistoryInnerRadius*2-borderWidth*2);
     m_triangleColorSelector->setVisible(true);
     KoColor fgcolor(Qt::black, KoColorSpaceRegistry::instance()->rgb8());
     if (m_resourceManager) {
         fgcolor = provider->fgColor();
     }
     m_triangleColorSelector->slotSetColor(fgcolor);
 
     QRegion maskedRegion(0, 0, m_triangleColorSelector->width(), m_triangleColorSelector->height(), QRegion::Ellipse );
     m_triangleColorSelector->setMask(maskedRegion);
 
     //setAttribute(Qt::WA_TranslucentBackground, true);
 
-    connect(m_triangleColorSelector, SIGNAL(sigNewColor(const KoColor &)),
+    connect(m_triangleColorSelector, SIGNAL(sigNewColor(KoColor)),
             m_colorChangeCompressor.data(), SLOT(start()));
     connect(m_colorChangeCompressor.data(), SIGNAL(timeout()),
             SLOT(slotEmitColorChanged()));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), m_triangleColorSelector, SLOT(configurationChanged()));
 
     connect(m_resourceManager, SIGNAL(sigChangeFGColorSelector(KoColor)),
             SLOT(slotExternalFgColorChanged(KoColor)));
     connect(this, SIGNAL(sigChangefGColor(KoColor)),
             m_resourceManager, SIGNAL(sigSetFGColor(KoColor)));
 
 
     connect(this, SIGNAL(sigChangeActivePaintop(int)), m_resourceManager, SLOT(slotChangeActivePaintop(int)));
     connect(this, SIGNAL(sigUpdateRecentColor(int)), m_resourceManager, SLOT(slotUpdateRecentColor(int)));
 
     connect(m_resourceManager, SIGNAL(setSelectedColor(int)), SLOT(slotSetSelectedColor(int)));
     connect(m_resourceManager, SIGNAL(updatePalettes()), SLOT(slotUpdate()));
     connect(m_resourceManager, SIGNAL(hidePalettes()), SLOT(slotHide()));
 
     // This is used to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     m_timer.setSingleShot(true);
     connect(this, SIGNAL(sigTriggerTimer()), this, SLOT(slotTriggerTimer()));
     connect(&m_timer, SIGNAL(timeout()), this, SLOT(slotEnableChangeFGColor()));
     connect(this, SIGNAL(sigEnableChangeFGColor(bool)), m_resourceManager, SIGNAL(sigEnableChangeColor(bool)));
 
     setCursor(Qt::ArrowCursor);
     setMouseTracking(true);
     setHoveredPreset(-1);
     setHoveredColor(-1);
     setSelectedColor(-1);
 
     m_brushHud = new KisBrushHud(provider, parent);
     m_brushHud->setMaximumHeight(m_popupPaletteSize);
     m_brushHud->setVisible(false);
 
     const int auxButtonSize = 35;
 
     m_settingsButton = new KisRoundHudButton(this);
 
     m_settingsButton->setGeometry(m_popupPaletteSize - 2.2 * auxButtonSize, m_popupPaletteSize - auxButtonSize,
                                   auxButtonSize, auxButtonSize);
 
     connect(m_settingsButton, SIGNAL(clicked()), SLOT(slotShowTagsPopup()));
 
     KisConfig cfg(true);
     m_brushHudButton = new KisRoundHudButton(this);
     m_brushHudButton->setCheckable(true);
 
     m_brushHudButton->setGeometry(m_popupPaletteSize - 1.0 * auxButtonSize, m_popupPaletteSize - auxButtonSize,
                                   auxButtonSize, auxButtonSize);
     connect(m_brushHudButton, SIGNAL(toggled(bool)), SLOT(showHudWidget(bool)));
     m_brushHudButton->setChecked(cfg.showBrushHud());
 
 
     // add some stuff below the pop-up palette that will make it easier to use for tablet people
     QVBoxLayout* vLayout = new QVBoxLayout(this); // main layout
 
     QSpacerItem* verticalSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
     vLayout->addSpacerItem(verticalSpacer); // this should push the box to the bottom
 
 
     QHBoxLayout* hLayout = new QHBoxLayout();
 
     vLayout->addLayout(hLayout);
 
     mirrorMode = new KisHighlightedToolButton(this);
     mirrorMode->setCheckable(true);
     mirrorMode->setFixedSize(35, 35);
 
     mirrorMode->setToolTip(i18n("Mirror Canvas"));
     connect(mirrorMode, SIGNAL(clicked(bool)), this, SLOT(slotmirroModeClicked()));
 
 
     canvasOnlyButton = new KisHighlightedToolButton(this);
     canvasOnlyButton->setCheckable(true);
     canvasOnlyButton->setFixedSize(35, 35);
 
     canvasOnlyButton->setToolTip(i18n("Canvas Only"));
     connect(canvasOnlyButton, SIGNAL(clicked(bool)), this, SLOT(slotCanvasonlyModeClicked()));
 
     zoomToOneHundredPercentButton = new QPushButton(this);
     zoomToOneHundredPercentButton->setText(i18n("100%"));
     zoomToOneHundredPercentButton->setFixedHeight(35);
 
     zoomToOneHundredPercentButton->setToolTip(i18n("Zoom to 100%"));
     connect(zoomToOneHundredPercentButton, SIGNAL(clicked(bool)), this, SLOT(slotZoomToOneHundredPercentClicked()));
 
     zoomCanvasSlider = new QSlider(Qt::Horizontal, this);
     zoomSliderMinValue = 10; // set in %
     zoomSliderMaxValue = 200; // set in %
 
     zoomCanvasSlider->setRange(zoomSliderMinValue, zoomSliderMaxValue);
     zoomCanvasSlider->setFixedHeight(35);
     zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent());
 
     zoomCanvasSlider->setSingleStep(1);
     zoomCanvasSlider->setPageStep(1);
 
     connect(zoomCanvasSlider, SIGNAL(valueChanged(int)), this, SLOT(slotZoomSliderChanged(int)));
 
     slotUpdateIcons();
 
     hLayout->addWidget(mirrorMode);
     hLayout->addWidget(canvasOnlyButton);
     hLayout->addWidget(zoomToOneHundredPercentButton);
     hLayout->addWidget(zoomCanvasSlider);
 
     setVisible(true);
     setVisible(false);
 
     // Prevent tablet events from being captured by the canvas
     setAttribute(Qt::WA_NoMousePropagation, true);
 }
 
 void KisPopupPalette::slotExternalFgColorChanged(const KoColor &color)
 {
     //hack to get around cmyk for now.
     if (color.colorSpace()->colorChannelCount()>3) {
         KoColor c(KoColorSpaceRegistry::instance()->rgb8());
         c.fromKoColor(color);
         m_triangleColorSelector->slotSetColor(c);
     } else {
         m_triangleColorSelector->slotSetColor(color);
     }
 }
 
 void KisPopupPalette::slotEmitColorChanged()
 {
     if (isVisible()) {
         update();
         emit sigChangefGColor(m_triangleColorSelector->getCurrentColor());
     }
 }
 
 //setting KisPopupPalette properties
 int KisPopupPalette::hoveredPreset() const
 {
     return m_hoveredPreset;
 }
 
 void KisPopupPalette::setHoveredPreset(int x)
 {
     m_hoveredPreset = x;
 }
 
 int KisPopupPalette::hoveredColor() const
 {
     return m_hoveredColor;
 }
 
 void KisPopupPalette::setHoveredColor(int x)
 {
     m_hoveredColor = x;
 }
 
 int KisPopupPalette::selectedColor() const
 {
     return m_selectedColor;
 }
 
 void KisPopupPalette::setSelectedColor(int x)
 {
     m_selectedColor = x;
 }
 
 void KisPopupPalette::slotTriggerTimer()
 {
     m_timer.start(750);
 }
 
 void KisPopupPalette::slotEnableChangeFGColor()
 {
     emit sigEnableChangeFGColor(true);
 }
 
 void KisPopupPalette::slotZoomSliderChanged(int zoom) {
     emit zoomLevelChanged(zoom);
 }
 
 void KisPopupPalette::adjustLayout(const QPoint &p)
 {
     KIS_ASSERT_RECOVER_RETURN(m_brushHud);
     if (isVisible() && parentWidget())  {
 
         float hudMargin = 30.0;
         const QRect fitRect = kisGrowRect(parentWidget()->rect(), -20.0); // -20 is widget margin
         const QPoint paletteCenterOffset(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
         QRect paletteRect = rect();
         paletteRect.moveTo(p - paletteCenterOffset);
         if (m_brushHudButton->isChecked()) {
             m_brushHud->updateGeometry();
             paletteRect.adjust(0, 0, m_brushHud->width() + hudMargin, 0);
         }
 
         paletteRect = kisEnsureInRect(paletteRect, fitRect);
         move(paletteRect.topLeft());
         m_brushHud->move(paletteRect.topLeft() + QPoint(m_popupPaletteSize + hudMargin, 0));
         m_lastCenterPoint = p;
     }
 }
 
 void KisPopupPalette::slotUpdateIcons()
 {
     zoomToOneHundredPercentButton->setIcon(KisIconUtils::loadIcon("zoom-original"));
     canvasOnlyButton->setIcon(KisIconUtils::loadIcon("document-new"));
     mirrorMode->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_settingsButton->setIcon(KisIconUtils::loadIcon("configure"));
     m_brushHud->updateIcons();
     m_brushHudButton->setOnOffIcons(KisIconUtils::loadIcon("arrow-left"), KisIconUtils::loadIcon("arrow-right"));
 }
 
 void KisPopupPalette::showHudWidget(bool visible)
 {
     KIS_ASSERT_RECOVER_RETURN(m_brushHud);
 
     const bool reallyVisible = visible && m_brushHudButton->isChecked();
 
     if (reallyVisible) {
         m_brushHud->updateProperties();
     }
 
     m_brushHud->setVisible(reallyVisible);
     adjustLayout(m_lastCenterPoint);
 
     KisConfig cfg(false);
     cfg.setShowBrushHud(visible);
 }
 
 void KisPopupPalette::showPopupPalette(const QPoint &p)
 {
     showPopupPalette(!isVisible());
     adjustLayout(p);
 }
 
 void KisPopupPalette::showPopupPalette(bool show)
 {
     if (show) {
         m_hadMousePressSinceOpening = false;
         m_timeSinceOpening.start();
 
 
         // don't set the zoom slider if we are outside of the zoom slider bounds. It will change the zoom level to within
         // the bounds and cause the canvas to jump between the slider's min and max
         if (m_coordinatesConverter->zoomInPercent() > zoomSliderMinValue &&
                 m_coordinatesConverter->zoomInPercent() < zoomSliderMaxValue  ){
 
             KisSignalsBlocker b(zoomCanvasSlider);
             zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent()); // sync the zoom slider
         }
         emit sigEnableChangeFGColor(!show);
     } else {
         emit sigTriggerTimer();
     }
     setVisible(show);
     m_brushHud->setVisible(show && m_brushHudButton->isChecked());
 }
 
 //redefinition of setVariable function to change the scope to private
 void KisPopupPalette::setVisible(bool b)
 {
     QWidget::setVisible(b);
 }
 
 void KisPopupPalette::setParent(QWidget *parent) {
     m_brushHud->setParent(parent);
     QWidget::setParent(parent);
 }
 
 QSize KisPopupPalette::sizeHint() const
 {
     return QSize(m_popupPaletteSize, m_popupPaletteSize + 50); // last number is the space for the toolbar below
 }
 
 void KisPopupPalette::resizeEvent(QResizeEvent*)
 {
 }
 
 void KisPopupPalette::paintEvent(QPaintEvent* e)
 {
     Q_UNUSED(e);
 
     QPainter painter(this);
 
     QPen pen(palette().color(QPalette::Text));
     pen.setWidth(3);
     painter.setPen(pen);
 
     painter.setRenderHint(QPainter::Antialiasing);
     painter.setRenderHint(QPainter::SmoothPixmapTransform);
 
     // painting background color indicator
     QPainterPath bgColor;
     bgColor.addEllipse(QPoint( 50, 80), 30, 30);
     painter.fillPath(bgColor, m_displayRenderer->toQColor(m_resourceManager->bgColor()));
     painter.drawPath(bgColor);
 
     // painting foreground color indicator
     QPainterPath fgColor;
     fgColor.addEllipse(QPoint( 60, 50), 30, 30);
     painter.fillPath(fgColor, m_displayRenderer->toQColor(m_triangleColorSelector->getCurrentColor()));
     painter.drawPath(fgColor);
 
     // create a circle background that everything else will go into
     QPainterPath backgroundContainer;
     float shrinkCircleAmount = 3;// helps the circle when the stroke is put around it
 
     QRectF circleRect(shrinkCircleAmount, shrinkCircleAmount,
                       m_popupPaletteSize - shrinkCircleAmount*2,m_popupPaletteSize - shrinkCircleAmount*2);
 
 
     backgroundContainer.addEllipse( circleRect );
     painter.fillPath(backgroundContainer,palette().brush(QPalette::Background));
 
     painter.drawPath(backgroundContainer);
 
     // create a path slightly inside the container circle. this will create a 'track' to indicate that we can rotate the canvas
     // with the indicator
     QPainterPath rotationTrackPath;
     shrinkCircleAmount = 18;
     QRectF circleRect2(shrinkCircleAmount, shrinkCircleAmount,
                        m_popupPaletteSize - shrinkCircleAmount*2,m_popupPaletteSize - shrinkCircleAmount*2);
 
     rotationTrackPath.addEllipse( circleRect2 );
     pen.setWidth(1);
     painter.setPen(pen);
     painter.drawPath(rotationTrackPath);
 
     // this thing will help indicate where the starting brush preset is at.
     // also what direction they go to give sor order to the presets populated
     /*
     pen.setWidth(6);
     pen.setCapStyle(Qt::RoundCap);
     painter.setPen(pen);
     painter.drawArc(circleRect, (16*90), (16*-30)); // span angle (last parameter) is in 16th of degrees
 
     QPainterPath brushDir;
     brushDir.arcMoveTo(circleRect, 60);
     brushDir.lineTo(brushDir.currentPosition().x()-5, brushDir.currentPosition().y() - 14);
     painter.drawPath(brushDir);
 
     brushDir.lineTo(brushDir.currentPosition().x()-2, brushDir.currentPosition().y() + 6);
     painter.drawPath(brushDir);
     */
 
     // the following things needs to be based off the center, so let's translate the painter
     painter.translate(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
 
     // create the canvas rotation handle
     QPainterPath rotationIndicator = drawRotationIndicator(m_coordinatesConverter->rotationAngle(), true);
 
     painter.fillPath(rotationIndicator,palette().brush(QPalette::Text));
 
     // hover indicator for the canvas rotation
     if (m_isOverCanvasRotationIndicator == true) {
         painter.save();
 
         QPen pen(palette().color(QPalette::Highlight));
         pen.setWidth(2);
         painter.setPen(pen);
         painter.drawPath(rotationIndicator);
 
         painter.restore();
     }
 
     // create a reset canvas rotation indicator to bring the canvas back to 0 degrees
     QPainterPath resetRotationIndicator = drawRotationIndicator(0, false);
 
     QPen resetPen(palette().color(QPalette::Text));
     resetPen.setWidth(1);
     painter.save();
     painter.setPen(resetPen);
     painter.drawPath(resetRotationIndicator);
 
     painter.restore();
 
     // painting favorite brushes
     QList<QImage> images(m_resourceManager->favoritePresetImages());
 
     // painting favorite brushes pixmap/icon
     QPainterPath presetPath;
     for (int pos = 0; pos < numSlots(); pos++) {
         painter.save();
 
         presetPath = createPathFromPresetIndex(pos);
 
         if (pos < images.size()) {
             painter.setClipPath(presetPath);
 
             QRect bounds = presetPath.boundingRect().toAlignedRect();
             painter.drawImage(bounds.topLeft() , images.at(pos).scaled(bounds.size() , Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation));
         }
         else {
             painter.fillPath(presetPath, palette().brush(QPalette::Window));  // brush slot that has no brush in it
         }
         QPen pen = painter.pen();
         pen.setWidth(1);
         painter.setPen(pen);
         painter.drawPath(presetPath);
 
         painter.restore();
     }
     if (hoveredPreset() > -1) {
         presetPath = createPathFromPresetIndex(hoveredPreset());
         QPen pen(palette().color(QPalette::Highlight));
         pen.setWidth(3);
         painter.setPen(pen);
         painter.drawPath(presetPath);
     }
 
     // paint recent colors area.
     painter.setPen(Qt::NoPen);
     float rotationAngle = -360.0 / m_resourceManager->recentColorsTotal();
 
     // there might be no recent colors at the start, so paint a placeholder
     if (m_resourceManager->recentColorsTotal() == 0) {
         painter.setBrush(Qt::transparent);
 
         QPainterPath emptyRecentColorsPath(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
         painter.setPen(QPen(palette().color(QPalette::Background).lighter(150), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
         painter.drawPath(emptyRecentColorsPath);
     } else {
 
         for (int pos = 0; pos < m_resourceManager->recentColorsTotal(); pos++) {
             QPainterPath recentColorsPath(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
 
             //accessing recent color of index pos
             painter.fillPath(recentColorsPath, m_displayRenderer->toQColor( m_resourceManager->recentColorAt(pos) ));
             painter.drawPath(recentColorsPath);
             painter.rotate(rotationAngle);
         }
 
     }
 
     // painting hovered color
     if (hoveredColor() > -1) {
         painter.setPen(QPen(palette().color(QPalette::Highlight), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
         if (m_resourceManager->recentColorsTotal() == 1) {
             QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
             painter.drawPath(path_ColorDonut);
         } else {
             painter.rotate((m_resourceManager->recentColorsTotal() + hoveredColor()) *rotationAngle);
             QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
             painter.drawPath(path);
             painter.rotate(hoveredColor() * -1 * rotationAngle);
         }
     }
 
     // painting selected color
     if (selectedColor() > -1) {
         painter.setPen(QPen(palette().color(QPalette::Highlight).darker(130), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
         if (m_resourceManager->recentColorsTotal() == 1) {
             QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
             painter.drawPath(path_ColorDonut);
         } else {
             painter.rotate((m_resourceManager->recentColorsTotal() + selectedColor()) *rotationAngle);
             QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
             painter.drawPath(path);
             painter.rotate(selectedColor() * -1 * rotationAngle);
         }
     }
 }
 
 QPainterPath KisPopupPalette::drawDonutPathFull(int x, int y, int inner_radius, int outer_radius)
 {
     QPainterPath path;
     path.addEllipse(QPointF(x, y), outer_radius, outer_radius);
     path.addEllipse(QPointF(x, y), inner_radius, inner_radius);
     path.setFillRule(Qt::OddEvenFill);
 
     return path;
 }
 
 QPainterPath KisPopupPalette::drawDonutPathAngle(int inner_radius, int outer_radius, int limit)
 {
     QPainterPath path;
     path.moveTo(-0.999 * outer_radius * sin(M_PI / limit), 0.999 * outer_radius * cos(M_PI / limit));
     path.arcTo(-1 * outer_radius, -1 * outer_radius, 2 * outer_radius, 2 * outer_radius, -90.0 - 180.0 / limit,
                360.0 / limit);
     path.arcTo(-1 * inner_radius, -1 * inner_radius, 2 * inner_radius, 2 * inner_radius, -90.0 + 180.0 / limit,
                - 360.0 / limit);
     path.closeSubpath();
 
     return path;
 }
 
 QPainterPath KisPopupPalette::drawRotationIndicator(qreal rotationAngle, bool canDrag)
 {
     // used for canvas rotation. This function gets called twice. Once by the canvas rotation indicator,
     // and another time by the reset canvas position
 
     float canvasRotationRadians = qDegreesToRadians(rotationAngle - 90);  // -90 will make 0 degrees be at the top
     float rotationDialXPosition = qCos(canvasRotationRadians) * (m_popupPaletteSize/2 - 10); // m_popupPaletteSize/2  = radius
     float rotationDialYPosition = qSin(canvasRotationRadians) * (m_popupPaletteSize/2 - 10);
 
     QPainterPath canvasRotationIndicator;
     int canvasIndicatorSize = 15;
     float canvasIndicatorMiddle = canvasIndicatorSize/2;
     QRect indicatorRectangle = QRect( rotationDialXPosition - canvasIndicatorMiddle, rotationDialYPosition - canvasIndicatorMiddle,
                                       canvasIndicatorSize, canvasIndicatorSize );
 
     if (canDrag) {
         m_canvasRotationIndicatorRect = indicatorRectangle;
     } else {
         m_resetCanvasRotationIndicatorRect = indicatorRectangle;
     }
 
     canvasRotationIndicator.addEllipse(indicatorRectangle.x(), indicatorRectangle.y(),
                                        indicatorRectangle.width(), indicatorRectangle.height() );
 
     return canvasRotationIndicator;
 }
 
 
 void KisPopupPalette::mouseMoveEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     setToolTip(QString());
     setHoveredPreset(-1);
     setHoveredColor(-1);
 
     // calculate if we are over the canvas rotation knob
     // before we started painting, we moved the painter to the center of the widget, so the X/Y positions are offset. we need to
     // correct them first before looking for a click event intersection
 
     float rotationCorrectedXPos = m_canvasRotationIndicatorRect.x() + (m_popupPaletteSize / 2);
     float rotationCorrectedYPos = m_canvasRotationIndicatorRect.y() + (m_popupPaletteSize / 2);
     QRect correctedCanvasRotationIndicator = QRect(rotationCorrectedXPos, rotationCorrectedYPos,
                                                    m_canvasRotationIndicatorRect.width(), m_canvasRotationIndicatorRect.height());
 
     if (correctedCanvasRotationIndicator.contains(point.x(), point.y())) {
         m_isOverCanvasRotationIndicator = true;
     } else {
         m_isOverCanvasRotationIndicator = false;
     }
 
     if (m_isRotatingCanvasIndicator) {
         // we are rotating the canvas, so calculate the rotation angle based off the center
         // calculate the angle we are at first
         QPoint widgetCenterPoint = QPoint(m_popupPaletteSize/2, m_popupPaletteSize/2);
 
         float dX = point.x() - widgetCenterPoint.x();
         float dY = point.y() - widgetCenterPoint.y();
 
 
         float finalAngle = qAtan2(dY,dX) * 180 / M_PI; // what we need if we have two points, but don't know the angle
         finalAngle = finalAngle + 90; // add 90 degrees so 0 degree position points up
         float angleDifference = finalAngle - m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs, so find it out
 
         KisCanvasController *canvasController =
             dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
         canvasController->rotateCanvas(angleDifference);
 
         emit sigUpdateCanvas();
     }
 
     // don't highlight the presets if we are in the middle of rotating the canvas
     if (m_isRotatingCanvasIndicator == false) {
         QPainterPath pathColor(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
         {
             int pos = calculatePresetIndex(point, m_resourceManager->numFavoritePresets());
 
             if (pos >= 0 && pos < m_resourceManager->numFavoritePresets()) {
                 setToolTip(m_resourceManager->favoritePresetList().at(pos).data()->name());
                 setHoveredPreset(pos);
             }
         }
         if (pathColor.contains(point)) {
             int pos = calculateIndex(point, m_resourceManager->recentColorsTotal());
 
             if (pos >= 0 && pos < m_resourceManager->recentColorsTotal()) {
                 setHoveredColor(pos);
             }
         }
     }
 
     update();
 }
 
 void KisPopupPalette::mousePressEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     /**
      * Tablet support code generates a spurious right-click right after opening
      * the window, so we should ignore it. Next right-click will be used for
      * closing the popup palette
      */
     if (!m_hadMousePressSinceOpening && m_timeSinceOpening.elapsed() > 100) {
         m_hadMousePressSinceOpening = true;
     }
 
     if (event->button() == Qt::LeftButton) {
 
         //in favorite brushes area
         int pos = calculateIndex(point, m_resourceManager->numFavoritePresets());
         if (pos >= 0 && pos < m_resourceManager->numFavoritePresets()
                 && isPointInPixmap(point, pos)) {
             //setSelectedBrush(pos);
             update();
         }
 
         if (m_isOverCanvasRotationIndicator) {
             m_isRotatingCanvasIndicator = true;
         }
 
         // reset the canvas if we are over the reset canvas rotation indicator
         float rotationCorrectedXPos = m_resetCanvasRotationIndicatorRect.x() + (m_popupPaletteSize / 2);
         float rotationCorrectedYPos = m_resetCanvasRotationIndicatorRect.y() + (m_popupPaletteSize / 2);
         QRect correctedResetCanvasRotationIndicator = QRect(rotationCorrectedXPos, rotationCorrectedYPos,
                                                             m_resetCanvasRotationIndicatorRect.width(), m_resetCanvasRotationIndicatorRect.height());
 
         if (correctedResetCanvasRotationIndicator.contains(point.x(), point.y())) {
             float angleDifference = -m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs
             KisCanvasController *canvasController =
                     dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
             canvasController->rotateCanvas(angleDifference);
 
             emit sigUpdateCanvas();
         }
     }
 }
 
 void KisPopupPalette::slotShowTagsPopup()
 {
     KisPaintOpPresetResourceServer *rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QStringList tags = rServer->tagNamesList();
     std::sort(tags.begin(), tags.end());
 
     if (!tags.isEmpty()) {
         QMenu menu;
         Q_FOREACH (const QString& tag, tags) {
             menu.addAction(tag);
         }
 
         QAction *action = menu.exec(QCursor::pos());
         if (action) {
             m_resourceManager->setCurrentTag(action->text());
         }
     } else {
         QWhatsThis::showText(QCursor::pos(),
                              i18n("There are no tags available to show in this popup. To add presets, you need to tag them and then select the tag here."));
     }
 }
 
 void KisPopupPalette::slotmirroModeClicked() {
     QAction *action = m_actionCollection->action("mirror_canvas");
 
     if (action) {
         action->trigger();
     }
 }
 
 void KisPopupPalette::slotCanvasonlyModeClicked() {
     QAction *action = m_actionCollection->action("view_show_canvas_only");
 
     if (action) {
         action->trigger();
     }
 }
 
 void KisPopupPalette::slotZoomToOneHundredPercentClicked() {
     QAction *action = m_actionCollection->action("zoom_to_100pct");
 
     if (action) {
         action->trigger();
     }
 
     // also move the zoom slider to 100% position so they are in sync
     zoomCanvasSlider->setValue(100);
 }
 
 void KisPopupPalette::tabletEvent(QTabletEvent *event) {
     event->ignore();
 }
 
 void KisPopupPalette::mouseReleaseEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     // see a comment in KisPopupPalette::mousePressEvent
     if (m_hadMousePressSinceOpening &&
         event->buttons() == Qt::NoButton &&
         event->button() == Qt::RightButton) {
 
         showPopupPalette(false);
         return;
     }
 
     m_isOverCanvasRotationIndicator = false;
     m_isRotatingCanvasIndicator = false;
 
     if (event->button() == Qt::LeftButton) {
         QPainterPath pathColor(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
 
         //in favorite brushes area
         if (hoveredPreset() > -1) {
             //setSelectedBrush(hoveredBrush());
             emit sigChangeActivePaintop(hoveredPreset());
         }
         if (pathColor.contains(point)) {
             int pos = calculateIndex(point, m_resourceManager->recentColorsTotal());
 
             if (pos >= 0 && pos < m_resourceManager->recentColorsTotal()) {
                 emit sigUpdateRecentColor(pos);
             }
         }
     }
 }
 
 int KisPopupPalette::calculateIndex(QPointF point, int n)
 {
     calculatePresetIndex(point, n);
     //translate to (0,0)
     point.setX(point.x() - m_popupPaletteSize / 2);
     point.setY(point.y() - m_popupPaletteSize / 2);
 
     //rotate
     float smallerAngle = M_PI / 2 + M_PI / n - atan2(point.y(), point.x());
     float radius = sqrt((float)point.x() * point.x() + point.y() * point.y());
     point.setX(radius * cos(smallerAngle));
     point.setY(radius * sin(smallerAngle));
 
     //calculate brush index
     int pos = floor(acos(point.x() / radius) * n / (2 * M_PI));
     if (point.y() < 0) pos =  n - pos - 1;
 
     return pos;
 }
 
 bool KisPopupPalette::isPointInPixmap(QPointF &point, int pos)
 {
     if (createPathFromPresetIndex(pos).contains(point + QPointF(-m_popupPaletteSize / 2, -m_popupPaletteSize / 2))) {
         return true;
     }
     return false;
 }
 
 KisPopupPalette::~KisPopupPalette()
 {
 }
 
 QPainterPath KisPopupPalette::createPathFromPresetIndex(int index)
 {
     qreal angleSlice = 360.0 / numSlots() ; // how many degrees each slice will get
 
     // the starting angle of the slice we need to draw. the negative sign makes us go clockwise.
     // adding 90 degrees makes us start at the top. otherwise we would start at the right
     qreal startingAngle = -(index * angleSlice) + 90;
 
     // the radius will get smaller as the amount of presets shown increases. 10 slots == 41
     qreal presetRadius = m_colorHistoryOuterRadius * qSin(qDegreesToRadians(angleSlice/2)) / (1-qSin(qDegreesToRadians(angleSlice/2)));
 
 
     QPainterPath path;
     float pathX = (m_colorHistoryOuterRadius + presetRadius) * qCos(qDegreesToRadians(startingAngle)) - presetRadius;
     float pathY = -(m_colorHistoryOuterRadius + presetRadius) * qSin(qDegreesToRadians(startingAngle)) - presetRadius;
     float pathDiameter = 2 * presetRadius; // distance is used to calculate the X/Y in addition to the preset circle size
     path.addEllipse(pathX, pathY, pathDiameter, pathDiameter);
 
     return path;
 }
 
 int KisPopupPalette::calculatePresetIndex(QPointF point, int /*n*/)
 {
     for(int i = 0; i < numSlots(); i++)
     {
         QPointF adujustedPoint = point - QPointF(m_popupPaletteSize/2, m_popupPaletteSize/2);
         if(createPathFromPresetIndex(i).contains(adujustedPoint))
         {
             return i;
         }
     }
     return -1;
 }
 
 int KisPopupPalette::numSlots()
 {
     KisConfig config(true);
     return qMax(config.favoritePresets(), 10);
 }
diff --git a/libs/ui/kis_stopgradient_editor.cpp b/libs/ui/kis_stopgradient_editor.cpp
index 9d2dbfe57a..f5f1eb50a3 100644
--- a/libs/ui/kis_stopgradient_editor.cpp
+++ b/libs/ui/kis_stopgradient_editor.cpp
@@ -1,198 +1,198 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *                2016 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_stopgradient_editor.h"
 #include <QPainter>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
 
 #include <KoColorSpace.h>
 #include <resources/KoStopGradient.h>
 
 #include "kis_debug.h"
 
 #include <kis_icon_utils.h>
 
 /****************************** KisStopGradientEditor ******************************/
 
 KisStopGradientEditor::KisStopGradientEditor(QWidget *parent)
     : QWidget(parent),
       m_gradient(0)
 {
     setupUi(this);
 
     connect(gradientSlider, SIGNAL(sigSelectedStop(int)), this, SLOT(stopChanged(int)));
     connect(nameedit, SIGNAL(editingFinished()), this, SLOT(nameChanged()));
-    connect(colorButton, SIGNAL(changed(const KoColor&)), SLOT(colorChanged(const KoColor&)));
+    connect(colorButton, SIGNAL(changed(KoColor)), SLOT(colorChanged(KoColor)));
 
     opacitySlider->setPrefix(i18n("Opacity: "));
     opacitySlider->setRange(0.0, 1.0, 2);
     connect(opacitySlider, SIGNAL(valueChanged(qreal)), this, SLOT(opacityChanged(qreal)));
 
 
     buttonReverse->setIcon(KisIconUtils::loadIcon("view-refresh"));
     buttonReverse->setToolTip(i18n("Flip Gradient"));
     KisIconUtils::updateIcon(buttonReverse);
     connect(buttonReverse, SIGNAL(pressed()), SLOT(reverse()));
 
     buttonReverseSecond->setIcon(KisIconUtils::loadIcon("view-refresh"));
     buttonReverseSecond->setToolTip(i18n("Flip Gradient"));
     KisIconUtils::updateIcon(buttonReverseSecond);
     connect(buttonReverseSecond, SIGNAL(clicked()), SLOT(reverse()));
 
     setCompactMode(false);
 
     setGradient(0);
     stopChanged(-1);
 }
 
 KisStopGradientEditor::KisStopGradientEditor(KoStopGradient* gradient, QWidget *parent, const char* name, const QString& caption)
     : KisStopGradientEditor(parent)
 {
     setObjectName(name);
     setWindowTitle(caption);
 
     setGradient(gradient);
 }
 
 void KisStopGradientEditor::setCompactMode(bool value)
 {
     lblName->setVisible(!value);
     buttonReverse->setVisible(!value);
     nameedit->setVisible(!value);
 
     buttonReverseSecond->setVisible(value);
 }
 
 void KisStopGradientEditor::setGradient(KoStopGradient *gradient)
 {
     m_gradient = gradient;
     setEnabled(m_gradient);
 
     if (m_gradient) {
         gradientSlider->setGradientResource(m_gradient);
         nameedit->setText(gradient->name());
         stopChanged(gradientSlider->selectedStop());
     }
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::notifyGlobalColorChanged(const KoColor &color)
 {
     if (colorButton->isEnabled() &&
         color != colorButton->color()) {
 
         colorButton->setColor(color);
     }
 }
 
 boost::optional<KoColor> KisStopGradientEditor::currentActiveStopColor() const
 {
     if (!colorButton->isEnabled()) return boost::none;
     return colorButton->color();
 }
 
 void KisStopGradientEditor::stopChanged(int stop)
 {
     if (!m_gradient) return;
 
     const bool hasStopSelected = stop >= 0;
 
     opacitySlider->setEnabled(hasStopSelected);
     colorButton->setEnabled(hasStopSelected);
     stopLabel->setEnabled(hasStopSelected);
 
     if (hasStopSelected) {
         KoColor color = m_gradient->stops()[stop].second;
         opacitySlider->setValue(color.opacityF());
    
         color.setOpacity(1.0);
         colorButton->setColor(color);
     }
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::colorChanged(const KoColor& color)
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
 
     int currentStop = gradientSlider->selectedStop();
     double t = stops[currentStop].first;
     
     KoColor c(color, stops[currentStop].second.colorSpace());
     c.setOpacity(stops[currentStop].second.opacityU8());
     
     stops.removeAt(currentStop);
     stops.insert(currentStop, KoGradientStop(t, c));
     
     m_gradient->setStops(stops);
     gradientSlider->update();
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::opacityChanged(qreal value)
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
 
     int currentStop = gradientSlider->selectedStop();
     double t = stops[currentStop].first;
     
     KoColor c = stops[currentStop].second;
     c.setOpacity(value);
     
     stops.removeAt(currentStop);
     stops.insert(currentStop, KoGradientStop(t, c));
     
     m_gradient->setStops(stops);
     gradientSlider->update();
 
     emit sigGradientChanged();
 }
 
 
 void KisStopGradientEditor::nameChanged()
 {
     if (!m_gradient) return;
 
     m_gradient->setName(nameedit->text());
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::reverse()
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
     QList<KoGradientStop> reversedStops;
     for(const KoGradientStop& stop : stops) {
         reversedStops.push_front(KoGradientStop(1 - stop.first, stop.second));
     }
     m_gradient->setStops(reversedStops);
     gradientSlider->setSelectedStop(stops.size() - 1 - gradientSlider->selectedStop());
 
     emit sigGradientChanged();
 }
 
diff --git a/libs/ui/tests/kis_derived_resources_test.cpp b/libs/ui/tests/kis_derived_resources_test.cpp
index cd9080de65..edbd9f4e36 100644
--- a/libs/ui/tests/kis_derived_resources_test.cpp
+++ b/libs/ui/tests/kis_derived_resources_test.cpp
@@ -1,159 +1,159 @@
 /*
  *  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_derived_resources_test.h"
 
 #include <QTest>
 #include <brushengine/kis_paintop_preset.h>
 
 #include <QApplication>
 
 #include <KoCanvasResourceManager.h>
 
 #include "kis_canvas_resource_provider.h"
 #include <util.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <KisView.h>
 #include <KisViewManager.h>
 #include <kis_paintop_settings.h>
 #include <KoResourcePaths.h>
 #include <kis_config.h>
 #include "testutil.h"
 #include "opengl/kis_opengl.h"
 
 
 void addResourceTypes()
 {
     // All Krita's resource types
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_windowlayouts", "data", "/windowlayouts/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
 
     KisOpenGL::setDefaultFormat(false, false);
 
     KisConfig cfg(false);
     cfg.setUseOpenGL(false);
 }
 
 void KisDerivedResourcesTest::test()
 {
     addResourceTypes();
 
     KisDocument* doc = createEmptyDocument();
 
 
 
     KisMainWindow* mainWindow = KisPart::instance()->createMainWindow();
     QPointer<KisView> view = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
     KisViewManager *viewManager = new KisViewManager(mainWindow, mainWindow->actionCollection());
     KoCanvasResourceManager *manager = viewManager->resourceProvider()->resourceManager();
 
     QApplication::processEvents();
 
     QString presetFileName = "autobrush_300px.kpp";
 
     QVariant i;
 
     KisPaintOpPresetSP preset;
     if (!presetFileName.isEmpty()) {
         QString fullFileName = TestUtil::fetchDataFileLazy(presetFileName);
         preset = new KisPaintOpPreset(fullFileName);
         bool presetValid = preset->load();
         Q_ASSERT(presetValid); Q_UNUSED(presetValid);
 
         i.setValue(preset);
 
     }
 
     QVERIFY(i.isValid());
 
-    QSignalSpy spy(manager, SIGNAL(canvasResourceChanged(int, const QVariant &)));
+    QSignalSpy spy(manager, SIGNAL(canvasResourceChanged(int,QVariant)));
 
     manager->setResource(KisCanvasResourceProvider::CurrentPaintOpPreset, i);
 
     QMap<int, QVariant> expectedSignals;
     expectedSignals[KisCanvasResourceProvider::CurrentPaintOpPreset] = QVariant::fromValue(preset);
     expectedSignals[KisCanvasResourceProvider::EraserMode] = false;
     expectedSignals[KisCanvasResourceProvider::LodSizeThresholdSupported] = true;
     expectedSignals[KisCanvasResourceProvider::EffectiveLodAvailablility] = true;
     expectedSignals[KisCanvasResourceProvider::LodSizeThreshold] = 100;
     expectedSignals[KisCanvasResourceProvider::LodAvailability] = true;
     expectedSignals[KisCanvasResourceProvider::Opacity] = 1.0;
     expectedSignals[KisCanvasResourceProvider::Size] = 300.0;
     expectedSignals[KisCanvasResourceProvider::Flow] = 1.0;
     expectedSignals[KisCanvasResourceProvider::CurrentEffectiveCompositeOp] = COMPOSITE_OVER;
     expectedSignals[KisCanvasResourceProvider::CurrentCompositeOp] = COMPOSITE_OVER;
 
     auto it = spy.begin();
     for (; it != spy.end(); ++it) {
         const int id = (*it)[0].toInt();
         const QVariant value = (*it)[1];
 
         if (!expectedSignals.contains(id)) {
             qDebug() << ppVar(id) << ppVar(value);
             QFAIL("Unexpected signal!");
         } else {
             if (expectedSignals[id] != value) {
                 qDebug() << ppVar(id) << ppVar(value) << ppVar(expectedSignals[id]);
                 QFAIL("Unexpected value!");
             }
         }
     }
 
     QCOMPARE(spy.size(), expectedSignals.size());
 
     spy.clear();
 
     preset->settings()->setPaintOpOpacity(0.8);
 
     QCOMPARE(spy.size(), 1);
     QCOMPARE(spy[0][0].toInt(), (int)KisCanvasResourceProvider::Opacity);
     QCOMPARE(spy[0][1].toDouble(), 0.8);
     spy.clear();
 
 
     mainWindow->hide();
     QApplication::processEvents();
 
     delete view;
     delete doc;
     delete mainWindow;
 }
 
 KISTEST_MAIN(KisDerivedResourcesTest)
diff --git a/libs/ui/tool/kis_rectangle_constraint_widget.cpp b/libs/ui/tool/kis_rectangle_constraint_widget.cpp
index 83b03c4794..b2cc0ba16c 100644
--- a/libs/ui/tool/kis_rectangle_constraint_widget.cpp
+++ b/libs/ui/tool/kis_rectangle_constraint_widget.cpp
@@ -1,123 +1,123 @@
 /*
  *  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_rectangle_constraint_widget.h"
 #include "kis_tool_rectangle_base.h"
 
 #include <kis_icon.h>
 #include "kis_aspect_ratio_locker.h"
 #include "kis_signals_blocker.h"
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 KisRectangleConstraintWidget::KisRectangleConstraintWidget(QWidget *parent, KisToolRectangleBase *tool, bool showRoundCornersGUI)
     : QWidget(parent)
 {
     m_tool = tool;
     
     setupUi(this);
     
     lockWidthButton->setIcon(KisIconUtils::loadIcon("layer-locked"));
     lockHeightButton->setIcon(KisIconUtils::loadIcon("layer-locked"));
     lockRatioButton->setIcon(KisIconUtils::loadIcon("layer-locked"));
-    connect(lockWidthButton, SIGNAL(toggled(bool)), this, SLOT(inputsChanged(void)));
-    connect(lockHeightButton, SIGNAL(toggled(bool)), this, SLOT(inputsChanged(void)));
-    connect(lockRatioButton, SIGNAL(toggled(bool)), this, SLOT(inputsChanged(void)));
+    connect(lockWidthButton, SIGNAL(toggled(bool)), this, SLOT(inputsChanged()));
+    connect(lockHeightButton, SIGNAL(toggled(bool)), this, SLOT(inputsChanged()));
+    connect(lockRatioButton, SIGNAL(toggled(bool)), this, SLOT(inputsChanged()));
 
-    connect(intWidth,  SIGNAL(valueChanged(int)), this, SLOT(inputsChanged(void)));
-    connect(intHeight, SIGNAL(valueChanged(int)), this, SLOT(inputsChanged(void)));
-    connect(doubleRatio, SIGNAL(valueChanged(double)), this, SLOT(inputsChanged(void)));
+    connect(intWidth,  SIGNAL(valueChanged(int)), this, SLOT(inputsChanged()));
+    connect(intHeight, SIGNAL(valueChanged(int)), this, SLOT(inputsChanged()));
+    connect(doubleRatio, SIGNAL(valueChanged(double)), this, SLOT(inputsChanged()));
   
     connect(this, SIGNAL(constraintsChanged(bool,bool,bool,float,float,float)), m_tool, SLOT(constraintsChanged(bool,bool,bool,float,float,float)));
     connect(m_tool, SIGNAL(rectangleChanged(QRectF)), this, SLOT(rectangleChanged(QRectF)));
 
     m_cornersAspectLocker = new KisAspectRatioLocker(this);
     m_cornersAspectLocker->connectSpinBoxes(intRoundCornersX, intRoundCornersY, cornersAspectButton);
 
     connect(m_cornersAspectLocker, SIGNAL(sliderValueChanged()), SLOT(slotRoundCornersChanged()));
     connect(m_cornersAspectLocker, SIGNAL(aspectButtonChanged()), SLOT(slotRoundCornersAspectLockChanged()));
 
     connect(m_tool, SIGNAL(sigRequestReloadConfig()), SLOT(slotReloadConfig()));
     slotReloadConfig();
 
     if (!showRoundCornersGUI) {
         intRoundCornersX->setVisible(false);
         intRoundCornersY->setVisible(false);
         lblRoundCornersX->setVisible(false);
         lblRoundCornersY->setVisible(false);
         cornersAspectButton->setVisible(false);
     }
 }
 
 void KisRectangleConstraintWidget::inputsChanged() 
 {
     emit constraintsChanged(
         lockRatioButton->isChecked(),
         lockWidthButton->isChecked(),
         lockHeightButton->isChecked(),
         doubleRatio->value(), 
         intWidth->value(), 
         intHeight->value()
                 );
 }
 
 void KisRectangleConstraintWidget::slotRoundCornersChanged()
 {
     m_tool->roundCornersChanged(intRoundCornersX->value(), intRoundCornersY->value());
 
     KConfigGroup cfg = KSharedConfig::openConfig()->group(m_tool->toolId());
     cfg.writeEntry("roundCornersX", intRoundCornersX->value());
     cfg.writeEntry("roundCornersY", intRoundCornersY->value());
 }
 
 void KisRectangleConstraintWidget::slotRoundCornersAspectLockChanged()
 {
     KConfigGroup cfg = KSharedConfig::openConfig()->group(m_tool->toolId());
     cfg.writeEntry("roundCornersAspectLocked", cornersAspectButton->keepAspectRatio());
 }
 
 void KisRectangleConstraintWidget::slotReloadConfig()
 {
     KConfigGroup cfg = KSharedConfig::openConfig()->group(m_tool->toolId());
 
     {
         KisSignalsBlocker b(intRoundCornersX, intRoundCornersY, cornersAspectButton);
         intRoundCornersX->setValue(cfg.readEntry("roundCornersX", 0));
         intRoundCornersY->setValue(cfg.readEntry("roundCornersY", 0));
         cornersAspectButton->setKeepAspectRatio(cfg.readEntry("roundCornersAspectLocked", true));
         m_cornersAspectLocker->updateAspect();
     }
 
     slotRoundCornersChanged();
 }
 
 void KisRectangleConstraintWidget::rectangleChanged(const QRectF &rect) 
 {
     intWidth->blockSignals(true);
     intHeight->blockSignals(true);
     doubleRatio->blockSignals(true);
     
     if (!lockWidthButton->isChecked()) intWidth->setValue(rect.width());
     if (!lockHeightButton->isChecked()) intHeight->setValue(rect.height());
 
     if (!lockRatioButton->isChecked() && !(rect.width() == 0 && rect.height() == 0)) {
         doubleRatio->setValue(fabs(rect.width()) / fabs(rect.height()));
     }
   
     intWidth->blockSignals(false);
     intHeight->blockSignals(false);
     doubleRatio->blockSignals(false);
 }
diff --git a/libs/ui/widgets/KisNewsWidget.cpp b/libs/ui/widgets/KisNewsWidget.cpp
index 5a2cd2a5c0..e308fa2d7e 100644
--- a/libs/ui/widgets/KisNewsWidget.cpp
+++ b/libs/ui/widgets/KisNewsWidget.cpp
@@ -1,112 +1,112 @@
 /*
  * Copyright (c) 2018 boud <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 "KisNewsWidget.h"
 
 #include <QDesktopServices>
 #include <QUrl>
 #include <QPainter>
 #include <QStyleOptionViewItem>
 #include <QModelIndex>
 #include <QTextDocument>
 #include <QAbstractTextDocumentLayout>
 
 #include "kis_config.h"
 #include "KisMultiFeedRSSModel.h"
 
 
 KisNewsDelegate::KisNewsDelegate(QObject *parent)
     : QStyledItemDelegate(parent)
 {
     qDebug() << "Delegate created";
 }
 
 void KisNewsDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     painter->save();
 
     QStyleOptionViewItem optionCopy = option;
     initStyleOption(&optionCopy, index);
 
     QStyle *style = optionCopy.widget? optionCopy.widget->style() : QApplication::style();
 
     QTextDocument doc;
     doc.setHtml(optionCopy.text);
     doc.setDocumentMargin(10);
 
     /// Painting item without text
     optionCopy.text = QString();
     style->drawControl(QStyle::CE_ItemViewItem, &optionCopy, painter);
 
     QAbstractTextDocumentLayout::PaintContext ctx;
 
     // Highlighting text if item is selected
     if (optionCopy.state & QStyle::State_Selected) {
         ctx.palette.setColor(QPalette::Text, optionCopy.palette.color(QPalette::Active, QPalette::HighlightedText));
     }
 
     painter->translate(optionCopy.rect.left(), optionCopy.rect.top());
     QRect clip(0, 0, optionCopy.rect.width(), optionCopy.rect.height());
     doc.setPageSize(clip.size());
     doc.drawContents(painter, clip);
     painter->restore();
 }
 
 QSize KisNewsDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QStyleOptionViewItem optionCopy = option;
     initStyleOption(&optionCopy, index);
 
     QTextDocument doc;
     doc.setHtml(optionCopy.text);
     doc.setTextWidth(optionCopy.rect.width());
     return QSize(doc.idealWidth(), doc.size().height());
 }
 
 KisNewsWidget::KisNewsWidget(QWidget *parent)
     : QWidget(parent)
 {
     setupUi(this);
     m_rssModel = new MultiFeedRssModel(this);
 
     setCursor(Qt::PointingHandCursor);
 
     listNews->setModel(m_rssModel);
     listNews->setItemDelegate(new KisNewsDelegate(listNews));
-    connect(listNews, SIGNAL(clicked(const QModelIndex&)), this, SLOT(itemSelected(const QModelIndex&)));
+    connect(listNews, SIGNAL(clicked(QModelIndex)), this, SLOT(itemSelected(QModelIndex)));
 }
 
 void KisNewsWidget::toggleNews(bool toggle)
 {
     KisConfig cfg(false);
     cfg.writeEntry<bool>("FetchNews", toggle);
 
     if (toggle) {
         m_rssModel->addFeed(QLatin1String("https://krita.org/en/feed/"));
     }
     else {
         m_rssModel->removeFeed(QLatin1String("https://krita.org/en/feed/"));
     }
 }
 
 void KisNewsWidget::itemSelected(const QModelIndex &idx)
 {
     if (idx.isValid()) {
         QString link = idx.data(RssRoles::LinkRole).toString();
         QDesktopServices::openUrl(QUrl(link));
     }
 }
diff --git a/libs/ui/widgets/KoFillConfigWidget.cpp b/libs/ui/widgets/KoFillConfigWidget.cpp
index efd13872fb..ec391ec0de 100644
--- a/libs/ui/widgets/KoFillConfigWidget.cpp
+++ b/libs/ui/widgets/KoFillConfigWidget.cpp
@@ -1,851 +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 "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->colorAction, SIGNAL(colorChanged(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> )),
+    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->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 984327a767..1a301a7ad6 100644
--- a/libs/ui/widgets/KoStrokeConfigWidget.cpp
+++ b/libs/ui/widgets/KoStrokeConfigWidget.cpp
@@ -1,804 +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 <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 &)));
+            canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+            this, SLOT(canvasResourceChanged(int,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_paintop_preset_icon_library.cpp b/libs/ui/widgets/kis_paintop_preset_icon_library.cpp
index 1215f52e1e..f1ef5f2a3c 100644
--- a/libs/ui/widgets/kis_paintop_preset_icon_library.cpp
+++ b/libs/ui/widgets/kis_paintop_preset_icon_library.cpp
@@ -1,165 +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 <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->vwBase->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(updateIcon()));
+    connect(ui->vwOptional->selectionModel(), SIGNAL(selectionChanged(QItemSelection,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 b4c6ae43a4..ea87a4ba51 100644
--- a/libs/ui/widgets/kis_paintop_presets_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_popup.cpp
@@ -1,850 +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 <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)));
+            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_scratch_pad.cpp b/libs/ui/widgets/kis_scratch_pad.cpp
index d1b34a9c92..3f3e90b26b 100644
--- a/libs/ui/widgets/kis_scratch_pad.cpp
+++ b/libs/ui/widgets/kis_scratch_pad.cpp
@@ -1,518 +1,518 @@
 /* This file is part of the KDE project
  * Copyright 2010 (C) Boudewijn Rempt <boud@valdyas.org>
  * Copyright 2011 (C) Dmitry Kazakov <dimula73@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "kis_scratch_pad.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoPointerEvent.h>
 #include <resources/KoAbstractGradient.h>
 
 #include <kis_cursor.h>
 #include <kis_tool_utils.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_gradient_painter.h>
 #include <kis_default_bounds.h>
 #include <kis_canvas_resource_provider.h>
 
 #include "kis_config.h"
 #include "kis_image.h"
 #include "kis_undo_stores.h"
 #include "kis_update_scheduler.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_scratch_pad_event_filter.h"
 #include "kis_painting_information_builder.h"
 #include "kis_tool_freehand_helper.h"
 #include "kis_image_patch.h"
 #include "kis_canvas_widget_base.h"
 #include "kis_layer_projection_plane.h"
 #include "kis_node_graph_listener.h"
 
 
 class KisScratchPadNodeListener : public KisNodeGraphListener
 {
 public:
     KisScratchPadNodeListener(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     void requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache) override {
         KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 
         QMutexLocker locker(&m_lock);
 
         Q_FOREACH (const QRect &rc, rects) {
             m_scratchPad->imageUpdated(rc);
         }
     }
 
 private:
     KisScratchPad *m_scratchPad;
     QMutex m_lock;
 };
 
 
 class KisScratchPadDefaultBounds : public KisDefaultBounds
 {
 public:
 
     KisScratchPadDefaultBounds(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     ~KisScratchPadDefaultBounds() override {}
 
     QRect bounds() const override {
         return m_scratchPad->imageBounds();
     }
 
 private:
     Q_DISABLE_COPY(KisScratchPadDefaultBounds)
 
     KisScratchPad *m_scratchPad;
 };
 
 
 KisScratchPad::KisScratchPad(QWidget *parent)
     : QWidget(parent)
     , m_toolMode(HOVERING)
     , m_paintLayer(0)
     , m_displayProfile(0)
     , m_resourceProvider(0)
 {
     setAutoFillBackground(false);
     setMouseTracking(true);
 
     m_cursor = KisCursor::load("tool_freehand_cursor.png", 5, 5);
     setCursor(m_cursor);
 
     KisConfig cfg(true);
     QImage checkImage = KisCanvasWidgetBase::createCheckersImage(cfg.checkSize());
     m_checkBrush = QBrush(checkImage);
 
 
     // We are not supposed to use updates here,
     // so just set the listener to null
     m_updateScheduler = new KisUpdateScheduler(0);
     m_undoStore = new KisSurrogateUndoStore();
     m_undoAdapter = new KisPostExecutionUndoAdapter(m_undoStore, m_updateScheduler);
     m_nodeListener = new KisScratchPadNodeListener(this);
 
     connect(this, SIGNAL(sigUpdateCanvas(QRect)), SLOT(slotUpdateCanvas(QRect)), Qt::QueuedConnection);
 
     // filter will be deleted by the QObject hierarchy
     m_eventFilter = new KisScratchPadEventFilter(this);
 
     m_infoBuilder = new KisPaintingInformationBuilder();
     m_helper = new KisToolFreehandHelper(m_infoBuilder);
 
     m_scaleBorderWidth = 1;
 }
 
 KisScratchPad::~KisScratchPad() {
     delete m_helper;
     delete m_infoBuilder;
 
     delete m_undoAdapter;
     delete m_undoStore;
     delete m_updateScheduler;
     delete m_nodeListener;
 }
 
 KisScratchPad::Mode KisScratchPad::modeFromButton(Qt::MouseButton button) const
 {
     return
         button == Qt::NoButton ? HOVERING :
         button == Qt::MidButton ? PANNING :
         button == Qt::RightButton ? PICKING :
         PAINTING;
 }
 
 void KisScratchPad::pointerPress(KoPointerEvent *event)
 {
     if (m_toolMode != HOVERING) return;
 
     m_toolMode = modeFromButton(event->button());
 
     if (m_toolMode == PAINTING) {
         beginStroke(event);
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         beginPan(event);
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         pick(event);
         event->accept();
     }
 }
 
 void KisScratchPad::pointerRelease(KoPointerEvent *event)
 {
     if (modeFromButton(event->button()) != m_toolMode) return;
 
     if (m_toolMode == PAINTING) {
         endStroke(event);
         m_toolMode = HOVERING;
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         endPan(event);
         m_toolMode = HOVERING;
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         event->accept();
         m_toolMode = HOVERING;
     }
 }
 
 void KisScratchPad::pointerMove(KoPointerEvent *event)
 {
     m_helper->cursorMoved(documentToWidget().map(event->point));
     if (m_toolMode == PAINTING) {
         doStroke(event);
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         doPan(event);
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         pick(event);
         event->accept();
     }
 }
 
 void KisScratchPad::beginStroke(KoPointerEvent *event)
 {
     KoCanvasResourceManager *resourceManager = m_resourceProvider->resourceManager();
     m_helper->initPaint(event,
                         documentToWidget().map(event->point),
                         resourceManager,
                         0,
                         0,
                         m_updateScheduler,
                         m_paintLayer,
                         m_paintLayer->paintDevice()->defaultBounds());
 }
 
 void KisScratchPad::doStroke(KoPointerEvent *event)
 {
     m_helper->paintEvent(event);
 }
 
 void KisScratchPad::endStroke(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     m_helper->endPaint();
 }
 
 void KisScratchPad::beginPan(KoPointerEvent *event)
 {
     setCursor(QCursor(Qt::ClosedHandCursor));
     m_panDocPoint = event->point;
 }
 
 void KisScratchPad::doPan(KoPointerEvent *event)
 {
     QPointF docOffset = event->point - m_panDocPoint;
 
     m_translateTransform.translate(-docOffset.x(), -docOffset.y());
     updateTransformations();
     update();
 }
 
 void KisScratchPad::endPan(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     setCursor(m_cursor);
 }
 
 void KisScratchPad::pick(KoPointerEvent *event)
 {
     KoColor color;
     if (KisToolUtils::pickColor(color, m_paintLayer->projection(), event->point.toPoint())) {
         emit colorSelected(color);
     }
 }
 
 void KisScratchPad::setOnScreenResolution(qreal scaleX, qreal scaleY)
 {
     m_scaleBorderWidth = BORDER_SIZE(qMax(scaleX, scaleY));
 
     m_scaleTransform = QTransform::fromScale(scaleX, scaleY);
     updateTransformations();
     update();
 }
 
 QTransform KisScratchPad::documentToWidget() const
 {
     return m_translateTransform.inverted() * m_scaleTransform;
 }
 
 QTransform KisScratchPad::widgetToDocument() const
 {
     return m_scaleTransform.inverted() * m_translateTransform;
 }
 
 void KisScratchPad::updateTransformations()
 {
     m_eventFilter->setWidgetToDocumentTransform(widgetToDocument());
 }
 
 QRect KisScratchPad::imageBounds() const
 {
     return widgetToDocument().mapRect(rect());
 }
 
 void KisScratchPad::imageUpdated(const QRect &rect)
 {
     emit sigUpdateCanvas(documentToWidget().mapRect(QRectF(rect)).toAlignedRect());
 }
 
 void KisScratchPad::slotUpdateCanvas(const QRect &rect)
 {
     update(rect);
 }
 
 void KisScratchPad::paintEvent ( QPaintEvent * event ) {
     if(!m_paintLayer) return;
 
     QRectF imageRect = widgetToDocument().mapRect(QRectF(event->rect()));
 
     QRect alignedImageRect =
         imageRect.adjusted(-m_scaleBorderWidth, -m_scaleBorderWidth,
                            m_scaleBorderWidth, m_scaleBorderWidth).toAlignedRect();
 
     QPointF offset = alignedImageRect.topLeft();
 
     m_paintLayer->projectionPlane()->recalculate(alignedImageRect, m_paintLayer);
     KisPaintDeviceSP projection = m_paintLayer->projection();
 
     QImage image = projection->convertToQImage(m_displayProfile,
                                                alignedImageRect.x(),
                                                alignedImageRect.y(),
                                                alignedImageRect.width(),
                                                alignedImageRect.height(),
                                                KoColorConversionTransformation::internalRenderingIntent(),
                                                KoColorConversionTransformation::internalConversionFlags());
 
     QPainter gc(this);
     gc.fillRect(event->rect(), m_checkBrush);
 
     gc.setRenderHints(QPainter::SmoothPixmapTransform);
     gc.drawImage(QRectF(event->rect()), image, imageRect.translated(-offset));
 
     QBrush brush(Qt::lightGray);
     QPen pen(brush, 1, Qt::DotLine);
     gc.setPen(pen);
     if (m_cutoutOverlay.isValid()) {
         gc.drawRect(m_cutoutOverlay);
     }
 
     if(!isEnabled()) {
         QColor color(Qt::lightGray);
         color.setAlphaF(0.5);
         QBrush disabledBrush(color);
         gc.fillRect(event->rect(), disabledBrush);
     }
     gc.end();
 }
 
 void KisScratchPad::setupScratchPad(KisCanvasResourceProvider* resourceProvider,
                                     const QColor &defaultColor)
 {
     m_resourceProvider = resourceProvider;
     KisConfig cfg(true);
     setDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this)));
     connect(m_resourceProvider, SIGNAL(sigDisplayProfileChanged(const KoColorProfile*)),
             SLOT(setDisplayProfile(const KoColorProfile*)));
 
     connect(m_resourceProvider, SIGNAL(sigOnScreenResolutionChanged(qreal,qreal)),
             SLOT(setOnScreenResolution(qreal,qreal)));
-    connect(this, SIGNAL(colorSelected(const KoColor&)),
-            m_resourceProvider, SLOT(slotSetFGColor(const KoColor&)));
+    connect(this, SIGNAL(colorSelected(KoColor)),
+            m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
 
     m_defaultColor = KoColor(defaultColor, KoColorSpaceRegistry::instance()->rgb8());
 
     KisPaintDeviceSP paintDevice =
         new KisPaintDevice(m_defaultColor.colorSpace(), "scratchpad");
 
     m_paintLayer = new KisPaintLayer(0, "ScratchPad", OPACITY_OPAQUE_U8, paintDevice);
     m_paintLayer->setGraphListener(m_nodeListener);
     m_paintLayer->paintDevice()->setDefaultBounds(new KisScratchPadDefaultBounds(this));
 
     fillDefault();
 }
 
 void KisScratchPad::setCutoutOverlayRect(const QRect& rc)
 {
     m_cutoutOverlay = rc;
 }
 
 QImage KisScratchPad::cutoutOverlay() const
 {
     if(!m_paintLayer) return QImage();
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect rc = widgetToDocument().mapRect(m_cutoutOverlay);
     QImage rawImage = paintDevice->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 
     QImage scaledImage = rawImage.scaled(m_cutoutOverlay.size(),
                                          Qt::IgnoreAspectRatio,
                                          Qt::SmoothTransformation);
 
     return scaledImage;
 }
 
 void KisScratchPad::setPresetImage(const QImage& image)
 {
     m_presetImage = image;
 }
 
 
 void KisScratchPad::paintCustomImage(const QImage& loadedImage)
 {
     // this is 99% copied from the normal paintPresetImage()
     // we don't want to save over the preset image, so we don't
     // want to store it in the m_presetImage
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
     QRect imageRect(QPoint(), overlayRect.size());
 
     QImage scaledImage = loadedImage.scaled(overlayRect.size(),
                                               Qt::IgnoreAspectRatio,
                                               Qt::SmoothTransformation);
     KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
     device->convertFromQImage(scaledImage, 0);
 
     KisPainter painter(paintDevice);
     painter.bitBlt(overlayRect.topLeft(), device, imageRect);
     update();
 }
 
 void KisScratchPad::paintPresetImage()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
     QRect imageRect(QPoint(), overlayRect.size());
 
     QImage scaledImage = m_presetImage.scaled(overlayRect.size(),
                                               Qt::IgnoreAspectRatio,
                                               Qt::SmoothTransformation);
     KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
     device->convertFromQImage(scaledImage, 0);
 
     KisPainter painter(paintDevice);
     painter.bitBlt(overlayRect.topLeft(), device, imageRect);
     update();
 }
 
 void KisScratchPad::setDisplayProfile(const KoColorProfile *colorProfile)
 {
     if (colorProfile) {
         m_displayProfile = colorProfile;
         QWidget::update();
     }
 }
 
 void KisScratchPad::fillDefault()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     paintDevice->setDefaultPixel(m_defaultColor);
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillTransparent() {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     QColor transQColor(0,0,0,0);
     KoColor transparentColor(transQColor, KoColorSpaceRegistry::instance()->rgb8());
     transparentColor.setOpacity(0.0);
 
     paintDevice->setDefaultPixel(transparentColor);
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillGradient()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KoAbstractGradient* gradient = m_resourceProvider->currentGradient();
     QRect gradientRect = widgetToDocument().mapRect(rect());
 
     paintDevice->clear();
 
     KisGradientPainter painter(paintDevice);
 
     painter.setGradient(gradient);
     painter.setGradientShape(KisGradientPainter::GradientShapeLinear);
     painter.paintGradient(gradientRect.topLeft(),
                           gradientRect.bottomRight(),
                           KisGradientPainter::GradientRepeatNone,
                           0.2, false,
                           gradientRect.left(), gradientRect.top(),
                           gradientRect.width(), gradientRect.height());
 
     update();
 }
 
 void KisScratchPad::fillBackground()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     paintDevice->setDefaultPixel(m_resourceProvider->bgColor());
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillLayer()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KisPainter painter(paintDevice);
     QRect sourceRect(0, 0, paintDevice->exactBounds().width(), paintDevice->exactBounds().height());
     painter.bitBlt(QPoint(0, 0), m_resourceProvider->currentImage()->projection(), sourceRect);
     update();
 }
diff --git a/libs/vectorimage/libemf/demo/EmfViewer.cpp b/libs/vectorimage/libemf/demo/EmfViewer.cpp
index 4730e1a506..5024b19f57 100644
--- a/libs/vectorimage/libemf/demo/EmfViewer.cpp
+++ b/libs/vectorimage/libemf/demo/EmfViewer.cpp
@@ -1,99 +1,99 @@
 /*
   Copyright 2008 Brad Hards  <bradh@frogmouth.net>
   Copyright 2008 Inge Wallin <inge@lysator.liu.se>
 
   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, see <http://www.gnu.org/licenses/>.
 */
 
 #include "EmfViewer.h"
 
 #include <QApplication>
 #include <QFileDialog>
 #include <QMenuBar>
 
 #include "../EmfOutputPainterStrategy.h"
 
 
 EmfViewer::EmfViewer( QSize &size )
     : QMainWindow()
 {
     m_size = size;
 
     setWindowTitle( "EMF Demo Viewer" );
 
     QMenu *fileMenu = menuBar()->addMenu( "&File" );
 
     // The "Open" action
     m_fileOpenAction->setShortcut( Qt::CTRL + Qt::Key_O );
     m_fileOpenAction = fileMenu->addAction( "&Open", this,
-                                            SLOT( slotOpenFile() ) );
+                                            SLOT(slotOpenFile()) );
 
     fileMenu->addSeparator();
 
     // The "Quit" action
     m_fileQuitAction->setShortcut( Qt::CTRL + Qt::Key_Q );
     m_fileQuitAction = fileMenu->addAction( "&Quit", qApp,
-                                            SLOT( closeAllWindows() ) );
+                                            SLOT(closeAllWindows()) );
 
     // Set a suitably large size.
     resize( m_size + QSize( 50, 50 ) );
 
     // ...and finably create the label that will show everything.
     m_label = new QLabel(this);
     setCentralWidget( m_label );
 }
 
 EmfViewer::~EmfViewer()
 {
 }
 
 
 void EmfViewer::loadFile( const QString &fileName )
 {
     Parser parser;
 
     // The image that the EMF parser should paint on.
     QImage    image( m_size, QImage::Format_ARGB32_Premultiplied );
     QPainter  painter( &image );
 
     OutputPainterStrategy output( painter, m_size );
     parser.setOutput( &output );
     parser.load( QString( fileName ) );
 
     QPixmap pixmap = QPixmap::fromImage( image );
     m_label->setPixmap( pixmap.scaled(m_size, Qt::KeepAspectRatio, Qt::SmoothTransformation));
 
     m_label->show();
 
 
 }
 
 // ----------------------------------------------------------------
 //                                 Slots
 
 
 void EmfViewer::slotOpenFile()
 {
     QString fileName = QFileDialog::getOpenFileName(this, "Open EMF document", QDir::homePath(), "EMF Documents (*.emf)" );
     if (fileName.isEmpty()) {
         return;
     }
 
     loadFile( fileName );
 }
 
 
 #include <EmfViewer.moc>
 
 
diff --git a/libs/widgets/KoColorPopupAction.cpp b/libs/widgets/KoColorPopupAction.cpp
index 7e92083b06..d8312360ed 100644
--- a/libs/widgets/KoColorPopupAction.cpp
+++ b/libs/widgets/KoColorPopupAction.cpp
@@ -1,259 +1,259 @@
 /* This file is part of the KDE project
  * Copyright (c) 2007 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2007 Fredy Yanardi <fyanardi@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 "KoColorPopupAction.h"
 
 #include "KoColorSetWidget.h"
 #include "KoTriangleColorSelector.h"
 #include "KoColorSlider.h"
 #include "KoCheckerBoardPainter.h"
 #include "KoResourceServer.h"
 #include "KoResourceServerProvider.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 
 #include <WidgetsDebug.h>
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QWidgetAction>
 #include <QMenu>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QToolButton>
 #include <QPointer>
 
 class KoColorPopupAction::KoColorPopupActionPrivate
 {
 public:
     KoColorPopupActionPrivate()
         : colorSetWidget(0)
         , colorChooser(0)
         , opacitySlider(0)
         , menu(0)
         , checkerPainter(4)
         , showFilter(true)
         , applyMode(true)
         , firstTime(true)
     {}
 
     ~KoColorPopupActionPrivate()
     {
         delete menu;
     }
 
     KoColor currentColor;
     KoColor buddyColor;
 
     KoColorSetWidget *colorSetWidget;
     KoTriangleColorSelector * colorChooser;
     KoColorSlider * opacitySlider;
     QMenu *menu;
     KoCheckerBoardPainter checkerPainter;
     bool showFilter;
     bool applyMode;
 
     bool firstTime;
 };
 
 KoColorPopupAction::KoColorPopupAction(QObject *parent)
     : QAction(parent),
     d(new KoColorPopupActionPrivate())
 {
     d->menu = new QMenu();
     QWidget *widget = new QWidget(d->menu);
     QWidgetAction *wdgAction = new QWidgetAction(d->menu);
     d->colorSetWidget = new KoColorSetWidget(widget);
     KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
 
     QPointer<KoColorSet> defaultColorSet = rServer->resourceByName("Default");
     if (!defaultColorSet && rServer->resources().count() > 0) {
         defaultColorSet = rServer->resources().first();
     }
     d->colorSetWidget->setColorSet(defaultColorSet);
 
     d->colorChooser = new KoTriangleColorSelector( widget );
     // prevent mouse release on color selector from closing popup
     d->colorChooser->setAttribute( Qt::WA_NoMousePropagation );
     d->opacitySlider = new KoColorSlider( Qt::Vertical, widget );
     d->opacitySlider->setFixedWidth(25);
     d->opacitySlider->setRange(0, 255);
     d->opacitySlider->setValue(255);
     d->opacitySlider->setToolTip( i18n( "Opacity" ) );
 
     QGridLayout * layout = new QGridLayout( widget );
     layout->addWidget( d->colorSetWidget, 0, 0, 1, -1 );
     layout->addWidget( d->colorChooser, 1, 0 );
     layout->addWidget( d->opacitySlider, 1, 1 );
     layout->setMargin(4);
 
     wdgAction->setDefaultWidget(widget);
     d->menu->addAction(wdgAction);
     setMenu(d->menu);
     new QHBoxLayout(d->menu);
     d->menu->layout()->addWidget(widget);
     d->menu->layout()->setMargin(0);
 
     connect(this, SIGNAL(triggered()), this, SLOT(emitColorChanged()));
 
-    connect(d->colorSetWidget, SIGNAL(colorChanged(const KoColor &, bool)), this, SLOT(colorWasSelected(const KoColor &, bool)));
+    connect(d->colorSetWidget, SIGNAL(colorChanged(KoColor,bool)), this, SLOT(colorWasSelected(KoColor,bool)));
 
-    connect( d->colorChooser, SIGNAL( colorChanged( const QColor &) ),
-             this, SLOT( colorWasEdited( const QColor &) ) );
+    connect( d->colorChooser, SIGNAL(colorChanged(QColor)),
+             this, SLOT(colorWasEdited(QColor)) );
     connect( d->opacitySlider, SIGNAL(valueChanged(int)),
              this, SLOT(opacityWasChanged(int)));
 }
 
 KoColorPopupAction::~KoColorPopupAction()
 {
     delete d;
 }
 
 void KoColorPopupAction::setCurrentColor( const KoColor &color )
 {
     KoColor minColor( color );
     d->currentColor = minColor;
 
     d->colorChooser->blockSignals(true);
     d->colorChooser->slotSetColor(color);
     d->colorChooser->blockSignals(false);
 
     KoColor maxColor( color );
     minColor.setOpacity( OPACITY_TRANSPARENT_U8 );
     maxColor.setOpacity( OPACITY_OPAQUE_U8 );
 
     d->opacitySlider->blockSignals( true );
     d->opacitySlider->setColors( minColor, maxColor );
     d->opacitySlider->setValue( color.opacityU8() );
     d->opacitySlider->blockSignals( false );
 
     updateIcon();
 }
 
 void KoColorPopupAction::setCurrentColor( const QColor &_color )
 {
 #ifndef NDEBUG
     if (!_color.isValid()) {
         warnWidgets << "Invalid color given, defaulting to black";
     }
 #endif
     const QColor color(_color.isValid() ? _color : QColor(0,0,0,255));
     setCurrentColor(KoColor(color, KoColorSpaceRegistry::instance()->rgb8() ));
 }
 
 QColor KoColorPopupAction::currentColor() const
 {
     return d->currentColor.toQColor();
 }
 
 KoColor KoColorPopupAction::currentKoColor() const
 {
     return d->currentColor;
 }
 
 void KoColorPopupAction::updateIcon()
 {
     QSize iconSize;
     QToolButton *toolButton = dynamic_cast<QToolButton*>(parentWidget());
     if (toolButton) {
         iconSize = QSize(toolButton->iconSize());
     } else {
         iconSize = QSize(16, 16);
     }
 
     // This must be a QImage, as drawing to a QPixmap outside the
     // UI thread will cause sporadic crashes.
     QImage pm;
 
     if (icon().isNull()) {
         d->applyMode = false;
     }
 
     if(d->applyMode) {
         pm = icon().pixmap(iconSize).toImage();
         if (pm.isNull()) {
             pm = QImage(iconSize, QImage::Format_ARGB32_Premultiplied);
             pm.fill(Qt::transparent);
         }
         QPainter p(&pm);
         p.fillRect(0, iconSize.height() - 4, iconSize.width(), 4, d->currentColor.toQColor());
         p.end();
     } else {
         pm = QImage(iconSize, QImage::Format_ARGB32_Premultiplied);
         pm.fill(Qt::transparent);
         QPainter p(&pm);
         d->checkerPainter.paint(p, QRect(QPoint(),iconSize));
         p.fillRect(0, 0, iconSize.width(), iconSize.height(), d->currentColor.toQColor());
         p.end();
     }
     setIcon(QIcon(QPixmap::fromImage(pm)));
 }
 
 void KoColorPopupAction::emitColorChanged()
 {
     emit colorChanged( d->currentColor );
 }
 
 void KoColorPopupAction::colorWasSelected(const KoColor &color, bool final)
 {
     d->currentColor = color;
     if (final) {
         menu()->hide();
         emitColorChanged();
     }
     updateIcon();
 }
 
 void KoColorPopupAction::colorWasEdited( const QColor &color )
 {
     d->currentColor = KoColor( color, KoColorSpaceRegistry::instance()->rgb8() );
     quint8 opacity = d->opacitySlider->value();
     d->currentColor.setOpacity( opacity );
 
     KoColor minColor = d->currentColor;
     minColor.setOpacity( OPACITY_TRANSPARENT_U8 );
     KoColor maxColor = minColor;
     maxColor.setOpacity( OPACITY_OPAQUE_U8 );
 
     d->opacitySlider->setColors( minColor, maxColor );
 
     emitColorChanged();
 
     updateIcon();
 }
 
 void KoColorPopupAction::opacityWasChanged( int opacity )
 {
     d->currentColor.setOpacity( quint8(opacity) );
 
     emitColorChanged();
 }
 
 void KoColorPopupAction::slotTriggered(bool)
 {
     if (d->firstTime) {
         KoResourceServer<KoColorSet>* srv = KoResourceServerProvider::instance()->paletteServer();
         QList<KoColorSet*> palettes = srv->resources();
         if (!palettes.empty()) {
             d->colorSetWidget->setColorSet(palettes.first());
         }
         d->firstTime = false;
     }
 }
diff --git a/libs/widgets/KoColorSetWidget.cpp b/libs/widgets/KoColorSetWidget.cpp
index 2a616dfc5a..ab2f13acc2 100644
--- a/libs/widgets/KoColorSetWidget.cpp
+++ b/libs/widgets/KoColorSetWidget.cpp
@@ -1,335 +1,335 @@
 /* This file is part of the KDE project
    Copyright (c) 2007, 2012 C. Boemann <cbo@boemann.dk>
    Copyright (c) 2007-2008 Fredy Yanardi <fyanardi@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 "KoColorSetWidget.h"
 #include "KoColorSetWidget_p.h"
 
 #include <QTimer>
 #include <QApplication>
 #include <QSize>
 #include <QToolButton>
 #include <QHBoxLayout>
 #include <QCheckBox>
 #include <QFrame>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QMenu>
 #include <QWidgetAction>
 #include <QDir>
 #include <QPointer>
 #include <QScrollArea>
 #include <QGroupBox>
 #include <QVBoxLayout>
 
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 
 #include <resources/KoColorSet.h>
 #include <resources/KoColorSetEntry.h>
 #include <KoColorPatch.h>
 #include <KoEditColorSetDialog.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 
 void KoColorSetWidget::KoColorSetWidgetPrivate::fillColors()
 {
     delete colorSetContainer;
     colorSetContainer = new QWidget();
     colorSetLayout = new QVBoxLayout();
     colorSetLayout->setMargin(3);
     colorSetLayout->setSpacing(0); // otherwise the use can click where there is none
     colorSetContainer->setBackgroundRole(QPalette::Dark);
 
     int patchSize = 12;
 
     int columns = 16;
     if (colorSet) {
         columns = colorSet->columnCount();
     }
     colorSetContainer->setMinimumWidth(columns*patchSize+6);
     colorSetContainer->setLayout(colorSetLayout);
     patchWidgetList.clear();
     colornames.clear();
     colorNameCmb->clear();
 
     QWidget *defaultGroupContainer = new QWidget();
     QGridLayout *colorGroupLayout = new QGridLayout();
     for(int i = 0; i<columns; i++) {
         colorGroupLayout->setColumnMinimumWidth(i, patchSize);
     }
     defaultGroupContainer->setMinimumWidth(columns*patchSize);
     defaultGroupContainer->setMaximumWidth(columns*patchSize);
     colorGroupLayout->setSpacing(0);
     colorGroupLayout->setMargin(0);
     defaultGroupContainer->setLayout(colorGroupLayout);
     if (colorSet) {
         for( quint32 i = 0, p= 0; i < colorSet->nColorsGroup(); i++) {
             KoColorPatch *patch = new KoColorPatch(colorSetContainer);
             patch->setFrameStyle(QFrame::Plain | QFrame::Box);
             patch->setLineWidth(1);
             KoColorSetEntry c = colorSet->getColorGlobal(i);
             patch->setColor(c.color());
             patch->setToolTip(c.name());
-            connect(patch, SIGNAL(triggered(KoColorPatch *)), thePublic, SLOT(colorTriggered(KoColorPatch *)));
+            connect(patch, SIGNAL(triggered(KoColorPatch*)), thePublic, SLOT(colorTriggered(KoColorPatch*)));
             colorGroupLayout->addWidget(patch, p/columns, p%columns);
             patch->setDisplayRenderer(displayRenderer);
             patchWidgetList.append(patch);
             colornames.append(c.name());
             QPixmap colorsquare = QPixmap(12,12);
             colorsquare.fill(c.color().toQColor());
             colorNameCmb->addItem(QIcon(colorsquare), c.name());
             ++p;
         }
         colorSetLayout->addWidget(defaultGroupContainer);
         Q_FOREACH(QString groupName, colorSet->getGroupNames()) {
             QGroupBox *groupbox = new QGroupBox();
             groupbox->setTitle(groupName);
             QGridLayout *groupLayout = new QGridLayout();
             for(int i = 0; i<columns; i++) {
                 groupLayout->setColumnMinimumWidth(i, patchSize);
             }
             groupLayout->setSpacing(0);
             groupLayout->setMargin(0);
             groupbox->setMinimumWidth(columns*patchSize);
             groupbox->setMaximumWidth(columns*patchSize);
             groupbox->setLayout(groupLayout);
             groupbox->setFlat(true);
             for( quint32 i = 0, p= 0; i < colorSet->nColorsGroup(groupName); i++) {
                 KoColorPatch *patch = new KoColorPatch(colorSetContainer);
                 patch->setFrameStyle(QFrame::Plain | QFrame::Box);
                 patch->setLineWidth(1);
                 KoColorSetEntry c = colorSet->getColorGroup(i, groupName);
                 patch->setColor(c.color());
                 patch->setToolTip(c.name());
-                connect(patch, SIGNAL(triggered(KoColorPatch *)), thePublic, SLOT(colorTriggered(KoColorPatch *)));
+                connect(patch, SIGNAL(triggered(KoColorPatch*)), thePublic, SLOT(colorTriggered(KoColorPatch*)));
                 groupLayout->addWidget(patch, p/columns, p%columns);
                 patch->setDisplayRenderer(displayRenderer);
                 patchWidgetList.append(patch);
                 colornames.append(c.name());
                 QPixmap colorsquare = QPixmap(12,12);
                 colorsquare.fill(c.color().toQColor());
                 colorNameCmb->addItem(QIcon(colorsquare), c.name());
                 ++p;
             }
             colorSetLayout->addWidget(groupbox);
         }
     }
 
     scrollArea->setWidget(colorSetContainer);
     connect(colorNameCmb, SIGNAL(activated(QString)), thePublic, SLOT(setColorFromString(QString)), Qt::UniqueConnection);
 }
 
 void KoColorSetWidget::KoColorSetWidgetPrivate::addRemoveColors()
 {
     KoResourceServer<KoColorSet>* srv = KoResourceServerProvider::instance()->paletteServer();
     QList<KoColorSet*> palettes = srv->resources();
 
     Q_ASSERT(colorSet);
     KoEditColorSetDialog *dlg = new KoEditColorSetDialog(palettes, colorSet->name(), thePublic);
     if (dlg->exec() == KoDialog::Accepted ) { // always reload the color set
         KoColorSet * cs = dlg->activeColorSet();
         // check if the selected colorset is predefined
         if( cs && !palettes.contains( cs ) ) {
             int i = 1;
             QFileInfo fileInfo;
             QString savePath = srv->saveLocation();
 
             do {
                 fileInfo.setFile(savePath + QString("%1.%2").arg(i++, 4, 10, QChar('0')).arg(colorSet->defaultFileExtension()));
             }
             while (fileInfo.exists());
 
             cs->setFilename( fileInfo.filePath() );
             cs->setValid( true );
 
             // add new colorset to predefined colorsets
             if (!srv->addResource(cs)) {
 
                 delete cs;
                 cs = 0;
             }
         }
         if (cs) {
             thePublic->setColorSet(cs);
         }
     }
     delete dlg;
 }
 
 void KoColorSetWidget::KoColorSetWidgetPrivate::addRecent(const KoColor &color)
 {
     if(numRecents<6) {
         recentPatches[numRecents] = new KoColorPatch(thePublic);
         recentPatches[numRecents]->setFrameShape(QFrame::StyledPanel);
         recentPatches[numRecents]->setDisplayRenderer(displayRenderer);
         recentsLayout->insertWidget(numRecents+1, recentPatches[numRecents]);
-        connect(recentPatches[numRecents], SIGNAL(triggered(KoColorPatch *)), thePublic, SLOT(colorTriggered(KoColorPatch *)));
+        connect(recentPatches[numRecents], SIGNAL(triggered(KoColorPatch*)), thePublic, SLOT(colorTriggered(KoColorPatch*)));
         numRecents++;
     }
     // shift colors to the right
     for (int i = numRecents- 1; i >0; i--) {
         recentPatches[i]->setColor(recentPatches[i-1]->color());
     }
 
     //Finally set the recent color
     recentPatches[0]->setColor(color);
 }
 
 void KoColorSetWidget::KoColorSetWidgetPrivate::activateRecent(int i)
 {
     KoColor color = recentPatches[i]->color();
 
     while (i >0) {
         recentPatches[i]->setColor(recentPatches[i-1]->color());
         i--;
     }
     recentPatches[0]->setColor(color);
 }
 
 KoColorSetWidget::KoColorSetWidget(QWidget *parent)
    : QFrame(parent)
     ,d(new KoColorSetWidgetPrivate())
 {
     d->thePublic = this;
     d->colorSet = 0;
 
     d->firstShowOfContainer = true;
 
     d->mainLayout = new QVBoxLayout();
     d->mainLayout->setMargin(4);
     d->mainLayout->setSpacing(2);
 
     d->colorSetContainer = 0;
 
     d->numRecents = 0;
     d->recentsLayout = new QHBoxLayout();
     d->mainLayout->addLayout(d->recentsLayout);
     d->recentsLayout->setMargin(0);
     d->recentsLayout->addWidget(new QLabel(i18n("Recent:")));
     d->recentsLayout->addStretch(1);
 
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(QColor(128,0,0));
     d->addRecent(color);
 
     d->scrollArea = new QScrollArea();
     d->scrollArea->setBackgroundRole(QPalette::Dark);
     d->mainLayout->addWidget(d->scrollArea);
     d->colorNameCmb = new QComboBox(this);
     d->colorNameCmb->setEditable(true);
     d->colorNameCmb->setInsertPolicy(QComboBox::NoInsert);
     d->mainLayout->addWidget(d->colorNameCmb);
     d->fillColors();
 
 
     d->addRemoveButton = new QToolButton(this);
     d->addRemoveButton->setText(i18n("Add / Remove Colors..."));
     d->addRemoveButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     connect(d->addRemoveButton, SIGNAL(clicked()), SLOT(addRemoveColors()));
     d->mainLayout->addWidget(d->addRemoveButton);
 
     setLayout(d->mainLayout);
 
     KoColorSet *colorSet = new KoColorSet();
     d->colorSet = colorSet;
     d->fillColors();
 }
 
 KoColorSetWidget::~KoColorSetWidget()
 {
     KoResourceServer<KoColorSet>* srv = KoResourceServerProvider::instance()->paletteServer();
     QList<KoColorSet*> palettes = srv->resources();
     if (!palettes.contains(d->colorSet)) {
         delete d->colorSet;
     }
     delete d;
 }
 
 void KoColorSetWidget::KoColorSetWidgetPrivate::colorTriggered(KoColorPatch *patch)
 {
     int i;
 
     emit thePublic->colorChanged(patch->color(), true);
 
     colorNameCmb->setCurrentIndex(colornames.indexOf(QRegExp(patch->toolTip()+"|Fixed")));
 
     for (i = 0; i <numRecents; i++)
         if(patch == recentPatches[i]) {
             activateRecent(i);
             break;
         }
 
     if (i == numRecents) // we didn't find it above
         addRecent(patch->color());
 }
 
 void KoColorSetWidget::KoColorSetWidgetPrivate::setColorFromString(QString s)
 {
     int i = colornames.indexOf(QRegExp(s+"|Fixed"));
     i = qMax(i,0);
     colorTriggered(patchWidgetList.at(i));
 }
 
 void KoColorSetWidget::setColorSet(QPointer<KoColorSet> colorSet)
 {
     if (!colorSet) return;
 
     if (colorSet != d->colorSet) {
         KoResourceServer<KoColorSet>* srv = KoResourceServerProvider::instance()->paletteServer();
         QList<KoColorSet*> palettes = srv->resources();
         if (!palettes.contains(d->colorSet)) {
             delete d->colorSet;
         }
 
         d->colorSet = colorSet;
     }
 
     d->fillColors();
 }
 
 KoColorSet* KoColorSetWidget::colorSet()
 {
     return d->colorSet;
 }
 
 void KoColorSetWidget::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     if (displayRenderer) {
         d->displayRenderer = displayRenderer;
         Q_FOREACH(KoColorPatch *p, d->patchWidgetList) {
             p->setDisplayRenderer(displayRenderer);
         }
         for (int i=0; i<6; i++) {
             if (d->recentPatches[i]) {
                 d->recentPatches[i]->setDisplayRenderer(displayRenderer);
             }
         }
     }
 }
 
 void KoColorSetWidget::resizeEvent(QResizeEvent *event)
 {
     emit widgetSizeChanged(event->size());
     QFrame::resizeEvent(event);
 }
 
 //have to include this because of Q_PRIVATE_SLOT
 #include "moc_KoColorSetWidget.cpp"
 
diff --git a/libs/widgets/KoEditColorSetDialog.cpp b/libs/widgets/KoEditColorSetDialog.cpp
index ce19ad921a..a10de93213 100644
--- a/libs/widgets/KoEditColorSetDialog.cpp
+++ b/libs/widgets/KoEditColorSetDialog.cpp
@@ -1,243 +1,243 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Fredy Yanardi <fyanardi@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 "KoEditColorSetDialog.h"
 
 #include <KoIcon.h>
 
 #include <QScrollArea>
 #include <QHBoxLayout>
 #include <QFileInfo>
 #include <QColorDialog>
 #include <QInputDialog>
 
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 
 #include <resources/KoColorSet.h>
 #include <KoColorPatch.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoFileDialog.h>
 
 // debug
 #include <WidgetsDebug.h>
 
 KoEditColorSetWidget::KoEditColorSetWidget(const QList<KoColorSet *> &palettes, const QString &activePalette, QWidget *parent)
     : QWidget(parent),
     m_colorSets(palettes),
     m_gridLayout(0),
     m_activeColorSet(0),
     m_activePatch(0),
     m_initialColorSetCount(palettes.count()),
     m_activeColorSetRequested(false)
 {
     widget.setupUi(this);
     foreach (KoColorSet *colorSet, m_colorSets) {
         //colorSet->load(); resources are loaded at startup...
         widget.selector->addItem(colorSet->name());
     }
     connect(widget.selector, SIGNAL(currentIndexChanged(int)), this, SLOT(setActiveColorSet(int)));
 
     // A widget that shows all colors from active palette
     // FIXME no need to handcode the QScrollArea if designer can add QScrollArea (Qt 4.4?)
     m_scrollArea = new QScrollArea(widget.patchesFrame);
 
     int index = 0;
     foreach (KoColorSet *set, m_colorSets) {
         if (set->name() == activePalette) {
             m_activeColorSet = set;
             index = widget.selector->findText(set->name());
             widget.selector->setCurrentIndex(index);
         }
     }
     if (!m_activeColorSet && !palettes.isEmpty()) {
         m_activeColorSet = palettes.first();
         index = widget.selector->findText(m_activeColorSet->name());
     }
 
     int columns = 16;
     if(m_activeColorSet) {
         columns = m_activeColorSet->columnCount();
         if (columns==0){
             columns = 16;
         }
     }
     m_scrollArea->setMinimumWidth(columns*(12+2));
 
     QHBoxLayout *layout = new QHBoxLayout();
     layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(m_scrollArea);
     widget.patchesFrame->setLayout(layout);
 
     widget.add->setIcon(koIcon("list-add"));
     widget.remove->setIcon(koIcon("list-remove"));
     widget.open->setIcon(koIcon("document-open"));
     widget.save->setIcon(koIcon("document-save"));
 
     setEnabled(m_activeColorSet != 0);
     setActiveColorSet(index);
     widget.remove->setEnabled(false); // initially no color selected
 
     connect(widget.add, SIGNAL(clicked()), this, SLOT(addColor()));
     connect(widget.remove, SIGNAL(clicked()), this, SLOT(removeColor()));
     connect(widget.open, SIGNAL(clicked()), this, SLOT(open()));
     connect(widget.save, SIGNAL(clicked()), this, SLOT(save()));
 }
 
 KoEditColorSetWidget::~KoEditColorSetWidget()
 {
     // only delete new color sets
     uint colorSetCount = m_colorSets.count();
     for( uint i = m_initialColorSetCount; i < colorSetCount; ++i ) {
         KoColorSet * cs = m_colorSets[i];
         // if the active color set was requested by activeColorSet()
         // the caller takes ownership and then we do not delete it here
         if( cs == m_activeColorSet && m_activeColorSetRequested )
             continue;
         delete cs;
     }
 }
 
 void KoEditColorSetWidget::setActiveColorSet(int index)
 {
     if (m_gridLayout) {
         qDeleteAll(m_gridLayout->children());
         delete m_gridLayout;
         m_activePatch = 0;
     }
 
     QWidget *wdg = new QWidget(m_scrollArea);
     m_gridLayout = new QGridLayout();
     m_gridLayout->setMargin(0);
     m_gridLayout->setSpacing(2);
 
     m_activeColorSet = m_colorSets.value(index);
     setEnabled(m_activeColorSet != 0);
     int columns = 16;
 
     if (m_activeColorSet) {
         columns = m_activeColorSet->columnCount();
         if (columns==0){columns=16;}
         widget.remove->setEnabled(false);
         for (quint32 i = 0; i < m_activeColorSet->nColors(); i++) {
             KoColorPatch *patch = new KoColorPatch(widget.patchesFrame);
             KoColorSetEntry c = m_activeColorSet->getColorGlobal(i);
             patch->setColor(c.color());
             patch->setToolTip(c.name());
-            connect(patch, SIGNAL(triggered(KoColorPatch *)), this, SLOT(setTextLabel(KoColorPatch *)));
+            connect(patch, SIGNAL(triggered(KoColorPatch*)), this, SLOT(setTextLabel(KoColorPatch*)));
             m_gridLayout->addWidget(patch, i/columns, i%columns);
         }
     }
     m_scrollArea->setMinimumWidth(columns*(12+2));
 
     wdg->setLayout(m_gridLayout);
     m_scrollArea->setWidget(wdg);
 }
 
 void KoEditColorSetWidget::setTextLabel(KoColorPatch *patch)
 {
     widget.colorName->setText(patch->toolTip());
     if (m_activePatch) {
         m_activePatch->setFrameShape(QFrame::NoFrame);
         m_activePatch->setFrameShadow(QFrame::Plain);
     }
     m_activePatch = patch;
     m_activePatch->setFrameShape(QFrame::Panel);
     m_activePatch->setFrameShadow(QFrame::Raised);
     widget.remove->setEnabled(true);
 }
 
 void KoEditColorSetWidget::addColor()
 {
     QColor color;
 
     color = QColorDialog::getColor(color);
     if (color.isValid()) {
         KoColorSetEntry newEntry(
                     KoColor(color, KoColorSpaceRegistry::instance()->rgb8()),
                     QInputDialog::getText(this, i18n("Add Color To Palette"), i18n("Color name:")));
         KoColorPatch *patch = new KoColorPatch(widget.patchesFrame);
         patch->setColor(newEntry.color());
         patch->setToolTip(newEntry.name());
-        connect(patch, SIGNAL(triggered(KoColorPatch *)), this, SLOT(setTextLabel(KoColorPatch *)));
+        connect(patch, SIGNAL(triggered(KoColorPatch*)), this, SLOT(setTextLabel(KoColorPatch*)));
         Q_ASSERT(m_gridLayout);
         Q_ASSERT(m_activeColorSet);
         m_gridLayout->addWidget(patch, m_activeColorSet->nColors()/m_activeColorSet->columnCount(), m_activeColorSet->nColors()%m_activeColorSet->columnCount());
         m_activeColorSet->add(newEntry);
     }
 }
 
 void KoEditColorSetWidget::removeColor()
 {
     Q_ASSERT(m_activeColorSet);
     for (quint32 i = 0; i < m_activeColorSet->nColors(); i++) {
         KoColorSetEntry c = m_activeColorSet->getColorGlobal(i);
         if (m_activePatch->color() == c.color()) {
             m_activeColorSet->removeAt(i);
             setActiveColorSet(widget.selector->currentIndex());
             break;
         }
     }
 }
 
 void KoEditColorSetWidget::open()
 {
     Q_ASSERT(m_activeColorSet);
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "OpenColorSet");
     dialog.setDefaultDir(m_activeColorSet->filename());
     dialog.setMimeTypeFilters(QStringList() << "application/x-gimp-color-palette");
     QString fileName = dialog.filename();
     KoColorSet *colorSet = new KoColorSet(fileName);
     colorSet->load();
     m_colorSets.append(colorSet);
     widget.selector->addItem(colorSet->name());
     widget.selector->setCurrentIndex(widget.selector->count() - 1);
 }
 
 void KoEditColorSetWidget::save()
 {
     Q_ASSERT(m_activeColorSet);
     if (!m_activeColorSet->save())
         KMessageBox::error(0, i18n("Cannot write to palette file %1. Maybe it is read-only. ", m_activeColorSet->filename()), i18n("Palette"));
 }
 
 KoColorSet *KoEditColorSetWidget::activeColorSet()
 {
     m_activeColorSetRequested = true;
     return m_activeColorSet;
 }
 
 KoEditColorSetDialog::KoEditColorSetDialog(const QList<KoColorSet *> &palettes, const QString &activePalette, QWidget *parent)
     : KoDialog(parent)
 {
     ui = new KoEditColorSetWidget(palettes, activePalette, this);
     setMainWidget(ui);
     setCaption(i18n("Add/Remove Colors"));
     enableButton(KoDialog::Ok, ui->isEnabled());
 }
 
 KoEditColorSetDialog::~KoEditColorSetDialog()
 {
     delete ui;
 }
 
 KoColorSet *KoEditColorSetDialog::activeColorSet()
 {
     return ui->activeColorSet();
 }
diff --git a/libs/widgets/KoPageLayoutDialog.cpp b/libs/widgets/KoPageLayoutDialog.cpp
index 5e9bcf401c..26f2c8b625 100644
--- a/libs/widgets/KoPageLayoutDialog.cpp
+++ b/libs/widgets/KoPageLayoutDialog.cpp
@@ -1,147 +1,147 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007,2010 Thomas Zander <zander@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 "KoPageLayoutDialog.h"
 
 #include "KoPageLayoutWidget.h"
 #include "KoPagePreviewWidget.h"
 
 #include <klocalizedstring.h>
 #include <WidgetsDebug.h>
 
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QHBoxLayout>
 #include <QTimer>
 
 class Q_DECL_HIDDEN KoPageLayoutDialog::Private
 {
 public:
     Private() : pageLayoutWidget(0), documentCheckBox(0) {}
     KoPageLayoutWidget *pageLayoutWidget;
     QCheckBox *documentCheckBox;
 };
 
 
 KoPageLayoutDialog::KoPageLayoutDialog(QWidget *parent, const KoPageLayout &layout)
     : KPageDialog(parent)
     , d(new Private)
 {
     setWindowTitle(i18n("Page Layout"));
     setFaceType(KPageDialog::Tabbed);
 
     QWidget *widget = new QWidget(this);
     addPage(widget, i18n("Page"));
 
     QHBoxLayout *lay = new QHBoxLayout(widget);
 
     d->pageLayoutWidget = new KoPageLayoutWidget(widget, layout);
     d->pageLayoutWidget->showUnitchooser(false);
     lay->addWidget(d->pageLayoutWidget,1);
 
     KoPagePreviewWidget *prev = new KoPagePreviewWidget(widget);
     // use not original layout, but "fixed" one (e.g. with 0 values) as now hold by pageLayoutWidget
     prev->setPageLayout(d->pageLayoutWidget->pageLayout());
     lay->addWidget(prev, 1);
 
-    connect (d->pageLayoutWidget, SIGNAL(layoutChanged(const KoPageLayout&)),
-            prev, SLOT(setPageLayout(const KoPageLayout&)));
-    connect (d->pageLayoutWidget, SIGNAL(layoutChanged(const KoPageLayout&)),
-            this, SLOT(setPageLayout(const KoPageLayout&)));
-    connect (d->pageLayoutWidget, SIGNAL(unitChanged(const KoUnit&)),
-            this, SIGNAL(unitChanged(const KoUnit&)));
+    connect (d->pageLayoutWidget, SIGNAL(layoutChanged(KoPageLayout)),
+            prev, SLOT(setPageLayout(KoPageLayout)));
+    connect (d->pageLayoutWidget, SIGNAL(layoutChanged(KoPageLayout)),
+            this, SLOT(setPageLayout(KoPageLayout)));
+    connect (d->pageLayoutWidget, SIGNAL(unitChanged(KoUnit)),
+            this, SIGNAL(unitChanged(KoUnit)));
 }
 
 KoPageLayoutDialog::~KoPageLayoutDialog()
 {
     delete d;
 }
 
 KoPageLayout KoPageLayoutDialog::pageLayout() const
 {
     return d->pageLayoutWidget->pageLayout();
 }
 
 void KoPageLayoutDialog::setPageLayout(const KoPageLayout &layout)
 {
     d->pageLayoutWidget->setPageLayout(layout);
 }
 
 void KoPageLayoutDialog::accept()
 {
     KPageDialog::accept();
     deleteLater();
 }
 
 void KoPageLayoutDialog::reject()
 {
     KPageDialog::reject();
     deleteLater();
 }
 
 bool KoPageLayoutDialog::applyToDocument() const
 {
     return d->documentCheckBox && d->documentCheckBox->isChecked();
 }
 
 void KoPageLayoutDialog::showApplyToDocument(bool on)
 {
     if (on && d->documentCheckBox == 0) {
         for (int i = 0; i < children().count(); ++i) {
             if (QDialogButtonBox *buttonBox = qobject_cast<QDialogButtonBox*>(children()[i])) {
                 d->documentCheckBox = new QCheckBox(i18n("Apply to document"), buttonBox);
                 d->documentCheckBox->setChecked(true);
                 buttonBox->addButton(d->documentCheckBox, QDialogButtonBox::ResetRole);
                 break;
             }
         }
 
         Q_ASSERT(d->pageLayoutWidget);
         connect (d->documentCheckBox, SIGNAL(toggled(bool)),
                 d->pageLayoutWidget, SLOT(setApplyToDocument(bool)));
     } else if (d->documentCheckBox) {
         d->documentCheckBox->setVisible(on);
     }
 }
 
 void KoPageLayoutDialog::showTextDirection(bool on)
 {
     d->pageLayoutWidget->showTextDirection(on);
 }
 
 void KoPageLayoutDialog::showPageSpread(bool on)
 {
     d->pageLayoutWidget->showPageSpread(on);
 }
 
 void KoPageLayoutDialog::setPageSpread(bool pageSpread)
 {
     d->pageLayoutWidget->setPageSpread(pageSpread);
 }
 
 void KoPageLayoutDialog::showUnitchooser(bool on)
 {
     d->pageLayoutWidget->showUnitchooser(on);
 }
 
 void KoPageLayoutDialog::setUnit(const KoUnit &unit)
 {
     d->pageLayoutWidget->setUnit(unit);
 }
 
diff --git a/libs/widgets/KoPageLayoutWidget.cpp b/libs/widgets/KoPageLayoutWidget.cpp
index d1a2b0504f..7fb2d7261f 100644
--- a/libs/widgets/KoPageLayoutWidget.cpp
+++ b/libs/widgets/KoPageLayoutWidget.cpp
@@ -1,320 +1,320 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007, 2010 Thomas Zander <zander@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 "KoPageLayoutWidget.h"
 
 #include <ui_KoPageLayoutWidget.h>
 
 #include <KoUnit.h>
 
 #include <QButtonGroup>
 
 class Q_DECL_HIDDEN KoPageLayoutWidget::Private
 {
 public:
     Ui::KoPageLayoutWidget widget;
     KoPageLayout pageLayout;
     KoUnit unit;
 
     QButtonGroup *orientationGroup;
     bool marginsEnabled;
     bool allowSignals;
 };
 
 
 KoPageLayoutWidget::KoPageLayoutWidget(QWidget *parent, const KoPageLayout &layout)
     : QWidget(parent)
     , d(new Private)
 {
     d->widget.setupUi(this);
 
     d->pageLayout = layout;
     d->marginsEnabled = true;
     d->allowSignals = true;
     d->orientationGroup = new QButtonGroup(this);
     d->orientationGroup->addButton(d->widget.portrait, KoPageFormat::Portrait);
     d->orientationGroup->addButton(d->widget.landscape, KoPageFormat::Landscape);
 
     QButtonGroup *group2 = new QButtonGroup(this);
     group2->addButton(d->widget.singleSided);
     group2->addButton(d->widget.facingPages);
     // the two sets of labels we use might have different lengths; make sure this does not create a 'jumping' ui
     d->widget.facingPages->setChecked(true);
     facingPagesChanged();
     int width = qMax(d->widget.leftLabel->width(), d->widget.rightLabel->width());
     d->widget.singleSided->setChecked(true);
     facingPagesChanged();
     width = qMax(width, qMax(d->widget.leftLabel->width(), d->widget.rightLabel->width()));
     d->widget.leftLabel->setMinimumSize(QSize(width, 5));
 
     d->widget.units->addItems(KoUnit::listOfUnitNameForUi(KoUnit::HidePixel));
     d->widget.sizes->addItems(KoPageFormat::localizedPageFormatNames());
     setPageSpread(false);
 
     connect(d->widget.sizes, SIGNAL(currentIndexChanged(int)), this, SLOT(sizeChanged(int)));
     connect(d->widget.units, SIGNAL(currentIndexChanged(int)), this, SLOT(unitChanged(int)));
-    connect(group2, SIGNAL(buttonClicked (int)), this, SLOT(facingPagesChanged()));
-    connect(d->orientationGroup, SIGNAL(buttonClicked (int)), this, SLOT(orientationChanged()));
+    connect(group2, SIGNAL(buttonClicked(int)), this, SLOT(facingPagesChanged()));
+    connect(d->orientationGroup, SIGNAL(buttonClicked(int)), this, SLOT(orientationChanged()));
     connect(d->widget.width, SIGNAL(valueChangedPt(qreal)), this, SLOT(optionsChanged()));
     connect(d->widget.height, SIGNAL(valueChangedPt(qreal)), this, SLOT(optionsChanged()));
     connect(d->widget.topMargin, SIGNAL(valueChangedPt(qreal)), this, SLOT(marginsChanged()));
     connect(d->widget.bottomMargin, SIGNAL(valueChangedPt(qreal)), this, SLOT(marginsChanged()));
     connect(d->widget.bindingEdgeMargin, SIGNAL(valueChangedPt(qreal)), this, SLOT(marginsChanged()));
     connect(d->widget.pageEdgeMargin, SIGNAL(valueChangedPt(qreal)), this, SLOT(marginsChanged()));
     connect(d->widget.width, SIGNAL(valueChangedPt(qreal)), this, SLOT(optionsChanged()));
     connect(d->widget.height, SIGNAL(valueChangedPt(qreal)), this, SLOT(optionsChanged()));
 
     setUnit(KoUnit(KoUnit::Millimeter));
     setPageLayout(layout);
     if (layout.format == 0) // make sure we always call this during startup, even if the A3 (index=0) was chosen
         sizeChanged(layout.format);
 
     showTextDirection(false);
     /* disable advanced page layout features by default */
     d->widget.facingPageLabel->setVisible(false);
     d->widget.facingPages->setVisible(false);
     d->widget.singleSided->setVisible(false);
     d->widget.stylesLabel->setVisible(false);
     d->widget.pageStyle->setVisible(false);
 }
 
 KoPageLayoutWidget::~KoPageLayoutWidget()
 {
     delete d;
 }
 
 KoPageLayout KoPageLayoutWidget::pageLayout() const
 {
     return d->pageLayout;
 }
 
 void KoPageLayoutWidget::sizeChanged(int row)
 {
     if (row < 0) return;
     if (! d->allowSignals) return;
     d->allowSignals = false;
     d->pageLayout.format = static_cast<KoPageFormat::Format> (row);
     bool custom =  d->pageLayout.format == KoPageFormat::CustomSize;
     d->widget.width->setEnabled( custom );
     d->widget.height->setEnabled( custom );
 
     if ( !custom ) {
         d->pageLayout.width = MM_TO_POINT( KoPageFormat::width( d->pageLayout.format, d->pageLayout.orientation ) );
         d->pageLayout.height = MM_TO_POINT( KoPageFormat::height( d->pageLayout.format, d->pageLayout.orientation ) );
         if (d->widget.facingPages->isChecked()) // is pagespread
             d->pageLayout.width *= 2;
     }
 
     d->widget.width->changeValue( d->pageLayout.width );
     d->widget.height->changeValue( d->pageLayout.height );
 
     emit layoutChanged(d->pageLayout);
     d->allowSignals = true;
 }
 
 void KoPageLayoutWidget::unitChanged(int row)
 {
     setUnit(KoUnit::fromListForUi(row, KoUnit::HidePixel));
 }
 
 void KoPageLayoutWidget::setUnit(const KoUnit &unit)
 {
     if (d->unit == unit)
         return;
     d->unit = unit;
 
     d->widget.width->setUnit(unit);
     d->widget.height->setUnit(unit);
     d->widget.topMargin->setUnit(unit);
     d->widget.bottomMargin->setUnit(unit);
     d->widget.bindingEdgeMargin->setUnit(unit);
     d->widget.pageEdgeMargin->setUnit(unit);
     d->widget.units->setCurrentIndex(unit.indexInListForUi(KoUnit::HidePixel));
 
     emit unitChanged(d->unit);
 }
 
 void KoPageLayoutWidget::setPageLayout(const KoPageLayout &layout)
 {
     if (! d->allowSignals) return;
     d->allowSignals = false;
     d->pageLayout = layout;
 
     Q_ASSERT(d->orientationGroup->button( layout.orientation ));
     d->orientationGroup->button( layout.orientation )->setChecked( true );
     if (layout.bindingSide >= 0 && layout.pageEdge >= 0) {
         d->widget.facingPages->setChecked(true);
         d->widget.bindingEdgeMargin->changeValue(layout.bindingSide);
         d->widget.pageEdgeMargin->changeValue(layout.pageEdge);
         d->pageLayout.leftMargin = -1;
         d->pageLayout.rightMargin = -1;
     }
     else {
         d->widget.singleSided->setChecked(true);
         d->widget.bindingEdgeMargin->changeValue(layout.leftMargin);
         d->widget.pageEdgeMargin->changeValue(layout.rightMargin);
         d->pageLayout.pageEdge = -1;
         d->pageLayout.bindingSide = -1;
     }
     facingPagesChanged();
 
     d->widget.topMargin->changeValue(layout.topMargin);
     d->widget.bottomMargin->changeValue(layout.bottomMargin);
     d->allowSignals = true;
     d->widget.sizes->setCurrentIndex(layout.format); // calls sizeChanged()
 }
 
 void KoPageLayoutWidget::facingPagesChanged()
 {
     if (! d->allowSignals) return;
     d->allowSignals = false;
     if (d->widget.singleSided->isChecked()) {
         d->widget.leftLabel->setText(i18n("Left Edge:"));
         d->widget.rightLabel->setText(i18n("Right Edge:"));
     }
     else {
         d->widget.leftLabel->setText(i18n("Binding Edge:"));
         d->widget.rightLabel->setText(i18n("Page Edge:"));
     }
     d->allowSignals = true;
     marginsChanged();
     sizeChanged(d->widget.sizes->currentIndex());
 }
 
 void KoPageLayoutWidget::marginsChanged()
 {
     if (! d->allowSignals) return;
     d->allowSignals = false;
     d->pageLayout.leftMargin = -1;
     d->pageLayout.rightMargin = -1;
     d->pageLayout.bindingSide = -1;
     d->pageLayout.pageEdge = -1;
     d->pageLayout.topMargin = d->marginsEnabled?d->widget.topMargin->value():0;
     d->pageLayout.bottomMargin = d->marginsEnabled?d->widget.bottomMargin->value():0;
     qreal left = d->marginsEnabled?d->widget.bindingEdgeMargin->value():0;
     qreal right = d->marginsEnabled?d->widget.pageEdgeMargin->value():0;
     if (left + right > d->pageLayout.width - 10) {
         // make sure the actual text area is never smaller than 10 points.
         qreal diff = d->pageLayout.width - 10 - left - right;
         left = qMin(d->pageLayout.width - 10, qMax(qreal(0.0), left - diff / qreal(2.0)));
         right = qMax(qreal(0.0), right - d->pageLayout.width - 10 - left);
     }
 
     if (d->widget.singleSided->isChecked()) {
         d->pageLayout.leftMargin  = left;
         d->pageLayout.rightMargin = right;
     }
     else {
         d->pageLayout.bindingSide = left;
         d->pageLayout.pageEdge = right;
     }
     // debugWidgets << "  " << d->pageLayout.left <<"|"<< d->pageLayout.bindingSide << "," <<
     //    d->pageLayout.right << "|"<< d->pageLayout.pageEdge;
     emit layoutChanged(d->pageLayout);
     d->allowSignals = true;
 }
 
 void KoPageLayoutWidget::setTextAreaAvailable(bool available)
 {
     d->marginsEnabled = available;
     d->widget.margins->setEnabled(available);
     marginsChanged();
 }
 
 void KoPageLayoutWidget::optionsChanged()
 {
     if (! d->allowSignals) return;
     if (d->widget.sizes->currentIndex() == KoPageFormat::CustomSize) {
         d->pageLayout.width = d->widget.width->value();
         d->pageLayout.height = d->widget.height->value();
     } else
         sizeChanged(d->widget.sizes->currentIndex());
 
     marginsChanged();
 }
 
 void KoPageLayoutWidget::orientationChanged()
 {
     if (! d->allowSignals) return;
     d->allowSignals = false;
     d->pageLayout.orientation = d->widget.landscape->isChecked() ? KoPageFormat::Landscape : KoPageFormat::Portrait;
 
     qreal x = d->widget.height->value();
     d->widget.height->changeValue( d->widget.width->value() );
     d->widget.width->changeValue( x );
 
     d->allowSignals = true;
     optionsChanged();
 }
 
 void KoPageLayoutWidget::showUnitchooser(bool on) {
     d->widget.units->setVisible(on);
     d->widget.unitsLabel->setVisible(on);
 }
 
 void KoPageLayoutWidget::showPageSpread(bool on)
 {
     d->widget.facingPageLabel->setVisible(on);
     d->widget.singleSided->setVisible(on);
     d->widget.facingPages->setVisible(on);
 }
 
 void KoPageLayoutWidget::setPageSpread(bool pageSpread)
 {
     if (pageSpread)
         d->widget.facingPages->setChecked(true);
     else
         d->widget.singleSided->setChecked(true);
 }
 
 void KoPageLayoutWidget::setApplyToDocument(bool apply)
 {
     if (apply) {
         d->widget.facingPageLabel->setText(i18n("Facing Pages:"));
         d->widget.facingPages->setText(i18n("Facing pages"));
     }
     else {
         d->widget.facingPageLabel->setText(i18n("Page Layout:"));
         d->widget.facingPages->setText(i18n("Page spread"));
     }
 }
 
 void KoPageLayoutWidget::showTextDirection(bool on)
 {
     d->widget.directionLabel->setVisible(on);
     d->widget.textDirection->setVisible(on);
 }
 
 
 void KoPageLayoutWidget::showPageStyles(bool on)
 {
     d->widget.stylesLabel->setVisible(on);
     d->widget.pageStyle->setVisible(on);
 }
 
 void KoPageLayoutWidget::setPageStyles(const QStringList &styles)
 {
     d->widget.pageStyle->clear();
     d->widget.pageStyle->addItems(styles);
 }
 
 QString KoPageLayoutWidget::currentPageStyle() const
 {
     return d->widget.pageStyle->currentText();
 }
diff --git a/libs/widgets/KoResourceItemChooser.cpp b/libs/widgets/KoResourceItemChooser.cpp
index d9df8d8bc0..0a91074c2e 100644
--- a/libs/widgets/KoResourceItemChooser.cpp
+++ b/libs/widgets/KoResourceItemChooser.cpp
@@ -1,627 +1,627 @@
 /* This file is part of the KDE project
    Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
    Copyright (c) 2007 Jan Hambrecht <jaham@gmx.net>
    Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
    Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
    Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
    Copyright (c) 2013 Sascha Suelzer <s.suelzer@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 #include "KoResourceItemChooser.h"
 
 #include <math.h>
 
 #include <QGridLayout>
 #include <QButtonGroup>
 #include <QHeaderView>
 #include <QAbstractProxyModel>
 #include <QLabel>
 #include <QScrollArea>
 #include <QImage>
 #include <QPixmap>
 #include <QPainter>
 #include <QSplitter>
 #include <QToolButton>
 #include <QWheelEvent>
 
 #include <klocalizedstring.h>
 
 #include <KoIcon.h>
 #include <KoFileDialog.h>
 #include <KisMimeDatabase.h>
 #include "KoResourceServerAdapter.h"
 #include "KoResourceItemView.h"
 #include "KoResourceItemDelegate.h"
 #include "KoResourceModel.h"
 #include <resources/KoResource.h>
 #include "KoResourceTaggingManager.h"
 #include "KoTagFilterWidget.h"
 #include "KoTagChooserWidget.h"
 #include "KoResourceItemChooserSync.h"
 #include "kis_assert.h"
 
 
 class Q_DECL_HIDDEN KoResourceItemChooser::Private
 {
 public:
     Private()
         : model(0)
         , view(0)
         , buttonGroup(0)
         , viewModeButton(0)
         , usePreview(false)
         , previewScroller(0)
         , previewLabel(0)
         , splitter(0)
         , tiledPreview(false)
         , grayscalePreview(false)
         , synced(false)
         , updatesBlocked(false)
         , savedResourceWhileReset(0)
     {}
     KoResourceModel *model;
     KoResourceTaggingManager *tagManager;
     KoResourceItemView *view;
     QButtonGroup *buttonGroup;
     QToolButton  *viewModeButton;
 
     bool usePreview;
     QScrollArea *previewScroller;
     QLabel *previewLabel;
     QSplitter *splitter;
     QGridLayout *buttonLayout;
     bool tiledPreview;
     bool grayscalePreview;
     bool synced;
     bool updatesBlocked;
 
     KoResource *savedResourceWhileReset;
 
     QList<QAbstractButton*> customButtons;
 };
 
 KoResourceItemChooser::KoResourceItemChooser(QSharedPointer<KoAbstractResourceServerAdapter> resourceAdapter, QWidget *parent, bool usePreview)
     : QWidget(parent)
     , d(new Private())
 {
     Q_ASSERT(resourceAdapter);
 
     d->splitter = new QSplitter(this);
 
     d->model = new KoResourceModel(resourceAdapter, this);
-    connect(d->model, SIGNAL(beforeResourcesLayoutReset(KoResource *)), SLOT(slotBeforeResourcesLayoutReset(KoResource *)));
+    connect(d->model, SIGNAL(beforeResourcesLayoutReset(KoResource*)), SLOT(slotBeforeResourcesLayoutReset(KoResource*)));
     connect(d->model, SIGNAL(afterResourcesLayoutReset()), SLOT(slotAfterResourcesLayoutReset()));
 
     d->view = new KoResourceItemView(this);
     d->view->setObjectName("ResourceItemview");
     d->view->setModel(d->model);
     d->view->setItemDelegate(new KoResourceItemDelegate(this));
     d->view->setSelectionMode(QAbstractItemView::SingleSelection);
     d->view->viewport()->installEventFilter(this);
 
     connect(d->view, SIGNAL(currentResourceChanged(QModelIndex)), this, SLOT(activated(QModelIndex)));
     connect(d->view, SIGNAL(currentResourceClicked(QModelIndex)), this, SLOT(clicked(QModelIndex)));
     connect(d->view, SIGNAL(contextMenuRequested(QPoint)), this, SLOT(contextMenuRequested(QPoint)));
 
     connect(d->view, SIGNAL(sigSizeChanged()), this, SLOT(updateView()));
 
     d->splitter->addWidget(d->view);
     d->splitter->setStretchFactor(0, 2);
 
     d->usePreview = usePreview;
     if (d->usePreview) {
         d->previewScroller = new QScrollArea(this);
         d->previewScroller->setWidgetResizable(true);
         d->previewScroller->setBackgroundRole(QPalette::Dark);
         d->previewScroller->setVisible(true);
         d->previewScroller->setAlignment(Qt::AlignCenter);
         d->previewLabel = new QLabel(this);
         d->previewScroller->setWidget(d->previewLabel);
         d->splitter->addWidget(d->previewScroller);
 
         if (d->splitter->count() == 2) {
             d->splitter->setSizes(QList<int>() << 280 << 160);
         }
     }
 
     d->splitter->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
-    connect(d->splitter, SIGNAL(splitterMoved(int, int)), SIGNAL(splitterMoved()));
+    connect(d->splitter, SIGNAL(splitterMoved(int,int)), SIGNAL(splitterMoved()));
 
     d->buttonGroup = new QButtonGroup(this);
     d->buttonGroup->setExclusive(false);
 
     QGridLayout *layout = new QGridLayout(this);
 
     d->buttonLayout = new QGridLayout();
 
     importButton = new QPushButton(this);
 
     importButton->setToolTip(i18nc("@info:tooltip", "Import resource"));
     importButton->setEnabled(true);
     d->buttonGroup->addButton(importButton, Button_Import);
     d->buttonLayout->addWidget(importButton, 0, 0);
 
     deleteButton = new QPushButton(this);
     deleteButton->setToolTip(i18nc("@info:tooltip", "Delete resource"));
     deleteButton->setEnabled(false);
     d->buttonGroup->addButton(deleteButton, Button_Remove);
     d->buttonLayout->addWidget(deleteButton, 0, 1);
 
     connect(d->buttonGroup, SIGNAL(buttonClicked(int)), this, SLOT(slotButtonClicked(int)));
 
     d->buttonLayout->setColumnStretch(0, 1);
     d->buttonLayout->setColumnStretch(1, 1);
     d->buttonLayout->setColumnStretch(2, 2);
     d->buttonLayout->setSpacing(0);
     d->buttonLayout->setMargin(0);
 
     d->viewModeButton = new QToolButton(this);
     d->viewModeButton->setPopupMode(QToolButton::InstantPopup);
     d->viewModeButton->setVisible(false);
 
     d->tagManager = new KoResourceTaggingManager(d->model, this);
     connect(d->tagManager, SIGNAL(updateView()), this, SLOT(updateView()));
 
     layout->addWidget(d->tagManager->tagChooserWidget(), 0, 0);
     layout->addWidget(d->viewModeButton, 0, 1);
     layout->addWidget(d->splitter, 1, 0, 1, 2);
     layout->addWidget(d->tagManager->tagFilterWidget(), 2, 0, 1, 2);
     layout->addLayout(d->buttonLayout, 3, 0, 1, 2);
     layout->setMargin(0);
     layout->setSpacing(0);
 
     updateView();
 
     updateButtonState();
     showTaggingBar(false);
     activated(d->model->index(0, 0));
 }
 
 KoResourceItemChooser::~KoResourceItemChooser()
 {
     disconnect();
     delete d;
 }
 
 void KoResourceItemChooser::slotButtonClicked(int button)
 {
     if (button == Button_Import) {
         QString extensions = d->model->extensions();
         QStringList mimeTypes;
         Q_FOREACH(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->model->importResourceFile(filename);
     } else if (button == Button_Remove) {
         QModelIndex index = d->view->currentIndex();
         int row = index.row();
         int column = index.column();
         if (index.isValid()) {
 
             KoResource *resource = resourceFromModelIndex(index);
             if (resource) {
                 d->model->removeResource(resource);
             }
         }
         if (column == 0) {
             int rowMin = --row;
             row = qBound(0, rowMin, row);
         }
         int columnMin = --column;
         column = qBound(0, columnMin, column);
         setCurrentItem(row, column);
         activated(d->model->index(row, column));
     }
     updateButtonState();
 }
 
 void KoResourceItemChooser::showButtons(bool show)
 {
     foreach (QAbstractButton * button, d->buttonGroup->buttons()) {
         show ? button->show() : button->hide();
     }
 
     Q_FOREACH (QAbstractButton *button, d->customButtons) {
         show ? button->show() : button->hide();
     }
 }
 
 void KoResourceItemChooser::addCustomButton(QAbstractButton *button, int cell)
 {
     d->buttonLayout->addWidget(button, 0, cell);
     d->buttonLayout->setColumnStretch(2, 1);
     d->buttonLayout->setColumnStretch(3, 1);
 }
 
 void KoResourceItemChooser::showTaggingBar(bool show)
 {
     d->tagManager->showTaggingBar(show);
 
 }
 
 void KoResourceItemChooser::setRowCount(int rowCount)
 {
     int resourceCount = d->model->resourcesCount();
     d->model->setColumnCount(static_cast<qreal>(resourceCount) / rowCount);
     //Force an update to get the right row height (in theory)
     QRect geometry = d->view->geometry();
     d->view->setViewMode(KoResourceItemView::FIXED_ROWS);
     d->view->setGeometry(geometry.adjusted(0, 0, 0, 1));
     d->view->setGeometry(geometry);
 }
 
 void KoResourceItemChooser::setColumnCount(int columnCount)
 {
     d->model->setColumnCount(columnCount);
 }
 
 void KoResourceItemChooser::setRowHeight(int rowHeight)
 {
     d->view->verticalHeader()->setDefaultSectionSize(rowHeight);
 }
 
 void KoResourceItemChooser::setColumnWidth(int columnWidth)
 {
     d->view->horizontalHeader()->setDefaultSectionSize(columnWidth);
 }
 
 void KoResourceItemChooser::setItemDelegate(QAbstractItemDelegate *delegate)
 {
     d->view->setItemDelegate(delegate);
 }
 
 KoResource *KoResourceItemChooser::currentResource() const
 {
     QModelIndex index = d->view->currentIndex();
     if (index.isValid()) {
         return resourceFromModelIndex(index);
     }
     return 0;
 }
 
 void KoResourceItemChooser::setCurrentResource(KoResource *resource)
 {
     // don't update if the change came from the same chooser
     if (d->updatesBlocked) {
         return;
     }
 
     QModelIndex index = d->model->indexFromResource(resource);
 
     d->view->setCurrentIndex(index);
     updatePreview(index.isValid() ? resource : 0);
 }
 
 void KoResourceItemChooser::slotBeforeResourcesLayoutReset(KoResource *activateAfterReset)
 {
     d->savedResourceWhileReset = activateAfterReset ? activateAfterReset : currentResource();
 }
 
 void KoResourceItemChooser::slotAfterResourcesLayoutReset()
 {
     if (d->savedResourceWhileReset) {
         this->blockSignals(true);
         setCurrentResource(d->savedResourceWhileReset);
         this->blockSignals(false);
     }
 }
 
 void KoResourceItemChooser::setPreviewOrientation(Qt::Orientation orientation)
 {
     d->splitter->setOrientation(orientation);
 }
 
 void KoResourceItemChooser::setPreviewTiled(bool tiled)
 {
     d->tiledPreview = tiled;
 }
 
 void KoResourceItemChooser::setGrayscalePreview(bool grayscale)
 {
     d->grayscalePreview = grayscale;
 }
 
 void KoResourceItemChooser::setCurrentItem(int row, int column)
 {
     QModelIndex index = d->model->index(row, column);
     if (!index.isValid())
         return;
 
     d->view->setCurrentIndex(index);
     if (index.isValid()) {
         updatePreview(resourceFromModelIndex(index));
     }
 }
 
 void KoResourceItemChooser::setProxyModel(QAbstractProxyModel *proxyModel)
 {
     proxyModel->setSourceModel(d->model);
     d->view->setModel(proxyModel);
 }
 
 void KoResourceItemChooser::activated(const QModelIndex &index)
 {
     if (!index.isValid()) return;
 
     KoResource *resource = 0;
 
     if (index.isValid()) {
         resource = resourceFromModelIndex(index);
     }
 
     KIS_SAFE_ASSERT_RECOVER (resource) {
         resource = currentResource();
     }
 
     if (resource) {
         d->updatesBlocked = true;
         emit resourceSelected(resource);
         d->updatesBlocked = false;
         updatePreview(resource);
         updateButtonState();
     }
 }
 
 void KoResourceItemChooser::clicked(const QModelIndex &index)
 {
     Q_UNUSED(index);
 
     KoResource *resource = currentResource();
     if (resource) {
         emit resourceClicked(resource);
     }
 }
 
 void KoResourceItemChooser::updateButtonState()
 {
     QAbstractButton *removeButton = d->buttonGroup->button(Button_Remove);
     if (! removeButton)
         return;
 
     KoResource *resource = currentResource();
     if (resource) {
         removeButton->setEnabled(!resource->permanent());
         return;
     }
     removeButton->setEnabled(false);
 }
 
 void KoResourceItemChooser::updatePreview(KoResource *resource)
 {
     if (!d->usePreview) return;
 
     if (!resource) {
         d->previewLabel->setPixmap(QPixmap());
         return;
     }
 
     QImage image = resource->image();
 
     if (image.format() != QImage::Format_RGB32 &&
         image.format() != QImage::Format_ARGB32 &&
         image.format() != QImage::Format_ARGB32_Premultiplied) {
 
         image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
     }
 
     if (d->tiledPreview) {
         int width = d->previewScroller->width() * 4;
         int height = d->previewScroller->height() * 4;
         QImage img(width, height, image.format());
         QPainter gc(&img);
         gc.fillRect(img.rect(), Qt::white);
         gc.setPen(Qt::NoPen);
         gc.setBrush(QBrush(image));
         gc.drawRect(img.rect());
         image = img;
     }
 
     // Only convert to grayscale if it is rgb. Otherwise, it's gray already.
     if (d->grayscalePreview && !image.isGrayscale()) {
 
         QRgb *pixel = reinterpret_cast<QRgb *>(image.bits());
         for (int row = 0; row < image.height(); ++row) {
             for (int col = 0; col < image.width(); ++col) {
                 const QRgb currentPixel = pixel[row * image.width() + col];
                 const int red = qRed(currentPixel);
                 const int green = qGreen(currentPixel);
                 const int blue = qBlue(currentPixel);
                 const int grayValue = (red * 11 + green * 16 + blue * 5) / 32;
                 pixel[row * image.width() + col] = qRgb(grayValue, grayValue, grayValue);
             }
         }
     }
     d->previewLabel->setPixmap(QPixmap::fromImage(image));
 
 }
 
 KoResource *KoResourceItemChooser::resourceFromModelIndex(const QModelIndex &index) const
 {
     if (!index.isValid())
         return 0;
 
     const QAbstractProxyModel *proxyModel = dynamic_cast<const QAbstractProxyModel *>(index.model());
     if (proxyModel) {
         //Get original model index, because proxy models destroy the internalPointer
         QModelIndex originalIndex = proxyModel->mapToSource(index);
         return static_cast<KoResource *>(originalIndex.internalPointer());
     }
 
     return static_cast<KoResource *>(index.internalPointer());
 }
 
 QSize KoResourceItemChooser::viewSize() const
 {
     return d->view->size();
 }
 
 KoResourceItemView *KoResourceItemChooser::itemView() const
 {
     return d->view;
 }
 
 void KoResourceItemChooser::contextMenuRequested(const QPoint &pos)
 {
     d->tagManager->contextMenuRequested(currentResource(), pos);
 }
 
 void KoResourceItemChooser::setViewModeButtonVisible(bool visible)
 {
     d->viewModeButton->setVisible(visible);
 }
 
 QToolButton *KoResourceItemChooser::viewModeButton() const
 {
     return d->viewModeButton;
 }
 
 void KoResourceItemChooser::setSynced(bool sync)
 {
     if (d->synced == sync)
         return;
 
     d->synced = sync;
     KoResourceItemChooserSync *chooserSync = KoResourceItemChooserSync::instance();
     if (sync) {
         connect(chooserSync, SIGNAL(baseLengthChanged(int)), SLOT(baseLengthChanged(int)));
         baseLengthChanged(chooserSync->baseLength());
     } else {
         chooserSync->disconnect(this);
     }
 }
 
 void KoResourceItemChooser::baseLengthChanged(int length)
 {
     if (d->synced) {
         int resourceCount = d->model->resourcesCount();
         int width = d->view->width();
         int maxColumns = width / length;
         int cols = width / (2 * length) + 1;
         while (cols <= maxColumns) {
             int size = width / cols;
             int rows = ceil(resourceCount / (double)cols);
             if (rows * size < (d->view->height() - 5)) {
                 break;
             }
             cols++;
         }
         setColumnCount(cols);
     }
     d->view->updateView();
 }
 
 bool KoResourceItemChooser::eventFilter(QObject *object, QEvent *event)
 {
     if (d->synced && event->type() == QEvent::Wheel) {
         KoResourceItemChooserSync *chooserSync = KoResourceItemChooserSync::instance();
         QWheelEvent *qwheel = static_cast<QWheelEvent *>(event);
         if (qwheel->modifiers() & Qt::ControlModifier) {
 
             int degrees = qwheel->delta() / 8;
             int newBaseLength = chooserSync->baseLength() + degrees / 15 * 10;
             chooserSync->setBaseLength(newBaseLength);
             return true;
         }
     }
     return QObject::eventFilter(object, event);
 }
 
 void KoResourceItemChooser::configureKineticScrolling(int gesture, int sensitivity, bool scrollbar)
 {
     QScroller::ScrollerGestureType gestureType;
 
     switch (gesture) {
     case 1: {
         gestureType = QScroller::TouchGesture;
         break;
     }
     case 2: {
         gestureType = QScroller::LeftMouseButtonGesture;
         break;
     }
     default:
         return;
     }
 
     KoResourceItemView *view = itemView();
 
     view->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
     if (!scrollbar) {
         view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     }
 
     QScroller *scroller = QScroller::scroller(view);
     scroller->grabGesture(view, gestureType);
 
     QScrollerProperties sp;
 
     // DragStartDistance seems to be based on meter per second; though it's
     // not explicitly documented, other QScroller values are in that metric.
 
     // To start kinetic scrolling, with minimal sensitity, we expect a drag
     // of 10 mm, with minimum sensitity any > 0 mm.
 
     const float mm = 0.001f; // 1 millimeter
     const float resistance = 1.0f - (sensitivity / 100.0f);
 
     sp.setScrollMetric(QScrollerProperties::DragStartDistance, resistance * 10.0f * mm);
     sp.setScrollMetric(QScrollerProperties::DragVelocitySmoothingFactor, 1.0f);
     sp.setScrollMetric(QScrollerProperties::MinimumVelocity, 0.0f);
     sp.setScrollMetric(QScrollerProperties::AxisLockThreshold, 1.0f);
     sp.setScrollMetric(QScrollerProperties::MaximumClickThroughVelocity, 0.0f);
     sp.setScrollMetric(QScrollerProperties::MousePressEventDelay, 1.0f - 0.75f * resistance);
     sp.setScrollMetric(QScrollerProperties::AcceleratingFlickSpeedupFactor, 1.5f);
 
     sp.setScrollMetric(QScrollerProperties::VerticalOvershootPolicy, QScrollerProperties::OvershootAlwaysOn);
     sp.setScrollMetric(QScrollerProperties::OvershootDragResistanceFactor, 0.1);
     sp.setScrollMetric(QScrollerProperties::OvershootDragDistanceFactor, 0.3);
     sp.setScrollMetric(QScrollerProperties::OvershootScrollDistanceFactor, 0.1);
     sp.setScrollMetric(QScrollerProperties::OvershootScrollTime, 0.4);
 
     scroller->setScrollerProperties(sp);
 }
 
 void KoResourceItemChooser::resizeEvent(QResizeEvent *event)
 {
     QWidget::resizeEvent(event);
     updateView();
 }
 
 void KoResourceItemChooser::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
     updateView();
 }
 
 void KoResourceItemChooser::updateView()
 {
     if (d->synced) {
         KoResourceItemChooserSync *chooserSync = KoResourceItemChooserSync::instance();
         baseLengthChanged(chooserSync->baseLength());
     }
 
     /// helps to set icons here in case the theme is changed
     d->viewModeButton->setIcon(koIcon("view-choose"));
     importButton->setIcon(koIcon("document-open"));
     deleteButton->setIcon(koIcon("trash-empty"));
 }
diff --git a/libs/widgets/KoResourceTaggingManager.cpp b/libs/widgets/KoResourceTaggingManager.cpp
index 4f60fc0156..41dca4fe6c 100644
--- a/libs/widgets/KoResourceTaggingManager.cpp
+++ b/libs/widgets/KoResourceTaggingManager.cpp
@@ -1,392 +1,392 @@
 /*
  *    This file is part of the KDE project
  *    Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *    Copyright (c) 2007 Jan Hambrecht <jaham@gmx.net>
  *    Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *    Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *    Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *    Copyright (c) 2013 Sascha Suelzer <s.suelzer@gmail.com>
  *
  *    This library is free software; you can redistribute it and/or
  *    modify it under the terms of the GNU Library General Public
  *    License as published by the Free Software Foundation; either
  *    version 2 of the License, or (at your option) any later version.
  *
  *    This library is distributed in the hope that it will be useful,
  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *    Library General Public License for more details.
  *
  *    You should have received a copy of the GNU Library General Public License
  *    along with this library; see the file COPYING.LIB.  If not, write to
  *    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *    Boston, MA 02110-1301, USA.
  */
 
 #include "KoResourceTaggingManager.h"
 
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QPointer>
 #include <QStringList>
 
 #include <WidgetsDebug.h>
 
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 
 #include "KoTagFilterWidget.h"
 #include "KoTagChooserWidget.h"
 #include "KoResourceModel.h"
 #include <resources/KoResource.h>
 #include "KoResourceItemChooserContextMenu.h"
 
 #include <kconfiggroup.h>
 
 class TaggedResourceSet
 {
 public:
     TaggedResourceSet()
     {}
 
     TaggedResourceSet(const QString& tagName, const QList<KoResource*>& resources)
         : tagName(tagName)
         , resources(resources)
     {}
 
     QString tagName;
     QList<KoResource*> resources;
 };
 
 
 class KoResourceTaggingManager::Private
 {
 public:
     QString currentTag;
     QList<KoResource*> originalResources;
     TaggedResourceSet lastDeletedTag;
 
     KoTagChooserWidget* tagChooser;
     KoTagFilterWidget* tagFilter;
 
     QCompleter* tagCompleter;
 
     QPointer<KoResourceModel> model;
 };
 
 
 KoResourceTaggingManager::KoResourceTaggingManager(KoResourceModel *model, QWidget* parent)
     : QObject(parent)
     , d(new Private())
 {
     d->model = model;
 
     d->tagChooser = new KoTagChooserWidget(parent);
     d->tagChooser->addReadOnlyItem("All"); // not translatable until other tags made translatable!
     d->tagChooser->addItems(d->model->tagNamesList());
 
     d->tagFilter = new KoTagFilterWidget(parent);
 
     connect(d->tagChooser, SIGNAL(tagChosen(QString)),
             this, SLOT(tagChooserIndexChanged(QString)));
     connect(d->tagChooser, SIGNAL(newTagRequested(QString)),
             this, SLOT(contextCreateNewTag(QString)));
     connect(d->tagChooser, SIGNAL(tagDeletionRequested(QString)),
             this, SLOT(removeTagFromComboBox(QString)));
-    connect(d->tagChooser, SIGNAL(tagRenamingRequested(QString, QString)),
-            this, SLOT(renameTag(QString, QString)));
+    connect(d->tagChooser, SIGNAL(tagRenamingRequested(QString,QString)),
+            this, SLOT(renameTag(QString,QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionRequested(QString)),
             this, SLOT(undeleteTag(QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionListPurgeRequested()),
             this, SLOT(purgeTagUndeleteList()));
 
     connect(d->tagFilter, SIGNAL(saveButtonClicked()),
             this, SLOT(tagSaveButtonPressed()));
     connect(d->tagFilter, SIGNAL(filterTextChanged(QString)),
             this, SLOT(tagSearchLineEditTextChanged(QString)));
 
     connect(d->model, SIGNAL(tagBoxEntryAdded(QString)),
             this, SLOT(syncTagBoxEntryAddition(QString)));
     connect(d->model, SIGNAL(tagBoxEntryRemoved(QString)),
             this, SLOT(syncTagBoxEntryRemoval(QString)));
     connect(d->model, SIGNAL(tagBoxEntryModified()),
             this, SLOT(syncTagBoxEntries()));
 
     // FIXME: fix tag completer
     // d->tagCompleter = new QCompleter(this);
     //  d->tagSearchLineEdit->setCompleter(d->tagCompleter);
 
     syncTagBoxEntries();
 }
 
 KoResourceTaggingManager::~KoResourceTaggingManager()
 {
     delete d;
 }
 
 void KoResourceTaggingManager::showTaggingBar(bool show)
 {
     show ? d->tagFilter->show() : d->tagFilter->hide();
     show ? d->tagChooser->show() : d->tagChooser->hide();
 
     blockSignals(!show);
 
     QString tag("All");
     if (show) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("SelectedTags");
         tag = group.readEntry<QString>(d->model->serverType(), "All");
     }
     int idx = d->tagChooser->findIndexOf(tag);
     if (idx < 0) idx = 0;
     d->tagChooser->setCurrentIndex(idx);
 }
 
 void KoResourceTaggingManager::purgeTagUndeleteList()
 {
     d->lastDeletedTag = TaggedResourceSet();
     d->tagChooser->setUndeletionCandidate(QString());
 }
 
 void KoResourceTaggingManager::undeleteTag(const QString & tagToUndelete)
 {
     QString tagName = tagToUndelete;
     QStringList allTags = availableTags();
 
     if (allTags.contains(tagName)) {
         bool ok;
         tagName = QInputDialog::getText(
                     d->tagChooser, i18n("Unable to undelete tag"),
                     i18n("<qt>The tag you are trying to undelete already exists in tag list.<br>Please enter a new, unique name for it.</qt>"),
                     QLineEdit::Normal,
                     tagName, &ok);
 
         if (!ok || allTags.contains(tagName) || tagName.isEmpty()) {
             QMessageBox msgBox;
             msgBox.setIcon(QMessageBox::Warning);
             msgBox.setText(i18n("Tag was not undeleted."));
             msgBox.exec();
             return;
         }
     }
 
     QList<KoResource*> serverResources = d->model->serverResources();
 
     Q_FOREACH (KoResource * resource, d->lastDeletedTag.resources) {
         if (serverResources.contains(resource)) {
             addResourceTag(resource, tagName);
         }
     }
     d->model->tagCategoryAdded(tagName);
     d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tagName));
     d->tagChooser->setUndeletionCandidate(QString());
     d->lastDeletedTag = TaggedResourceSet();
 }
 
 QStringList KoResourceTaggingManager::availableTags() const
 {
     return d->tagChooser->allTags();
 }
 
 void KoResourceTaggingManager::addResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
     if (tagsList.isEmpty()) {
         d->model->addTag(resource, tagName);
     } else {
         Q_FOREACH (const QString & tag, tagsList) {
             if (tag.compare(tagName)) {
                 d->model->addTag(resource, tagName);
             }
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryAddition(const QString& tag)
 {
     d->tagChooser->insertItem(tag);
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->addTag(0, tag);
         d->model->tagCategoryAdded(tag);
         d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tag));
         updateTaggedResourceView();
     }
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(KoResource* resource , const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->tagCategoryAdded(tag);
         if (resource) {
             addResourceTag(resource, tag);
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryRemoval(const QString& tag)
 {
     d->tagChooser->removeItem(tag);
 }
 
 void KoResourceTaggingManager::syncTagBoxEntries()
 {
     QStringList tags = d->model->tagNamesList();
     tags.sort();
     Q_FOREACH (const QString &tag, tags) {
         d->tagChooser->insertItem(tag);
     }
 }
 
 void KoResourceTaggingManager::contextAddTagToResource(KoResource* resource, const QString& tag)
 {
     addResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextRemoveTagFromResource(KoResource* resource, const QString& tag)
 {
     removeResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::removeTagFromComboBox(const QString &tag)
 {
     QList<KoResource*> resources = d->model->currentlyVisibleResources();
     Q_FOREACH (KoResource * resource, resources) {
         removeResourceTag(resource, tag);
     }
     d->model->tagCategoryRemoved(tag);
     d->lastDeletedTag = TaggedResourceSet(tag, resources);
     d->tagChooser->setUndeletionCandidate(tag);
 }
 
 void KoResourceTaggingManager::removeResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
 
     Q_FOREACH (const QString & oldName, tagsList) {
         if (!oldName.compare(tagName)) {
             d->model->deleteTag(resource, oldName);
         }
     }
 }
 
 void KoResourceTaggingManager::renameTag(const QString &oldName, const QString& newName)
 {
     if (!d->model->tagNamesList().contains(newName)) {
         QList<KoResource*> resources = d->model->currentlyVisibleResources();
 
         Q_FOREACH (KoResource * resource, resources) {
             removeResourceTag(resource, oldName);
             addResourceTag(resource, newName);
         }
         contextCreateNewTag(newName);
         d->model->tagCategoryRemoved(oldName);
         d->model->tagCategoryAdded(newName);
     }
 }
 
 void KoResourceTaggingManager::updateTaggedResourceView()
 {
     d->model->setCurrentTag(d->currentTag);
     d->model->updateServer();
     d->originalResources = d->model->currentlyVisibleResources();
     emit updateView();
 }
 
 void KoResourceTaggingManager::tagChooserIndexChanged(const QString& lineEditText)
 {
     if (!d->tagChooser->selectedTagIsReadOnly()) {
         d->currentTag = lineEditText;
         d->tagFilter->allowSave(true);
         d->model->enableResourceFiltering(true);
     } else {
         d->model->enableResourceFiltering(false);
         d->tagFilter->allowSave(false);
         d->currentTag.clear();
     }
 
     d->tagFilter->clear();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::tagSearchLineEditTextChanged(const QString& lineEditText)
 {
     if (d->tagChooser->selectedTagIsReadOnly()) {
         d->model->enableResourceFiltering(!lineEditText.isEmpty());
     } else {
         d->model->enableResourceFiltering(true);
     }
 
     d->model->searchTextChanged(lineEditText);
     d->model->updateServer();
 
     ///FIXME: fix completer
     //     d->tagCompleter = new QCompleter(tagNamesList(lineEditText),this);
     //    d->tagSearchLineEdit->setCompleter(d->tagCompleter);
 
     emit updateView();
 }
 
 void KoResourceTaggingManager::tagSaveButtonPressed()
 {
     if (!d->tagChooser->selectedTagIsReadOnly()) {
         QList<KoResource*> newResources = d->model->currentlyVisibleResources();
         Q_FOREACH (KoResource * oldRes, d->originalResources) {
             if (!newResources.contains(oldRes))
                 removeResourceTag(oldRes, d->currentTag);
         }
         Q_FOREACH (KoResource * newRes, newResources) {
             if (!d->originalResources.contains(newRes))
                 addResourceTag(newRes, d->currentTag);
         }
         d->model->tagCategoryMembersChanged();
     }
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* resource, const QStringList& resourceTags, const QPoint& pos)
 {
     /* no visible tag chooser usually means no intended tag interaction,
      * context menu makes no sense then either */
     if (!resource || !d->tagChooser->isVisible())
         return;
 
     KoResourceItemChooserContextMenu menu(resource,
                                           resourceTags,
                                           d->tagChooser->currentlySelectedTag(),
                                           d->tagChooser->allTags());
 
-    connect(&menu, SIGNAL(resourceTagAdditionRequested(KoResource*, QString)),
-            this, SLOT(contextAddTagToResource(KoResource*, QString)));
+    connect(&menu, SIGNAL(resourceTagAdditionRequested(KoResource*,QString)),
+            this, SLOT(contextAddTagToResource(KoResource*,QString)));
 
-    connect(&menu, SIGNAL(resourceTagRemovalRequested(KoResource*, QString)),
-            this, SLOT(contextRemoveTagFromResource(KoResource*, QString)));
+    connect(&menu, SIGNAL(resourceTagRemovalRequested(KoResource*,QString)),
+            this, SLOT(contextRemoveTagFromResource(KoResource*,QString)));
 
-    connect(&menu, SIGNAL(resourceAssignmentToNewTagRequested(KoResource*, QString)),
-            this, SLOT(contextCreateNewTag(KoResource*, QString)));
+    connect(&menu, SIGNAL(resourceAssignmentToNewTagRequested(KoResource*,QString)),
+            this, SLOT(contextCreateNewTag(KoResource*,QString)));
     menu.exec(pos);
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* currentResource, QPoint pos)
 {
     if (currentResource) {
         contextMenuRequested(currentResource, d->model->assignedTagsList(currentResource), pos);
     }
 }
 
 KoTagChooserWidget* KoResourceTaggingManager::tagChooserWidget()
 {
     return d->tagChooser;
 }
 
 KoTagFilterWidget* KoResourceTaggingManager::tagFilterWidget()
 {
     return d->tagFilter;
 }
 
diff --git a/libs/widgets/KoShadowConfigWidget.cpp b/libs/widgets/KoShadowConfigWidget.cpp
index 6e4a44d163..86bf872891 100644
--- a/libs/widgets/KoShadowConfigWidget.cpp
+++ b/libs/widgets/KoShadowConfigWidget.cpp
@@ -1,241 +1,241 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2008 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 "KoShadowConfigWidget.h"
 #include "ui_KoShadowConfigWidget.h"
 
 #include <KoIcon.h>
 #include <KoUnit.h>
 #include <KoColorPopupAction.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasResourceManager.h>
 #include <KoSelection.h>
 #include <KoShapeShadow.h>
 #include <KoShapeShadowCommand.h>
 #include <KoSelectedShapesProxy.h>
 
 #include <klocalizedstring.h>
 
 #include <QCheckBox>
 
 #include <math.h>
 
 class Q_DECL_HIDDEN KoShadowConfigWidget::Private
 {
 public:
     Private()
     {
     }
     Ui_KoShadowConfigWidget widget;
     KoColorPopupAction *actionShadowColor;
     KoCanvasBase *canvas;
 };
 
 KoShadowConfigWidget::KoShadowConfigWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private())
 {
     d->widget.setupUi(this);
     d->widget.shadowOffset->setValue(8.0);
     d->widget.shadowBlur->setValue(8.0);
     d->widget.shadowBlur->setMinimum(0.0);
     d->widget.shadowAngle->setValue(315.0);
     d->widget.shadowAngle->setMinimum(0.0);
     d->widget.shadowAngle->setMaximum(360.0);
     d->widget.shadowVisible->setChecked(false);
     visibilityChanged();
 
     d->actionShadowColor = new KoColorPopupAction(this);
     d->actionShadowColor->setCurrentColor(QColor(0, 0, 0, 192)); // some reasonable default for shadow
     d->actionShadowColor->setIcon(koIcon("format-stroke-color"));
     d->actionShadowColor->setToolTip(i18n("Change the color of the shadow"));
     d->widget.shadowColor->setDefaultAction(d->actionShadowColor);
 
     connect(d->widget.shadowVisible, SIGNAL(toggled(bool)), this, SLOT(applyChanges()));
     connect(d->widget.shadowVisible, SIGNAL(toggled(bool)), this, SLOT(visibilityChanged()));
-    connect(d->actionShadowColor, SIGNAL(colorChanged(const KoColor&)), this, SLOT(applyChanges()));
+    connect(d->actionShadowColor, SIGNAL(colorChanged(KoColor)), this, SLOT(applyChanges()));
     connect(d->widget.shadowAngle, SIGNAL(valueChanged(int)), this, SLOT(applyChanges()));
     connect(d->widget.shadowOffset, SIGNAL(valueChangedPt(qreal)), this, SLOT(applyChanges()));
     connect(d->widget.shadowBlur, SIGNAL(valueChangedPt(qreal)), this, SLOT(applyChanges()));
 }
 
 KoShadowConfigWidget::~KoShadowConfigWidget()
 {
     delete d;
 }
 
 void KoShadowConfigWidget::setShadowColor(const QColor &color)
 {
     d->widget.shadowColor->blockSignals(true);
     d->actionShadowColor->blockSignals(true);
 
     d->actionShadowColor->setCurrentColor( color );
 
     d->actionShadowColor->blockSignals(false);
     d->widget.shadowColor->blockSignals(false);
 }
 
 QColor KoShadowConfigWidget::shadowColor() const
 {
     return d->actionShadowColor->currentColor();
 }
 
 void KoShadowConfigWidget::setShadowOffset(const QPointF &offset)
 {
     qreal length = sqrt(offset.x()*offset.x() + offset.y()*offset.y());
     qreal angle = atan2(-offset.y(), offset.x());
     if (angle < 0.0) {
         angle += 2*M_PI;
     }
 
     d->widget.shadowAngle->blockSignals(true);
     d->widget.shadowAngle->setValue(-90 - angle * 180.0 / M_PI);
     d->widget.shadowAngle->blockSignals(false);
 
     d->widget.shadowOffset->blockSignals(true);
     d->widget.shadowOffset->changeValue(length);
     d->widget.shadowOffset->blockSignals(false);
 }
 
 QPointF KoShadowConfigWidget::shadowOffset() const
 {
     QPointF offset(d->widget.shadowOffset->value(), 0);
     QTransform m;
     m.rotate(d->widget.shadowAngle->value() + 90);
     return m.map(offset);
 }
 
 void KoShadowConfigWidget::setShadowBlur(const qreal &blur)
 {
     d->widget.shadowBlur->blockSignals(true);
     d->widget.shadowBlur->changeValue(blur);
     d->widget.shadowBlur->blockSignals(false);
 }
 
 qreal KoShadowConfigWidget::shadowBlur() const
 {
     return d->widget.shadowBlur->value();
 }
 
 void KoShadowConfigWidget::setShadowVisible(bool visible)
 {
     d->widget.shadowVisible->blockSignals(true);
     d->widget.shadowVisible->setChecked(visible);
     d->widget.shadowVisible->blockSignals(false);
     visibilityChanged();
 }
 
 bool KoShadowConfigWidget::shadowVisible() const
 {
     return d->widget.shadowVisible->isChecked();
 }
 
 void KoShadowConfigWidget::visibilityChanged()
 {
     d->widget.shadowAngle->setEnabled( d->widget.shadowVisible->isChecked() );
     d->widget.shadowBlur->setEnabled( d->widget.shadowVisible->isChecked() );
     d->widget.shadowColor->setEnabled( d->widget.shadowVisible->isChecked() );
     d->widget.shadowOffset->setEnabled( d->widget.shadowVisible->isChecked() );
 }
 
 void KoShadowConfigWidget::applyChanges()
 {
     if (d->canvas) {
         KoSelection *selection = d->canvas->selectedShapesProxy()->selection();
         KoShape * shape = selection->firstSelectedShape();
         if (! shape) {
             return;
         }
 
         KoShapeShadow *newShadow = new KoShapeShadow();
         newShadow->setVisible(shadowVisible());
         newShadow->setColor(shadowColor());
         newShadow->setOffset(shadowOffset());
         newShadow->setBlur(shadowBlur());
         d->canvas->addCommand(new KoShapeShadowCommand(selection->selectedShapes(), newShadow));
     }
 }
 
 void KoShadowConfigWidget::selectionChanged()
 {
     if (! d->canvas) {
         return;
     }
 
     KoSelection *selection = d->canvas->selectedShapesProxy()->selection();
     KoShape * shape = selection->firstSelectedShape();
 
     setEnabled(shape != 0);
 
     if (! shape) {
         setShadowVisible(false);
         return;
     }
 
     KoShapeShadow * shadow = shape->shadow();
     if (! shadow) {
         setShadowVisible(false);
         return;
     }
 
     setShadowVisible(shadow->isVisible());
     setShadowOffset(shadow->offset());
     setShadowColor(shadow->color());
     setShadowBlur(shadow->blur());
 }
 
 void KoShadowConfigWidget::setCanvas(KoCanvasBase *canvas)
 {
     d->canvas = canvas;
     connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
     connect(canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()), this, SLOT(selectionChanged()));
 
     setUnit(canvas->unit());
 
-    connect( d->canvas->resourceManager(), SIGNAL( canvasResourceChanged( int, const QVariant& ) ),
-             this, SLOT( resourceChanged( int, const QVariant& ) ) );
+    connect( d->canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+             this, SLOT(resourceChanged(int,QVariant)) );
 }
 
 void KoShadowConfigWidget::setUnitManagers(KisSpinBoxUnitManager* managerBlur, KisSpinBoxUnitManager *managerOffset)
 {
     d->widget.shadowOffset->blockSignals(true);
     d->widget.shadowBlur->blockSignals(true);
     d->widget.shadowOffset->setUnitManager(managerOffset);
     d->widget.shadowBlur->setUnitManager(managerBlur);
     d->widget.shadowOffset->blockSignals(false);
     d->widget.shadowBlur->blockSignals(false);
 }
 
 void KoShadowConfigWidget::setUnit(const KoUnit &unit)
 {
     d->widget.shadowOffset->blockSignals(true);
     d->widget.shadowBlur->blockSignals(true);
     d->widget.shadowOffset->setUnit(unit);
     d->widget.shadowBlur->setUnit(unit);
     d->widget.shadowOffset->blockSignals(false);
     d->widget.shadowBlur->blockSignals(false);
 }
 
 void KoShadowConfigWidget::resourceChanged( int key, const QVariant & res )
 {
     if( key == KoCanvasResourceManager::Unit ) {
         setUnit(res.value<KoUnit>());
     }
 }
diff --git a/libs/widgets/KoStrokeConfigWidget.cpp b/libs/widgets/KoStrokeConfigWidget.cpp
index 85f42014ba..ad88bb25d6 100644
--- a/libs/widgets/KoStrokeConfigWidget.cpp
+++ b/libs/widgets/KoStrokeConfigWidget.cpp
@@ -1,571 +1,571 @@
 /* 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 <QLabel>
 #include <QToolButton>
 #include <QButtonGroup>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QSizePolicy>
 
 // 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 <KoToolManager.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoShapeStrokeCommand.h>
 #include <KoShapeStrokeModel.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->setToolTip(i18n("Miter limit"));
     miterLimit->setUnitChangeFromOutsideBehavior(false);
     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)
     {
     }
 
     KoLineStyleSelector *lineStyle;
     KisDoubleParseUnitSpinBox *lineWidth;
     KoMarkerSelector    *startMarkerSelector;
     KoMarkerSelector    *endMarkerSelector;
 
     CapNJoinMenu *capNJoinMenu;
     QToolButton *colorButton;
     KoColorPopupAction *colorAction;
 
     QWidget *spacer;
 
     KoCanvasBase *canvas;
 
     bool active;
     bool allowLocalUnitManagement;
 };
 
 KoStrokeConfigWidget::KoStrokeConfigWidget(QWidget * parent)
     : QWidget(parent)
     , d(new Private())
 {
     setObjectName("Stroke widget");
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->setMargin(0);
 
     QHBoxLayout *firstLineLayout = new QHBoxLayout();
 
     // Start marker
     QList<KoMarker*> markers;
 
     d->startMarkerSelector = new KoMarkerSelector(KoMarkerData::MarkerStart, this);
     d->startMarkerSelector->updateMarkers(markers);
     d->startMarkerSelector->setMaximumWidth(50);
     firstLineLayout->addWidget(d->startMarkerSelector);
 
     // Line style
     d->lineStyle = new KoLineStyleSelector(this);
     d->lineStyle->setMinimumWidth(70);
     firstLineLayout->addWidget(d->lineStyle);
 
     // End marker
     d->endMarkerSelector = new KoMarkerSelector(KoMarkerData::MarkerEnd, this);
     d->endMarkerSelector->updateMarkers(markers);
     d->endMarkerSelector->setMaximumWidth(50);
     firstLineLayout->addWidget(d->endMarkerSelector);
 
     QHBoxLayout *secondLineLayout = new QHBoxLayout();
 
     // Line width
     QLabel *l = new QLabel(this);
     l->setText(i18n("Thickness:"));
     l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     l->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     secondLineLayout->addWidget(l);
 
     // set min/max/step and value in points, then set actual unit
     d->lineWidth = new KisDoubleParseUnitSpinBox(this);
     d->lineWidth->setMinMaxStep(0.0, 1000.0, 0.5);
     d->lineWidth->setDecimals(2);
     d->lineWidth->setUnitChangeFromOutsideBehavior(false);
     d->lineWidth->setToolTip(i18n("Set line width of actual selection"));
     secondLineLayout->addWidget(d->lineWidth);
 
     QToolButton *capNJoinButton = new QToolButton(this);
     capNJoinButton->setMinimumHeight(25);
     d->capNJoinMenu = new CapNJoinMenu(this);
     capNJoinButton->setMenu(d->capNJoinMenu);
     capNJoinButton->setText("...");
     capNJoinButton->setPopupMode(QToolButton::InstantPopup);
 
     secondLineLayout->addWidget(capNJoinButton);
 
     d->colorButton = new QToolButton(this);
     secondLineLayout->addWidget(d->colorButton);
     d->colorAction = new KoColorPopupAction(this);
     d->colorAction->setIcon(koIcon("format-stroke-color"));
     d->colorAction->setToolTip(i18n("Change the color of the line/border"));
     d->colorButton->setDefaultAction(d->colorAction);
 
     mainLayout->addLayout(firstLineLayout);
     mainLayout->addLayout(secondLineLayout);
 
     // Spacer
     d->spacer = new QWidget();
     d->spacer->setObjectName("SpecialSpacer");
     mainLayout->addWidget(d->spacer);
 
 
     // set sensitive defaults
     d->lineStyle->setLineStyle(Qt::SolidLine);
     d->lineWidth->changeValue(1);
     d->colorAction->setCurrentColor(Qt::black);
 
     // Make the signals visible on the outside of this widget.
     connect(d->lineStyle,  SIGNAL(currentIndexChanged(int)), this, SLOT(applyChanges()));
     connect(d->lineWidth,  SIGNAL(valueChangedPt(qreal)),    this, SLOT(applyChanges()));
-    connect(d->colorAction, SIGNAL(colorChanged(const KoColor &)), this, SLOT(applyChanges()));
+    connect(d->colorAction, SIGNAL(colorChanged(KoColor)), this, SLOT(applyChanges()));
     connect(d->capNJoinMenu->capGroup,   SIGNAL(buttonClicked(int)),       this, SLOT(applyChanges()));
     connect(d->capNJoinMenu->joinGroup,  SIGNAL(buttonClicked(int)),       this, SLOT(applyChanges()));
     connect(d->capNJoinMenu->miterLimit, SIGNAL(valueChangedPt(qreal)),    this, SLOT(applyChanges()));
     connect(d->startMarkerSelector,  SIGNAL(currentIndexChanged(int)), this, SLOT(startMarkerChanged()));
     connect(d->endMarkerSelector,  SIGNAL(currentIndexChanged(int)), this, SLOT(endMarkerChanged()));
 }
 
 KoStrokeConfigWidget::~KoStrokeConfigWidget()
 {
     delete d;
 }
 
 // ----------------------------------------------------------------
 //                         getters and setters
 
 
 Qt::PenStyle KoStrokeConfigWidget::lineStyle() const
 {
     return d->lineStyle->lineStyle();
 }
 
 QVector<qreal> KoStrokeConfigWidget::lineDashes() const
 {
     return d->lineStyle->lineDashes();
 }
 
 qreal KoStrokeConfigWidget::lineWidth() const
 {
     return d->lineWidth->value();
 }
 
 QColor KoStrokeConfigWidget::color() const
 {
     return d->colorAction->currentColor();
 }
 
 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());
 }
 
 KoShapeStroke* KoStrokeConfigWidget::createShapeStroke() const
 {
     KoShapeStroke *stroke = new KoShapeStroke();
 
     stroke->setColor(color());
     stroke->setLineWidth(lineWidth());
     stroke->setCapStyle(capStyle());
     stroke->setJoinStyle(joinStyle());
     stroke->setMiterLimit(miterLimit());
     stroke->setLineStyle(lineStyle(), lineDashes());
 
     return stroke;
 }
 
 // ----------------------------------------------------------------
 //                         Other public functions
 
 void KoStrokeConfigWidget::updateControls(KoShapeStrokeModel *stroke, KoMarker *startMarker, KoMarker *endMarker)
 {
     blockChildSignals(true);
 
     const KoShapeStroke *lineStroke = dynamic_cast<const KoShapeStroke*>(stroke);
     if (lineStroke) {
         d->lineWidth->changeValue(lineStroke->lineWidth());
         QAbstractButton *button = d->capNJoinMenu->capGroup->button(lineStroke->capStyle());
         if (button) {
             button->setChecked(true);
         }
         button = d->capNJoinMenu->joinGroup->button(lineStroke->joinStyle());
         if (button) {
             button->setChecked(true);
         }
         d->capNJoinMenu->miterLimit->changeValue(lineStroke->miterLimit());
         d->capNJoinMenu->miterLimit->setEnabled(lineStroke->joinStyle() == Qt::MiterJoin);
         d->lineStyle->setLineStyle(lineStroke->lineStyle(), lineStroke->lineDashes());
         d->colorAction->setCurrentColor(lineStroke->color());
     }
     else {
         d->lineWidth->changeValue(0.0);
         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);
         d->lineStyle->setLineStyle(Qt::NoPen, QVector<qreal>());
     }
 
     d->startMarkerSelector->setMarker(startMarker);
     d->endMarkerSelector->setMarker(endMarker);
 
     blockChildSignals(false);
 }
 
 void KoStrokeConfigWidget::setUnit(const KoUnit &unit)
 {
     if (!d->allowLocalUnitManagement) {
         return; //the unit management is completely transferred to the unitManagers.
     }
 
     blockChildSignals(true);
 
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
     KoShape * shape = selection->firstSelectedShape();
 
     /**
      * 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 (shape) {
         newUnit.adjustByPixelTransform(shape->absoluteTransformation(0));
     }
 
     d->lineWidth->setUnit(newUnit);
     d->capNJoinMenu->miterLimit->setUnit(newUnit);
 
     blockChildSignals(false);
 }
 
 void KoStrokeConfigWidget::updateMarkers(const QList<KoMarker*> &markers)
 {
     d->startMarkerSelector->updateMarkers(markers);
     d->endMarkerSelector->updateMarkers(markers);
 }
 
 void KoStrokeConfigWidget::blockChildSignals(bool block)
 {
     d->colorAction->blockSignals(block);
     d->lineWidth->blockSignals(block);
     d->capNJoinMenu->capGroup->blockSignals(block);
     d->capNJoinMenu->joinGroup->blockSignals(block);
     d->capNJoinMenu->miterLimit->blockSignals(block);
     d->lineStyle->blockSignals(block);
     d->startMarkerSelector->blockSignals(block);
     d->endMarkerSelector->blockSignals(block);
 }
 
 void KoStrokeConfigWidget::setActive(bool active)
 {
     d->active = active;
 }
 
 void KoStrokeConfigWidget::setUnitManagers(KisSpinBoxUnitManager* managerLineWidth,
                                            KisSpinBoxUnitManager *managerMitterLimit)
 {
     blockChildSignals(true);
 
     d->allowLocalUnitManagement = false;
 
     d->lineWidth->setUnitManager(managerLineWidth);
     d->capNJoinMenu->miterLimit->setUnitManager(managerMitterLimit);
 
     blockChildSignals(false);
 }
 
 //------------------------
 void KoStrokeConfigWidget::applyChanges()
 {
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
 
     //FIXME d->canvas->resourceManager()->setActiveStroke( d->stroke );
 
     if (!selection || !selection->count()) {
         return;
     }
 
     KoShapeStroke *newStroke = new KoShapeStroke();
     KoShapeStroke *oldStroke = dynamic_cast<KoShapeStroke*>( selection->firstSelectedShape()->stroke() );
     if (oldStroke) {
         newStroke->setLineBrush(oldStroke->lineBrush());
     }
     newStroke->setColor(color());
     newStroke->setLineWidth(lineWidth());
     newStroke->setCapStyle(static_cast<Qt::PenCapStyle>(d->capNJoinMenu->capGroup->checkedId()));
     newStroke->setJoinStyle(static_cast<Qt::PenJoinStyle>(d->capNJoinMenu->joinGroup->checkedId()));
     newStroke->setMiterLimit(miterLimit());
     newStroke->setLineStyle(lineStyle(), lineDashes());
 
     if (d->active) {
         KoShapeStrokeCommand *cmd = new KoShapeStrokeCommand(selection->selectedShapes(), newStroke);
         canvasController->canvas()->addCommand(cmd);
     }
 }
 
 void KoStrokeConfigWidget::applyMarkerChanges(KoMarkerData::MarkerPosition position)
 {
     KoMarker *marker = 0;
     if (position == KoMarkerData::MarkerStart) {
         marker = startMarker();
     }
     else if (position == KoMarkerData::MarkerEnd) {
         marker = endMarker();
     }
 
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
 
     if (! selection || !selection->count()) {
         return;
     }
 
     QList<KoShape*> shapeList = selection->selectedShapes();
     QList<KoPathShape*> pathShapeList;
     for (QList<KoShape*>::iterator itShape = shapeList.begin(); itShape != shapeList.end(); ++itShape) {
         KoPathShape* pathShape = dynamic_cast<KoPathShape*>(*itShape);
         if (pathShape) {
             pathShapeList << pathShape;
         }
     }
 
     if (pathShapeList.size()) {
         KoPathShapeMarkerCommand* cmdMarker = new KoPathShapeMarkerCommand(pathShapeList, marker, position);
         canvasController->canvas()->addCommand(cmdMarker);
     }
 }
 
 void KoStrokeConfigWidget::startMarkerChanged()
 {
     applyMarkerChanges(KoMarkerData::MarkerStart);
 }
 
 void KoStrokeConfigWidget::endMarkerChanged()
 {
     applyMarkerChanges(KoMarkerData::MarkerEnd);
 }
 // ----------------------------------------------------------------
 
 
 
 void KoStrokeConfigWidget::selectionChanged()
 {
     // see a comment in setUnit()
     setUnit(d->canvas->unit());
 
 
     KoCanvasController* canvasController = KoToolManager::instance()->activeCanvasController();
     KoSelection *selection = canvasController->canvas()->shapeManager()->selection();
     KoShape * shape = selection->firstSelectedShape();
     if (shape && shape->stroke()) {
         KoPathShape *pathShape = dynamic_cast<KoPathShape *>(shape);
         if (pathShape) {
             updateControls(shape->stroke(), pathShape->marker(KoMarkerData::MarkerStart),
                            pathShape->marker(KoMarkerData::MarkerEnd));
         }
         else {
             updateControls(shape->stroke(), 0 ,0);
         }
     }
 }
 
 void KoStrokeConfigWidget::setCanvas( KoCanvasBase *canvas )
 {
     if (canvas) {
         connect(canvas->shapeManager()->selection(), SIGNAL(selectionChanged()),
                 this, SLOT(selectionChanged()));
         connect(canvas->shapeManager(), SIGNAL(selectionContentChanged()),
                 this, SLOT(selectionChanged()));
-        connect(canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
-                this, SLOT(canvasResourceChanged(int, const QVariant &)));
+        connect(canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+                this, SLOT(canvasResourceChanged(int,QVariant)));
         setUnit(canvas->unit());
 
         KoDocumentResourceManager *resourceManager = canvas->shapeController()->resourceManager();
         if (resourceManager) {
             KoMarkerCollection *collection = resourceManager->resource(KoDocumentResourceManager::MarkerCollection).value<KoMarkerCollection*>();
             if (collection) {
                 updateMarkers(collection->markers());
             }
         }
     }
 
     d->canvas = canvas;
 }
 
 void KoStrokeConfigWidget::canvasResourceChanged(int key, const QVariant &value)
 {
     switch (key) {
     case KoCanvasResourceManager::Unit:
         setUnit(value.value<KoUnit>());
         break;
     }
 }
diff --git a/libs/widgets/KoToolBox.cpp b/libs/widgets/KoToolBox.cpp
index 3bdac208fb..9b0c27b397 100644
--- a/libs/widgets/KoToolBox.cpp
+++ b/libs/widgets/KoToolBox.cpp
@@ -1,341 +1,341 @@
 /*
  * Copyright (c) 2005-2009 Thomas Zander <zander@kde.org>
  * Copyright (c) 2009 Peter Simonsson <peter.simonsson@gmail.com>
  * Copyright (c) 2010 Cyrille Berger <cberger@cberger.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 "KoToolBox_p.h"
 #include "KoToolBoxLayout_p.h"
 #include "KoToolBoxButton_p.h"
 
 #include <QButtonGroup>
 #include <QToolButton>
 #include <QStyleOptionFrameV3>
 #include <QPainter>
 #include <QHash>
 #include <QApplication>
 #include <QStyle>
 #include <QTimer>
 #include <QMenu>
 #include <QAction>
 
 #include <klocalizedstring.h>
 #include <WidgetsDebug.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <KoCanvasController.h>
 #include <KoShapeLayer.h>
 
 #define BUTTON_MARGIN 10
 
 static int buttonSize(int screen)
 {
     QRect rc = qApp->desktop()->screenGeometry(screen);
     if (rc.width() <= 1024) {
         return 12;
     }
     else if (rc.width() <= 1377) {
         return 14;
     }
     else  if (rc.width() <= 1920 ) {
         return 16;
     }
     else {
         return 22;
     }
 }
 
 class KoToolBox::Private
 {
 public:
     Private()
         : layout(0)
         , buttonGroup(0)
         , floating(false)
         , contextSize(0)
     {
     }
 
     void addSection(Section *section, const QString &name);
 
     QList<QToolButton*> buttons;
     QMap<QString, Section*> sections;
     KoToolBoxLayout *layout;
     QButtonGroup *buttonGroup;
     QHash<QToolButton*, QString> visibilityCodes;
     bool floating;
     QMap<QAction*,int> contextIconSizes;
     QMenu* contextSize;
     Qt::Orientation orientation;
 };
 
 void KoToolBox::Private::addSection(Section *section, const QString &name)
 {
     section->setName(name);
     layout->addSection(section);
     sections.insert(name, section);
 }
 
 KoToolBox::KoToolBox()
     : d(new Private)
 {
     d->layout = new KoToolBoxLayout(this);
     // add defaults
     d->addSection(new Section(this), "main");
     d->addSection(new Section(this), "dynamic");
 
     d->buttonGroup = new QButtonGroup(this);
     setLayout(d->layout);
     Q_FOREACH (KoToolAction *toolAction, KoToolManager::instance()->toolActionList()) {
         addButton(toolAction);
     }
 
     // Update visibility of buttons
     setButtonsVisible(QList<QString>());
 
-    connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*, int)),
-            this, SLOT(setActiveTool(KoCanvasController*, int)));
+    connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
+            this, SLOT(setActiveTool(KoCanvasController*,int)));
     connect(KoToolManager::instance(), SIGNAL(currentLayerChanged(const KoCanvasController*,const KoShapeLayer*)),
             this, SLOT(setCurrentLayer(const KoCanvasController*,const KoShapeLayer*)));
     connect(KoToolManager::instance(), SIGNAL(toolCodesSelected(QList<QString>)), this, SLOT(setButtonsVisible(QList<QString>)));
     connect(KoToolManager::instance(),
             SIGNAL(addedTool(KoToolAction*,KoCanvasController*)),
             this, SLOT(toolAdded(KoToolAction*,KoCanvasController*)));
 
 }
 
 KoToolBox::~KoToolBox()
 {
     delete d;
 }
 
 void KoToolBox::addButton(KoToolAction *toolAction)
 {
     KoToolBoxButton *button = new KoToolBoxButton(toolAction, this);
 
     d->buttons << button;
 
     int toolbuttonSize = buttonSize(qApp->desktop()->screenNumber(this));
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("KoToolBox");
     int iconSize = cfg.readEntry("iconSize", toolbuttonSize);
 
    button->setIconSize(QSize(iconSize, iconSize));
     foreach (Section *section, d->sections.values())  {
         section->setButtonSize(QSize(iconSize + BUTTON_MARGIN, iconSize + BUTTON_MARGIN));
     }
 
     QString sectionToBeAddedTo;
     const QString section = toolAction->section();
     if (section.contains(qApp->applicationName())) {
         sectionToBeAddedTo = "main";
     } else if (section.contains("main")) {
         sectionToBeAddedTo = "main";
     }  else if (section.contains("dynamic")) {
         sectionToBeAddedTo = "dynamic";
     } else {
         sectionToBeAddedTo = section;
     }
 
     Section *sectionWidget = d->sections.value(sectionToBeAddedTo);
     if (sectionWidget == 0) {
         sectionWidget = new Section(this);
         d->addSection(sectionWidget, sectionToBeAddedTo);
     }
     sectionWidget->addButton(button, toolAction->priority());
 
     d->buttonGroup->addButton(button, toolAction->buttonGroupId());
 
     d->visibilityCodes.insert(button, toolAction->visibilityCode());
 }
 
 void KoToolBox::setActiveTool(KoCanvasController *canvas, int id)
 {
     Q_UNUSED(canvas);
 
     QAbstractButton *button = d->buttonGroup->button(id);
     if (button) {
         button->setChecked(true);
         (qobject_cast<KoToolBoxButton*>(button))->setHighlightColor();
     }
     else {
         warnWidgets << "KoToolBox::setActiveTool(" << id << "): no such button found";
     }
 }
 
 void KoToolBox::setButtonsVisible(const QList<QString> &codes)
 {
     Q_FOREACH (QToolButton *button, d->visibilityCodes.keys()) {
         QString code = d->visibilityCodes.value(button);
 
         if (code.startsWith(QLatin1String("flake/"))) {
             continue;
         }
 
         if (code.endsWith( QLatin1String( "/always"))) {
             button->setVisible(true);
             button->setEnabled(true);
         }
         else if (code.isEmpty()) {
             button->setVisible(true);
             button->setEnabled( codes.count() != 0 );
         }
         else {
             button->setVisible( codes.contains(code) );
         }
     }
     layout()->invalidate();
     update();
 }
 
 void KoToolBox::setCurrentLayer(const KoCanvasController *canvas, const KoShapeLayer *layer)
 {
     Q_UNUSED(canvas);
     const bool enabled = layer == 0 || (layer->isShapeEditable() && layer->isVisible());
     foreach (QToolButton *button, d->visibilityCodes.keys()) {
         if (d->visibilityCodes[button].endsWith( QLatin1String( "/always") ) ) {
             continue;
         }
         button->setEnabled(enabled);
     }
 }
 
 void KoToolBox::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
 
     const QList<Section*> sections = d->sections.values();
     QList<Section*>::const_iterator iterator = sections.begin();
     int halfSpacing = layout()->spacing();
     if (halfSpacing > 0) {
         halfSpacing /= 2;
     }
     while(iterator != sections.end()) {
         Section *section = *iterator;
         QStyleOption styleoption;
         styleoption.palette = palette();
 
         if (section->separators() & Section::SeparatorTop) {
             int y = section->y() - halfSpacing;
             styleoption.state = QStyle::State_None;
             styleoption.rect = QRect(section->x(), y-1, section->width(), 2);
 
             style()->drawPrimitive(QStyle::PE_IndicatorToolBarSeparator, &styleoption, &painter);
         }
 
         if (section->separators() & Section::SeparatorLeft) {
             int x = section->x() - halfSpacing;
             styleoption.state = QStyle::State_Horizontal;
             styleoption.rect = QRect(x-1, section->y(), 2, section->height());
 
             style()->drawPrimitive(QStyle::PE_IndicatorToolBarSeparator, &styleoption, &painter);
         }
 
         ++iterator;
     }
 
     painter.end();
 }
 
 void KoToolBox::setOrientation(Qt::Orientation orientation)
 {
     d->orientation = orientation;
     d->layout->setOrientation(orientation);
     QTimer::singleShot(0, this, SLOT(update()));
     Q_FOREACH (Section* section, d->sections) {
         section->setOrientation(orientation);
     }
 }
 
 void KoToolBox::setFloating(bool v)
 {
     d->floating = v;
 }
 
 void KoToolBox::toolAdded(KoToolAction *toolAction, KoCanvasController *canvas)
 {
     Q_UNUSED(canvas);
     addButton(toolAction);
     setButtonsVisible(QList<QString>());
 
 }
 
 void KoToolBox::slotContextIconSize()
 {
     QAction* action = qobject_cast<QAction*>(sender());
     if (action && d->contextIconSizes.contains(action)) {
         const int iconSize = d->contextIconSizes.value(action);
 
         KConfigGroup cfg =  KSharedConfig::openConfig()->group("KoToolBox");
         cfg.writeEntry("iconSize", iconSize);
 
         Q_FOREACH (QToolButton *button, d->buttons) {
             button->setIconSize(QSize(iconSize, iconSize));
         }
 
         Q_FOREACH (Section *section, d->sections.values())  {
             section->setButtonSize(QSize(iconSize + BUTTON_MARGIN, iconSize + BUTTON_MARGIN));
         }
 
     }
 }
 
 void KoToolBox::contextMenuEvent(QContextMenuEvent *event)
 {
 
     int toolbuttonSize = buttonSize(qApp->desktop()->screenNumber(this));
 
     if (!d->contextSize) {
 
         d->contextSize = new QMenu(i18n("Icon Size"), this);
         d->contextIconSizes.insert(d->contextSize->addAction(i18nc("@item:inmenu Icon size", "Default"),
                                                           this, SLOT(slotContextIconSize())),
                                    toolbuttonSize);
 
         QList<int> sizes;
         sizes << 12 << 14 << 16 << 22 << 32 << 48 << 64; //<< 96 << 128 << 192 << 256;
         Q_FOREACH (int i, sizes) {
             d->contextIconSizes.insert(d->contextSize->addAction(i18n("%1x%2", i, i), this, SLOT(slotContextIconSize())), i);
         }
 
         QActionGroup *sizeGroup = new QActionGroup(d->contextSize);
         foreach (QAction *action, d->contextSize->actions()) {
             action->setActionGroup(sizeGroup);
             action->setCheckable(true);
         }
     }
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("KoToolBox");
     toolbuttonSize = cfg.readEntry("iconSize", toolbuttonSize);
 
     QMapIterator< QAction*, int > it = d->contextIconSizes;
     while (it.hasNext()) {
         it.next();
         if (it.value() == toolbuttonSize) {
             it.key()->setChecked(true);
             break;
         }
     }
 
     d->contextSize->exec(event->globalPos());
 }
 KoToolBoxLayout *KoToolBox::toolBoxLayout() const
 {
     return d->layout;
 }
 
 #include "moc_KoToolBoxScrollArea_p.cpp"
diff --git a/libs/widgets/KoToolDocker.cpp b/libs/widgets/KoToolDocker.cpp
index da7c01cf91..8330215f18 100644
--- a/libs/widgets/KoToolDocker.cpp
+++ b/libs/widgets/KoToolDocker.cpp
@@ -1,220 +1,220 @@
 /* This file is part of the KDE project
  *
  * Copyright (c) 2010-2011 C. Boemann <cbo@boemann.dk>
  * Copyright (c) 2005-2006 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (c) 2006 Thomas Zander <zander@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 "KoToolDocker.h"
 
 #include <KoIcon.h>
 
 #include <klocalizedstring.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <QIcon>
 #include <QApplication>
 #include <QPointer>
 #include <QGridLayout>
 #include <QScrollArea>
 #include <QScrollBar>
 #include <QLabel>
 #include <QSet>
 #include <QAction>
 #include <QStyleOptionFrame>
 #include <QToolButton>
 
 #include <WidgetsDebug.h>
 #include <kis_debug.h>
 
 class Q_DECL_HIDDEN KoToolDocker::Private
 {
 public:
     Private(KoToolDocker *dock)
         : q(dock)
     {
     }
 
     QList<QPointer<QWidget> > currentWidgetList;
     QSet<QWidget *> currentAuxWidgets;
     QScrollArea *scrollArea;
     QWidget *hiderWidget; // non current widgets are hidden by being children of this
     QWidget *housekeeperWidget;
     QGridLayout *housekeeperLayout;
     KoToolDocker *q;
     Qt::DockWidgetArea dockingArea;
 
     void resetWidgets()
     {
         currentWidgetList.clear();
         qDeleteAll(currentAuxWidgets);
         currentAuxWidgets.clear();
     }
 
     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;
             switch(dockingArea) {
             case Qt::TopDockWidgetArea:
             case Qt::BottomDockWidgetArea:
                 housekeeperLayout->setHorizontalSpacing(2);
                 housekeeperLayout->setVerticalSpacing(0);
                 Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
                     if (widget.isNull() || widget->objectName().isEmpty()) {
                         continue;
                     }
                     if (!widget->windowTitle().isEmpty()) {
                         housekeeperLayout->addWidget(l = new QLabel(widget->windowTitle()), 0, 2*cnt);
                         currentAuxWidgets.insert(l);
                     }
                     housekeeperLayout->addWidget(widget, 1, 2*cnt);
                     widget->show();
                     if (widget != currentWidgetList.last()) {
                         housekeeperLayout->addWidget(s = new QFrame(), 0, 2*cnt+1, 2, 1);
                         s->setFrameShape(QFrame::VLine);
                         currentAuxWidgets.insert(s);
                     }
                     cnt++;
                 }
                 break;
             case Qt::LeftDockWidgetArea:
             case Qt::RightDockWidgetArea: {
                 housekeeperLayout->setHorizontalSpacing(0);
                 housekeeperLayout->setVerticalSpacing(2);
                 int specialCount = 0;
                 Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
                     if (widget.isNull() || widget->objectName().isEmpty()) {
                         continue;
                     }
                     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);
                 }
                 break;
             }
             default:
                 break;
             }
 
         housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
         housekeeperLayout->invalidate();
     }
 
     void locationChanged(Qt::DockWidgetArea area)
     {
         dockingArea = area;
         recreateLayout(currentWidgetList);
     }
 
 };
 
 KoToolDocker::KoToolDocker(QWidget *parent)
     : QDockWidget(i18n("Tool Options"), parent),
       d(new Private(this))
 {
     setFeatures(DockWidgetMovable|DockWidgetFloatable);
 
-    connect(this, SIGNAL(dockLocationChanged(Qt::DockWidgetArea )), this, SLOT(locationChanged(Qt::DockWidgetArea)));
+    connect(this, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(locationChanged(Qt::DockWidgetArea)));
 
     d->housekeeperWidget = new QWidget();
     d->housekeeperLayout = new QGridLayout();
     d->housekeeperLayout->setContentsMargins(4,4,4,0);
     d->housekeeperWidget->setLayout(d->housekeeperLayout);
 
     d->housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
 
     d->hiderWidget = new QWidget(d->housekeeperWidget);
     d->hiderWidget->setVisible(false);
 
     d->scrollArea = new QScrollArea();
     d->scrollArea->setWidget(d->housekeeperWidget);
     d->scrollArea->setFrameShape(QFrame::NoFrame);
     d->scrollArea->setWidgetResizable(true);
     d->scrollArea->setFocusPolicy(Qt::NoFocus);
 
     setWidget(d->scrollArea);
 }
 
 KoToolDocker::~KoToolDocker()
 {
     delete d;
 }
 
 bool KoToolDocker::hasOptionWidget()
 {
     return !d->currentWidgetList.isEmpty();
 }
 
 void KoToolDocker::setOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     d->recreateLayout(optionWidgetList);
 }
 
 void KoToolDocker::resetWidgets()
 {
     d->resetWidgets();
 }
 
 
 void KoToolDocker::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
 }
 
 void KoToolDocker::unsetCanvas()
 {
     setEnabled(false);
 }
 
 //have to include this because of Q_PRIVATE_SLOT
 #include <moc_KoToolDocker.cpp>
diff --git a/libs/widgets/KoUnitDoubleSpinBox.cpp b/libs/widgets/KoUnitDoubleSpinBox.cpp
index 3681f65ad6..465e50002f 100644
--- a/libs/widgets/KoUnitDoubleSpinBox.cpp
+++ b/libs/widgets/KoUnitDoubleSpinBox.cpp
@@ -1,221 +1,221 @@
 /* This file is part of the KDE project
    Copyright (C) 2002, Rob Buis(buis@kde.org)
    Copyright (C) 2004, Nicolas GOUTTE <goutte@kde.org>
    Copyright (C) 2007, Thomas Zander <zander@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 "KoUnitDoubleSpinBox.h"
 
 #include <KoUnit.h>
 
 #include <WidgetsDebug.h>
 
 #include <klocalizedstring.h>
 #include <qnumeric.h>
 
 // #define DEBUG_VALIDATOR
 // #define DEBUG_VALUEFROMTEXT
 
 class Q_DECL_HIDDEN KoUnitDoubleSpinBox::Private
 {
 public:
     Private(double low, double up, double step)
         : lowerInPoints(low),
         upperInPoints(up),
         stepInPoints(step),
         unit(KoUnit(KoUnit::Point))
     {
     }
 
     double lowerInPoints; ///< lowest value in points
     double upperInPoints; ///< highest value in points
     double stepInPoints;  ///< step in points
     KoUnit unit;
 };
 
 KoUnitDoubleSpinBox::KoUnitDoubleSpinBox( QWidget *parent)
     : QDoubleSpinBox( parent ),
     d( new Private(-9999, 9999, 1))
 {
     QDoubleSpinBox::setDecimals( 2 );
     //setAcceptLocalizedNumbers( true );
     setUnit( KoUnit(KoUnit::Point) );
     setAlignment( Qt::AlignRight );
 
-    connect(this, SIGNAL(valueChanged( double )), SLOT(privateValueChanged()));
+    connect(this, SIGNAL(valueChanged(double)), SLOT(privateValueChanged()));
 }
 
 KoUnitDoubleSpinBox::~KoUnitDoubleSpinBox()
 {
     delete d;
 }
 
 QValidator::State KoUnitDoubleSpinBox::validate(QString &input, int &pos) const
 {
 #ifdef DEBUG_VALIDATOR
     debugWidgets <<"KoUnitDoubleSpinBox::validate :" << input <<" at" << pos;
 #else
     Q_UNUSED(pos);
 #endif
 
     QRegExp regexp ("([ a-zA-Z]+)$"); // Letters or spaces at end
     const int res = input.indexOf( regexp );
 
     if ( res == -1 )
     {
         // Nothing like an unit? The user is probably editing the unit
 #ifdef DEBUG_VALIDATOR
         debugWidgets <<"Intermediate (no unit)";
 #endif
         return QValidator::Intermediate;
     }
 
     // ### TODO: are all the QString::trimmed really necessary?
     const QString number ( input.left( res ).trimmed() );
     const QString unitName ( regexp.cap( 1 ).trimmed().toLower() );
 
 #ifdef DEBUG_VALIDATOR
     debugWidgets <<"Split:" << number <<":" << unitName <<":";
 #endif
 
     const double value = valueFromText( number );
     double newVal = 0.0;
     if (!qIsNaN(value)) {
         bool ok;
         const KoUnit unit = KoUnit::fromSymbol(unitName, &ok);
         if ( ok )
             newVal = unit.fromUserValue( value );
         else
         {
             // Probably the user is trying to edit the unit
 #ifdef DEBUG_VALIDATOR
             debugWidgets <<"Intermediate (unknown unit)";
 #endif
             return QValidator::Intermediate;
         }
     }
     else
     {
         warnWidgets << "Not a number: " << number;
         return QValidator::Invalid;
     }
     newVal = KoUnit::ptToUnit( newVal, d->unit );
     //input = textFromValue( newVal ); // don't overwrite for now; the effect is not exactly what I expect...
 
     return QValidator::Acceptable;
 }
 
 void KoUnitDoubleSpinBox::changeValue( double val )
 {
     QDoubleSpinBox::setValue( d->unit.toUserValue( val ) );
     // TODO: emit valueChanged ONLY if the value was out-of-bounds
     // This will allow the 'user' dialog to set a dirty bool and ensure
     // a proper value is getting saved.
 }
 
 void KoUnitDoubleSpinBox::privateValueChanged() {
     emit valueChangedPt( value () );
 }
 
 void KoUnitDoubleSpinBox::setUnit( const KoUnit &unit )
 {
     if (unit == d->unit) return;
 
     double oldvalue = d->unit.fromUserValue( QDoubleSpinBox::value() );
     QDoubleSpinBox::setMinimum( unit.toUserValue( d->lowerInPoints ) );
     QDoubleSpinBox::setMaximum( unit.toUserValue( d->upperInPoints ) );
 
     qreal step = unit.toUserValue( d->stepInPoints );
 
     if (unit.type() == KoUnit::Pixel) {
         // limit the pixel step by 1.0
         step = qMax(qreal(1.0), step);
     }
 
     QDoubleSpinBox::setSingleStep( step );
     d->unit = unit;
     QDoubleSpinBox::setValue( KoUnit::ptToUnit( oldvalue, unit ) );
     setSuffix(unit.symbol().prepend(QLatin1Char(' ')));
 }
 
 double KoUnitDoubleSpinBox::value( ) const
 {
     return d->unit.fromUserValue( QDoubleSpinBox::value() );
 }
 
 void KoUnitDoubleSpinBox::setMinimum( double min )
 {
   d->lowerInPoints = min;
   QDoubleSpinBox::setMinimum( d->unit.toUserValue( min ) );
 }
 
 void KoUnitDoubleSpinBox::setMaximum( double max )
 {
   d->upperInPoints = max;
   QDoubleSpinBox::setMaximum( d->unit.toUserValue( max ) );
 }
 
 void KoUnitDoubleSpinBox::setLineStep( double step )
 {
   d->stepInPoints = KoUnit(KoUnit::Point).toUserValue(step);
   QDoubleSpinBox::setSingleStep( step );
 }
 
 void KoUnitDoubleSpinBox::setLineStepPt( double step )
 {
   d->stepInPoints = step;
   QDoubleSpinBox::setSingleStep( d->unit.toUserValue( step ) );
 }
 
 void KoUnitDoubleSpinBox::setMinMaxStep( double min, double max, double step )
 {
   setMinimum( min );
   setMaximum( max );
   setLineStepPt( step );
 }
 
 QString KoUnitDoubleSpinBox::textFromValue( double value ) const
 {
     //debugWidgets <<"textFromValue:" << QString::number( value, 'f', 12 ) <<" =>" << num;
     //const QString num(QString("%1%2").arg(QLocale().toString(value, d->precision ), m_unit.symbol()));
     //const QString num ( QString( "%1").arg( QLocale().toString( value, d->precision )) );
     return QLocale().toString( value, 'f', decimals() );
 }
 
 double KoUnitDoubleSpinBox::valueFromText( const QString& str ) const
 {
     QString str2( str );
     str2.remove(d->unit.symbol());
     return QLocale().toDouble(str2);
 //    QString str2( str );
 //    /* KLocale::readNumber wants the thousand separator exactly at 1000.
 //       But when editing, it might be anywhere. So we need to remove it. */
 //    const QString sep( KGlobal::locale()->thousandsSeparator() );
 //    if ( !sep.isEmpty() )
 //        str2.remove( sep );
 //    str2.remove(d->unit.symbol());
 //    bool ok;
 //    const double dbl = KGlobal::locale()->readNumber( str2, &ok );
 //#ifdef DEBUG_VALUEFROMTEXT
 //    if ( ok )
 //      debugWidgets <<"valueFromText:" << str <<": => :" << str2 <<": =>" << QString::number( dbl, 'f', 12 );
 //    else
 //        warnWidgets << "valueFromText error:" << str << ": => :" << str2 << ":";
 //#endif
 //    return dbl;
 }
diff --git a/libs/widgets/KoZoomAction.cpp b/libs/widgets/KoZoomAction.cpp
index 06588ef2f8..dda78eaea0 100644
--- a/libs/widgets/KoZoomAction.cpp
+++ b/libs/widgets/KoZoomAction.cpp
@@ -1,357 +1,357 @@
 /*  This file is part of the KDE libraries
     Copyright (C) 2004 Ariya Hidayat <ariya@kde.org>
     Copyright (C) 2006 Peter Simonsson <peter.simonsson@gmail.com>
     Copyright (C) 2006-2007 C. Boemann <cbo@boemann.dk>
 
     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 "KoZoomAction.h"
 #include "KoZoomMode.h"
 #include "KoZoomWidget.h"
 
 #include <KoIcon.h>
 
 #include <QString>
 #include <QLocale>
 #include <QStringList>
 #include <QRegExp>
 #include <QList>
 #include <QSlider>
 #include <QLineEdit>
 #include <QToolButton>
 #include <QLabel>
 #include <QGridLayout>
 #include <QMenu>
 #include <QStatusBar>
 #include <QButtonGroup>
 #include <QComboBox>
 
 
 #include <klocalizedstring.h>
 #include <WidgetsDebug.h>
 
 #include <math.h>
 
 class Q_DECL_HIDDEN KoZoomAction::Private
 {
 public:
 
     Private(KoZoomAction *_parent)
         : parent(_parent)
         , minimumZoomValue(-1)
         , maximumZoomValue(-1)
     {}
 
     KoZoomAction *parent;
 
     KoZoomMode::Modes zoomModes;
     QList<qreal> sliderLookup;
 
     qreal effectiveZoom;
 
     QList<qreal> generateSliderZoomLevels() const;
     QList<qreal> filterMenuZoomLevels(const QList<qreal> &zoomLevels) const;
 
     qreal minimumZoomValue;
     qreal maximumZoomValue;
 };
 
 QList<qreal> KoZoomAction::Private::generateSliderZoomLevels() const
 {
     QList<qreal> zoomLevels;
 
     qreal defaultZoomStep = sqrt(2.0);
 
     zoomLevels << 0.25 / 2.0;
     zoomLevels << 0.25 / 1.5;
     zoomLevels << 0.25;
     zoomLevels << 1.0 / 3.0;
     zoomLevels << 0.5;
     zoomLevels << 2.0 / 3.0;
     zoomLevels << 1.0;
 
     for (qreal zoom = zoomLevels.first() / defaultZoomStep;
          zoom > parent->minimumZoom();
          zoom /= defaultZoomStep) {
 
         zoomLevels.prepend(zoom);
     }
 
     for (qreal zoom = zoomLevels.last() * defaultZoomStep;
          zoom < parent->maximumZoom();
          zoom *= defaultZoomStep) {
 
         zoomLevels.append(zoom);
     }
 
     return zoomLevels;
 }
 
 QList<qreal> KoZoomAction::Private::filterMenuZoomLevels(const QList<qreal> &zoomLevels) const
 {
     QList<qreal> filteredZoomLevels;
 
     Q_FOREACH (qreal zoom, zoomLevels) {
         if (zoom >= 0.2 && zoom <= 10) {
             filteredZoomLevels << zoom;
         }
     }
 
     return filteredZoomLevels;
 }
 
 KoZoomAction::KoZoomAction(KoZoomMode::Modes zoomModes, const QString& text, QObject *parent)
     : KSelectAction(text, parent)
     , d(new Private(this))
 {
     d->zoomModes = zoomModes;
     setIcon(koIcon("zoom-original"));
     setEditable( true );
     setMaxComboViewCount( 15 );
 
     d->sliderLookup = d->generateSliderZoomLevels();
 
     d->effectiveZoom = 1.0;
     regenerateItems(d->effectiveZoom, true);
 
-    connect( this, SIGNAL( triggered( const QString& ) ), SLOT( triggered( const QString& ) ) );
+    connect( this, SIGNAL(triggered(QString)), SLOT(triggered(QString)) );
 }
 
 KoZoomAction::~KoZoomAction()
 {
     delete d;
 }
 
 qreal KoZoomAction::effectiveZoom() const
 {
     return d->effectiveZoom;
 }
 
 void KoZoomAction::setZoom(qreal zoom)
 {
     setEffectiveZoom(zoom);
     regenerateItems(d->effectiveZoom, true);
 }
 
 void KoZoomAction::triggered(const QString& text)
 {
     QString zoomString = text;
     zoomString = zoomString.remove( '&' );
 
     KoZoomMode::Mode mode = KoZoomMode::toMode(zoomString);
     int zoom = 0;
 
     if( mode == KoZoomMode::ZOOM_CONSTANT ) {
         bool ok;
         QRegExp regexp( ".*(\\d+).*" ); // "Captured" non-empty sequence of digits
         int pos = regexp.indexIn( zoomString );
 
         if( pos > -1 ) {
             zoom = regexp.cap( 1 ).toInt( &ok );
 
             if( !ok ) {
                 zoom = 0;
             }
         }
     }
 
     emit zoomChanged( mode, zoom/100.0 );
 }
 
 void KoZoomAction::setZoomModes( KoZoomMode::Modes zoomModes )
 {
     d->zoomModes = zoomModes;
     regenerateItems( d->effectiveZoom );
 }
 
 void KoZoomAction::regenerateItems(const qreal zoom, bool asCurrent)
 {
     QList<qreal> zoomLevels = d->filterMenuZoomLevels(d->sliderLookup);
 
     if( !zoomLevels.contains( zoom ) )
         zoomLevels << zoom;
 
     std::sort(zoomLevels.begin(), zoomLevels.end());
 
     // update items with new sorted zoom values
     QStringList values;
     if(d->zoomModes & KoZoomMode::ZOOM_WIDTH) {
         values << KoZoomMode::toString(KoZoomMode::ZOOM_WIDTH);
     }
     if(d->zoomModes & KoZoomMode::ZOOM_PAGE) {
         values << KoZoomMode::toString(KoZoomMode::ZOOM_PAGE);
     }
 
     Q_FOREACH (qreal value, zoomLevels) {
         const qreal valueInPercent = value * 100;
         const int precision = (value > 10.0) ? 0 : 1;
 
         values << i18n("%1%", QLocale().toString(valueInPercent, 'f', precision));
     }
 
     setItems( values );
 
     emit zoomLevelsChanged(values);
 
     if(asCurrent)
     {
         const qreal zoomInPercent = zoom * 100;
         // TODO: why zoomInPercent and not zoom here? different from above
         const int precision = (zoomInPercent > 10.0) ? 0 : 1;
 
         const QString valueString = i18n("%1%", QLocale().toString(zoomInPercent, 'f', precision));
 
         setCurrentAction(valueString);
 
         emit currentZoomLevelChanged(valueString);
     }
 }
 
 void KoZoomAction::sliderValueChanged(int value)
 {
     setZoom(d->sliderLookup[value]);
 
     emit zoomChanged(KoZoomMode::ZOOM_CONSTANT, d->sliderLookup[value]);
 }
 
 qreal KoZoomAction::nextZoomLevel() const
 {
     const qreal eps = 1e-5;
     int i = 0;
     while (d->effectiveZoom > d->sliderLookup[i] - eps &&
            i < d->sliderLookup.size() - 1) i++;
 
     return qMax(d->effectiveZoom, d->sliderLookup[i]);
 }
 
 qreal KoZoomAction::prevZoomLevel() const
 {
     const qreal eps = 1e-5;
     int i = d->sliderLookup.size() - 1;
     while (d->effectiveZoom < d->sliderLookup[i] + eps && i > 0) i--;
 
     return qMin(d->effectiveZoom, d->sliderLookup[i]);
 }
 
 void KoZoomAction::zoomIn()
 {
     qreal zoom = nextZoomLevel();
 
     if (zoom > d->effectiveZoom) {
         setZoom(zoom);
         emit zoomChanged(KoZoomMode::ZOOM_CONSTANT, d->effectiveZoom);
     }
 }
 
 void KoZoomAction::zoomOut()
 {
     qreal zoom = prevZoomLevel();
 
     if (zoom < d->effectiveZoom) {
         setZoom(zoom);
         emit zoomChanged(KoZoomMode::ZOOM_CONSTANT, d->effectiveZoom);
     }
 }
 
 QWidget * KoZoomAction::createWidget(QWidget *parent)
 {
     KoZoomWidget* zoomWidget = new KoZoomWidget(parent, d->sliderLookup.size() - 1);
     connect(this, SIGNAL(zoomLevelsChanged(QStringList)), zoomWidget, SLOT(setZoomLevels(QStringList)));
     connect(this, SIGNAL(currentZoomLevelChanged(QString)), zoomWidget, SLOT(setCurrentZoomLevel(QString)));
     connect(this, SIGNAL(sliderChanged(int)), zoomWidget, SLOT(setSliderValue(int)));
     connect(this, SIGNAL(aspectModeChanged(bool)), zoomWidget, SLOT(setAspectMode(bool)));
     connect(zoomWidget, SIGNAL(sliderValueChanged(int)), this, SLOT(sliderValueChanged(int)));
-    connect(zoomWidget, SIGNAL(zoomLevelChanged(const QString&)), this, SLOT(triggered(const QString&)));
+    connect(zoomWidget, SIGNAL(zoomLevelChanged(QString)), this, SLOT(triggered(QString)));
     connect(zoomWidget, SIGNAL(aspectModeChanged(bool)), this, SIGNAL(aspectModeChanged(bool)));
     connect(zoomWidget, SIGNAL(zoomedToSelection()), this, SIGNAL(zoomedToSelection()));
     connect(zoomWidget, SIGNAL(zoomedToAll()), this, SIGNAL(zoomedToAll()));
     regenerateItems( d->effectiveZoom, true );
     syncSliderWithZoom();
     return zoomWidget;
 }
 
 void KoZoomAction::setEffectiveZoom(qreal zoom)
 {
     if(d->effectiveZoom == zoom)
         return;
 
     zoom = clampZoom(zoom);
     d->effectiveZoom = zoom;
     syncSliderWithZoom();
 }
 
 void KoZoomAction::setSelectedZoomMode(KoZoomMode::Mode mode)
 {
     QString modeString(KoZoomMode::toString(mode));
     setCurrentAction(modeString);
 
     emit currentZoomLevelChanged(modeString);
 }
 
 void KoZoomAction::setAspectMode(bool status)
 {
     emit aspectModeChanged(status);
 }
 
 void KoZoomAction::syncSliderWithZoom()
 {
     const qreal eps = 1e-5;
     int i = d->sliderLookup.size() - 1;
     while (d->effectiveZoom < d->sliderLookup[i] + eps && i > 0) i--;
     
     emit sliderChanged(i);
 }
 
 qreal KoZoomAction::minimumZoom()
 {
     if (d->minimumZoomValue < 0) {
         return KoZoomMode::minimumZoom();
     }
     return d->minimumZoomValue;
 }
 
 qreal KoZoomAction::maximumZoom()
 {
     if (d->maximumZoomValue < 0) {
         return KoZoomMode::maximumZoom();
     }
     return d->maximumZoomValue;
 }
 
 qreal KoZoomAction::clampZoom(qreal zoom)
 {
     return qMin(maximumZoom(), qMax(minimumZoom(), zoom));
 }
 
 void KoZoomAction::setMinimumZoom(qreal zoom)
 {
     Q_ASSERT(zoom > 0.0f);
     KoZoomMode::setMinimumZoom(zoom);
     d->minimumZoomValue = zoom;
     d->generateSliderZoomLevels();
     d->sliderLookup = d->generateSliderZoomLevels();
     regenerateItems(d->effectiveZoom, true);
     syncSliderWithZoom();
 }
 
 void KoZoomAction::setMaximumZoom(qreal zoom)
 {
     Q_ASSERT(zoom > 0.0f);
     KoZoomMode::setMaximumZoom(zoom);
     d->maximumZoomValue = zoom;
     d->sliderLookup = d->generateSliderZoomLevels();
     regenerateItems(d->effectiveZoom, true);
     syncSliderWithZoom();
 }
diff --git a/libs/widgets/KoZoomController.cpp b/libs/widgets/KoZoomController.cpp
index e5c1cf2a30..7f7f99c631 100644
--- a/libs/widgets/KoZoomController.cpp
+++ b/libs/widgets/KoZoomController.cpp
@@ -1,215 +1,215 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2007 Thomas Zander <zander@kde.org>
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2011 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  * 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 <KoZoomController.h>
 #include <KoZoomController_p.h>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <WidgetsDebug.h>
 
 #include <KoZoomHandler.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 void KoZoomController::Private::init(KoCanvasController *co,
                                      KoZoomHandler *zh,
                                      KActionCollection *actionCollection)
 {
     canvasController = co;
     fitMargin = co->margin();
     zoomHandler = zh;
-    connect(action, SIGNAL(zoomChanged(KoZoomMode::Mode, qreal)),
-            parent, SLOT(setZoom(KoZoomMode::Mode, qreal)));
+    connect(action, SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)),
+            parent, SLOT(setZoom(KoZoomMode::Mode,qreal)));
     connect(action, SIGNAL(aspectModeChanged(bool)),
             parent, SIGNAL(aspectModeChanged(bool)));
     connect(action, SIGNAL(zoomedToSelection()),
             parent, SIGNAL(zoomedToSelection()));
     connect(action, SIGNAL(zoomedToAll()),
             parent, SIGNAL(zoomedToAll()));
 
     actionCollection->addAction("view_zoom", action);
 
-    connect(canvasController->proxyObject, SIGNAL( sizeChanged(const QSize & ) ), parent, SLOT( setAvailableSize() ) );
+    connect(canvasController->proxyObject, SIGNAL(sizeChanged(QSize)), parent, SLOT(setAvailableSize()) );
 
-    connect(canvasController->proxyObject, SIGNAL( zoomRelative(const qreal, const QPointF& ) ), parent, SLOT( requestZoomRelative( const qreal, const QPointF& ) ) );
+    connect(canvasController->proxyObject, SIGNAL(zoomRelative(qreal,QPointF)), parent, SLOT(requestZoomRelative(qreal,QPointF)) );
 }
 
 KoZoomController::KoZoomController(KoCanvasController *co, KoZoomHandler *zh, KActionCollection *actionCollection, QObject *parent)
     : QObject(parent),
       d(new Private(this))
 {
     d->init(co, zh, actionCollection);
 }
 
 KoZoomController::~KoZoomController()
 {
     delete d;
 }
 
 KoZoomAction *KoZoomController::zoomAction() const
 {
     return d->action;
 }
 
 void KoZoomController::setZoomMode(KoZoomMode::Mode mode)
 {
     setZoom(mode, 1.0);
 }
 
 KoZoomMode::Mode KoZoomController::zoomMode() const
 {
     return d->zoomHandler->zoomMode();
 }
 
 void KoZoomController::setPageSize(const QSizeF &pageSize)
 {
     if(d->pageSize == pageSize) return;
     d->pageSize = pageSize;
 
     if(d->zoomHandler->zoomMode() == KoZoomMode::ZOOM_WIDTH)
         setZoom(KoZoomMode::ZOOM_WIDTH, 0);
     if(d->zoomHandler->zoomMode() == KoZoomMode::ZOOM_PAGE)
         setZoom(KoZoomMode::ZOOM_PAGE, 0);
 }
 
 QSizeF KoZoomController::pageSize() const
 {
     return d->pageSize;
 }
 
 void KoZoomController::setDocumentSize(const QSizeF &documentSize, bool recalculateCenter)
 {
     d->documentSize = documentSize;
     d->canvasController->updateDocumentSize(documentToViewport(d->documentSize), recalculateCenter);
 
     // Finally ask the canvasController to recenter
     d->canvasController->recenterPreferred();
 }
 
 QSizeF KoZoomController::documentSize() const
 {
     return d->documentSize;
 }
 
 void KoZoomController::setZoom(KoZoomMode::Mode mode, qreal zoom)
 {
     setZoom(mode, zoom, d->canvasController->preferredCenter());
 }
 
 void KoZoomController::setZoom(KoZoomMode::Mode mode, qreal zoom, const QPointF &stillPoint)
 {
     setZoom(mode, zoom, d->zoomHandler->resolutionX(), d->zoomHandler->resolutionY(), stillPoint);
 }
 
 void KoZoomController::setZoom(KoZoomMode::Mode mode, qreal zoom, qreal resolutionX, qreal resolutionY)
 {
     setZoom(mode, zoom, resolutionX, resolutionY, d->canvasController->preferredCenter());
 }
 
 void KoZoomController::setZoom(KoZoomMode::Mode mode, qreal zoom, qreal resolutionX, qreal resolutionY, const QPointF &stillPoint)
 {
     if (d->zoomHandler->zoomMode() == mode &&
             qFuzzyCompare(d->zoomHandler->zoom(), zoom) &&
             qFuzzyCompare(d->zoomHandler->resolutionX(), resolutionX) &&
             qFuzzyCompare(d->zoomHandler->resolutionY(), resolutionY)) {
         return; // no change
     }
 
     qreal oldEffectiveZoom = d->action->effectiveZoom();
     QSize oldPageViewportSize = documentToViewport(d->pageSize);
 
     if(!qFuzzyCompare(d->zoomHandler->resolutionX(), resolutionX) ||
             !qFuzzyCompare(d->zoomHandler->resolutionY(), resolutionY)) {
 
         d->zoomHandler->setResolution(resolutionX, resolutionY);
     }
 
     if(mode == KoZoomMode::ZOOM_CONSTANT) {
         if(zoom == 0.0) return;
         d->action->setZoom(zoom);
     }
     else if(mode == KoZoomMode::ZOOM_WIDTH) {
         zoom = (d->canvasController->viewportSize().width() - 2 * d->fitMargin)
                 / (oldPageViewportSize.width() / d->zoomHandler->zoom());
         d->action->setSelectedZoomMode(mode);
         d->action->setEffectiveZoom(zoom);
     }
     else if(mode == KoZoomMode::ZOOM_PAGE) {
         zoom = (d->canvasController->viewportSize().width() - 2 * d->fitMargin)
                 / (oldPageViewportSize.width() / d->zoomHandler->zoom());
         zoom = qMin(zoom, (d->canvasController->viewportSize().height() - 2 * d->fitMargin)
                     / (oldPageViewportSize.height() / d->zoomHandler->zoom()));
 
         d->action->setSelectedZoomMode(mode);
         d->action->setEffectiveZoom(zoom);
     }
 
     d->zoomHandler->setZoomMode(mode);
     d->zoomHandler->setZoom(d->action->effectiveZoom());
 
 #ifdef DEBUG
     if(! d->documentSize.isValid())
         warnWidgets << "Setting zoom while there is no document size set, this will fail";
     else if (d->pageSize.width() > d->documentSize.width() || d->pageSize.height() > d->documentSize.height())
         warnWidgets << "ZoomController; Your page size is larger than your document size (" <<
                        d->pageSize << " > " << d->documentSize << ")\n";
 #endif
 
     QSize documentViewportSize = documentToViewport(d->documentSize);
 
     // Tell the canvasController that the zoom has changed
     // Actually canvasController doesn't know about zoom, but the document in pixels
     // has changed as a result of the zoom change
     // To allow listeners of offset changes to react on the real new offset and not on the
     // intermediate offsets, we block the signals here, and emit by ourselves later.
     d->canvasController->proxyObject->blockSignals(true);
     d->canvasController->updateDocumentSize(documentViewportSize, true);
     d->canvasController->proxyObject->blockSignals(false);
 
     // Finally ask the canvasController to recenter
     QPointF documentCenter;
     if (mode == KoZoomMode::ZOOM_WIDTH || mode == KoZoomMode::ZOOM_PAGE) {
         documentCenter = QRectF(QPointF(), documentViewportSize).center();
     }
     else {
         qreal zoomCoeff = d->action->effectiveZoom() / oldEffectiveZoom;
         QPointF oldCenter = d->canvasController->preferredCenter();
         documentCenter = stillPoint * zoomCoeff - (stillPoint - 1.0 / zoomCoeff * oldCenter);
     }
     d->canvasController->setPreferredCenter(documentCenter);
     emit zoomChanged(mode, d->action->effectiveZoom());
 }
 
 QSize KoZoomController::documentToViewport(const QSizeF &size)
 {
     return d->zoomHandler->documentToView(size).toSize();
 }
 
 void KoZoomController::setAspectMode(bool status)
 {
     if (d->action) {
         d->action->setAspectMode(status);
     }
 }
 //have to include this because of Q_PRIVATE_SLOT
 #include <moc_KoZoomController.cpp>
diff --git a/libs/widgets/KoZoomInput.cpp b/libs/widgets/KoZoomInput.cpp
index 1716c227e8..2147fe93fc 100644
--- a/libs/widgets/KoZoomInput.cpp
+++ b/libs/widgets/KoZoomInput.cpp
@@ -1,146 +1,146 @@
 /* Copyright 2008  Peter Simonsson <peter.simonsson@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 "KoZoomInput.h"
 
 #include <WidgetsDebug.h>
 #include <klocalizedstring.h>
 
 #include <QComboBox>
 #include <QLabel>
 #include <QHBoxLayout>
 #include <QStyle>
 #include <QStyleOption>
 #include <QPainter>
 #include <QPalette>
 #include <QAbstractItemView>
 #include <QEvent>
 #include <QKeyEvent>
 #include <QLineEdit>
 
 class KoZoomInput::Private
 {
     public:
         QComboBox* combo;
         QLabel* label;
         bool inside;
 };
 
 KoZoomInput::KoZoomInput(QWidget* parent)
     : QStackedWidget(parent), d(new Private)
 {
 #ifdef Q_OS_OSX
     setAttribute(Qt::WA_MacMiniSize, true);
 #endif
 
     QWidget* first = new QWidget(this);
     QHBoxLayout* layout = new QHBoxLayout(first);
     layout->setSpacing(0);
     layout->setMargin(0);
     d->label = new QLabel(first);
     d->label->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     layout->addWidget(d->label, 10);
     QLabel* icon = new QLabel(first);
     QStyleOption option;
     option.state = QStyle::State_Enabled;
     QPixmap pixmap(16, 16);
     pixmap.fill(QColor(255, 255, 255, 0));
     QPainter painter(&pixmap);
     painter.translate(8, 8);
     style()->drawPrimitive(QStyle::PE_IndicatorArrowDown, &option, &painter);
     icon->setPixmap(pixmap);
     layout->addWidget(icon);
     addWidget(first);
     d->combo = new QComboBox(this);
     d->combo->setMaxVisibleItems(15);
     d->combo->setEditable(true);
     d->combo->installEventFilter(this);
     addWidget(d->combo);
     d->inside = false;
 
-    connect(d->combo, SIGNAL(activated(const QString&)), this, SIGNAL(zoomLevelChanged(const QString&)));
+    connect(d->combo, SIGNAL(activated(QString)), this, SIGNAL(zoomLevelChanged(QString)));
 }
 
 KoZoomInput::~KoZoomInput()
 {
     delete d;
 }
 
 void KoZoomInput::enterEvent(QEvent* event)
 {
     Q_UNUSED(event);
 
     d->inside = true;
     if (d->combo->view())
     {
         d->combo->view()->removeEventFilter(this);
     }
 
     setCurrentIndex(1);
 }
 
 void KoZoomInput::leaveEvent(QEvent* event)
 {
     Q_UNUSED(event);
 
     d->inside = false;
     if(d->combo->view() && d->combo->view()->isVisible())
     {
         d->combo->view()->installEventFilter(this);
         return;
     }
 
     if(!d->combo->hasFocus())
         setCurrentIndex(0);
 }
 
 void KoZoomInput::keyPressEvent(QKeyEvent* event)
 {
     if (event->key() == Qt::Key_Return ||
         event->key() == Qt::Key_Enter)
     {
         focusNextChild();
     }
 }
 
 void KoZoomInput::setZoomLevels(const QStringList& levels)
 {
     d->combo->clear();
     d->combo->addItems(levels);
 }
 
 void KoZoomInput::setCurrentZoomLevel(const QString& level)
 {
     d->combo->setCurrentIndex(d->combo->findText(level));
     d->label->setText(level);
 }
 
 bool KoZoomInput::eventFilter(QObject* watched, QEvent* event)
 {
     if(watched == d->combo->view() && event->type() == QEvent::Hide)
     {
         focusNextChild();
         setCurrentIndex(0);
     }
     else if (watched == d->combo && event->type() == QEvent::FocusOut &&
             (d->combo->view() && !d->combo->view()->hasFocus()) && !d->inside)
     {
         setCurrentIndex(0);
     }
     return false;
 }
diff --git a/libs/widgets/KoZoomWidget.cpp b/libs/widgets/KoZoomWidget.cpp
index 65687a85b8..886e2e9711 100644
--- a/libs/widgets/KoZoomWidget.cpp
+++ b/libs/widgets/KoZoomWidget.cpp
@@ -1,115 +1,115 @@
 /*  
     Copyright (C) 2004 Ariya Hidayat <ariya@kde.org>
     Copyright (C) 2006 Peter Simonsson <peter.simonsson@gmail.com>
     Copyright (C) 2006-2007 C. Boemann <cbo@boemann.dk>
     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 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 "KoZoomWidget.h"
 
 #include <QSlider>
 #include <QToolButton>
 #include <QBoxLayout>
 
 #include <klocalizedstring.h>
 
 #include "KoZoomInput.h"
 #include "KoIcon.h"
 
 class KoZoomWidget::Private
 {
 public:
 
     Private()
         : slider(0)
         , input(0)
         , aspectButton(0)
     {}
 
     QSlider* slider;
     KoZoomInput* input;
     QToolButton* aspectButton;
 
     qreal effectiveZoom;
 };
 
 KoZoomWidget::KoZoomWidget(QWidget* parent, int maxZoom )
     : QWidget(parent)
     , d(new Private)
 {
     QHBoxLayout *layout = new QHBoxLayout(this);
     //layout->setSizeConstraint(QLayout::SetFixedSize);
     layout->setMargin(0);
     layout->setSpacing(0);
 
     d->input = new KoZoomInput(this);
-    connect(d->input, SIGNAL(zoomLevelChanged(const QString&)), this, SIGNAL(zoomLevelChanged(const QString&)));
+    connect(d->input, SIGNAL(zoomLevelChanged(QString)), this, SIGNAL(zoomLevelChanged(QString)));
     layout->addWidget(d->input);
 
     d->slider = new QSlider(Qt::Horizontal);
     d->slider->setToolTip(i18n("Zoom"));
     d->slider->setMinimum(0);
     d->slider->setMaximum(maxZoom);
     d->slider->setValue(0);
     d->slider->setSingleStep(1);
     d->slider->setPageStep(1);
     d->slider->setMinimumWidth(80);
     layout->addWidget(d->slider);
     layout->setStretch(1, 1);
 
     d->aspectButton = new QToolButton(this);
     d->aspectButton->setIcon(koIcon("zoom-pixels"));
     d->aspectButton->setIconSize(QSize(16,16));
     d->aspectButton->setCheckable(true);
     d->aspectButton->setChecked(true);
     d->aspectButton->setAutoRaise(true);
     d->aspectButton->setToolTip(i18n("Use same aspect as pixels"));
     connect(d->aspectButton, SIGNAL(toggled(bool)), this, SIGNAL(aspectModeChanged(bool)));
     layout->addWidget(d->aspectButton);
 
     connect(d->slider, SIGNAL(valueChanged(int)), this, SIGNAL(sliderValueChanged(int)));
 }
 
 KoZoomWidget::~KoZoomWidget()
 {
 }
 
 void KoZoomWidget::setZoomLevels(const QStringList &values)
 {
     d->input->setZoomLevels(values);
 }
 
 void KoZoomWidget::setCurrentZoomLevel(const QString &valueString)
 {
     d->input->setCurrentZoomLevel(valueString);
 }
 
 void KoZoomWidget::setSliderValue(int value)
 {
     d->slider->blockSignals(true);
     d->slider->setValue(value);
     d->slider->blockSignals(false);
 }
 
 void KoZoomWidget::setAspectMode(bool status)
 {
     if(d->aspectButton && d->aspectButton->isChecked() != status) {
         d->aspectButton->blockSignals(true);
         d->aspectButton->setChecked(status);
         d->aspectButton->blockSignals(false);
     }
 }
diff --git a/libs/widgets/kis_double_parse_unit_spin_box.cpp b/libs/widgets/kis_double_parse_unit_spin_box.cpp
index 28e10403c8..cff3b246c9 100644
--- a/libs/widgets/kis_double_parse_unit_spin_box.cpp
+++ b/libs/widgets/kis_double_parse_unit_spin_box.cpp
@@ -1,439 +1,439 @@
 /*
  *  Copyright (c) 2016 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
  *
  *  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_double_parse_unit_spin_box.h"
 #include "kis_spin_box_unit_manager.h"
 
 #include <QLineEdit>
 
 class Q_DECL_HIDDEN KisDoubleParseUnitSpinBox::Private
 {
 public:
     Private(double low, double up, double step, KisSpinBoxUnitManager* unitManager)
         : lowerInPoints(low),
           upperInPoints(up),
           stepInPoints(step),
           unit(KoUnit(KoUnit::Point)),
           outPutSymbol(""),
           unitManager(unitManager),
           defaultUnitManager(unitManager),
           isDeleting(false),
           unitHasBeenChangedFromOutSideOnce(false),
           letUnitBeChangedFromOutsideMoreThanOnce(true),
           displayUnit(true),
           allowResetDecimals(true)
     {
     }
 
     double lowerInPoints; ///< lowest value in points
     double upperInPoints; ///< highest value in points
     double stepInPoints;  ///< step in points
     KoUnit unit;
 
     double previousValueInPoint; ///< allow to store the previous value in point, useful in some cases, even if, usually, we prefer to refer to the actual value (in selected unit) and convert it, since this is not always updated.
     QString previousSymbol;
     QString outPutSymbol;
 
     KisSpinBoxUnitManager* unitManager; //manage more units than permitted by KoUnit.
     KisSpinBoxUnitManager* defaultUnitManager; //the default unit manager is the one the spinbox rely on and go back to if a connected unit manager is destroyed before the spinbox.
 
     bool isDeleting;
 
     bool unitHasBeenChangedFromOutSideOnce; //in some part of the code the unit is reset. We want to prevent this overriding the unit defined by the user. We use this switch to do so.
     bool letUnitBeChangedFromOutsideMoreThanOnce;
 
     bool displayUnit;
 
     bool allowResetDecimals;
 
 };
 
 KisDoubleParseUnitSpinBox::KisDoubleParseUnitSpinBox(QWidget *parent) :
     KisDoubleParseSpinBox(parent),
     d(new Private(-9999, 9999, 1, KisSpinBoxUnitManagerFactory::buildDefaultUnitManager(this)))
 {
     setUnit( KoUnit(KoUnit::Point) );
     setAlignment( Qt::AlignRight );
 
-    connect(this, SIGNAL(valueChanged( double )), this, SLOT(privateValueChanged()));
+    connect(this, SIGNAL(valueChanged(double)), this, SLOT(privateValueChanged()));
     connect(lineEdit(), SIGNAL(textChanged(QString)),
             this, SLOT(detectUnitChanges()) );
 
     connect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange, this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
     connect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
 
     setDecimals(d->unitManager->getApparentUnitRecommandedDecimals());
 
 }
 
 KisDoubleParseUnitSpinBox::~KisDoubleParseUnitSpinBox()
 {
     d->isDeleting = true;
     delete d->defaultUnitManager;
     delete d;
 }
 
 void KisDoubleParseUnitSpinBox::setUnitManager(KisSpinBoxUnitManager* unitManager)
 {
     qreal oldVal = d->unitManager->getReferenceValue(KisDoubleParseSpinBox::value());
     QString oldSymbol = d->unitManager->getApparentUnitSymbol();
 
     qreal newVal = 0.0;
 
     double newMin;
     double newMax;
     double newStep;
 
     if (oldSymbol == unitManager->getApparentUnitSymbol() &&
             d->unitManager->getUnitDimensionType() == unitManager->getUnitDimensionType())
     {
         d->unitManager = unitManager; //set the new unitmanager anyway, since it may be a subclass, so change the behavior anyway.
         goto connect_signals;
     }
 
     if (d->unitManager->getUnitDimensionType() == unitManager->getUnitDimensionType()) {
         //dimension is the same, calculate the new value
         newVal = unitManager->getApparentValue(oldVal);
     } else {
         newVal = unitManager->getApparentValue(d->lowerInPoints);
     }
 
     newMin = unitManager->getApparentValue(d->lowerInPoints);
     newMax = unitManager->getApparentValue(d->upperInPoints);
     newStep = unitManager->getApparentValue(d->stepInPoints);
 
     if (unitManager->getApparentUnitSymbol() == KoUnit(KoUnit::Pixel).symbol()) {
         // limit the pixel step by 1.0
         newStep = qMax(qreal(1.0), newStep);
     }
 
     KisDoubleParseSpinBox::setMinimum(newMin);
     KisDoubleParseSpinBox::setMaximum(newMax);
     KisDoubleParseSpinBox::setSingleStep(newStep);
 
 connect_signals:
 
     if (d->unitManager != d->defaultUnitManager) {
         disconnect(d->unitManager, &QObject::destroyed,
                    this, &KisDoubleParseUnitSpinBox::disconnectExternalUnitManager); //there's no dependence anymore.
     }
     disconnect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange, this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
     disconnect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
 
     d->unitManager = unitManager;
 
     connect(d->unitManager, &QObject::destroyed,
             this, &KisDoubleParseUnitSpinBox::disconnectExternalUnitManager);
 
 
     connect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange, this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
     connect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
 
     KisDoubleParseSpinBox::setValue(newVal);
 
     if (d->allowResetDecimals) { //if the user has not fixed the number of decimals.
         setDecimals(d->unitManager->getApparentUnitRecommandedDecimals());
     }
 }
 
 void KisDoubleParseUnitSpinBox::changeValue( double newValue )
 {
     double apparentValue;
     double fact = 0.0;
     double cons = 0.0;
 
     if (d->outPutSymbol.isEmpty()) {
         apparentValue = d->unitManager->getApparentValue(newValue);
     } else {
 
         fact = d->unitManager->getConversionFactor(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
         cons = d->unitManager->getConversionConstant(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
 
         apparentValue = fact*newValue + cons;
     }
 
     if (apparentValue == KisDoubleParseSpinBox::value()) {
         return;
     }
 
     if (d->outPutSymbol.isEmpty()) {
         KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue(newValue) );
     } else {
 
         KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue((newValue - cons)/fact) );
     }
 }
 
 void KisDoubleParseUnitSpinBox::setUnit( const KoUnit & unit)
 {
     if (d->unitHasBeenChangedFromOutSideOnce && !d->letUnitBeChangedFromOutsideMoreThanOnce) {
         return;
     }
 
     if (d->unitManager->getUnitDimensionType() != KisSpinBoxUnitManager::LENGTH) {
         d->unitManager->setUnitDimension(KisSpinBoxUnitManager::LENGTH); //setting the unit using a KoUnit mean you want to use a length.
     }
 
     setUnit(unit.symbol());
     d->unit = unit;
 }
 void KisDoubleParseUnitSpinBox::setUnit(const QString &symbol)
 {
     d->unitManager->setApparentUnitFromSymbol(symbol); //via signals and slots, the correct functions should be called.
 }
 void KisDoubleParseUnitSpinBox::setReturnUnit(const QString & symbol)
 {
     d->outPutSymbol = symbol;
 }
 
 void KisDoubleParseUnitSpinBox::prepareUnitChange() {
 
     d->previousValueInPoint = d->unitManager->getReferenceValue(KisDoubleParseSpinBox::value());
     d->previousSymbol = d->unitManager->getApparentUnitSymbol();
 
 }
 
 void KisDoubleParseUnitSpinBox::internalUnitChange(const QString &symbol) {
 
     //d->unitManager->setApparentUnitFromSymbol(symbol);
 
     if (d->unitManager->getApparentUnitSymbol() == d->previousSymbol) { //the setApparentUnitFromSymbol is a bit clever, for example in regard of Casesensitivity. So better check like this.
         return;
     }
 
     KisDoubleParseSpinBox::setMinimum( d->unitManager->getApparentValue( d->lowerInPoints ) );
     KisDoubleParseSpinBox::setMaximum( d->unitManager->getApparentValue( d->upperInPoints ) );
 
     qreal step = d->unitManager->getApparentValue( d->stepInPoints );
 
     if (symbol == KoUnit(KoUnit::Pixel).symbol()) {
         // limit the pixel step by 1.0
         step = qMax(qreal(1.0), step);
     }
 
     KisDoubleParseSpinBox::setSingleStep( step );
     KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue( d->previousValueInPoint ) );
 
     if (d->allowResetDecimals) {
         setDecimals(d->unitManager->getApparentUnitRecommandedDecimals());
     }
 
     d->unitHasBeenChangedFromOutSideOnce = true;
 }
 
 void KisDoubleParseUnitSpinBox::setDimensionType(int dim)
 {
     if (!KisSpinBoxUnitManager::isUnitId(dim)) {
         return;
     }
 
     d->unitManager->setUnitDimension((KisSpinBoxUnitManager::UnitDimension) dim);
 }
 
 double KisDoubleParseUnitSpinBox::value( ) const
 {
     if (d->outPutSymbol.isEmpty()) {
         return d->unitManager->getReferenceValue( KisDoubleParseSpinBox::value() );
     }
 
     double ref = d->unitManager->getReferenceValue( KisDoubleParseSpinBox::value() );
     double fact = d->unitManager->getConversionFactor(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
     double cons = d->unitManager->getConversionConstant(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
 
     return fact*ref + cons;
 }
 
 void KisDoubleParseUnitSpinBox::setMinimum(double min)
 {
     d->lowerInPoints = min;
     KisDoubleParseSpinBox::setMinimum( d->unitManager->getApparentValue( min ) );
 }
 
 void KisDoubleParseUnitSpinBox::setMaximum(double max)
 {
     d->upperInPoints = max;
     KisDoubleParseSpinBox::setMaximum( d->unitManager->getApparentValue( max ) );
 }
 
 void KisDoubleParseUnitSpinBox::setLineStep(double step)
 {
     d->stepInPoints = d->unitManager->getReferenceValue(step);
     KisDoubleParseSpinBox::setSingleStep( step );
 }
 
 void KisDoubleParseUnitSpinBox::setLineStepPt(double step)
 {
     d->stepInPoints = step;
     KisDoubleParseSpinBox::setSingleStep( d->unitManager->getApparentValue( step ) );
 }
 
 
 void KisDoubleParseUnitSpinBox::setMinMaxStep( double min, double max, double step )
 {
     setMinimum( min );
     setMaximum( max );
     setLineStepPt( step );
 }
 
 
 QValidator::State KisDoubleParseUnitSpinBox::validate(QString &input, int &pos) const
 {
     Q_UNUSED(pos);
 
     QRegExp regexp ("([ a-zA-Z]+)$"); // Letters or spaces at end
     const int res = input.indexOf( regexp );
 
     /*if ( res == -1 ) {
         // Nothing like an unit? The user is probably editing the unit
         return QValidator::Intermediate;
     }*/
 
     QString expr ( (res > 0) ? input.left( res ) : input );
     const QString unitName ( (res > 0) ? regexp.cap( 1 ).trimmed().toLower() : "" );
 
     bool ok = true;
     bool interm = false;
 
     QValidator::State exprState = KisDoubleParseSpinBox::validate(expr, pos);
 
     if (res < 0) {
         return exprState;
     }
 
     if (exprState == QValidator::Invalid) {
         return exprState;
     } else if (exprState == QValidator::Intermediate) {
         interm = true;
     }
 
     //check if we can parse the unit.
     QStringList listOfSymbol = d->unitManager->getsUnitSymbolList();
     ok = listOfSymbol.contains(unitName);
 
     if (!ok || interm) {
         return QValidator::Intermediate;
     }
 
     return QValidator::Acceptable;
 }
 
 QString KisDoubleParseUnitSpinBox::textFromValue( double value ) const
 {
     QString txt = KisDoubleParseSpinBox::textFromValue(value);
     if (d->displayUnit) {
         if (!txt.endsWith(d->unitManager->getApparentUnitSymbol())) {
             txt += " " + d->unitManager->getApparentUnitSymbol();
         }
     }
     return txt;
 }
 
 QString KisDoubleParseUnitSpinBox::veryCleanText() const
 {
 
     return makeTextClean(cleanText());
 
 }
 
 double KisDoubleParseUnitSpinBox::valueFromText( const QString& str ) const
 {
 
     QString txt = makeTextClean(str);
 
     return KisDoubleParseSpinBox::valueFromText(txt); //this function will take care of prefix (and don't mind if suffix has been removed.
 }
 
 void KisDoubleParseUnitSpinBox::setUnitChangeFromOutsideBehavior(bool toggle) {
     d->letUnitBeChangedFromOutsideMoreThanOnce = toggle;
 }
 
 void KisDoubleParseUnitSpinBox::setDisplayUnit(bool toggle) {
 
     d->displayUnit = toggle;
 
 }
 
 void KisDoubleParseUnitSpinBox::preventDecimalsChangeFromUnitManager(bool prevent) {
     d->allowResetDecimals = !prevent;
 }
 
 void KisDoubleParseUnitSpinBox::privateValueChanged()
 {
     emit valueChangedPt( value() );
 }
 
 QString KisDoubleParseUnitSpinBox::detectUnit()
 {
     QString str = veryCleanText().trimmed(); //text with the new unit but not the old one.
 
     QRegExp regexp ("([ ]*[a-zA-Z]+[ ]*)$"); // Letters or spaces at end
     int res = str.indexOf( regexp );
 
     if (res > -1) {
         QString expr ( str.right( str.size() - res ) );
         expr = expr.trimmed();
         return expr;
     }
 
     return "";
 }
 
 void KisDoubleParseUnitSpinBox::detectUnitChanges()
 {
     QString unitSymb = detectUnit();
 
     if (unitSymb.isEmpty()) {
         return;
     }
 
     QString oldUnitSymb = d->unitManager->getApparentUnitSymbol();
 
     setUnit(unitSymb);
     setValue(valueFromText(cleanText())); //change value keep the old value, but converted to new unit... which is different from the value the user entered in the new unit. So we need to set the new value.
 
     if (oldUnitSymb != d->unitManager->getApparentUnitSymbol()) {
         // the user has changed the unit, so we block changes from outside.
         setUnitChangeFromOutsideBehavior(false);
     }
 }
 
 QString KisDoubleParseUnitSpinBox::makeTextClean(QString const& txt) const
 {
     QString expr = txt;
     QString symbol = d->unitManager->getApparentUnitSymbol();
 
     if ( expr.endsWith(suffix()) ) {
         expr.remove(expr.size()-suffix().size(), suffix().size());
     }
 
     expr = expr.trimmed();
 
     if ( expr.endsWith(symbol) ) {
         expr.remove(expr.size()-symbol.size(), symbol.size());
     }
 
     return expr.trimmed();
 }
 
 void KisDoubleParseUnitSpinBox::disconnectExternalUnitManager()
 {
     if (!d->isDeleting)
     {
         setUnitManager(d->defaultUnitManager); //go back to default unit manager.
     }
 }
diff --git a/libs/widgets/kis_file_name_requester.cpp b/libs/widgets/kis_file_name_requester.cpp
index 835b482f01..9e75aca3a0 100644
--- a/libs/widgets/kis_file_name_requester.cpp
+++ b/libs/widgets/kis_file_name_requester.cpp
@@ -1,110 +1,110 @@
 /*
  *  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_file_name_requester.h"
 #include "ui_wdg_file_name_requester.h"
 
 #include <QStandardPaths>
 #include <QDebug>
 
 #include "KoIcon.h"
 
 KisFileNameRequester::KisFileNameRequester(QWidget *parent)
     : QWidget(parent)
     , m_ui(new Ui::WdgFileNameRequester)
     , m_mode(KoFileDialog::OpenFile)
     , m_name("OpenDocument")
 {
     m_ui->setupUi(this);
 
     m_ui->btnSelectFile->setIcon(kisIcon("folder"));
 
     connect(m_ui->btnSelectFile, SIGNAL(clicked()), SLOT(slotSelectFile()));
-    connect(m_ui->txtFileName, SIGNAL(textChanged(const QString&)), SIGNAL(textChanged(const QString&)));
+    connect(m_ui->txtFileName, SIGNAL(textChanged(QString)), SIGNAL(textChanged(QString)));
 }
 
 KisFileNameRequester::~KisFileNameRequester()
 {
 }
 
 void KisFileNameRequester::setStartDir(const QString &path)
 {
     m_basePath = path;
 }
 
 void KisFileNameRequester::setConfigurationName(const QString &name)
 {
     m_name = name;
 }
 
 void KisFileNameRequester::setFileName(const QString &path)
 {
     m_ui->txtFileName->setText(path);
     m_basePath = path;
     emit fileSelected(path);
 }
 
 QString KisFileNameRequester::fileName() const
 {
     return m_ui->txtFileName->text();
 }
 
 void KisFileNameRequester::setMode(KoFileDialog::DialogType mode)
 {
     m_mode = mode;
 }
 
 KoFileDialog::DialogType KisFileNameRequester::mode() const
 {
     return m_mode;
 }
 
 void KisFileNameRequester::setMimeTypeFilters(const QStringList &filterList,
                                               QString defaultFilter)
 {
     m_mime_filter_list = filterList;
     m_mime_default_filter = defaultFilter;
 }
 
 void KisFileNameRequester::slotSelectFile()
 {
     KoFileDialog dialog(this, m_mode, m_name);
     if (m_mode == KoFileDialog::OpenFile)
     {
         dialog.setCaption(i18n("Select a file to load..."));
     }
     else if (m_mode == KoFileDialog::OpenDirectory)
     {
         dialog.setCaption(i18n("Select a directory to load..."));
     }
     if (m_basePath.isEmpty()) {
         dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     }
     else {
         dialog.setDefaultDir(m_basePath);
     }
 
     Q_ASSERT(!m_mime_filter_list.isEmpty());
     dialog.setMimeTypeFilters(m_mime_filter_list, m_mime_default_filter);
 
     QString newFileName = dialog.filename();
 
     if (!newFileName.isEmpty()) {
         setFileName(newFileName);
     }
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
index 4f340d21ce..17b3703199 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -1,366 +1,366 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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_color_selector.h"
 
 #include <cmath>
 
 #include <QHBoxLayout>
 #include <QColor>
 #include <QPainter>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QPushButton>
 #include <QApplication>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <kis_debug.h>
 
 #include <KoCanvasResourceManager.h>
 #include <kis_icon.h>
 
 #include "kis_color_selector_ring.h"
 #include "kis_color_selector_triangle.h"
 #include "kis_color_selector_simple.h"
 #include "kis_color_selector_wheel.h"
 #include "kis_color_selector_container.h"
 #include "kis_canvas2.h"
 #include "kis_signal_compressor.h"
 #include "KisViewManager.h"
 
 
 KisColorSelector::KisColorSelector(KisColorSelectorConfiguration conf, QWidget* parent)
     : KisColorSelectorBase(parent),
       m_ring(0),
       m_triangle(0),
       m_slider(0),
       m_square(0),
       m_wheel(0),
       m_mainComponent(0),
       m_subComponent(0),
       m_grabbingComponent(0),
       m_blipDisplay(true)
 {
     init();
     updateSettings();
     setConfiguration(conf);
 }
 
 KisColorSelector::KisColorSelector(QWidget* parent)
     : KisColorSelectorBase(parent),
       m_ring(0),
       m_triangle(0),
       m_slider(0),
       m_square(0),
       m_wheel(0),
       m_button(0),
       m_mainComponent(0),
       m_subComponent(0),
       m_grabbingComponent(0),
       m_blipDisplay(true)
 {
     init();
     updateSettings();
 }
 
 KisColorSelectorBase* KisColorSelector::createPopup() const
 {
     KisColorSelectorBase* popup = new KisColorSelector(0);
     popup->setColor(m_lastRealColor);
     return popup;
 }
 
 void KisColorSelector::setConfiguration(KisColorSelectorConfiguration conf)
 {
     m_configuration = conf;
 
     if(m_mainComponent!=0) {
         Q_ASSERT(m_subComponent!=0);
         m_mainComponent->setGeometry(0, 0, 0, 0);
         m_subComponent->setGeometry(0, 0, 0, 0);
 
         m_mainComponent->disconnect();
         m_subComponent->disconnect();
     }
 
     switch (m_configuration.mainType) {
     case KisColorSelectorConfiguration::Square:
         m_mainComponent=m_square;
         break;
     case KisColorSelectorConfiguration::Wheel:
         m_mainComponent=m_wheel;
         break;
     case KisColorSelectorConfiguration::Triangle:
         m_mainComponent=m_triangle;
         break;
     default:
         Q_ASSERT(false);
     }
 
     switch (m_configuration.subType) {
     case KisColorSelectorConfiguration::Ring:
         m_subComponent=m_ring;
         break;
     case KisColorSelectorConfiguration::Slider:
         m_subComponent=m_slider;
         break;
     default:
         Q_ASSERT(false);
     }
 
     connect(m_mainComponent, SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
             m_subComponent,  SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
     connect(m_subComponent,  SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
-            m_mainComponent, SLOT(setParam(qreal,qreal,qreal,qreal, qreal, qreal, qreal, qreal, qreal)), Qt::UniqueConnection);
+            m_mainComponent, SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
 
     connect(m_mainComponent, SIGNAL(update()), m_signalCompressor, SLOT(start()), Qt::UniqueConnection);
     connect(m_subComponent,  SIGNAL(update()), m_signalCompressor, SLOT(start()), Qt::UniqueConnection);
 
     m_mainComponent->setConfiguration(m_configuration.mainTypeParameter, m_configuration.mainType);
     m_subComponent->setConfiguration(m_configuration.subTypeParameter, m_configuration.subType);
 
     QResizeEvent event(QSize(width(), height()), QSize());
     resizeEvent(&event);
 }
 
 KisColorSelectorConfiguration KisColorSelector::configuration() const
 {
     return m_configuration;
 }
 
 void KisColorSelector::updateSettings()
 {
     KisColorSelectorBase::updateSettings();
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString())));
 }
 
 void KisColorSelector::updateIcons() {
     if (m_button) {
         m_button->setIcon(KisIconUtils::loadIcon("configure"));
     }
 }
 
 void KisColorSelector::hasAtLeastOneDocument(bool value)
 {
     m_hasAtLeastOneDocumentOpen = value;
 }
 
 void KisColorSelector::reset()
 {
     KisColorSelectorBase::reset();
 
     if (m_mainComponent) {
         m_mainComponent->setDirty();
     }
 
     if (m_subComponent) {
         m_subComponent->setDirty();
     }
 }
 
 void KisColorSelector::paintEvent(QPaintEvent* e)
 {
     Q_UNUSED(e);
     QPainter p(this);
     p.fillRect(0,0,width(), height(), QColor(128,128,128));
     p.setRenderHint(QPainter::Antialiasing);
 
     // this variable name isn't entirely accurate to what always happens. see definition in header file to understand it better
     if (!m_hasAtLeastOneDocumentOpen) {
         p.setOpacity(0.2);
     }
 
     m_mainComponent->paintEvent(&p);
     m_subComponent->paintEvent(&p);
 
     p.setOpacity(1.0);
 }
 
 inline int iconSize(qreal width, qreal height) {
     qreal radius = qMin(width, height)/2.;
     qreal xm = width/2.;
     qreal ym = height/2.;
     if(xm>=2*ym || ym>=2*xm)
         return qBound<qreal>(5., radius, 32.);
 
     qreal a=-2;
     qreal b=2.*(xm+ym);
     qreal c=radius*radius-xm*xm-ym*ym;
     return qBound<qreal>(5., ((-b+sqrt(b*b-4*a*c))/(2*a)), 32.);
 }
 
 void KisColorSelector::resizeEvent(QResizeEvent* e) {
     if (m_configuration.subType == KisColorSelectorConfiguration::Ring) {
 
         m_ring->setGeometry(0,0,width(), height());
 
         if (displaySettingsButton()) {
             int size = iconSize(width(), height());
             m_button->setGeometry(0, 0, size, size);
         }
 
         if (m_configuration.mainType == KisColorSelectorConfiguration::Triangle) {
             m_triangle->setGeometry(width()/2-m_ring->innerRadius(),
                                     height()/2-m_ring->innerRadius(),
                                     m_ring->innerRadius()*2,
                                     m_ring->innerRadius()*2);
         }
         else {
             int size = m_ring->innerRadius()*2/sqrt(2.);
             m_square->setGeometry(width()/2-size/2,
                                   height()/2-size/2,
                                   size,
                                   size);
         }
     }
     else {
         // type wheel and square
         if (m_configuration.mainType == KisColorSelectorConfiguration::Wheel) {
             if(displaySettingsButton()) {
                 int size = iconSize(width(), height()*0.9);
                 m_button->setGeometry(0, height()*0.1, size, size);
             }
             m_mainComponent->setGeometry(0, height()*0.1, width(), height()*0.9);
             m_subComponent->setGeometry( 0, 0,            width(), height()*0.1);
         }
         else {
             int buttonSize = 0;
             if(displaySettingsButton()) {
                 buttonSize = qBound(20, int(0.1*height()), 32);
                 m_button->setGeometry(0, 0, buttonSize, buttonSize);
             }
 
             if(height()>width()) {
                 int selectorHeight=height()-buttonSize;
                 m_mainComponent->setGeometry(0, buttonSize+selectorHeight*0.1, width(), selectorHeight*0.9);
                 m_subComponent->setGeometry( 0, buttonSize,                    width(), selectorHeight*0.1);
             }
             else {
                 int selectorWidth=width()-buttonSize;
                 m_mainComponent->setGeometry(buttonSize, height()*0.1, selectorWidth, height()*0.9);
                 m_subComponent->setGeometry( buttonSize, 0,            selectorWidth, height()*0.1);
             }
         }
     }
 
     // reset the correct color after resizing the widget
     setColor(m_lastRealColor);
 
     KisColorSelectorBase::resizeEvent(e);
 }
 
 void KisColorSelector::mousePressEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mousePressEvent(e);
 
     if(!e->isAccepted()) {
         if(m_mainComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_mainComponent;
         else if(m_subComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_subComponent;
 
         mouseEvent(e);
         updatePreviousColorPreview();
         e->accept();
     }
 }
 
 void KisColorSelector::mouseMoveEvent(QMouseEvent* e)
 {
     KisColorSelectorBase::mouseMoveEvent(e);
 
     mouseEvent(e);
     e->accept();
 }
 
 void KisColorSelector::mouseReleaseEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mousePressEvent(e);
 
     if(!e->isAccepted() &&
        !(m_lastRealColor == m_currentRealColor)) {
 
         m_lastRealColor = m_currentRealColor;
         m_lastColorRole = Acs::buttonToRole(e->button());
 
         updateColor(m_lastRealColor, m_lastColorRole, false);
         updateBaseColorPreview(m_currentRealColor);
         e->accept();
     }
 
     m_grabbingComponent=0;
 }
 
 bool KisColorSelector::displaySettingsButton()
 {
     return dynamic_cast<KisColorSelectorContainer*>(parent());
 }
 
 void KisColorSelector::setColor(const KoColor &color)
 {
     m_mainComponent->setColor(color);
     m_subComponent->setColor(color);
     m_lastRealColor = color;
 
     m_signalCompressor->start();
 }
 
 void KisColorSelector::mouseEvent(QMouseEvent *e)
 {
     if (m_grabbingComponent && (e->buttons() & Qt::LeftButton || e->buttons() & Qt::RightButton)) {
 
         m_grabbingComponent->mouseEvent(e->x(), e->y());
 
         KoColor color = m_mainComponent->currentColor();
         Acs::ColorRole role = Acs::buttonsToRole(e->button(), e->buttons());
         m_currentRealColor = color;
 
         requestUpdateColorAndPreview(color, role);
     }
 }
 
 void KisColorSelector::init()
 {
     setAcceptDrops(true);
 
     m_lastColorRole = Acs::Foreground;
     m_ring = new KisColorSelectorRing(this);
     m_triangle = new KisColorSelectorTriangle(this);
     m_slider = new KisColorSelectorSimple(this);
     m_square = new KisColorSelectorSimple(this);
     m_wheel = new KisColorSelectorWheel(this);
 
     if(displaySettingsButton()) {
         m_button = new QPushButton(this);
         m_button->setIcon(KisIconUtils::loadIcon("configure"));
         m_button->setFlat(true);
         connect(m_button, SIGNAL(clicked()), SIGNAL(settingsButtonClicked()));
     }
 
     // a tablet can send many more signals, than a mouse
     // this causes many repaints, if updating after every signal.
     m_signalCompressor = new KisSignalCompressor(20, KisSignalCompressor::FIRST_INACTIVE, this);
     connect(m_signalCompressor, SIGNAL(timeout()), SLOT(update()));
 
     setMinimumSize(40, 40);
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
index ab4419fa07..c6e9233f89 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
@@ -1,536 +1,536 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  */
 
 #include "kis_color_selector_base.h"
 
 #include <QMouseEvent>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QTimer>
 #include <QCursor>
 #include <QPainter>
 #include <QMimeData>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node.h"
 #include "KisViewManager.h"
 #include <KisView.h>
 #include "kis_image.h"
 #include "kis_display_color_converter.h"
 
 
 class KisColorPreviewPopup : public QWidget {
 public:
     KisColorPreviewPopup(KisColorSelectorBase* parent) : QWidget(), m_parent(parent)
     {
         setWindowFlags(Qt::ToolTip);
         setQColor(QColor(0,0,0));
         setMouseTracking(true);
         m_baseColor = QColor(0,0,0,0);
         m_previousColor = QColor(0,0,0,0);
         m_lastUsedColor = QColor(0,0,0,0);
     }
 
     void show()
     {
         updatePosition();
         QWidget::show();
     }
 
     void updatePosition()
     {
         QPoint parentPos = m_parent->mapToGlobal(QPoint(0,0));
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         QPoint targetPos;
         if ( parentPos.x() - 100 > availRect.x() ) {
             targetPos =  QPoint(parentPos.x() - 100, parentPos.y());
         } else if ( parentPos.x() + m_parent->width() + 100 < availRect.right()) {
             targetPos = m_parent->mapToGlobal(QPoint(m_parent->width(), 0));
         } else if ( parentPos.y() - 100 > availRect.y() ) {
             targetPos =  QPoint(parentPos.x(), parentPos.y() - 100);
         } else {
             targetPos =  QPoint(parentPos.x(), parentPos.y() + m_parent->height());
         }
         setGeometry(targetPos.x(), targetPos.y(), 100, 150);
         setAttribute(Qt::WA_TranslucentBackground);
     }
 
     void setQColor(const QColor& color)
     {
         m_color = color;
         update();
     }
 
     void setPreviousColor()
     {
         m_previousColor = m_baseColor;
     }
 
     void setBaseColor(const QColor& color)
     {
         m_baseColor = color;
         update();
     }
 
     void setLastUsedColor(const QColor& color)
     {
         m_lastUsedColor = color;
         update();
     }
 
 protected:
     void paintEvent(QPaintEvent *e) override {
         Q_UNUSED(e);
         QPainter p(this);
         p.fillRect(0, 0, width(), width(), m_color);
         p.fillRect(50, width(), width(), height(), m_previousColor);
         p.fillRect(0, width(), 50, height(), m_lastUsedColor);
     }
 
 private:
     KisColorSelectorBase* m_parent;
     QColor m_color;
     QColor m_baseColor;
     QColor m_previousColor;
     QColor m_lastUsedColor;
 };
 
 KisColorSelectorBase::KisColorSelectorBase(QWidget *parent) :
     QWidget(parent),
     m_canvas(0),
     m_popup(0),
     m_parent(0),
     m_colorUpdateAllowed(true),
     m_colorUpdateSelf(false),
     m_hideTimer(new QTimer(this)),
     m_popupOnMouseOver(false),
     m_popupOnMouseClick(true),
     m_colorSpace(0),
     m_isPopup(false),
     m_hideOnMouseClick(false),
     m_colorPreviewPopup(new KisColorPreviewPopup(this))
 {
     m_hideTimer->setInterval(0);
     m_hideTimer->setSingleShot(true);
     connect(m_hideTimer, SIGNAL(timeout()), this, SLOT(hidePopup()));
 
     using namespace std::placeholders; // For _1 placeholder
     auto function = std::bind(&KisColorSelectorBase::slotUpdateColorAndPreview, this, _1);
     m_updateColorCompressor.reset(new ColorCompressorType(20 /* ms */, function));
 }
 
 KisColorSelectorBase::~KisColorSelectorBase()
 {
     delete m_popup;
     delete m_colorPreviewPopup;
 }
 
 void KisColorSelectorBase::setPopupBehaviour(bool onMouseOver, bool onMouseClick)
 {
     m_popupOnMouseClick = onMouseClick;
     m_popupOnMouseOver = onMouseOver;
     if(onMouseClick) {
         m_popupOnMouseOver = false;
     }
 
     if(m_popupOnMouseOver) {
         setMouseTracking(true);
     }
 }
 
 void KisColorSelectorBase::setColorSpace(const KoColorSpace *colorSpace)
 {
     m_colorSpace = colorSpace;
 }
 
 void KisColorSelectorBase::setCanvas(KisCanvas2 *canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
     m_canvas = canvas;
     if (m_canvas) {
-        connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
-                SLOT(canvasResourceChanged(int, const QVariant&)), Qt::UniqueConnection);
+        connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+                SLOT(canvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(reset()));
 
         connect(canvas->imageView()->resourceProvider(), SIGNAL(sigFGColorUsed(KoColor)),
                 this,                               SLOT(updateLastUsedColorPreview(KoColor)), Qt::UniqueConnection);
 
         if (m_canvas->viewManager() && m_canvas->viewManager()->resourceProvider()) {
             setColor(Acs::currentColor(m_canvas->viewManager()->resourceProvider(), Acs::Foreground));
         }
     }
     if (m_popup) {
         m_popup->setCanvas(canvas);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::unsetCanvas()
 {
     if (m_popup) {
         m_popup->unsetCanvas();
     }
     m_canvas = 0;
 }
 
 
 
 void KisColorSelectorBase::mousePressEvent(QMouseEvent* event)
 {
     event->accept();
 
 
 //this boolean here is to check if the colour selector is updating the resource, so it won't update itself when the resource is updated//
    if (m_colorUpdateSelf==false)
    {m_colorUpdateSelf=true;}
 
     if(!m_isPopup && m_popupOnMouseClick &&
        event->button() == Qt::MidButton) {
 
         lazyCreatePopup();
 
         int x = event->globalX();
         int y = event->globalY();
         int popupsize = m_popup->width();
         x-=popupsize/2;
         y-=popupsize/2;
 
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         if(x<availRect.x())
             x = availRect.x();
         if(y<availRect.y())
             y = availRect.y();
         if(x+m_popup->width()>availRect.x()+availRect.width())
             x = availRect.x()+availRect.width()-m_popup->width();
         if(y+m_popup->height()>availRect.y()+availRect.height())
             y = availRect.y()+availRect.height()-m_popup->height();
 
 
         m_popup->move(x, y);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
 
     } else if (m_isPopup && event->button() == Qt::MidButton) {
         hide();
     } else {
         showColorPreview();
         event->ignore();
     }
 }
 
 void KisColorSelectorBase::mouseReleaseEvent(QMouseEvent *e) {
 
    Q_UNUSED(e);
 
     if (e->button() == Qt::MidButton) {
         e->accept();
     } else if (m_isPopup && m_hideOnMouseClick==true && !m_hideTimer->isActive()) {
         showColorPreview();
         hide();
     }
 }
 
 void KisColorSelectorBase::enterEvent(QEvent *e)
 {
     Q_UNUSED(e);
 
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->stop();
     }
 
     if (m_isPopup && m_hideTimer->isActive()) {
         m_hideTimer->stop();
     }
 
     // do not show the popup when boxed in
     // the configuration dialog (m_canvas == 0)
 
     if (m_canvas &&
         !m_isPopup && m_popupOnMouseOver &&
         (!m_popup || m_popup->isHidden())) {
 
         lazyCreatePopup();
 
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         QRect forbiddenRect = QRect(parentWidget()->mapToGlobal(QPoint(0,0)),
                                     QSize(parentWidget()->width(), parentWidget()->height()));
 
         int x,y;
         if(forbiddenRect.y()+forbiddenRect.height()/2 > availRect.height()/2) {
             //popup above forbiddenRect
             y = forbiddenRect.y()-m_popup->height();
         }
         else {
             //popup below forbiddenRect
             y = forbiddenRect.y()+forbiddenRect.height();
         }
 
         if(forbiddenRect.x()+forbiddenRect.width()/2 < availRect.width()/2) {
             //left edge of popup justified with left edge of popup
             x = forbiddenRect.x();
         }
         else {
             //the other way round
             x = forbiddenRect.x()+forbiddenRect.width()-m_popup->width();
         }
 
         m_popup->move(x, y);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
     }
 }
 
 void KisColorSelectorBase::leaveEvent(QEvent *e)
 {
     Q_UNUSED(e);
 
     if (m_colorPreviewPopup->isVisible()) {
         m_colorUpdateSelf=false; //this is for allowing advanced selector to listen to outside colour-change events.
         m_colorPreviewPopup->hide();
     }
 
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->start();
     }
 
     if (m_isPopup && !m_hideTimer->isActive()) {
         m_hideTimer->start();
     }
 }
 
 void KisColorSelectorBase::keyPressEvent(QKeyEvent *)
 {
     if (m_isPopup) {
         hidePopup();
     }
 }
 
 void KisColorSelectorBase::dragEnterEvent(QDragEnterEvent *e)
 {
     if(e->mimeData()->hasColor())
         e->acceptProposedAction();
     if(e->mimeData()->hasText() && QColor(e->mimeData()->text()).isValid())
         e->acceptProposedAction();
 }
 
 void KisColorSelectorBase::dropEvent(QDropEvent *e)
 {
     QColor color;
     if(e->mimeData()->hasColor()) {
         color = qvariant_cast<QColor>(e->mimeData()->colorData());
     }
     else if(e->mimeData()->hasText()) {
         color.setNamedColor(e->mimeData()->text());
         if(!color.isValid())
             return;
     }
 
     KoColor kocolor(color , KoColorSpaceRegistry::instance()->rgb8());
     updateColor(kocolor, Acs::Foreground, true);
 }
 
 void KisColorSelectorBase::updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset)
 {
     commitColor(color, role);
 
     if (needsExplicitColorReset) {
         setColor(color);
     }
 }
 
 void KisColorSelectorBase::requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role)
 {
     m_updateColorCompressor->start(qMakePair(color, role));
 }
 
 void KisColorSelectorBase::slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color)
 {
     updateColorPreview(color.first);
     updateColor(color.first, color.second, false);
 }
 
 void KisColorSelectorBase::setColor(const KoColor& color)
 {
     Q_UNUSED(color);
 }
 
 void KisColorSelectorBase::setHidingTime(int time)
 {
     KIS_ASSERT_RECOVER_NOOP(m_isPopup);
 
     m_hideTimer->setInterval(time);
 }
 
 void KisColorSelectorBase::lazyCreatePopup()
 {
     if (!m_popup) {
         m_popup = createPopup();
         Q_ASSERT(m_popup);
         m_popup->setWindowFlags(Qt::FramelessWindowHint|Qt::SubWindow|Qt::X11BypassWindowManagerHint);
         m_popup->m_parent = this;
         m_popup->m_isPopup=true;
     }
     m_popup->setCanvas(m_canvas);
     m_popup->updateSettings();
 }
 
 void KisColorSelectorBase::showPopup(Move move)
 {
     // This slot may be called by some action,
     // so we need to be able to handle it
     lazyCreatePopup();
 
     QPoint cursorPos = QCursor::pos();
 
     if (move == MoveToMousePosition) {
         m_popup->move(cursorPos.x()-m_popup->width()/2, cursorPos.y()-m_popup->height()/2);
         QRect rc = m_popup->geometry();
         if (rc.x() < 0) rc.setX(0);
         if (rc.y() < 0) rc.setY(0);
         m_popup->setGeometry(rc);
 
     }
     m_popup->show();
     m_popup->m_colorPreviewPopup->show();
 }
 
 void KisColorSelectorBase::hidePopup()
 {
     KIS_ASSERT_RECOVER_RETURN(m_isPopup);
 
     m_colorPreviewPopup->hide();
     hide();
 }
 
 void KisColorSelectorBase::commitColor(const KoColor& color, Acs::ColorRole role)
 {
     if (!m_canvas)
         return;
 
     m_colorUpdateAllowed=false;
 
     if (role == Acs::Foreground)
         m_canvas->resourceManager()->setForegroundColor(color);
     else
         m_canvas->resourceManager()->setBackgroundColor(color);
 
     m_colorUpdateAllowed=true;
 }
 
 void KisColorSelectorBase::showColorPreview()
 {
     if(m_colorPreviewPopup->isHidden()) {
         m_colorPreviewPopup->show();
     }
 }
 
 void KisColorSelectorBase::updateColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setQColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::canvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KoCanvasResourceManager::ForegroundColor || key == KoCanvasResourceManager::BackgroundColor) {
         KoColor realColor(v.value<KoColor>());
         updateColorPreview(realColor);
         if (m_colorUpdateAllowed && !m_colorUpdateSelf) {
             setColor(realColor);
         }
     }
 }
 
 const KoColorSpace* KisColorSelectorBase::colorSpace() const
 {
     return converter()->paintingColorSpace();
 }
 
 void KisColorSelectorBase::updateSettings()
 {
     if(m_popup) {
         m_popup->updateSettings();
     }
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
 
    int zoomSelectorOptions =  (int) cfg.readEntry("zoomSelectorOptions", 0) ;
    if (zoomSelectorOptions == 0)   {
        setPopupBehaviour(false, true);   // middle mouse button click will open zoom selector
    } else if (zoomSelectorOptions == 1)   {
        setPopupBehaviour(true, false);   // move over will open the zoom selector
    }
    else
    {
         setPopupBehaviour(false, false); // do not show zoom selector
    }
 
 
     if(m_isPopup) {
         m_hideOnMouseClick = cfg.readEntry("hidePopupOnClickCheck", false);
         const int zoomSize = cfg.readEntry("zoomSize", 280);
         resize(zoomSize, zoomSize);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::reset()
 {
     update();
 }
 
 void KisColorSelectorBase::updateBaseColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setBaseColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::updatePreviousColorPreview()
 {
     m_colorPreviewPopup->setPreviousColor();
 }
 
 void KisColorSelectorBase::updateLastUsedColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setLastUsedColor(converter()->toQColor(color));
 }
 
 KisDisplayColorConverter* KisColorSelectorBase::converter() const
 {
     return m_canvas ?
         m_canvas->displayColorConverter() :
         KisDisplayColorConverter::dumbConverterInstance();
 }
 
 
 void KisColorSelectorBase::mouseMoveEvent(QMouseEvent *event)
 {
     event->accept();
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_common_colors.cpp b/plugins/dockers/advancedcolorselector/kis_common_colors.cpp
index 6f4ee57827..f8512ea1b3 100644
--- a/plugins/dockers/advancedcolorselector/kis_common_colors.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_common_colors.cpp
@@ -1,139 +1,139 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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_common_colors.h"
 #include <QImage>
 #include <QList>
 #include <QPushButton>
 #include <QColor>
 #include <QRunnable>
 #include <QThreadPool>
 #include <QApplication>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include "KoColor.h"
 #include "kis_canvas2.h"
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_config.h"
 #include "kis_common_colors_recalculation_runner.h"
 
 
 KisCommonColors::KisCommonColors(QWidget *parent) :
     KisColorPatches("commonColors", parent)
 {
     m_reloadButton = new QPushButton();
     m_reloadButton->setIcon(KisIconUtils::loadIcon("view-refresh"));
     m_reloadButton->setToolTip(i18n("Create a list of colors from the image"));
     connect(m_reloadButton, SIGNAL(clicked()), this, SLOT(recalculate()));
 
     QList<QWidget*> tmpList;
     tmpList.append(m_reloadButton);
     setAdditionalButtons(tmpList);
     updateSettings();
 
     m_recalculationTimer.setInterval(2000);
     m_recalculationTimer.setSingleShot(true);
 
     connect(&m_recalculationTimer, SIGNAL(timeout()),
             this,                  SLOT(recalculate()));
 
 }
 
 void KisCommonColors::setCanvas(KisCanvas2 *canvas)
 {
     KisColorPatches::setCanvas(canvas);
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     if (cfg.readEntry("commonColorsAutoUpdate", false)) {
         if (m_image) {
             m_image->disconnect(this);
         }
         if (m_canvas) {
-            connect(m_canvas->image(), SIGNAL(sigImageUpdated(const QRect &)),
+            connect(m_canvas->image(), SIGNAL(sigImageUpdated(QRect)),
                     &m_recalculationTimer, SLOT(start()), Qt::UniqueConnection);
             m_image = m_canvas->image();
         }
         else {
             m_image = 0;
         }
     }
 }
 
 KisColorSelectorBase* KisCommonColors::createPopup() const
 {
     KisCommonColors* ret = new KisCommonColors();
     ret->setCanvas(m_canvas);
     ret->setColors(colors());
     return ret;
 }
 
 void KisCommonColors::updateSettings()
 {
     KisColorPatches::updateSettings();
 
     if(!(m_canvas && m_canvas->image()))
         return;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     if (cfg.readEntry("commonColorsAutoUpdate", false)) {
-        connect(m_canvas->image(), SIGNAL(sigImageUpdated(const QRect &)),
+        connect(m_canvas->image(), SIGNAL(sigImageUpdated(QRect)),
                 &m_recalculationTimer, SLOT(start()), Qt::UniqueConnection);
     }
     else {
-        disconnect(m_canvas->image(), SIGNAL(sigImageUpdated(const QRect &)),
+        disconnect(m_canvas->image(), SIGNAL(sigImageUpdated(QRect)),
                 &m_recalculationTimer, SLOT(start()));
     }
 
     m_reloadButton->setEnabled(true);
 }
 
 void KisCommonColors::setColors(QList<KoColor> colors)
 {
     QMutexLocker locker(&m_mutex);
     KisColorPatches::setColors(colors);
     m_reloadButton->setEnabled(true);
     m_calculatedColors = colors;
 }
 
 void KisCommonColors::recalculate()
 {
     if (!m_canvas) {
         return;
     }
     if(m_reloadButton->isEnabled()==false) {
         // on old computation is still running
         // try later to recalculate
         m_recalculationTimer.start();
         return;
     }
     m_reloadButton->setEnabled(false);
     qApp->processEvents();
 
     KisImageWSP kisImage = m_canvas->image();
 
     QImage image = kisImage->projection()->createThumbnail(1024, 1024, kisImage->bounds(), 1, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 
     KisCommonColorsRecalculationRunner* runner = new KisCommonColorsRecalculationRunner(image, patchCount(), this);
     QThreadPool::globalInstance()->start(runner);
 }
 
diff --git a/plugins/dockers/animation/kis_equalizer_widget.cpp b/plugins/dockers/animation/kis_equalizer_widget.cpp
index 7a05139fc5..055a446458 100644
--- a/plugins/dockers/animation/kis_equalizer_widget.cpp
+++ b/plugins/dockers/animation/kis_equalizer_widget.cpp
@@ -1,153 +1,153 @@
 /*
  *  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_equalizer_widget.h"
 
 #include <QMouseEvent>
 #include <QApplication>
 #include <QHBoxLayout>
 
 #include "kis_equalizer_column.h"
 #include "kis_signal_compressor.h"
 
 #include "timeline_color_scheme.h"
 
 #include "kis_debug.h"
 
 
 struct KisEqualizerWidget::Private
 {
     Private()
         : maxDistance(0),
           updateCompressor(300, KisSignalCompressor::FIRST_ACTIVE)
     {
     }
 
     QMap<int, KisEqualizerColumn*> columns;
     int maxDistance;
     KisSignalCompressor updateCompressor;
 };
 
 KisEqualizerWidget::KisEqualizerWidget(int maxDistance, QWidget *parent)
     : QWidget(parent),
       m_d(new Private)
 {
     m_d->maxDistance = maxDistance;
 
     QHBoxLayout *layout = new QHBoxLayout(this);
     layout->setSpacing(0);
 
     for (int i = -m_d->maxDistance; i <= m_d->maxDistance; i++) {
         KisEqualizerColumn *c = new KisEqualizerColumn(this, i, QString::number(i));
         layout->addWidget(c, i == 0 ? 2 : 1);
 
         if (i == m_d->maxDistance) {
             c->setRightmost(true);
         }
 
         m_d->columns.insert(i, c);
 
-        connect(c, SIGNAL(sigColumnChanged(int, bool, int)),
+        connect(c, SIGNAL(sigColumnChanged(int,bool,int)),
                 &m_d->updateCompressor, SLOT(start()));
     }
 
     connect(&m_d->updateCompressor, SIGNAL(timeout()), SIGNAL(sigConfigChanged()));
-    connect(m_d->columns[0], SIGNAL(sigColumnChanged(int,bool,int)), this, SLOT(slotMasterColumnChanged(int, bool, int)));
+    connect(m_d->columns[0], SIGNAL(sigColumnChanged(int,bool,int)), this, SLOT(slotMasterColumnChanged(int,bool,int)));
 
     setLayout(layout);
 }
 
 KisEqualizerWidget::~KisEqualizerWidget()
 {
 }
 
 KisEqualizerWidget::EqualizerValues KisEqualizerWidget::getValues() const
 {
     EqualizerValues v;
     v.maxDistance = m_d->maxDistance;
 
     for (int i = -m_d->maxDistance; i <= m_d->maxDistance; i++) {
         v.value.insert(i, m_d->columns[i]->value());
         v.state.insert(i, m_d->columns[i]->state());
     }
 
     return v;
 }
 
 void KisEqualizerWidget::setValues(const EqualizerValues &v)
 {
     for (int i = -m_d->maxDistance; i <= m_d->maxDistance; i++) {
         if (qAbs(i) <= v.maxDistance) {
             m_d->columns[i]->setValue(v.value[i]);
             m_d->columns[i]->setState(v.state[i]);
         } else {
             m_d->columns[i]->setState(false);
         }
     }
 }
 
 void KisEqualizerWidget::toggleMasterSwitch()
 {
     const bool currentState = m_d->columns[0]->state();
     m_d->columns[0]->setState(!currentState);
 }
 
 void KisEqualizerWidget::resizeEvent(QResizeEvent *event)
 {
     Q_UNUSED(event);
     const QSize newSize = m_d->columns[1]->size();
 
     QFont font =
         TimelineColorScheme::instance()->getOnionSkinsFont(
             QString::number(100), newSize);
 
     if (font.pointSize() != this->font().pointSize()) {
         setFont(font);
 
         for (int i = -m_d->maxDistance; i <= m_d->maxDistance; i++) {
             m_d->columns[i]->setFont(font);
         }
 
     }
 }
 
 void KisEqualizerWidget::mouseMoveEvent(QMouseEvent *ev)
 {
     if (!(ev->modifiers() & Qt::ShiftModifier)) return;
 
     QPoint globalPos = ev->globalPos();
     QWidget *w = qApp->widgetAt(globalPos);
 
     if (w && w->inherits("QAbstractSlider")) {
         QMouseEvent newEv(ev->type(),
                           w->mapFromGlobal(globalPos),
                           globalPos,
                           ev->button(),
                           ev->buttons(),
                           ev->modifiers() & ~Qt::ShiftModifier);
         qApp->sendEvent(w, &newEv);
     }
 }
 
 void KisEqualizerWidget::slotMasterColumnChanged(int, bool state, int)
 {
     for (int i = 1; i <= m_d->maxDistance; i++) {
         m_d->columns[i]->setForceDisabled(!state);
         m_d->columns[-i]->setForceDisabled(!state);
     }
 }
diff --git a/plugins/dockers/animation/timeline_frames_view.cpp b/plugins/dockers/animation/timeline_frames_view.cpp
index b3cdc8124f..0954298403 100644
--- a/plugins/dockers/animation/timeline_frames_view.cpp
+++ b/plugins/dockers/animation/timeline_frames_view.cpp
@@ -1,1503 +1,1503 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_frames_view.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_ruler_header.h"
 #include "timeline_layers_header.h"
 #include "timeline_insert_keyframe_dialog.h"
 #include "timeline_frames_item_delegate.h"
 
 #include <QPainter>
 #include <QApplication>
 #include <QDropEvent>
 #include <QMenu>
 #include <QScrollBar>
 #include <QDrag>
 #include <QInputDialog>
 #include <QClipboard>
 #include <QMimeData>
 
 #include "KSharedConfig"
 
 #include "kis_zoom_button.h"
 #include "kis_icon_utils.h"
 #include "kis_animation_utils.h"
 #include "kis_custom_modifiers_catcher.h"
 #include "kis_action.h"
 #include "kis_signal_compressor.h"
 #include "kis_time_range.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_slider_spin_box.h"
 #include <KisImportExportManager.h>
 #include <kis_signals_blocker.h>
 #include <kis_image_config.h>
 
 #include <KoFileDialog.h>
 #include <KoIconToolTip.h>
 
 typedef QPair<QRect, QModelIndex> QItemViewPaintPair;
 typedef QList<QItemViewPaintPair> QItemViewPaintPairs;
 
 struct TimelineFramesView::Private
 {
     Private(TimelineFramesView *_q)
         : q(_q),
           fps(1),
           zoomStillPointIndex(-1),
           zoomStillPointOriginalOffset(0),
           dragInProgress(false),
           dragWasSuccessful(false),
           modifiersCatcher(0),
           selectionChangedCompressor(300, KisSignalCompressor::FIRST_INACTIVE)
     {}
 
     TimelineFramesView *q;
 
     TimelineFramesModel *model;
     TimelineRulerHeader *horizontalRuler;
     TimelineLayersHeader *layersHeader;
     int fps;
     int zoomStillPointIndex;
     int zoomStillPointOriginalOffset;
     QPoint initialDragPanValue;
     QPoint initialDragPanPos;
 
     QToolButton *addLayersButton;
     KisAction *showHideLayerAction;
 
     QToolButton *audioOptionsButton;
 
     KisColorLabelSelectorWidget *colorSelector;
     QWidgetAction *colorSelectorAction;
     KisColorLabelSelectorWidget *multiframeColorSelector;
     QWidgetAction *multiframeColorSelectorAction;
 
     QMenu *audioOptionsMenu;
     QAction *openAudioAction;
     QAction *audioMuteAction;
     KisSliderSpinBox *volumeSlider;
 
     QMenu *layerEditingMenu;
     QMenu *existingLayersMenu;
 
     TimelineInsertKeyframeDialog *insertKeyframeDialog;
 
     KisZoomButton *zoomDragButton;
 
     bool dragInProgress;
     bool dragWasSuccessful;
 
     KisCustomModifiersCatcher *modifiersCatcher;
     QPoint lastPressedPosition;
     Qt::KeyboardModifiers lastPressedModifier;
     KisSignalCompressor selectionChangedCompressor;
 
     QStyleOptionViewItem viewOptionsV4() const;
     QItemViewPaintPairs draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const;
     QPixmap renderToPixmap(const QModelIndexList &indexes, QRect *r) const;
 
     KoIconToolTip tip;
 
     KisActionManager *actionMan = 0;
 };
 
 TimelineFramesView::TimelineFramesView(QWidget *parent)
     : QTableView(parent),
       m_d(new Private(this))
 {
     m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
     m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
     m_d->modifiersCatcher->addModifier("offset-frame", Qt::Key_Alt);
 
     setCornerButtonEnabled(false);
     setSelectionBehavior(QAbstractItemView::SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     setItemDelegate(new TimelineFramesItemDelegate(this));
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
     setDefaultDropAction(Qt::MoveAction);
 
     m_d->horizontalRuler = new TimelineRulerHeader(this);
     this->setHorizontalHeader(m_d->horizontalRuler);
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnLeft()), SLOT(slotInsertKeyframeColumnLeft()));
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnRight()), SLOT(slotInsertKeyframeColumnRight()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertMultipleColumns()), SLOT(slotInsertMultipleKeyframeColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumns()), SLOT(slotRemoveSelectedColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumnsAndShift()), SLOT(slotRemoveSelectedColumnsAndShift()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumns()), SLOT(slotInsertHoldFrameColumn()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumns()), SLOT(slotRemoveHoldFrameColumn()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumnsCustom()), SLOT(slotInsertMultipleHoldFrameColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumnsCustom()), SLOT(slotRemoveMultipleHoldFrameColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigMirrorColumns()), SLOT(slotMirrorColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigCopyColumns()), SLOT(slotCopyColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigCutColumns()), SLOT(slotCutColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigPasteColumns()), SLOT(slotPasteColumns()));
 
     m_d->layersHeader = new TimelineLayersHeader(this);
 
     m_d->layersHeader->setSectionResizeMode(QHeaderView::Fixed);
 
     m_d->layersHeader->setDefaultSectionSize(24);
     m_d->layersHeader->setMinimumWidth(60);
     m_d->layersHeader->setHighlightSections(true);
 
     this->setVerticalHeader(m_d->layersHeader);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), SLOT(slotUpdateInfiniteFramesCount()));
     connect(horizontalScrollBar(), SIGNAL(sliderReleased()), SLOT(slotUpdateInfiniteFramesCount()));
 
     /********** New Layer Menu ***********************************************************/
 
     m_d->addLayersButton = new QToolButton(this);
     m_d->addLayersButton->setAutoRaise(true);
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->addLayersButton->setIconSize(QSize(20, 20));
     m_d->addLayersButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->layerEditingMenu = new QMenu(this);
     m_d->layerEditingMenu->addAction(KisAnimationUtils::newLayerActionName, this, SLOT(slotAddNewLayer()));
     m_d->existingLayersMenu = m_d->layerEditingMenu->addMenu(KisAnimationUtils::addExistingLayerActionName);
     m_d->layerEditingMenu->addSeparator();
 
     m_d->layerEditingMenu->addAction(KisAnimationUtils::removeLayerActionName, this, SLOT(slotRemoveLayer()));
 
     connect(m_d->existingLayersMenu, SIGNAL(aboutToShow()), SLOT(slotUpdateLayersMenu()));
     connect(m_d->existingLayersMenu, SIGNAL(triggered(QAction*)), SLOT(slotAddExistingLayer(QAction*)));
 
-    connect(m_d->layersHeader, SIGNAL(sigRequestContextMenu(const QPoint&)), SLOT(slotLayerContextMenuRequested(const QPoint&)));
+    connect(m_d->layersHeader, SIGNAL(sigRequestContextMenu(QPoint)), SLOT(slotLayerContextMenuRequested(QPoint)));
 
     m_d->addLayersButton->setMenu(m_d->layerEditingMenu);
 
     /********** Audio Channel Menu *******************************************************/
 
     m_d->audioOptionsButton = new QToolButton(this);
     m_d->audioOptionsButton->setAutoRaise(true);
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->audioOptionsButton->setIconSize(QSize(20, 20)); // very small on windows if not explicitly set
     m_d->audioOptionsButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->audioOptionsMenu = new QMenu(this);
 
 #ifndef HAVE_QT_MULTIMEDIA
     m_d->audioOptionsMenu->addSection(i18nc("@item:inmenu", "Audio playback is not supported in this build!"));
 #endif
 
     m_d->openAudioAction= new QAction("XXX", this);
     connect(m_d->openAudioAction, SIGNAL(triggered()), this, SLOT(slotSelectAudioChannelFile()));
     m_d->audioOptionsMenu->addAction(m_d->openAudioAction);
 
     m_d->audioMuteAction = new QAction(i18nc("@item:inmenu", "Mute"), this);
     m_d->audioMuteAction->setCheckable(true);
     connect(m_d->audioMuteAction, SIGNAL(triggered(bool)), SLOT(slotAudioChannelMute(bool)));
 
     m_d->audioOptionsMenu->addAction(m_d->audioMuteAction);
     m_d->audioOptionsMenu->addAction(i18nc("@item:inmenu", "Remove audio"), this, SLOT(slotAudioChannelRemove()));
 
     m_d->audioOptionsMenu->addSeparator();
 
     m_d->volumeSlider = new KisSliderSpinBox(this);
     m_d->volumeSlider->setRange(0, 100);
     m_d->volumeSlider->setSuffix("%");
     m_d->volumeSlider->setPrefix(i18nc("@item:inmenu, slider", "Volume:"));
     m_d->volumeSlider->setSingleStep(1);
     m_d->volumeSlider->setPageStep(10);
     m_d->volumeSlider->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
 
     connect(m_d->volumeSlider, SIGNAL(valueChanged(int)), SLOT(slotAudioVolumeChanged(int)));
 
     QWidgetAction *volumeAction = new QWidgetAction(m_d->audioOptionsMenu);
     volumeAction->setDefaultWidget(m_d->volumeSlider);
     m_d->audioOptionsMenu->addAction(volumeAction);
 
     m_d->audioOptionsButton->setMenu(m_d->audioOptionsMenu);
 
     /********** Frame Editing Context Menu ***********************************************/
 
     m_d->colorSelector = new KisColorLabelSelectorWidget(this);
     m_d->colorSelectorAction = new QWidgetAction(this);
     m_d->colorSelectorAction->setDefaultWidget(m_d->colorSelector);
     connect(m_d->colorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     m_d->multiframeColorSelector = new KisColorLabelSelectorWidget(this);
     m_d->multiframeColorSelectorAction = new QWidgetAction(this);
     m_d->multiframeColorSelectorAction->setDefaultWidget(m_d->multiframeColorSelector);
     connect(m_d->multiframeColorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     /********** Insert Keyframes Dialog **************************************************/
 
     m_d->insertKeyframeDialog = new TimelineInsertKeyframeDialog(this);
 
     /********** Zoom Button **************************************************************/
 
     m_d->zoomDragButton = new KisZoomButton(this);
     m_d->zoomDragButton->setAutoRaise(true);
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
     m_d->zoomDragButton->setIconSize(QSize(20, 20)); // this icon is very small on windows if no explicitly set
 
     m_d->zoomDragButton->setToolTip(i18nc("@info:tooltip", "Zoom Timeline. Hold down and drag left or right."));
     m_d->zoomDragButton->setPopupMode(QToolButton::InstantPopup);
     connect(m_d->zoomDragButton, SIGNAL(zoomLevelChanged(qreal)), SLOT(slotZoomButtonChanged(qreal)));
     connect(m_d->zoomDragButton, SIGNAL(zoomStarted(qreal)), SLOT(slotZoomButtonPressed(qreal)));
 
     setFramesPerSecond(12);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotSelectionChanged()));
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotUpdateFrameActions()));
 
     {
         QClipboard *cb = QApplication::clipboard();
         connect(cb, SIGNAL(dataChanged()), SLOT(slotUpdateFrameActions()));
     }
 }
 
 TimelineFramesView::~TimelineFramesView()
 {
 }
 
 void TimelineFramesView::setShowInTimeline(KisAction *action)
 {
     m_d->showHideLayerAction = action;
     m_d->layerEditingMenu->addAction(m_d->showHideLayerAction);
 }
 
 void TimelineFramesView::setActionManager(KisActionManager *actionManager)
 {
     m_d->actionMan = actionManager;
     m_d->horizontalRuler->setActionManager(actionManager);
 
 
     if (actionManager) {
         KisAction *action = 0;
 
         action = m_d->actionMan->createAction("add_blank_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddBlankFrame()));
 
         action = m_d->actionMan->createAction("add_duplicate_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddDuplicateFrame()));
 
         action = m_d->actionMan->createAction("insert_keyframe_left");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeLeft()));
 
         action = m_d->actionMan->createAction("insert_keyframe_right");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeRight()));
 
         action = m_d->actionMan->createAction("insert_multiple_keyframes");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleKeyframes()));
 
         action = m_d->actionMan->createAction("remove_frames_and_pull");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFramesAndShift()));
 
         action = m_d->actionMan->createAction("remove_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFrames()));
 
         action = m_d->actionMan->createAction("insert_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertHoldFrame()));
 
         action = m_d->actionMan->createAction("insert_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("remove_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveHoldFrame()));
 
         action = m_d->actionMan->createAction("remove_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("mirror_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotMirrorFrames()));
 
         action = m_d->actionMan->createAction("copy_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCopyFrames()));
 
         action = m_d->actionMan->createAction("cut_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCutFrames()));
 
         action = m_d->actionMan->createAction("paste_frames_from_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotPasteFrames()));
 
         action = m_d->actionMan->createAction("set_start_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetStartTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("set_end_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetEndTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("update_playback_range");
         connect(action, SIGNAL(triggered()), SLOT(slotUpdatePlackbackRange()));
     }
 }
 
 void resizeToMinimalSize(QAbstractButton *w, int minimalSize) {
     QSize buttonSize = w->sizeHint();
     if (buttonSize.height() > minimalSize) {
         buttonSize = QSize(minimalSize, minimalSize);
     }
     w->resize(buttonSize);
 }
 
 void TimelineFramesView::updateGeometries()
 {
     QTableView::updateGeometries();
 
     const int availableHeight = m_d->horizontalRuler->height();
     const int margin = 2;
     const int minimalSize = availableHeight - 2 * margin;
 
     resizeToMinimalSize(m_d->addLayersButton, minimalSize);
     resizeToMinimalSize(m_d->audioOptionsButton, minimalSize);
     resizeToMinimalSize(m_d->zoomDragButton, minimalSize);
 
     int x = 2 * margin;
     int y = (availableHeight - minimalSize) / 2;
     m_d->addLayersButton->move(x, 2 * y);
     m_d->audioOptionsButton->move(x + minimalSize + 2 * margin, 2 * y);
 
     const int availableWidth = m_d->layersHeader->width();
 
     x = availableWidth - margin - minimalSize;
     m_d->zoomDragButton->move(x, 2 * y);
 }
 
 void TimelineFramesView::setModel(QAbstractItemModel *model)
 {
     TimelineFramesModel *framesModel = qobject_cast<TimelineFramesModel*>(model);
     m_d->model = framesModel;
 
     QTableView::setModel(model);
 
-    connect(m_d->model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
-            this, SLOT(slotHeaderDataChanged(Qt::Orientation, int, int)));
+    connect(m_d->model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
+            this, SLOT(slotHeaderDataChanged(Qt::Orientation,int,int)));
 
     connect(m_d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(slotDataChanged(QModelIndex,QModelIndex)));
 
-    connect(m_d->model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
+    connect(m_d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SLOT(slotReselectCurrentIndex()));
 
     connect(m_d->model, SIGNAL(sigInfiniteTimelineUpdateNeeded()),
             this, SLOT(slotUpdateInfiniteFramesCount()));
 
     connect(m_d->model, SIGNAL(sigAudioChannelChanged()),
             this, SLOT(slotUpdateAudioActions()));
 
-    connect(selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
+    connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             &m_d->selectionChangedCompressor, SLOT(start()));
 
     connect(m_d->model, SIGNAL(sigEnsureRowVisible(int)), SLOT(slotEnsureRowVisible(int)));
     slotUpdateAudioActions();
 }
 
 void TimelineFramesView::setFramesPerSecond(int fps)
 {
     m_d->fps = fps;
     m_d->horizontalRuler->setFramePerSecond(fps);
 
     // For some reason simple update sometimes doesn't work here, so
     // reset the whole header
     //
     // m_d->horizontalRuler->reset();
 }
 
 void TimelineFramesView::slotZoomButtonPressed(qreal staticPoint)
 {
     m_d->zoomStillPointIndex =
             qIsNaN(staticPoint) ? currentIndex().column() : staticPoint;
 
     const int w = m_d->horizontalRuler->defaultSectionSize();
 
     m_d->zoomStillPointOriginalOffset =
             w * m_d->zoomStillPointIndex -
             horizontalScrollBar()->value();
 }
 
 void TimelineFramesView::slotZoomButtonChanged(qreal zoomLevel)
 {
     if (m_d->horizontalRuler->setZoom(zoomLevel)) {
         slotUpdateInfiniteFramesCount();
 
         const int w = m_d->horizontalRuler->defaultSectionSize();
         horizontalScrollBar()->setValue(w * m_d->zoomStillPointIndex - m_d->zoomStillPointOriginalOffset);
 
         viewport()->update();
     }
 }
 
 void TimelineFramesView::slotColorLabelChanged(int label)
 {
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, label, TimelineFramesModel::FrameColorLabelIndexRole);
     }
     KisImageConfig(false).setDefaultFrameColorLabel(label);
 }
 
 void TimelineFramesView::slotSelectAudioChannelFile()
 {
     if (!m_d->model) return;
 
     QString defaultDir = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
 
     const QString currentFile = m_d->model->audioChannelFileName();
     QDir baseDir = QFileInfo(currentFile).absoluteDir();
     if (baseDir.exists()) {
         defaultDir = baseDir.absolutePath();
     }
 
     const QString result = KisImportExportManager::askForAudioFileName(defaultDir, this);
     const QFileInfo info(result);
 
     if (info.exists()) {
         m_d->model->setAudioChannelFileName(info.absoluteFilePath());
     }
 }
 
 void TimelineFramesView::slotAudioChannelMute(bool value)
 {
     if (!m_d->model) return;
 
     if (value != m_d->model->isAudioMuted()) {
         m_d->model->setAudioMuted(value);
     }
 }
 
 void TimelineFramesView::slotUpdateIcons()
 {
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
 }
 
 void TimelineFramesView::slotAudioChannelRemove()
 {
     if (!m_d->model) return;
     m_d->model->setAudioChannelFileName(QString());
 }
 
 void TimelineFramesView::slotUpdateAudioActions()
 {
     if (!m_d->model) return;
 
     const QString currentFile = m_d->model->audioChannelFileName();
 
     if (currentFile.isEmpty()) {
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Open audio..."));
     } else {
         QFileInfo info(currentFile);
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Change audio (%1)...", info.fileName()));
     }
 
     m_d->audioMuteAction->setChecked(m_d->model->isAudioMuted());
 
     QIcon audioIcon;
     if (currentFile.isEmpty()) {
         audioIcon = KisIconUtils::loadIcon("audio-none");
     } else {
         if (m_d->model->isAudioMuted()) {
             audioIcon = KisIconUtils::loadIcon("audio-volume-mute");
         } else {
             audioIcon = KisIconUtils::loadIcon("audio-volume-high");
         }
     }
 
     m_d->audioOptionsButton->setIcon(audioIcon);
 
     m_d->volumeSlider->setEnabled(!m_d->model->isAudioMuted());
 
     KisSignalsBlocker b(m_d->volumeSlider);
     m_d->volumeSlider->setValue(qRound(m_d->model->audioVolume() * 100.0));
 }
 
 void TimelineFramesView::slotAudioVolumeChanged(int value)
 {
     m_d->model->setAudioVolume(qreal(value) / 100.0);
 }
 
 void TimelineFramesView::slotUpdateInfiniteFramesCount()
 {
     if (horizontalScrollBar()->isSliderDown()) return;
 
     const int sectionWidth = m_d->horizontalRuler->defaultSectionSize();
     const int calculatedIndex =
             (horizontalScrollBar()->value() +
              m_d->horizontalRuler->width() - 1) / sectionWidth;
 
     m_d->model->setLastVisibleFrame(calculatedIndex);
 }
 
 void TimelineFramesView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTableView::currentChanged(current, previous);
 
     if (previous.column() != current.column()) {
         m_d->model->setData(previous, false, TimelineFramesModel::ActiveFrameRole);
         m_d->model->setData(current, true, TimelineFramesModel::ActiveFrameRole);
     }
 }
 
 QItemSelectionModel::SelectionFlags TimelineFramesView::selectionCommand(const QModelIndex &index,
                                                                          const QEvent *event) const
 {
     // WARNING: Copy-pasted from KisNodeView! Please keep in sync!
 
     /**
      * Qt has a bug: when we Ctrl+click on an item, the item's
      * selections gets toggled on mouse *press*, whereas usually it is
      * done on mouse *release*.  Therefore the user cannot do a
      * Ctrl+D&D with the default configuration. This code fixes the
      * problem by manually returning QItemSelectionModel::NoUpdate
      * flag when the user clicks on an item and returning
      * QItemSelectionModel::Toggle on release.
      */
 
     if (event &&
             (event->type() == QEvent::MouseButtonPress ||
              event->type() == QEvent::MouseButtonRelease) &&
             index.isValid()) {
 
         const QMouseEvent *mevent = static_cast<const QMouseEvent*>(event);
 
         if (mevent->button() == Qt::RightButton &&
                 selectionModel()->selectedIndexes().contains(index)) {
 
             // Allow calling context menu for multiple layers
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonPress &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonRelease &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::Toggle;
         }
     }
 
     return QAbstractItemView::selectionCommand(index, event);
 }
 
 void TimelineFramesView::slotSelectionChanged()
 {
     int minColumn = std::numeric_limits<int>::max();
     int maxColumn = std::numeric_limits<int>::min();
 
     foreach (const QModelIndex &idx, selectedIndexes()) {
         if (idx.column() > maxColumn) {
             maxColumn = idx.column();
         }
 
         if (idx.column() < minColumn) {
             minColumn = idx.column();
         }
     }
 
     KisTimeRange range;
     if (maxColumn > minColumn) {
         range = KisTimeRange(minColumn, maxColumn - minColumn + 1);
     }
     m_d->model->setPlaybackRange(range);
 }
 
 void TimelineFramesView::slotReselectCurrentIndex()
 {
     QModelIndex index = currentIndex();
     currentChanged(index, index);
 }
 
 void TimelineFramesView::slotEnsureRowVisible(int row)
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() || row < 0) return;
 
     index = m_d->model->index(row, index.column());
     scrollTo(index);
 }
 
 void TimelineFramesView::slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
 {
     if (m_d->model->isPlaybackActive()) return;
 
     int selectedColumn = -1;
 
     for (int j = topLeft.column(); j <= bottomRight.column(); j++) {
         QVariant value = m_d->model->data(
                     m_d->model->index(topLeft.row(), j),
                     TimelineFramesModel::ActiveFrameRole);
 
         if (value.isValid() && value.toBool()) {
             selectedColumn = j;
             break;
         }
     }
 
     QModelIndex index = currentIndex();
 
     if (!index.isValid() && selectedColumn < 0) {
         return;
     }
 
 
     if (selectedColumn == -1) {
         selectedColumn = index.column();
     }
 
     if (selectedColumn != index.column() && !m_d->dragInProgress) {
         int row= index.isValid() ? index.row() : 0;
         selectionModel()->setCurrentIndex(m_d->model->index(row, selectedColumn), QItemSelectionModel::ClearAndSelect);
     }
 }
 
 void TimelineFramesView::slotHeaderDataChanged(Qt::Orientation orientation, int first, int last)
 {
     Q_UNUSED(first);
     Q_UNUSED(last);
 
     if (orientation == Qt::Horizontal) {
         const int newFps = m_d->model->headerData(0, Qt::Horizontal, TimelineFramesModel::FramesPerSecondRole).toInt();
 
         if (newFps != m_d->fps) {
             setFramesPerSecond(newFps);
         }
     }
 }
 
 void TimelineFramesView::rowsInserted(const QModelIndex& parent, int start, int end)
 {
     QTableView::rowsInserted(parent, start, end);
 }
 
 inline bool isIndexDragEnabled(QAbstractItemModel *model, const QModelIndex &index) {
     return (model->flags(index) & Qt::ItemIsDragEnabled);
 }
 
 QStyleOptionViewItem TimelineFramesView::Private::viewOptionsV4() const
 {
     QStyleOptionViewItem option = q->viewOptions();
     option.locale = q->locale();
     option.locale.setNumberOptions(QLocale::OmitGroupSeparator);
     option.widget = q;
     return option;
 }
 
 QItemViewPaintPairs TimelineFramesView::Private::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QRect &rect = *r;
     const QRect viewportRect = q->viewport()->rect();
     QItemViewPaintPairs ret;
     for (int i = 0; i < indexes.count(); ++i) {
         const QModelIndex &index = indexes.at(i);
         const QRect current = q->visualRect(index);
         if (current.intersects(viewportRect)) {
             ret += qMakePair(current, index);
             rect |= current;
         }
     }
     rect &= viewportRect;
     return ret;
 }
 
 QPixmap TimelineFramesView::Private::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
     if (paintPairs.isEmpty())
         return QPixmap();
     QPixmap pixmap(r->size());
     pixmap.fill(Qt::transparent);
     QPainter painter(&pixmap);
     QStyleOptionViewItem option = viewOptionsV4();
     option.state |= QStyle::State_Selected;
     for (int j = 0; j < paintPairs.count(); ++j) {
         option.rect = paintPairs.at(j).first.translated(-r->topLeft());
         const QModelIndex &current = paintPairs.at(j).second;
         //adjustViewOptionsForIndex(&option, current);
 
         q->itemDelegate(current)->paint(&painter, option, current);
     }
     return pixmap;
 }
 
 void TimelineFramesView::startDrag(Qt::DropActions supportedActions)
 {
     QModelIndexList indexes = selectionModel()->selectedIndexes();
 
     if (!indexes.isEmpty() && m_d->modifiersCatcher->modifierPressed("offset-frame")) {
         QVector<int> rows;
         int leftmostColumn = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             leftmostColumn = qMin(leftmostColumn, index.column());
             if (!rows.contains(index.row())) {
                 rows.append(index.row());
             }
         }
 
         const int lastColumn = m_d->model->columnCount() - 1;
 
         selectionModel()->clear();
         Q_FOREACH (const int row, rows) {
             QItemSelection sel(m_d->model->index(row, leftmostColumn), m_d->model->index(row, lastColumn));
             selectionModel()->select(sel, QItemSelectionModel::Select);
         }
 
         supportedActions = Qt::MoveAction;
 
         {
             QModelIndexList indexes = selectedIndexes();
             for(int i = indexes.count() - 1 ; i >= 0; --i) {
                 if (!isIndexDragEnabled(m_d->model, indexes.at(i)))
                     indexes.removeAt(i);
             }
 
             selectionModel()->clear();
 
             if (indexes.count() > 0) {
                 QMimeData *data = m_d->model->mimeData(indexes);
                 if (!data)
                     return;
                 QRect rect;
                 QPixmap pixmap = m_d->renderToPixmap(indexes, &rect);
                 rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
                 QDrag *drag = new QDrag(this);
                 drag->setPixmap(pixmap);
                 drag->setMimeData(data);
                 drag->setHotSpot(m_d->lastPressedPosition - rect.topLeft());
                 drag->exec(supportedActions, Qt::MoveAction);
                 setCurrentIndex(currentIndex());
             }
         }
     } else {
 
         /**
          * Workaround for Qt5's bug: if we start a dragging action right during
          * Shift-selection, Qt will get crazy. We cannot workaround it easily,
          * because we would need to fork mouseMoveEvent() for that (where the
          * decision about drag state is done). So we just abort dragging in that
          * case.
          *
          * BUG:373067
          */
         if (m_d->lastPressedModifier & Qt::ShiftModifier) {
             return;
         }
 
         /**
          * Workaround for Qt5's bugs:
          *
          * 1) Qt doesn't treat selection the selection on D&D
          *    correctly, so we save it in advance and restore
          *    afterwards.
          *
          * 2) There is a private variable in QAbstractItemView:
          *    QAbstractItemView::Private::currentSelectionStartIndex.
          *    It is initialized *only* when the setCurrentIndex() is called
          *    explicitly on the view object, not on the selection model.
          *    Therefore we should explicitly call setCurrentIndex() after
          *    D&D, even if it already has *correct* value!
          *
          * 2) We should also call selectionModel()->select()
          *    explicitly.  There are two reasons for it: 1) Qt doesn't
          *    maintain selection over D&D; 2) when reselecting single
          *    element after D&D, Qt goes crazy, because it tries to
          *    read *global* keyboard modifiers. Therefore if we are
          *    dragging with Shift or Ctrl pressed it'll get crazy. So
          *    just reset it explicitly.
          */
 
         QModelIndexList selectionBefore = selectionModel()->selectedIndexes();
         QModelIndex currentBefore = selectionModel()->currentIndex();
 
         // initialize a global status variable
         m_d->dragWasSuccessful = false;
         QAbstractItemView::startDrag(supportedActions);
 
         QModelIndex newCurrent;
         QPoint selectionOffset;
 
         if (m_d->dragWasSuccessful) {
             newCurrent = currentIndex();
             selectionOffset = QPoint(newCurrent.column() - currentBefore.column(),
                                      newCurrent.row() - currentBefore.row());
         } else {
             newCurrent = currentBefore;
             selectionOffset = QPoint();
         }
 
         setCurrentIndex(newCurrent);
         selectionModel()->clearSelection();
         Q_FOREACH (const QModelIndex &idx, selectionBefore) {
             QModelIndex newIndex =
                     model()->index(idx.row() + selectionOffset.y(),
                                    idx.column() + selectionOffset.x());
             selectionModel()->select(newIndex, QItemSelectionModel::Select);
         }
     }
 }
 
 void TimelineFramesView::dragEnterEvent(QDragEnterEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragEnterEvent(event);
 }
 
 void TimelineFramesView::dragMoveEvent(QDragMoveEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragMoveEvent(event);
 
     if (event->isAccepted()) {
         QModelIndex index = indexAt(event->pos());
         if (!m_d->model->canDropFrameData(event->mimeData(), index)) {
             event->ignore();
         } else {
             selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
         }
     }
 }
 
 void TimelineFramesView::dropEvent(QDropEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dropEvent(event);
     m_d->dragWasSuccessful = event->isAccepted();
 }
 
 void TimelineFramesView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dragLeaveEvent(event);
 }
 
 void TimelineFramesView::createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions)
 {
     slotUpdateFrameActions();
 
     // calculate if selection range is set. This will determine if the update playback range is available
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     bool selectionExists = minColumn != maxColumn;
 
 
     if (selectionExists) {
         KisActionManager::safePopulateMenu(menu, "update_playback_range", m_d->actionMan);
     } else {
         KisActionManager::safePopulateMenu(menu, "set_start_time", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "set_end_time", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "cut_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "copy_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "paste_frames_from_clipboard", m_d->actionMan);
 
     menu->addSeparator();
 
     {   //Frames submenu.
         QMenu *frames = menu->addMenu(i18nc("@item:inmenu", "Keyframes"));
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_left", m_d->actionMan);
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_right", m_d->actionMan);
         frames->addSeparator();
         KisActionManager::safePopulateMenu(frames, "insert_multiple_keyframes", m_d->actionMan);
     }
 
     {   //Holds submenu.
         QMenu *hold = menu->addMenu(i18nc("@item:inmenu", "Hold Frames"));
         KisActionManager::safePopulateMenu(hold, "insert_hold_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_hold_frame", m_d->actionMan);
         hold->addSeparator();
         KisActionManager::safePopulateMenu(hold, "insert_multiple_hold_frames", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_multiple_hold_frames", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "remove_frames", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "remove_frames_and_pull", m_d->actionMan);
 
     menu->addSeparator();
 
     if (addFrameCreationActions) {
         KisActionManager::safePopulateMenu(menu, "add_blank_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "add_duplicate_frame", m_d->actionMan);
         menu->addSeparator();
     }
 }
 
 void TimelineFramesView::mousePressEvent(QMouseEvent *event)
 {
     QPersistentModelIndex index = indexAt(event->pos());
 
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (event->button() == Qt::RightButton) {
             // TODO: try calculate index under mouse cursor even when
             //       it is outside any visible row
             qreal staticPoint = index.isValid() ? index.column() : currentIndex().column();
             m_d->zoomDragButton->beginZoom(event->pos(), staticPoint);
         } else if (event->button() == Qt::LeftButton) {
             m_d->initialDragPanPos = event->pos();
             m_d->initialDragPanValue =
                     QPoint(horizontalScrollBar()->value(),
                            verticalScrollBar()->value());
         }
         event->accept();
 
     } else if (event->button() == Qt::RightButton) {
 
         int numSelectedItems = selectionModel()->selectedIndexes().size();
 
         if (index.isValid() &&
                 numSelectedItems <= 1 &&
                 m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
             model()->setData(index, true, TimelineFramesModel::ActiveLayerRole);
             model()->setData(index, true, TimelineFramesModel::ActiveFrameRole);
             setCurrentIndex(index);
 
             if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool() ||
                     model()->data(index, TimelineFramesModel::SpecialKeyframeExists).toBool()) {
 
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                     int labelIndex = colorLabel.isValid() ? colorLabel.toInt() : 0;
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, false);
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
 
             } else {
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     const int labelIndex = KisImageConfig(true).defaultFrameColorLabel();
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, true);
 
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
             }
         } else if (numSelectedItems > 1) {
             int labelIndex = -1;
             bool haveFrames = false;
             Q_FOREACH(QModelIndex index, selectedIndexes()) {
                 haveFrames |= index.data(TimelineFramesModel::FrameExistsRole).toBool();
                 QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                 if (colorLabel.isValid()) {
                     if (labelIndex == -1) {
                         // First label
                         labelIndex = colorLabel.toInt();
                     } else if (labelIndex != colorLabel.toInt()) {
                         // Mixed colors in selection
                         labelIndex = -1;
                         break;
                     }
                 }
             }
 
             if (haveFrames) {
                 KisSignalsBlocker b(m_d->multiframeColorSelector);
                 m_d->multiframeColorSelector->setCurrentIndex(labelIndex);
             }
 
             QMenu menu;
             createFrameEditingMenuActions(&menu, false);
             menu.addSeparator();
             KisActionManager::safePopulateMenu(&menu, "mirror_frames", m_d->actionMan);
             menu.addSeparator();
             menu.addAction(m_d->multiframeColorSelectorAction);
             menu.exec(event->globalPos());
         }
     } else if (event->button() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(event->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, event->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         event->accept();
     } else {
         if (index.isValid()) {
             m_d->model->setLastClickedIndex(index);
         }
 
         m_d->lastPressedPosition =
                 QPoint(horizontalOffset(), verticalOffset()) + event->pos();
         m_d->lastPressedModifier = event->modifiers();
 
         QAbstractItemView::mousePressEvent(event);
     }
 }
 
 void TimelineFramesView::mouseMoveEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (e->buttons() & Qt::RightButton) {
             m_d->zoomDragButton->continueZoom(e->pos());
         } else if (e->buttons() & Qt::LeftButton) {
             QPoint diff = e->pos() - m_d->initialDragPanPos;
             QPoint offset = QPoint(m_d->initialDragPanValue.x() - diff.x(),
                                    m_d->initialDragPanValue.y() - diff.y());
 
             const int height = m_d->layersHeader->defaultSectionSize();
 
             horizontalScrollBar()->setValue(offset.x());
             verticalScrollBar()->setValue(offset.y() / height);
         }
         e->accept();
     } else if (e->buttons() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(e->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, e->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         e->accept();
     } else {
         m_d->model->setScrubState(true);
         QTableView::mouseMoveEvent(e);
     }
 }
 
 void TimelineFramesView::mouseReleaseEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
         e->accept();
     } else {
         m_d->model->setScrubState(false);
         QTableView::mouseReleaseEvent(e);
     }
 }
 
 void TimelineFramesView::wheelEvent(QWheelEvent *e)
 {
     QModelIndex index = currentIndex();
     int column= -1;
 
     if (index.isValid()) {
         column= index.column() + ((e->delta() > 0) ? 1 : -1);
     }
 
     if (column >= 0 && !m_d->dragInProgress) {
         setCurrentIndex(m_d->model->index(index.row(), column));
     }
 }
 
 void TimelineFramesView::slotUpdateLayersMenu()
 {
     QAction *action = 0;
 
     m_d->existingLayersMenu->clear();
 
     QVariant value = model()->headerData(0, Qt::Vertical, TimelineFramesModel::OtherLayersRole);
     if (value.isValid()) {
         TimelineFramesModel::OtherLayersList list = value.value<TimelineFramesModel::OtherLayersList>();
 
         int i = 0;
         Q_FOREACH (const TimelineFramesModel::OtherLayer &l, list) {
             action = m_d->existingLayersMenu->addAction(l.name);
             action->setData(i++);
         }
     }
 }
 
 void TimelineFramesView::slotUpdateFrameActions()
 {
     if (!m_d->actionMan) return;
 
     const QModelIndexList editableIndexes = calculateSelectionSpan(false, true);
     const bool hasEditableFrames = !editableIndexes.isEmpty();
 
     bool hasExistingFrames = false;
     Q_FOREACH (const QModelIndex &index, editableIndexes) {
         if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool()) {
             hasExistingFrames = true;
             break;
         }
     }
 
     auto enableAction = [this] (const QString &id, bool value) {
         KisAction *action = m_d->actionMan->actionByName(id);
         KIS_SAFE_ASSERT_RECOVER_RETURN(action);
         action->setEnabled(value);
     };
 
     enableAction("add_blank_frame", hasEditableFrames);
     enableAction("add_duplicate_frame", hasEditableFrames);
 
     enableAction("insert_keyframe_left", hasEditableFrames);
     enableAction("insert_keyframe_right", hasEditableFrames);
     enableAction("insert_multiple_keyframes", hasEditableFrames);
 
     enableAction("remove_frames", hasEditableFrames && hasExistingFrames);
     enableAction("remove_frames_and_pull", hasEditableFrames);
 
     enableAction("insert_hold_frame", hasEditableFrames);
     enableAction("insert_multiple_hold_frames", hasEditableFrames);
 
     enableAction("remove_hold_frame", hasEditableFrames);
     enableAction("remove_multiple_hold_frames", hasEditableFrames);
 
     enableAction("mirror_frames", hasEditableFrames && editableIndexes.size() > 1);
 
     enableAction("copy_frames_to_clipboard", true);
     enableAction("cut_frames_to_clipboard", hasEditableFrames);
 
     QClipboard *cp = QApplication::clipboard();
     const QMimeData *data = cp->mimeData();
 
     enableAction("paste_frames_from_clipboard", data && data->hasFormat("application/x-krita-frame"));
 
     //TODO: update column actions!
 }
 
 void TimelineFramesView::slotSetStartTimeToCurrentPosition()
 {
      m_d->model->setFullClipRangeStart(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotSetEndTimeToCurrentPosition()
 {
     m_d->model->setFullClipRangeEnd(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotUpdatePlackbackRange()
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     m_d->model->setFullClipRangeStart(minColumn);
     m_d->model->setFullClipRangeEnd(maxColumn);
 }
 
 void TimelineFramesView::slotLayerContextMenuRequested(const QPoint &globalPos)
 {
     m_d->layerEditingMenu->exec(globalPos);
 }
 
 void TimelineFramesView::slotAddNewLayer()
 {
     QModelIndex index = currentIndex();
     const int newRow = index.isValid() ? index.row() : 0;
     model()->insertRow(newRow);
 }
 
 void TimelineFramesView::slotAddExistingLayer(QAction *action)
 {
     QVariant value = action->data();
 
     if (value.isValid()) {
         QModelIndex index = currentIndex();
         const int newRow = index.isValid() ? index.row() + 1 : 0;
 
         m_d->model->insertOtherLayer(value.toInt(), newRow);
     }
 }
 
 void TimelineFramesView::slotRemoveLayer()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid()) return;
 
     model()->removeRow(index.row());
 }
 
 void TimelineFramesView::slotAddBlankFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->createFrame(index);
 }
 
 void TimelineFramesView::slotAddDuplicateFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->copyFrame(index);
 }
 
 void TimelineFramesView::calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const
 {
     minColumn = std::numeric_limits<int>::max();
     maxColumn = std::numeric_limits<int>::min();
 
     Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
         if (!m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
         rows.insert(index.row());
         minColumn = qMin(minColumn, index.column());
         maxColumn = qMax(maxColumn, index.column());
     }
 }
 
 void TimelineFramesView::insertKeyframes(int count, int timing, TimelineDirection direction, bool entireColumn)
 {
     QSet<int> rows;
     int minColumn = 0, maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     if (count <= 0) { //Negative count? Use number of selected frames.
         count = qMax(1, maxColumn - minColumn + 1);
     }
 
     const int insertionColumn =
         direction == TimelineDirection::RIGHT ?
         maxColumn + 1 : minColumn;
 
     if (entireColumn) {
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (!m_d->model->data(m_d->model->index(i, insertionColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
             rows.insert(i);
         }
     }
 
     if (!rows.isEmpty()) {
         m_d->model->insertFrames(insertionColumn, rows.toList(), count, timing);
     }
 }
 
 void TimelineFramesView::insertMultipleKeyframes(bool entireColumn)
 {
     int count, timing;
     TimelineDirection direction;
 
     if (m_d->insertKeyframeDialog->promptUserSettings(count, timing, direction)) {
         insertKeyframes(count, timing, direction, entireColumn);
     }
 }
 
 QModelIndexList TimelineFramesView::calculateSelectionSpan(bool entireColumn, bool editableOnly) const
 {
     QModelIndexList indexes;
 
     if (entireColumn) {
         QSet<int> rows;
         int minColumn = 0;
         int maxColumn = 0;
 
         calculateSelectionMetrics(minColumn, maxColumn, rows);
 
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (editableOnly &&
                 !m_d->model->data(m_d->model->index(i, minColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
             for (int column = minColumn; column <= maxColumn; column++) {
                 indexes << m_d->model->index(i, column);
             }
         }
     } else {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (!editableOnly || m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     return indexes;
 }
 
 void TimelineFramesView::slotRemoveSelectedFrames(bool entireColumn, bool pull)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn);
 
     if (!selectedIndices.isEmpty()) {
         if (pull) {
             m_d->model->removeFramesAndOffset(selectedIndices);
         } else {
             m_d->model->removeFrames(selectedIndices);
         }
     }
 }
 
 void TimelineFramesView::insertOrRemoveHoldFrames(int count, bool entireColumn)
 {
     QModelIndexList indexes;
 
     if (!entireColumn) {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     } else {
         const int column = selectionModel()->currentIndex().column();
 
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             const QModelIndex index = m_d->model->index(i, column);
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     if (!indexes.isEmpty()) {
         m_d->model->insertHoldFrames(indexes, count);
     }
 }
 
 void TimelineFramesView::insertOrRemoveMultipleHoldFrames(bool insertion, bool entireColumn)
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Insert or Remove Hold Frames"),
                                            i18nc("@label:spinbox", "Enter number of frames"),
                                            insertion ?
                                                m_d->insertKeyframeDialog->defaultTimingOfAddedFrames() :
                                                m_d->insertKeyframeDialog->defaultNumberOfHoldFramesToRemove(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         if (insertion) {
             m_d->insertKeyframeDialog->setDefaultTimingOfAddedFrames(count);
             insertOrRemoveHoldFrames(count, entireColumn);
         } else {
             m_d->insertKeyframeDialog->setDefaultNumberOfHoldFramesToRemove(count);
             insertOrRemoveHoldFrames(-count, entireColumn);
         }
 
     }
 }
 
 void TimelineFramesView::slotMirrorFrames(bool entireColumn)
 {
     const QModelIndexList indexes = calculateSelectionSpan(entireColumn);
 
     if (!indexes.isEmpty()) {
         m_d->model->mirrorFrames(indexes);
     }
 }
 
 void TimelineFramesView::cutCopyImpl(bool entireColumn, bool copy)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn, !copy);
     if (selectedIndices.isEmpty()) return;
 
     int minColumn = std::numeric_limits<int>::max();
     int minRow = std::numeric_limits<int>::max();
 
     Q_FOREACH (const QModelIndex &index, selectedIndices) {
         minRow = qMin(minRow, index.row());
         minColumn = qMin(minColumn, index.column());
     }
 
     const QModelIndex baseIndex = m_d->model->index(minRow, minColumn);
 
     QMimeData *data = m_d->model->mimeDataExtended(selectedIndices,
                                                    baseIndex,
                                                    copy ?
                                                        TimelineFramesModel::CopyFramesPolicy :
                                                        TimelineFramesModel::MoveFramesPolicy);
 
     if (data) {
         QClipboard *cb = QApplication::clipboard();
         cb->setMimeData(data);
     }
 }
 
 void TimelineFramesView::slotPasteFrames(bool entireColumn)
 {
     const QModelIndex currentIndex =
         !entireColumn ? this->currentIndex() : m_d->model->index(0, this->currentIndex().column());
 
     if (!currentIndex.isValid()) return;
 
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *data = cb->mimeData();
 
     if (data && data->hasFormat("application/x-krita-frame")) {
 
         bool dataMoved = false;
         bool result = m_d->model->dropMimeDataExtended(data, Qt::MoveAction, currentIndex, &dataMoved);
 
         if (result && dataMoved) {
             cb->clear();
         }
     }
 }
 
 bool TimelineFramesView::viewportEvent(QEvent *event)
 {
     if (event->type() == QEvent::ToolTip && model()) {
         QHelpEvent *he = static_cast<QHelpEvent *>(event);
         QModelIndex index = model()->buddy(indexAt(he->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, he->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
             return true;
         }
     }
 
     return QTableView::viewportEvent(event);
 }
diff --git a/plugins/dockers/animation/timeline_node_list_keeper.cpp b/plugins/dockers/animation/timeline_node_list_keeper.cpp
index 98b07c8d47..5631972eb1 100644
--- a/plugins/dockers/animation/timeline_node_list_keeper.cpp
+++ b/plugins/dockers/animation/timeline_node_list_keeper.cpp
@@ -1,249 +1,249 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_node_list_keeper.h"
 
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "timeline_frames_index_converter.h"
 
 #include <QSet>
 #include <QSignalMapper>
 #include "kis_keyframe_channel.h"
 
 
 struct TimelineNodeListKeeper::Private
 {
     Private(TimelineNodeListKeeper *_q,
             ModelWithExternalNotifications *_model,
             KisDummiesFacadeBase *_dummiesFacade)
         : q(_q),
           model(_model),
           dummiesFacade(_dummiesFacade),
           converter(dummiesFacade)
     {
     }
 
     TimelineNodeListKeeper *q;
     ModelWithExternalNotifications *model;
     KisDummiesFacadeBase *dummiesFacade;
 
     TimelineFramesIndexConverter converter;
 
     QVector<KisNodeDummy*> dummiesList;
     QSignalMapper dummiesUpdateMapper;
     QSet<KisNodeDummy*> connectionsSet;
 
     void populateDummiesList() {
         const int rowCount = converter.rowCount();
         for (int i = 0; i < rowCount; ++i) {
             KisNodeDummy *dummy = converter.dummyFromRow(i);
 
             dummiesList.append(dummy);
             tryConnectDummy(dummy);
         }
     }
 
     void tryConnectDummy(KisNodeDummy *dummy);
     void disconnectDummy(KisNodeDummy *dummy);
 };
 
 TimelineNodeListKeeper::TimelineNodeListKeeper(ModelWithExternalNotifications *model, KisDummiesFacadeBase *dummiesFacade)
     : m_d(new Private(this, model, dummiesFacade))
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->dummiesFacade);
 
     connect(m_d->dummiesFacade, SIGNAL(sigEndInsertDummy(KisNodeDummy*)),
             SLOT(slotEndInsertDummy(KisNodeDummy*)));
     connect(m_d->dummiesFacade, SIGNAL(sigBeginRemoveDummy(KisNodeDummy*)),
             SLOT(slotBeginRemoveDummy(KisNodeDummy*)));
     connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
             SLOT(slotDummyChanged(KisNodeDummy*)));
 
     m_d->populateDummiesList();
 
     connect(&m_d->dummiesUpdateMapper, SIGNAL(mapped(QObject*)), SLOT(slotUpdateDummyContent(QObject*)));
 }
 
 TimelineNodeListKeeper::~TimelineNodeListKeeper()
 {
 }
 
 KisNodeDummy* TimelineNodeListKeeper::dummyFromRow(int row)
 {
     if (row >= 0 && row < m_d->dummiesList.size()) {
         return m_d->dummiesList[row];
     }
 
     return 0;
 }
 
 int TimelineNodeListKeeper::rowForDummy(KisNodeDummy *dummy)
 {
     return m_d->dummiesList.indexOf(dummy);
 }
 
 int TimelineNodeListKeeper::rowCount()
 {
     return m_d->dummiesList.size();
 }
 
 void TimelineNodeListKeeper::updateActiveDummy(KisNodeDummy *dummy)
 {
     bool oldRemoved = false;
     bool newAdded = false;
 
     KisNodeDummy *oldActiveDummy = m_d->converter.activeDummy();
     m_d->converter.updateActiveDummy(dummy, &oldRemoved, &newAdded);
 
     if (oldRemoved) {
         slotBeginRemoveDummy(oldActiveDummy);
     }
 
     if (newAdded) {
         slotEndInsertDummy(dummy);
     }
 }
 
 void TimelineNodeListKeeper::slotUpdateDummyContent(QObject *_dummy)
 {
     KisNodeDummy *dummy = qobject_cast<KisNodeDummy*>(_dummy);
     int pos = m_d->converter.rowForDummy(dummy);
     if (pos < 0) return;
 
     QModelIndex index0 = m_d->model->index(pos, 0);
     QModelIndex index1 = m_d->model->index(pos, m_d->model->columnCount() - 1);
     m_d->model->callIndexChanged(index0, index1);
 }
 
 void TimelineNodeListKeeper::Private::tryConnectDummy(KisNodeDummy *dummy)
 {
     QMap<QString, KisKeyframeChannel*> channels = dummy->node()->keyframeChannels();
 
     if (channels.isEmpty()) {
         if (connectionsSet.contains(dummy)) {
             connectionsSet.remove(dummy);
         }
 
         return;
     }
 
     if (connectionsSet.contains(dummy)) return;
 
     Q_FOREACH(KisKeyframeChannel *channel, channels) {
         connect(channel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)),
                 &dummiesUpdateMapper, SLOT(map()));
         connect(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframeSP)),
                 &dummiesUpdateMapper, SLOT(map()));
-        connect(channel, SIGNAL(sigKeyframeMoved(KisKeyframeSP, int)),
+        connect(channel, SIGNAL(sigKeyframeMoved(KisKeyframeSP,int)),
                 &dummiesUpdateMapper, SLOT(map()));
 
         dummiesUpdateMapper.setMapping(channel, (QObject*)dummy);
     }
     connectionsSet.insert(dummy);
 }
 
 void TimelineNodeListKeeper::Private::disconnectDummy(KisNodeDummy *dummy)
 {
     if (!connectionsSet.contains(dummy)) return;
 
     QMap<QString, KisKeyframeChannel*> channels = dummy->node()->keyframeChannels();
 
     if (channels.isEmpty()) {
         if (connectionsSet.contains(dummy)) {
             connectionsSet.remove(dummy);
         }
         return;
     }
 
     Q_FOREACH(KisKeyframeChannel *channel, channels) {
         channel->disconnect(&dummiesUpdateMapper);
     }
 
     connectionsSet.remove(dummy);
 }
 
 void TimelineNodeListKeeper::slotEndInsertDummy(KisNodeDummy *dummy)
 {
     KIS_ASSERT_RECOVER_RETURN(!m_d->dummiesList.contains(dummy));
 
     if (m_d->converter.isDummyVisible(dummy)) {
         int pos = m_d->converter.rowForDummy(dummy);
 
         m_d->model->callBeginInsertRows(QModelIndex(), pos, pos);
         m_d->dummiesList.insert(pos, 1, dummy);
         m_d->tryConnectDummy(dummy);
         m_d->model->callEndInsertRows();
     }
 }
 
 void TimelineNodeListKeeper::slotBeginRemoveDummy(KisNodeDummy *dummy)
 {
     if (m_d->dummiesList.contains(dummy)) {
         int pos = m_d->dummiesList.indexOf(dummy);
 
         m_d->model->callBeginRemoveRows(QModelIndex(), pos, pos);
         m_d->disconnectDummy(dummy);
         m_d->dummiesList.remove(pos);
         m_d->model->callEndRemoveRows();
     }
 
     m_d->converter.notifyDummyRemoved(dummy);
 }
 
 void TimelineNodeListKeeper::slotDummyChanged(KisNodeDummy *dummy)
 {
     const bool present = m_d->dummiesList.contains(dummy);
     const bool shouldBe = m_d->converter.isDummyVisible(dummy);
 
     m_d->tryConnectDummy(dummy);
 
     if (!present && shouldBe) {
         slotEndInsertDummy(dummy);
     } else if (present && !shouldBe) {
         slotBeginRemoveDummy(dummy);
     }
 }
 
 void findOtherLayers(KisNodeDummy *root,
                      TimelineNodeListKeeper::OtherLayersList *list,
                      const QString &prefix)
 {
     KisNodeSP node = root->node();
 
     if (root->parent() && !node->useInTimeline()) {
         *list <<
             TimelineNodeListKeeper::OtherLayer(
                 QString(prefix + node->name()),
                 root);
     }
 
     KisNodeDummy *dummy = root->lastChild();
     while(dummy) {
         findOtherLayers(dummy, list, prefix + " ");
         dummy = dummy->prevSibling();
     }
 }
 
 TimelineNodeListKeeper::OtherLayersList
 TimelineNodeListKeeper::otherLayersList() const
 {
     OtherLayersList list;
     findOtherLayers(m_d->dummiesFacade->rootDummy(), &list, "");
     return list;
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
index 76b4dfd068..de889fc2b4 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -1,512 +1,512 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; 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_debug.h>
 
 #include <klocalizedstring.h>
 #include <KoCanvasResourceManager.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerObserver.h>
 #include <KoResourceServerAdapter.h>
 #include <KoCanvasBase.h>
 #include <kis_canvas2.h>
 #include <KoColor.h>
 #include <resources/KoGamutMask.h>
 #include <kis_icon_utils.h>
 #include <KisPart.h>
 #include <kis_shape_layer.h>
 #include <kis_types.h>
 #include <KisDocument.h>
 #include <kis_node_selection_adapter.h>
 #include <kis_group_layer.h>
 #include <KisView.h>
 #include <KoResourceItemChooser.h>
 #include <kis_display_color_converter.h>
 
 #include <QWidget>
 #include <QMenu>
 #include <QButtonGroup>
 #include <QRegExpValidator>
 #include <QRegExp>
 #include <QFileInfo>
 
 #include "artisticcolorselector_dock.h"
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 
 #include "ui_wdgArtisticColorSelector.h"
 #include "ui_wdgARCSSettings.h"
 #include "ui_wdgWheelPreferencesPopup.h"
 
 class KisMainWindow;
 
 struct ArtisticColorSelectorUI: public QWidget, public Ui_wdgArtisticColorSelector
 {
     ArtisticColorSelectorUI() {
         setupUi(this);
     }
 };
 
 struct ARCSSettingsUI: public QWidget, public Ui_wdgARCSSettings
 {
     ARCSSettingsUI() {
         setupUi(this);
     }
 };
 
 struct WheelPreferencesPopupUI: public QWidget, public Ui_wdgWheelPreferencesPopup
 {
     WheelPreferencesPopupUI() {
         setupUi(this);
     }
 };
 
 
 ArtisticColorSelectorDock::ArtisticColorSelectorDock()
     : QDockWidget(i18n("Artistic Color Selector"))
     , m_canvas(nullptr)
     , m_resourceProvider(0)
     , m_selectedMask(nullptr)
 {
     setEnabled(false);
 
     m_hsxButtons    = new QButtonGroup();
     m_preferencesUI = new ARCSSettingsUI();
     m_wheelPrefsUI  = new WheelPreferencesPopupUI();
     m_selectorUI    = new ArtisticColorSelectorUI();
 
     QPixmap hueStepsPixmap = KisIconUtils::loadIcon("wheel-sectors").pixmap(16,16);
     QPixmap saturationStepsPixmap = KisIconUtils::loadIcon("wheel-rings").pixmap(16,16);
     QPixmap valueScaleStepsPixmap = KisIconUtils::loadIcon("wheel-light").pixmap(16,16);
     QIcon infinityIcon = KisIconUtils::loadIcon("infinity");
     m_infinityPixmap = infinityIcon.pixmap(16,16);
     m_iconMaskOff = KisIconUtils::loadIcon("gamut-mask-off");
     m_iconMaskOn = KisIconUtils::loadIcon("gamut-mask-on");
 
     m_selectorUI->colorSelector->loadSettings();
 
     m_selectorUI->bnWheelPrefs->setIcon(KisIconUtils::loadIcon("wheel-sectors"));
     m_selectorUI->bnWheelPrefs->setPopupWidget(m_wheelPrefsUI);
 
     m_selectorUI->bnDockerPrefs->setPopupWidget(m_preferencesUI);
     m_selectorUI->bnDockerPrefs->setIcon(KisIconUtils::loadIcon("configure"));
 
     m_selectorUI->bnToggleMask->setChecked(false);
     m_selectorUI->bnToggleMask->setIcon(m_iconMaskOff);
 
     //preferences
     m_hsxButtons->addButton(m_preferencesUI->bnHsy, KisColor::HSY);
     m_hsxButtons->addButton(m_preferencesUI->bnHsi, KisColor::HSI);
     m_hsxButtons->addButton(m_preferencesUI->bnHsl, KisColor::HSL);
     m_hsxButtons->addButton(m_preferencesUI->bnHsv, KisColor::HSV);
 
     m_wheelPrefsUI->bnInverseSat->setChecked(m_selectorUI->colorSelector->isSaturationInverted());
 
     m_wheelPrefsUI->labelHueSteps->setPixmap(hueStepsPixmap);
     m_wheelPrefsUI->labelSaturationSteps->setPixmap(saturationStepsPixmap);
     m_wheelPrefsUI->labelValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
     m_wheelPrefsUI->numHueSteps->setRange(MIN_NUM_UI_HUE_PIECES, MAX_NUM_HUE_PIECES);
     m_wheelPrefsUI->numSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
     m_wheelPrefsUI->numValueScaleSteps->setRange(MIN_NUM_UI_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
     m_wheelPrefsUI->bnInfHueSteps->setIcon(infinityIcon);
     m_wheelPrefsUI->bnInfValueScaleSteps->setIcon(infinityIcon);
 
     m_wheelPrefsUI->bnInfHueSteps->setToolTip(i18n("Continuous Mode"));
     m_wheelPrefsUI->bnInfValueScaleSteps->setToolTip(i18n("Continuous Mode"));
 
     int selectorHueSteps = m_selectorUI->colorSelector->getNumPieces();
     if (selectorHueSteps == 1) {
         m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
     }
     m_wheelPrefsUI->numHueSteps->setValue(selectorHueSteps);
 
     m_wheelPrefsUI->numSaturationSteps->setValue(m_selectorUI->colorSelector->getNumRings());
 
     int selectorValueScaleSteps = m_selectorUI->colorSelector->getNumLightPieces();
     if (selectorValueScaleSteps == 1) {
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
     }
     m_wheelPrefsUI->numValueScaleSteps->setValue(m_selectorUI->colorSelector->getNumLightPieces());
 
     m_preferencesUI->bnDefInfHueSteps->setIcon(infinityIcon);
     m_preferencesUI->bnDefInfValueScaleSteps->setIcon(infinityIcon);
 
     m_preferencesUI->labelDefHueSteps->setPixmap(hueStepsPixmap);
     m_preferencesUI->labelDefSaturationSteps->setPixmap(saturationStepsPixmap);
     m_preferencesUI->labelDefValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
     m_preferencesUI->defaultHueSteps->setRange(MIN_NUM_HUE_PIECES, MAX_NUM_HUE_PIECES);
     m_preferencesUI->defaultSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
     m_preferencesUI->defaultValueScaleSteps->setRange(MIN_NUM_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
     m_preferencesUI->defaultHueSteps->setValue(m_selectorUI->colorSelector->getDefaultHueSteps());
     m_preferencesUI->defaultSaturationSteps->setValue(m_selectorUI->colorSelector->getDefaultSaturationSteps());
     m_preferencesUI->defaultValueScaleSteps->setValue(m_selectorUI->colorSelector->getDefaultValueScaleSteps());
 
     m_preferencesUI->showColorBlip->setChecked(m_selectorUI->colorSelector->getShowColorBlip());
     m_preferencesUI->showBgColor->setChecked(m_selectorUI->colorSelector->getShowBgColor());
     m_preferencesUI->showValueScaleNumbers->setChecked(m_selectorUI->colorSelector->getShowValueScaleNumbers());
 
     m_preferencesUI->enforceGamutMask->setChecked(m_selectorUI->colorSelector->enforceGamutMask());
     m_preferencesUI->permissiveGamutMask->setChecked(!m_selectorUI->colorSelector->enforceGamutMask());
     m_preferencesUI->showMaskPreview->setChecked(m_selectorUI->colorSelector->maskPreviewActive());
 
     m_preferencesUI->spLumaR->setValue(m_selectorUI->colorSelector->lumaR());
     m_preferencesUI->spLumaG->setValue(m_selectorUI->colorSelector->lumaG());
     m_preferencesUI->spLumaB->setValue(m_selectorUI->colorSelector->lumaB());
     m_preferencesUI->spLumaGamma->setValue(m_selectorUI->colorSelector->lumaGamma());
 
     switch(m_selectorUI->colorSelector->getColorSpace())
     {
         case KisColor::HSV: { m_preferencesUI->bnHsv->setChecked(true); } break;
         case KisColor::HSI: { m_preferencesUI->bnHsi->setChecked(true); } break;
         case KisColor::HSL: { m_preferencesUI->bnHsl->setChecked(true); } break;
         case KisColor::HSY: { m_preferencesUI->bnHsy->setChecked(true); } break;
     }
 
     if (m_selectorUI->colorSelector->getColorSpace() == KisColor::HSY) {
         m_preferencesUI->lumaCoefficientBox->show();
     } else {
         m_preferencesUI->lumaCoefficientBox->hide();
     }
 
     connect(m_wheelPrefsUI->numValueScaleSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->numHueSteps         , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->numSaturationSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInverseSat        , SIGNAL(clicked(bool))                          , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnDefault           , SIGNAL(clicked(bool))                          , SLOT(slotResetDefaultSettings()));
 
     connect(m_preferencesUI->defaultHueSteps    , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->defaultSaturationSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->defaultValueScaleSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnDefInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnDefInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
 
     connect(m_preferencesUI->showColorBlip      , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->showBgColor        , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->showValueScaleNumbers, SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->enforceGamutMask   , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->showMaskPreview   , SIGNAL(toggled(bool)), SLOT(slotGamutMaskActivatePreview(bool)));
 
     connect(m_preferencesUI->spLumaR   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaG   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaB   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaGamma   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
 
-    connect(m_selectorUI->colorSelector         , SIGNAL(sigFgColorChanged(const KisColor&))     , SLOT(slotFgColorChanged(const KisColor&)));
-    connect(m_selectorUI->colorSelector         , SIGNAL(sigBgColorChanged(const KisColor&))     , SLOT(slotBgColorChanged(const KisColor&)));
+    connect(m_selectorUI->colorSelector         , SIGNAL(sigFgColorChanged(KisColor))     , SLOT(slotFgColorChanged(KisColor)));
+    connect(m_selectorUI->colorSelector         , SIGNAL(sigBgColorChanged(KisColor))     , SLOT(slotBgColorChanged(KisColor)));
 
     // gamut mask connections
     connect(m_selectorUI->bnToggleMask          , SIGNAL(toggled(bool))                          , SLOT(slotGamutMaskToggle(bool)));
 
     connect(m_hsxButtons                        , SIGNAL(buttonClicked(int))                     , SLOT(slotColorSpaceSelected()));
 
     setWidget(m_selectorUI);
 }
 
 ArtisticColorSelectorDock::~ArtisticColorSelectorDock()
 {
     m_selectorUI->colorSelector->saveSettings();
     delete m_hsxButtons;
 }
 
 void ArtisticColorSelectorDock::setViewManager(KisViewManager* kisview)
 {
     m_resourceProvider = kisview->resourceProvider();
     m_selectorUI->colorSelector->setFgColor(m_resourceProvider->resourceManager()->foregroundColor());
     m_selectorUI->colorSelector->setBgColor(m_resourceProvider->resourceManager()->backgroundColor());
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
             this, SLOT(slotGamutMaskSet(KoGamutMask*)));
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskUnset()),
             this, SLOT(slotGamutMaskUnset()));
 
     if (m_selectorUI->colorSelector->maskPreviewActive()) {
         connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
                 this, SLOT(slotGamutMaskPreviewUpdate()));
     }
 }
 
 void ArtisticColorSelectorDock::slotCanvasResourceChanged(int key, const QVariant& value)
 {
     if(key == KoCanvasResourceManager::ForegroundColor)
         m_selectorUI->colorSelector->setFgColor(value.value<KoColor>());
 
     if(key == KoCanvasResourceManager::BackgroundColor)
         m_selectorUI->colorSelector->setBgColor(value.value<KoColor>());
 }
 
 void ArtisticColorSelectorDock::slotFgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setForegroundColor(
         KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->foregroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotBgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setBackgroundColor(
         KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->backgroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotColorSpaceSelected()
 {
     KisColor::Type type = static_cast<KisColor::Type>(
                 m_hsxButtons->id(m_hsxButtons->checkedButton()));
 
     m_selectorUI->colorSelector->setColorSpace(type);
 
     if (type == KisColor::HSY) {
         m_preferencesUI->lumaCoefficientBox->show();
     } else {
         m_preferencesUI->lumaCoefficientBox->hide();
     }
 
     m_selectorUI->colorSelector->setLumaCoefficients(
                 m_preferencesUI->spLumaR->value(),
                 m_preferencesUI->spLumaG->value(),
                 m_preferencesUI->spLumaB->value(),
                 m_preferencesUI->spLumaGamma->value()
                 );
 }
 
 void ArtisticColorSelectorDock::slotPreferenceChanged()
 {
     int hueSteps = DEFAULT_HUE_STEPS;
     if (m_wheelPrefsUI->bnInfHueSteps->isChecked()) {
         m_wheelPrefsUI->numHueSteps->setEnabled(false);
         hueSteps = 1;
     } else {
         m_wheelPrefsUI->numHueSteps->setEnabled(true);
         hueSteps = m_wheelPrefsUI->numHueSteps->value();
     }
     m_selectorUI->colorSelector->setNumPieces(hueSteps);
 
     m_selectorUI->colorSelector->setNumRings(m_wheelPrefsUI->numSaturationSteps->value());
 
     int valueScaleSteps;
     if (m_wheelPrefsUI->bnInfValueScaleSteps->isChecked()) {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
         valueScaleSteps = 1;
     } else {
         valueScaleSteps = m_wheelPrefsUI->numValueScaleSteps->value();
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
     }
     m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
 
     int defHueSteps;
     if (m_preferencesUI->bnDefInfHueSteps->isChecked()) {
         m_preferencesUI->defaultHueSteps->setEnabled(false);
         defHueSteps = 1;
     } else {
         m_preferencesUI->defaultHueSteps->setEnabled(true);
         defHueSteps = m_preferencesUI->defaultHueSteps->value();
     }
     m_selectorUI->colorSelector->setDefaultHueSteps(defHueSteps);
 
     m_selectorUI->colorSelector->setDefaultSaturationSteps(m_preferencesUI->defaultSaturationSteps->value());
 
     int defValueScaleSteps;
     if (m_preferencesUI->bnDefInfValueScaleSteps->isChecked()) {
         m_preferencesUI->defaultValueScaleSteps->setEnabled(false);
         defValueScaleSteps = 1;
     } else {
         m_preferencesUI->defaultValueScaleSteps->setEnabled(true);
         defValueScaleSteps = m_preferencesUI->defaultValueScaleSteps->value();
     }
     m_selectorUI->colorSelector->setDefaultValueScaleSteps(defValueScaleSteps);
 
     m_selectorUI->colorSelector->setShowColorBlip(m_preferencesUI->showColorBlip->isChecked());
     m_selectorUI->colorSelector->setShowBgColor(m_preferencesUI->showBgColor->isChecked());
     m_selectorUI->colorSelector->setShowValueScaleNumbers(m_preferencesUI->showValueScaleNumbers->isChecked());
     m_selectorUI->colorSelector->setEnforceGamutMask(m_preferencesUI->enforceGamutMask->isChecked());
 
     // the selector wheel forbids saturation inversion in some cases,
     // reflecting that in the ui
     if (m_selectorUI->colorSelector->saturationIsInvertible()) {
         m_wheelPrefsUI->bnInverseSat->setEnabled(true);
         m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
     } else {
         m_wheelPrefsUI->bnInverseSat->setEnabled(false);
         m_wheelPrefsUI->bnInverseSat->setChecked(false);
         m_selectorUI->colorSelector->setInverseSaturation(false);
     }
 }
 
 void ArtisticColorSelectorDock::slotResetDefaultSettings()
 {
     quint32 hueSteps = m_selectorUI->colorSelector->getDefaultHueSteps();
     quint32 saturationSteps = m_selectorUI->colorSelector->getDefaultSaturationSteps();
     quint32 valueScaleSteps = m_selectorUI->colorSelector->getDefaultValueScaleSteps();
 
     m_selectorUI->colorSelector->setNumRings(saturationSteps);
     m_wheelPrefsUI->numSaturationSteps->blockSignals(true);
     m_wheelPrefsUI->numSaturationSteps->setValue(saturationSteps);
     m_wheelPrefsUI->numSaturationSteps->blockSignals(false);
 
     m_selectorUI->colorSelector->setNumPieces(hueSteps);
     m_wheelPrefsUI->numHueSteps->blockSignals(true);
     m_wheelPrefsUI->numHueSteps->setValue(hueSteps);
     m_wheelPrefsUI->numHueSteps->blockSignals(false);
 
     if (hueSteps == 1) {
         m_wheelPrefsUI->numHueSteps->setEnabled(false);
         m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->numHueSteps->setEnabled(true);
         m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
     }
 
     m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
     m_wheelPrefsUI->numValueScaleSteps->blockSignals(true);
     m_wheelPrefsUI->numValueScaleSteps->setValue(valueScaleSteps);
     m_wheelPrefsUI->numValueScaleSteps->blockSignals(false);
 
     if (valueScaleSteps == 1) {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
     }
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskActivatePreview(bool value)
 {
     m_selectorUI->colorSelector->setMaskPreviewActive(value);
 
     if (value) {
         connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
                 this, SLOT(slotGamutMaskPreviewUpdate()));
     } else {
         disconnect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
                 this, SLOT(slotGamutMaskPreviewUpdate()));
     }
 
     m_selectorUI->colorSelector->update();
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskToggle(bool checked)
 {
     bool b = (!m_selectedMask) ? false : checked;
 
     m_selectorUI->bnToggleMask->setChecked(b);
 
     if (b == true) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
         m_selectorUI->bnToggleMask->setIcon(m_iconMaskOn);
     } else {
         m_selectorUI->bnToggleMask->setIcon(m_iconMaskOff);
     }
 
     m_selectorUI->colorSelector->setGamutMaskOn(b);
 
     // TODO: HACK
     // the selector wheel forbids saturation inversion in some cases,
     // reflecting that in the ui
     if (m_selectorUI->colorSelector->saturationIsInvertible()) {
         m_wheelPrefsUI->bnInverseSat->setEnabled(true);
         m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
     } else {
         m_wheelPrefsUI->bnInverseSat->setEnabled(false);
         m_wheelPrefsUI->bnInverseSat->setChecked(false);
         m_selectorUI->colorSelector->setInverseSaturation(false);
     }
 
 }
 
 void ArtisticColorSelectorDock::setCanvas(KoCanvasBase *canvas)
 {
     if (!canvas) {
         return;
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
 
     if (m_canvas) {
-        connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
-                SLOT(slotCanvasResourceChanged(int, const QVariant&)));
+        connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
+                SLOT(slotCanvasResourceChanged(int,QVariant)));
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(slotSelectorSettingsChanged()));
 
         m_selectorUI->colorSelector->setColorConverter(m_canvas->displayColorConverter());
         setEnabled(true);
     }
 }
 
 void ArtisticColorSelectorDock::unsetCanvas()
 {
     setEnabled(false);
     m_canvas = nullptr;
     m_selectorUI->colorSelector->setColorConverter(KisDisplayColorConverter::dumbConverterInstance());
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskSet(KoGamutMask *mask)
 {
     if (!mask) {
         return;
     }
 
     m_selectedMask = mask;
 
     if (m_selectedMask) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
         m_selectorUI->labelMaskName->setText(m_selectedMask->title());
         slotGamutMaskToggle(true);
     } else {
         slotGamutMaskToggle(false);
         m_selectorUI->labelMaskName->setText(i18n("Select a mask in \"Gamut Masks\" docker"));
     }
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskUnset()
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask = nullptr;
 
     slotGamutMaskToggle(false);
     m_selectorUI->labelMaskName->setText(i18n("Select a mask in \"Gamut Masks\" docker"));
     m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskPreviewUpdate()
 {
     m_selectorUI->colorSelector->update();
 }
 
 void ArtisticColorSelectorDock::slotSelectorSettingsChanged()
 {
     m_selectorUI->colorSelector->update();
 }
diff --git a/plugins/dockers/compositiondocker/compositiondocker_dock.cpp b/plugins/dockers/compositiondocker/compositiondocker_dock.cpp
index 91788aa87e..c5cddd49df 100644
--- a/plugins/dockers/compositiondocker/compositiondocker_dock.cpp
+++ b/plugins/dockers/compositiondocker/compositiondocker_dock.cpp
@@ -1,304 +1,304 @@
 /*
  *  Copyright (c) 2012 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 "compositiondocker_dock.h"
 
 #include <QGridLayout>
 #include <QListView>
 #include <QHeaderView>
 #include <QStyledItemDelegate>
 #include <QPainter>
 #include <QInputDialog>
 #include <QThread>
 #include <QAction>
 #include <QStandardPaths>
 #include <QMenu>
 
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 
 #include <kis_icon.h>
 #include <KoCanvasBase.h>
 #include <KoFileDialog.h>
 
 #include <KisPart.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <KisDocument.h>
 #include <kis_group_layer.h>
 #include <kis_painter.h>
 #include <kis_paint_layer.h>
 #include <kis_action.h>
 #include <kis_action_manager.h>
 #include <kis_action_registry.h>
 
 #include "compositionmodel.h"
 
 
 CompositionDockerDock::CompositionDockerDock( ) : QDockWidget(i18n("Compositions")), m_canvas(0)
 {
     QWidget* widget = new QWidget(this);
     setupUi(widget);
     m_model = new CompositionModel(this);
     compositionView->setModel(m_model);
     compositionView->installEventFilter(this);
     deleteButton->setIcon(KisIconUtils::loadIcon("edit-delete"));
     saveButton->setIcon(KisIconUtils::loadIcon("list-add"));
     exportButton->setIcon(KisIconUtils::loadIcon("document-export"));
 
     deleteButton->setToolTip(i18n("Delete Composition"));
     saveButton->setToolTip(i18n("New Composition"));
     exportButton->setToolTip(i18n("Export Composition"));
 
 
     setWidget(widget);
 
     connect( compositionView, SIGNAL(doubleClicked(QModelIndex)),
-             this, SLOT(activated ( const QModelIndex & ) ) );
+             this, SLOT(activated(QModelIndex)) );
 
     compositionView->setContextMenuPolicy(Qt::CustomContextMenu);
     connect( compositionView, SIGNAL(customContextMenuRequested(QPoint)),
              this, SLOT(customContextMenuRequested(QPoint)));
 
     connect( deleteButton, SIGNAL(clicked(bool)), this, SLOT(deleteClicked()));
     connect( saveButton, SIGNAL(clicked(bool)), this, SLOT(saveClicked()));
     connect( exportButton, SIGNAL(clicked(bool)), this, SLOT(exportClicked()));
     saveNameEdit->setPlaceholderText(i18n("Insert Name"));
 
 
 }
 
 CompositionDockerDock::~CompositionDockerDock()
 {
 
 }
 
 void CompositionDockerDock::setCanvas(KoCanvasBase * canvas)
 {
     if (m_canvas && m_canvas->viewManager()) {
         Q_FOREACH (KisAction *action, m_actions) {
             m_canvas->viewManager()->actionManager()->takeAction(action);
         }
     }
 
     unsetCanvas();
     setEnabled(canvas != 0);
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
     if (m_canvas && m_canvas->viewManager()) {
         if (m_actions.isEmpty()) {
             KisAction *updateAction = m_canvas->viewManager()->actionManager()->createAction("update_composition");
             connect(updateAction, SIGNAL(triggered()), this, SLOT(updateComposition()));
             m_actions.append(updateAction);
 
             KisAction *renameAction = m_canvas->viewManager()->actionManager()->createAction("rename_composition");
             connect(renameAction, SIGNAL(triggered()), this, SLOT(renameComposition()));
             m_actions.append(renameAction);
         } else {
             Q_FOREACH (KisAction *action, m_actions) {
                 m_canvas->viewManager()->actionManager()->addAction(action->objectName(), action);
             }
         }
         updateModel();
     }
 }
 
 void CompositionDockerDock::unsetCanvas()
 {
     setEnabled(false);
     m_canvas = 0;
     m_model->setCompositions(QList<KisLayerCompositionSP>());
 }
 
 void CompositionDockerDock::activated(const QModelIndex& index)
 {
     KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
     composition->apply();
 }
 
 void CompositionDockerDock::deleteClicked()
 {
     QModelIndex index = compositionView->currentIndex();
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
         KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
         m_canvas->viewManager()->image()->removeComposition(composition);
         updateModel();
     }
 }
 
 void CompositionDockerDock::saveClicked()
 {
     KisImageWSP image = m_canvas->viewManager()->image();
     if (!image) return;
 
     // format as 001, 002 ...
     QString name = saveNameEdit->text();
     if (name.isEmpty()) {
         bool found = false;
         int i = 1;
         do {
             name = QString("%1").arg(i, 3, 10, QChar('0'));
             found = false;
             Q_FOREACH (KisLayerCompositionSP composition, m_canvas->viewManager()->image()->compositions()) {
                 if (composition->name() == name) {
                     found = true;
                     break;
                 }
             }
             i++;
         } while(found && i < 1000);
     }
     KisLayerCompositionSP composition(new KisLayerComposition(image, name));
     composition->store();
     image->addComposition(composition);
     saveNameEdit->clear();
     updateModel();
     compositionView->setCurrentIndex(m_model->index(image->compositions().count()-1, 0));
     image->setModified();
 }
 
 void CompositionDockerDock::updateModel()
 {
     if (m_model && m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image()) {
         m_model->setCompositions(m_canvas->viewManager()->image()->compositions());
     }
 }
 
 void CompositionDockerDock::exportClicked()
 {
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image()) {
         QString path;
 
         KoFileDialog dialog(0, KoFileDialog::OpenDirectory, "compositiondockerdock");
         dialog.setCaption(i18n("Select a Directory"));
         dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
         path = dialog.filename();
 
 
         if (path.isNull()) return;
 
         if (!path.endsWith('/')) {
             path.append('/');
         }
 
         KisImageWSP image = m_canvas->viewManager()->image();
         QString filename = m_canvas->viewManager()->document()->localFilePath();
         if (!filename.isEmpty()) {
             QFileInfo info(filename);
             path += info.baseName() + '_';
         }
 
         Q_FOREACH (KisLayerCompositionSP composition, m_canvas->viewManager()->image()->compositions()) {
             if (!composition->isExportEnabled()) {
                 continue;
             }
 
             composition->apply();
             image->refreshGraph();
             image->lock();
 #if 0
             image->rootLayer()->projection()->convertToQImage(0, 0, 0, image->width(), image->height()).save(path + composition->name() + ".png");
 #else
             QRect r = image->bounds();
 
             KisDocument *d = KisPart::instance()->createDocument();
 
             KisImageWSP dst = new KisImage(d->createUndoStore(), r.width(), r.height(), image->colorSpace(), composition->name());
             dst->setResolution(image->xRes(), image->yRes());
             d->setCurrentImage(dst);
             KisPaintLayer* paintLayer = new KisPaintLayer(dst, "projection", OPACITY_OPAQUE_U8);
             KisPainter gc(paintLayer->paintDevice());
             gc.bitBlt(QPoint(0, 0), image->rootLayer()->projection(), r);
             dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
             dst->refreshGraph();
 
             d->setFileBatchMode(true);
 
             const QByteArray outputFormat("image/png");
             d->exportDocumentSync(QUrl::fromLocalFile(path + composition->name() + ".png"), outputFormat);
 
             delete d;
 
 #endif
             image->unlock();
         }
     }
 }
 
 bool CompositionDockerDock::eventFilter(QObject* obj, QEvent* event)
 {
     if (event->type() == QEvent::KeyPress ) {
         QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
         if (keyEvent->key() == Qt::Key_Up || keyEvent->key() == Qt::Key_Down) {
             // new index will be set after the method is called
             QTimer::singleShot(0, this, SLOT(activateCurrentIndex()));
         }
         return false;
     } else {
         return QObject::eventFilter(obj, event);
     }
 }
 
 void CompositionDockerDock::activateCurrentIndex()
 {
     QModelIndex index = compositionView->currentIndex();
     if (index.isValid()) {
         activated(index);
     }
 }
 
 void CompositionDockerDock::customContextMenuRequested(QPoint pos)
 {
     if (m_actions.isEmpty()) return;
 
     QMenu menu;
     Q_FOREACH (KisAction *action, m_actions) {
         menu.addAction(action);
 
     }
     menu.exec(compositionView->mapToGlobal(pos));
 }
 
 void CompositionDockerDock::updateComposition()
 {
     QModelIndex index = compositionView->currentIndex();
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
         KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
         composition->store();
         m_canvas->image()->setModified();
     }
 }
 
 void CompositionDockerDock::renameComposition()
 {
     dbgKrita << "rename";
     QModelIndex index = compositionView->currentIndex();
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->image() && index.isValid()) {
         KisLayerCompositionSP composition = m_model->compositionFromIndex(index);
         bool ok;
         QString name = QInputDialog::getText(this, i18n("Rename Composition"),
                                              i18n("New Name:"), QLineEdit::Normal,
                                              composition->name(), &ok);
         if (ok && !name.isEmpty()) {
             composition->setName(name);
             m_canvas->image()->setModified();
         }
     }
 }
 
 
diff --git a/plugins/dockers/defaultdockers/kis_layer_box.cpp b/plugins/dockers/defaultdockers/kis_layer_box.cpp
index d1779a3e5a..d7a8cbd1ea 100644
--- a/plugins/dockers/defaultdockers/kis_layer_box.cpp
+++ b/plugins/dockers/defaultdockers/kis_layer_box.cpp
@@ -1,1083 +1,1083 @@
 /*
  *  kis_layer_box.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  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_layer_box.h"
 
 
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 #include <QMenu>
 #include <QWidgetAction>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KisNodeView.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_base_node.h>
 #include <kis_composite_ops_model.h>
 #include <kis_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 #include <KoProperties.h>
 
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 
 #include "canvas/kis_canvas2.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "sync_button_and_action.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_signals_blocker.h"
 #include "kis_color_filter_combo.h"
 #include "kis_node_filter_proxy_model.h"
 
 #include "kis_selection.h"
 #include "kis_processing_applicator.h"
 #include "commands/kis_set_global_selection_command.h"
 #include "KisSelectionActionsAdapter.h"
 
 #include "kis_layer_utils.h"
 
 #include "ui_wdglayerbox.h"
 
 #include <QProxyStyle>
 
 class KisLayerBoxStyle : public QProxyStyle
 {
 public:
     KisLayerBoxStyle(QStyle *baseStyle = 0) : QProxyStyle(baseStyle) {}
 
     void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                        QPainter *painter, const QWidget *widget) const
     {
         if (element == QStyle::PE_IndicatorItemViewItemDrop)
         {
             QColor color(widget->palette().color(QPalette::Highlight).lighter());
 
             if (option->rect.height() == 0) {
                 QBrush brush(color);
 
                 QRect r(option->rect);
                 r.setTop(r.top() - 2);
                 r.setBottom(r.bottom() + 2);
 
                 painter->fillRect(r, brush);
             } else {
                 color.setAlpha(200);
                 QBrush brush(color);
                 painter->fillRect(option->rect, brush);
             }
         }
         else
         {
             QProxyStyle::drawPrimitive(element, option, painter, widget);
         }
     }
 };
 
 inline void KisLayerBox::connectActionToButton(KisViewManager* viewManager, QAbstractButton *button, const QString &id)
 {
     if (!viewManager || !button) return;
 
     KisAction *action = viewManager->actionManager()->actionByName(id);
 
     if (!action) return;
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
     connect(viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 inline void KisLayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     if (m_canvas) {
         menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
     }
 }
 
 KisLayerBox::KisLayerBox()
     : QDockWidget(i18n("Layers"))
     , m_canvas(0)
     , m_wdgLayerBox(new Ui_WdgLayerBox)
     , m_thumbnailCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_colorLabelCompressor(900, KisSignalCompressor::FIRST_INACTIVE)
     , m_thumbnailSizeCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     KisConfig cfg(false);
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setStyle(new KisLayerBoxStyle(m_wdgLayerBox->listLayers->style()));
 
     connect(m_wdgLayerBox->listLayers,
-            SIGNAL(contextMenuRequested(const QPoint&, const QModelIndex&)),
-            this, SLOT(slotContextMenuRequested(const QPoint&, const QModelIndex&)));
+            SIGNAL(contextMenuRequested(QPoint,QModelIndex)),
+            this, SLOT(slotContextMenuRequested(QPoint,QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
-            SIGNAL(collapsed(const QModelIndex&)), SLOT(slotCollapsed(const QModelIndex &)));
+            SIGNAL(collapsed(QModelIndex)), SLOT(slotCollapsed(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
-            SIGNAL(expanded(const QModelIndex&)), SLOT(slotExpanded(const QModelIndex &)));
+            SIGNAL(expanded(QModelIndex)), SLOT(slotExpanded(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
-            SIGNAL(selectionChanged(const QModelIndexList&)), SLOT(selectionChanged(const QModelIndexList&)));
+            SIGNAL(selectionChanged(QModelIndexList)), SLOT(selectionChanged(QModelIndexList)));
 
     slotUpdateIcons();
 
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnRaise->setEnabled(false);
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix("%");
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_newLayerMenu = new QMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
     m_filteringModel = new KisNodeFilterProxyModel(this);
     m_filteringModel->setNodeModel(m_nodeModel);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
-    connect(m_nodeModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), SLOT(updateUI()));
-    connect(m_nodeModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), SLOT(updateUI()));
-    connect(m_nodeModel, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)), SLOT(updateUI()));
-    connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), SLOT(updateUI()));
+    connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(updateUI()));
+    connect(m_nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(updateUI()));
+    connect(m_nodeModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(updateUI()));
+    connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setActivationFlags(KisAction::ACTIVE_IMAGE);
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_colorSelector = new KisColorLabelSelectorWidget(this);
     connect(m_colorSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
     m_colorSelectorAction = new QWidgetAction(this);
     m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
-    connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
+    connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             &m_colorLabelCompressor, SLOT(start()));
 
     m_wdgLayerBox->listLayers->setModel(m_filteringModel);
     // this connection should be done *after* the setModel() call to
     // happen later than the internal selection model
     connect(m_filteringModel.data(), &KisNodeFilterProxyModel::rowsAboutToBeRemoved,
             this, &KisLayerBox::slotAboutToRemoveRows);
 
     connect(m_wdgLayerBox->cmbFilter, SIGNAL(selectedColorsChanged()), SLOT(updateLayerFiltering()));
 
     setEnabled(false);
 
     connect(&m_thumbnailCompressor, SIGNAL(timeout()), SLOT(updateThumbnail()));
     connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 
 
 
     // set up the configure menu for changing thumbnail size
     QMenu* configureMenu = new QMenu(this);
     configureMenu->setStyleSheet("margin: 6px");
     configureMenu->addSection(i18n("Thumbnail Size"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setMenu(configureMenu);
     m_wdgLayerBox->configureLayerDockerToolbar->setIcon(KisIconUtils::loadIcon("configure"));
     m_wdgLayerBox->configureLayerDockerToolbar->setIconSize(QSize(13, 13));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setPopupMode(QToolButton::InstantPopup);
 
 
     // add horizontal slider
     thumbnailSizeSlider = new QSlider(this);
     thumbnailSizeSlider->setOrientation(Qt::Horizontal);
     thumbnailSizeSlider->setRange(20, 80);
 
     thumbnailSizeSlider->setValue(cfg.layerThumbnailSize(false)); // grab this from the kritarc
 
     thumbnailSizeSlider->setMinimumHeight(20);
     thumbnailSizeSlider->setMinimumWidth(40);
     thumbnailSizeSlider->setTickInterval(5);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(thumbnailSizeSlider);
     configureMenu->addAction(sliderAction);
 
 
     connect(thumbnailSizeSlider, SIGNAL(sliderMoved(int)), &m_thumbnailSizeCompressor, SLOT(start()));
     connect(&m_thumbnailSizeCompressor, SIGNAL(timeout()), SLOT(slotUpdateThumbnailIconSize()));
 }
 
 KisLayerBox::~KisLayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeFilterProxyModel> filteringModel, KisNodeView *nodeView)
 {
     if (!root) return;
     if (filteringModel.isNull()) return;
     if (!nodeView) return;
 
     nodeView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = filteringModel->indexFromNode(node);
         if (idx.isValid()) {
             nodeView->setExpanded(idx, !node->collapsed());
         }
         if (node->childCount() > 0) {
             expandNodesRecursively(node, filteringModel, nodeView);
         }
         node = node->nextSibling();
     }
     nodeView->blockSignals(false);
 }
 
 void KisLayerBox::slotAddLayerBnClicked()
 {
     if (m_canvas) {
         KisNodeList nodes = m_nodeManager->selectedNodes();
 
         if (nodes.size() == 1) {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("add_new_paint_layer");
             action->trigger();
         } else {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("create_quick_group");
             action->trigger();
         }
     }
 }
 
 void KisLayerBox::setViewManager(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
     Q_FOREACH (KisAction *action, m_actions) {
         kisview->actionManager()->
                 addAction(action->objectName(),
                           action);
     }
 
     connect(m_wdgLayerBox->bnAdd, SIGNAL(clicked()), this, SLOT(slotAddLayerBnClicked()));
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
     KisActionManager *actionManager = kisview->actionManager();
 
     KisAction *action = actionManager->createAction("RenameCurrentLayer");
     Q_ASSERT(action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
     m_propertiesAction = actionManager->createAction("layer_properties");
     Q_ASSERT(m_propertiesAction);
     new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
     m_removeAction = actionManager->createAction("remove_layer");
     Q_ASSERT(m_removeAction);
     new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
     action = actionManager->createAction("move_layer_up");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
     action = actionManager->createAction("move_layer_down");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 }
 
 void KisLayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if (m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0, 0, 0);
         m_selectionActionsAdapter.reset();
 
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
             animation->disconnect(this);
         }
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         m_nodeManager->slotSetSelectedNodes(KisNodeList());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), &m_thumbnailCompressor, SLOT(start()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade =
                 static_cast<KisDummiesFacadeBase*>(kritaShapeController);
 
 
         m_selectionActionsAdapter.reset(new KisSelectionActionsAdapter(m_canvas->viewManager()->selectionManager()));
         m_nodeModel->setDummiesFacade(kritaDummiesFacade,
                                       m_image,
                                       kritaShapeController,
                                       m_nodeManager->nodeSelectionAdapter(),
                                       m_nodeManager->nodeInsertionAdapter(),
                                       m_selectionActionsAdapter.data(),
                                       m_nodeManager->nodeDisplayModeAdapter());
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
             // Connection KisNodeManager -> KisLayerBox
             connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                     this, SLOT(setCurrentNode(KisNodeSP)));
 
             connect(m_nodeManager,
-                    SIGNAL(sigUiNeedChangeSelectedNodes(const QList<KisNodeSP> &)),
-                    SLOT(slotNodeManagerChangedSelection(const QList<KisNodeSP> &)));
+                    SIGNAL(sigUiNeedChangeSelectedNodes(QList<KisNodeSP>)),
+                    SLOT(slotNodeManagerChangedSelection(QList<KisNodeSP>)));
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection KisLayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                 m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         KisImageAnimationInterface *animation = m_image->animationInterface();
         connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &KisLayerBox::slotImageTimeChanged);
 
         expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
         updateAvailableLabels();
 
         addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
         addActionToMenu(m_newLayerMenu, "add_new_group_layer");
         addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
         addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
         addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
         addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
         addActionToMenu(m_newLayerMenu, "add_new_file_layer");
         m_newLayerMenu->addSeparator();
         addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
         addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
         addActionToMenu(m_newLayerMenu, "add_new_colorize_mask");
         addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void KisLayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
 
     m_filteringModel->unsetDummiesFacade();
     disconnect(m_image, 0, this, 0);
     disconnect(m_nodeManager, 0, this, 0);
     disconnect(m_nodeModel, 0, m_nodeManager, 0);
     m_nodeManager->slotSetSelectedNodes(KisNodeList());
 
     m_canvas = 0;
 }
 
 void KisLayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void KisLayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     if (activeNode != m_activeNode) {
         if( !m_activeNode.isNull() )
             m_activeNode->disconnect(this);
         m_activeNode = activeNode;
 
         if (activeNode) {
             KisKeyframeChannel *opacityChannel = activeNode->getKeyframeChannel(KisKeyframeChannel::Opacity.id(), false);
             if (opacityChannel) {
                 watchOpacityChannel(opacityChannel);
             } else {
                 watchOpacityChannel(0);
                 connect(activeNode.data(), &KisNode::keyframeChannelAdded, this, &KisLayerBox::slotKeyframeChannelAdded);
             }
         }
     }
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
     m_wdgLayerBox->cmbComposite->validate(m_image->colorSpace());
 
     if (activeNode) {
         if (activeNode->inherits("KisColorizeMask") ||
                 activeNode->inherits("KisLayer")) {
 
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             slotSetOpacity(activeNode->opacity() * 100.0 / 255);
 
             const KoCompositeOp* compositeOp = activeNode->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         } else if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         }
     }
 }
 
 
 /**
  * This method is called *only* when non-GUI code requested the
  * change of the current node
  */
 void KisLayerBox::setCurrentNode(KisNodeSP node)
 {
     m_filteringModel->setActiveNode(node);
 
     QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
     m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
     updateUI();
 }
 
 void KisLayerBox::slotModelReset()
 {
     if(m_nodeModel->hasDummiesFacade()) {
         QItemSelection selection;
         Q_FOREACH (const KisNodeSP node, m_nodeManager->selectedNodes()) {
             const QModelIndex &idx = m_filteringModel->indexFromNode(node);
             if(idx.isValid()){
                 QItemSelectionRange selectionRange(idx);
                 selection << selectionRange;
             }
         }
 
         m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
     }
 
     updateUI();
 }
 
 void KisLayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 // range: 0-100
 void KisLayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void KisLayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
     KisNodeSP activeNode = m_nodeManager->activeNode();
     if (nodes.isEmpty() || !activeNode) return;
 
     if (m_canvas) {
         QMenu menu;
 
         const bool singleLayer = nodes.size() == 1;
 
         if (index.isValid()) {
             menu.addAction(m_propertiesAction);
 
             if (singleLayer) {
                 addActionToMenu(&menu, "layer_style");
             }
 
             {
                 KisSignalsBlocker b(m_colorSelector);
                 m_colorSelector->setCurrentIndex(singleLayer ? activeNode->colorLabelIndex() : -1);
             }
             menu.addAction(m_colorSelectorAction);
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "cut_layer_clipboard");
             addActionToMenu(&menu, "copy_layer_clipboard");
             addActionToMenu(&menu, "paste_layer_from_clipboard");
             menu.addAction(m_removeAction);
             addActionToMenu(&menu, "duplicatelayer");
             addActionToMenu(&menu, "merge_layer");
 
             if (singleLayer) {
                 addActionToMenu(&menu, "flatten_image");
                 addActionToMenu(&menu, "flatten_layer");
             }
 
             menu.addSeparator();
             QMenu *selectMenu = menu.addMenu(i18n("&Select"));
             addActionToMenu(selectMenu, "select_all_layers");
             addActionToMenu(selectMenu, "select_visible_layers");
             addActionToMenu(selectMenu, "select_invisible_layers");
             addActionToMenu(selectMenu, "select_locked_layers");
             addActionToMenu(selectMenu, "select_unlocked_layers");
             QMenu *groupMenu = menu.addMenu(i18n("&Group"));
             addActionToMenu(groupMenu, "create_quick_group");
             addActionToMenu(groupMenu, "create_quick_clipping_group");
             addActionToMenu(groupMenu, "quick_ungroup");
             QMenu *locksMenu = menu.addMenu(i18n("&Toggle Locks && Visibility"));
             addActionToMenu(locksMenu, "toggle_layer_visibility");
             addActionToMenu(locksMenu, "toggle_layer_lock");
             addActionToMenu(locksMenu, "toggle_layer_inherit_alpha");
             addActionToMenu(locksMenu, "toggle_layer_alpha_lock");
 
             if (singleLayer) {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_transparency_mask");
                 addActionToMenu(addLayerMenu, "add_new_filter_mask");
                 addActionToMenu(addLayerMenu, "add_new_colorize_mask");
                 addActionToMenu(addLayerMenu, "add_new_transform_mask");
                 addActionToMenu(addLayerMenu, "add_new_selection_mask");
 
                 QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
                 addActionToMenu(convertToMenu, "convert_to_paint_layer");
                 addActionToMenu(convertToMenu, "convert_to_transparency_mask");
                 addActionToMenu(convertToMenu, "convert_to_filter_mask");
                 addActionToMenu(convertToMenu, "convert_to_selection_mask");
                 addActionToMenu(convertToMenu, "convert_layer_to_file_layer");
 
                 QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
                 addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
                 addActionToMenu(splitAlphaMenu, "split_alpha_write");
                 addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
             }
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "show_in_timeline");
 
             if (singleLayer) {
                 KisNodeSP node = m_filteringModel->nodeFromIndex(index);
                 if (node && !node->inherits("KisTransformMask")) {
                     addActionToMenu(&menu, "isolate_layer");
                 }
 
                 addActionToMenu(&menu, "selectopaque");
             }
         }
         menu.exec(pos);
     }
 }
 
 void KisLayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::MinimalMode);
 }
 
 void KisLayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::DetailedMode);
 }
 
 void KisLayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::ThumbnailMode);
 }
 
 void KisLayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void KisLayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->raiseNode();
 }
 
 void KisLayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->lowerNode();
 }
 
 void KisLayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void KisLayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void KisLayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_blockOpacityUpdate = true;
     m_nodeManager->nodeOpacityChanged(m_newOpacity, true);
     m_blockOpacityUpdate = false;
 }
 
 void KisLayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void KisLayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void KisLayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void KisLayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void KisLayerBox::slotNodeCollapsedChanged()
 {
     expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP KisLayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (KisNodeManager::isNodeHidden(startNode, true) &&
             startNode->parent() &&
             !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && KisNodeManager::isNodeHidden(node, true)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void KisLayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
     KisSelectionMaskSP globalSelectionMask;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     globalSelectionMask = m_image->rootLayer()->selectionMask();
 
     // try to find deactivated, but visible masks
     if (!globalSelectionMask) {
         KoProperties properties;
         properties.setProperty("visible", true);
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     // try to find at least any selection mask
     if (!globalSelectionMask) {
         KoProperties properties;
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     if (globalSelectionMask) {
         if (showSelections) {
             activateNode = globalSelectionMask;
         }
     }
 
     if (activateNode != lastActiveNode) {
         m_nodeManager->slotNonUiActivatedNode(activateNode);
     } else if (lastActiveNode) {
         setCurrentNode(lastActiveNode);
     }
 
     if (showSelections && !globalSelectionMask) {
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Quick Selection Mask"));
 
         applicator.applyCommand(
             new KisLayerUtils::KeepNodesSelectedCommand(
                 m_nodeManager->selectedNodes(), KisNodeList(),
                 lastActiveNode, 0, m_image, false),
             KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisLayerUtils::SelectGlobalSelectionMask(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
 
         applicator.end();
     } else if (!showSelections &&
                globalSelectionMask &&
                globalSelectionMask->selection()->selectedRect().isEmpty()) {
 
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Cancel Quick Selection Mask"));
         applicator.applyCommand(new KisSetGlobalSelectionCommand(m_image, 0), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
 }
 
 void KisLayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     /**
      * When the user clears the extended selection by clicking on the
      * empty area of the docker, the selection should be reset on to
      * the active layer, which might be even unselected(!).
      */
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         QModelIndex selectedIndex =
                 m_filteringModel->indexFromNode(m_nodeManager->activeNode());
 
         m_wdgLayerBox->listLayers->selectionModel()->
                 setCurrentIndex(selectedIndex, QItemSelectionModel::ClearAndSelect);
         return;
     }
 
     QList<KisNodeSP> selectedNodes;
     Q_FOREACH (const QModelIndex &idx, selection) {
         selectedNodes << m_filteringModel->nodeFromIndex(idx);
     }
 
     m_nodeManager->slotSetSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void KisLayerBox::slotAboutToRemoveRows(const QModelIndex &parent, int start, int end)
 {
     /**
      * Qt has changed its behavior when deleting an item. Previously
      * the selection priority was on the next item in the list, and
      * now it has shanged to the previous item. Here we just adjust
      * the selected item after the node removal. Please take care that
      * this method overrides what was done by the corresponding method
      * of QItemSelectionModel, which *has already done* its work. That
      * is why we use (start - 1) and (end + 1) in the activation
      * condition.
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=345601
      */
 
     QModelIndex currentIndex = m_wdgLayerBox->listLayers->currentIndex();
     QAbstractItemModel *model = m_filteringModel;
 
     if (currentIndex.isValid() && parent == currentIndex.parent()
             && currentIndex.row() >= start - 1 && currentIndex.row() <= end + 1) {
         QModelIndex old = currentIndex;
         if (model && end < model->rowCount(parent) - 1) // there are rows left below the change
             currentIndex = model->index(end + 1, old.column(), parent);
         else if (start > 0) // there are rows left above the change
             currentIndex = model->index(start - 1, old.column(), parent);
         else // there are no rows left in the table
             currentIndex = QModelIndex();
 
         if (currentIndex.isValid() && currentIndex != old) {
             m_wdgLayerBox->listLayers->setCurrentIndex(currentIndex);
         }
     }
 }
 
 void KisLayerBox::slotNodeManagerChangedSelection(const KisNodeList &nodes)
 {
     if (!m_nodeManager) return;
 
     QModelIndexList newSelection;
     Q_FOREACH(KisNodeSP node, nodes) {
         newSelection << m_filteringModel->indexFromNode(node);
     }
 
     QItemSelectionModel *model = m_wdgLayerBox->listLayers->selectionModel();
 
     if (KritaUtils::compareListsUnordered(newSelection, model->selectedIndexes())) {
         return;
     }
 
     QItemSelection selection;
     Q_FOREACH(const QModelIndex &idx, newSelection) {
         selection.select(idx, idx);
     }
 
     model->select(selection, QItemSelectionModel::ClearAndSelect);
 }
 
 void KisLayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void KisLayerBox::slotRenameCurrentNode()
 {
     m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void KisLayerBox::slotColorLabelChanged(int label)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
 
     Q_FOREACH(KisNodeSP node, nodes) {
         auto applyLabelFunc =
                 [label](KisNodeSP node) {
             node->setColorLabelIndex(label);
         };
 
         KisLayerUtils::recursiveApplyNodes(node, applyLabelFunc);
     }
 }
 
 void KisLayerBox::updateAvailableLabels()
 {
     if (!m_image) return;
     m_wdgLayerBox->cmbFilter->updateAvailableLabels(m_image->root());
 }
 
 void KisLayerBox::updateLayerFiltering()
 {
     m_filteringModel->setAcceptedLabels(m_wdgLayerBox->cmbFilter->selectedColors());
 }
 
 void KisLayerBox::slotKeyframeChannelAdded(KisKeyframeChannel *channel)
 {
     if (channel->id() == KisKeyframeChannel::Opacity.id()) {
         watchOpacityChannel(channel);
     }
 }
 
 void KisLayerBox::watchOpacityChannel(KisKeyframeChannel *channel)
 {
     if (m_opacityChannel) {
         m_opacityChannel->disconnect(this);
     }
 
     m_opacityChannel = channel;
     if (m_opacityChannel) {
         connect(m_opacityChannel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeMoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeMoved(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeChanged(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
     }
 }
 
 void KisLayerBox::slotOpacityKeyframeChanged(KisKeyframeSP keyframe)
 {
     Q_UNUSED(keyframe);
     if (m_blockOpacityUpdate) return;
     updateUI();
 }
 
 void KisLayerBox::slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime)
 {
     Q_UNUSED(fromTime);
     slotOpacityKeyframeChanged(keyframe);
 }
 
 void KisLayerBox::slotImageTimeChanged(int time)
 {
     Q_UNUSED(time);
     updateUI();
 }
 
 void KisLayerBox::slotUpdateIcons() {
     m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowupblr"));
     m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
     m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
     m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     // call child function about needing to update icons
     m_wdgLayerBox->listLayers->slotUpdateIcons();
 }
 
 void KisLayerBox::slotUpdateThumbnailIconSize()
 {
     KisConfig cfg(false);
     cfg.setLayerThumbnailSize(thumbnailSizeSlider->value());
 
     // this is a hack to force the layers list to update its display and
     // re-layout all the layers with the new thumbnail size
     resize(this->width()+1, this->height()+1);
     resize(this->width()-1, this->height()-1);
 }
 
 
 #include "moc_kis_layer_box.cpp"
diff --git a/plugins/dockers/griddocker/grid_config_widget.cpp b/plugins/dockers/griddocker/grid_config_widget.cpp
index 2c42278797..56d1d6e08f 100644
--- a/plugins/dockers/griddocker/grid_config_widget.cpp
+++ b/plugins/dockers/griddocker/grid_config_widget.cpp
@@ -1,365 +1,365 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@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 "grid_config_widget.h"
 #include "ui_grid_config_widget.h"
 
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_debug.h"
 #include "kis_aspect_ratio_locker.h"
 #include "kis_int_parse_spin_box.h"
 
 #include <kis_config.h>
 #include <kis_config_notifier.h>
 
 #include <QStandardItem>
 #include <QStandardItemModel>
 
 struct GridConfigWidget::Private
 {
     Private() : guiSignalsBlocked(false) {}
 
     KisGridConfig gridConfig;
     KisGuidesConfig guidesConfig;
     bool guiSignalsBlocked;
 };
 
 GridConfigWidget::GridConfigWidget(QWidget *parent) :
     QWidget(parent),
     ui(new Ui::GridConfigWidget),
     m_d(new Private)
 {
     ui->setupUi(this);
 
     ui->colorMain->setAlphaChannelEnabled(true);
     ui->colorSubdivision->setAlphaChannelEnabled(true);
     ui->colorGuides->setAlphaChannelEnabled(true);
 
 
     ui->angleLeftSpinbox->setSuffix(QChar(Qt::Key_degree));
     ui->angleRightSpinbox->setSuffix(QChar(Qt::Key_degree));
     ui->cellSpacingSpinbox->setSuffix(i18n(" px"));
 
 
     ui->gridTypeCombobox->addItem(i18n("Rectangle"));
     ui->gridTypeCombobox->addItem(i18n("Isometric"));
 
     ui->gridTypeCombobox->setCurrentIndex(0); // set to rectangle by default
     slotGridTypeChanged(); // update the UI to hide any elements we don't need
 
 
     connect(ui->gridTypeCombobox, SIGNAL(currentIndexChanged(int)), SLOT(slotGridTypeChanged()));
 
 
     m_isGridEnabled = false;
 
     setGridConfig(m_d->gridConfig);
     setGuidesConfig(m_d->guidesConfig);
 
     // hide offset UI elements if offset is disabled
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->lblXOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->lblYOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->intXOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->intYOffset, SLOT(setVisible(bool)));
     connect(ui->chkOffset, SIGNAL(toggled(bool)), ui->offsetAspectButton, SLOT(setVisible(bool)));
 
 
     ui->lblXOffset->setVisible(false);
     ui->lblYOffset->setVisible(false);
     ui->intXOffset->setVisible(false);
     ui->intYOffset->setVisible(false);
     ui->offsetAspectButton->setVisible(false);
 
     connect(ui->chkShowGrid, SIGNAL(stateChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->chkSnapToGrid, SIGNAL(stateChanged(int)), SLOT(slotGridGuiChanged()));
 
     connect(ui->chkShowGuides, SIGNAL(stateChanged(int)), SLOT(slotGuidesGuiChanged()));
     connect(ui->chkSnapToGuides, SIGNAL(stateChanged(int)), SLOT(slotGuidesGuiChanged()));
     connect(ui->chkLockGuides, SIGNAL(stateChanged(int)), SLOT(slotGuidesGuiChanged()));
 
     connect(ui->intSubdivision, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->angleLeftSpinbox, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->angleRightSpinbox, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
     connect(ui->cellSpacingSpinbox, SIGNAL(valueChanged(int)), SLOT(slotGridGuiChanged()));
 
     connect(ui->selectMainStyle, SIGNAL(currentIndexChanged(int)), SLOT(slotGridGuiChanged()));
-    connect(ui->colorMain, SIGNAL(changed(const QColor&)), SLOT(slotGridGuiChanged()));
+    connect(ui->colorMain, SIGNAL(changed(QColor)), SLOT(slotGridGuiChanged()));
     connect(ui->selectSubdivisionStyle, SIGNAL(currentIndexChanged(int)), SLOT(slotGridGuiChanged()));
-    connect(ui->colorSubdivision, SIGNAL(changed(const QColor&)), SLOT(slotGridGuiChanged()));
+    connect(ui->colorSubdivision, SIGNAL(changed(QColor)), SLOT(slotGridGuiChanged()));
     connect(ui->selectGuidesStyle, SIGNAL(currentIndexChanged(int)), SLOT(slotGuidesGuiChanged()));
-    connect(ui->colorGuides, SIGNAL(changed(const QColor&)), SLOT(slotGuidesGuiChanged()));
+    connect(ui->colorGuides, SIGNAL(changed(QColor)), SLOT(slotGuidesGuiChanged()));
 
     ui->chkOffset->setChecked(false);
 
     KisAspectRatioLocker *offsetLocker = new KisAspectRatioLocker(this);
     offsetLocker->connectSpinBoxes(ui->intXOffset, ui->intYOffset, ui->offsetAspectButton);
 
     KisAspectRatioLocker *spacingLocker = new KisAspectRatioLocker(this);
     spacingLocker->connectSpinBoxes(ui->intHSpacing, ui->intVSpacing, ui->spacingAspectButton);
 
     connect(offsetLocker, SIGNAL(sliderValueChanged()), SLOT(slotGridGuiChanged()));
     connect(offsetLocker, SIGNAL(aspectButtonChanged()), SLOT(slotGridGuiChanged()));
 
     connect(spacingLocker, SIGNAL(sliderValueChanged()), SLOT(slotGridGuiChanged()));
     connect(spacingLocker, SIGNAL(aspectButtonChanged()), SLOT(slotGridGuiChanged()));
 
     connect(ui->chkShowRulers,SIGNAL(toggled(bool)),SIGNAL(showRulersChanged(bool)));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotPreferencesUpdated()));
 }
 
 GridConfigWidget::~GridConfigWidget()
 {
     delete ui;
 }
 
 void GridConfigWidget::setGridConfig(const KisGridConfig &value)
 {
     KisGridConfig currentConfig = fetchGuiGridConfig();
     if (currentConfig == value) return;
 
     setGridConfigImpl(value);
 }
 
 void GridConfigWidget::setGuidesConfig(const KisGuidesConfig &value)
 {
     KisGuidesConfig currentConfig = fetchGuiGuidesConfig();
     if (currentConfig == value) return;
 
     setGuidesConfigImpl(value);
 }
 
 void GridConfigWidget::setGridConfigImpl(const KisGridConfig &value)
 {
     m_d->gridConfig = value;
     m_d->guiSignalsBlocked = true;
 
     ui->offsetAspectButton->setKeepAspectRatio(m_d->gridConfig.offsetAspectLocked());
     ui->spacingAspectButton->setKeepAspectRatio(m_d->gridConfig.spacingAspectLocked());
     ui->chkShowGrid->setChecked(m_d->gridConfig.showGrid());
     ui->intHSpacing->setValue(m_d->gridConfig.spacing().x());
     ui->intVSpacing->setValue(m_d->gridConfig.spacing().y());
     ui->intXOffset->setValue(m_d->gridConfig.offset().x());
     ui->intYOffset->setValue(m_d->gridConfig.offset().y());
     ui->intSubdivision->setValue(m_d->gridConfig.subdivision());
     ui->chkSnapToGrid->setChecked(m_d->gridConfig.snapToGrid());
     ui->angleLeftSpinbox->setValue(m_d->gridConfig.angleLeft());
     ui->angleRightSpinbox->setValue(m_d->gridConfig.angleRight());
     ui->cellSpacingSpinbox->setValue(m_d->gridConfig.cellSpacing());
 
 
     ui->selectMainStyle->setCurrentIndex(int(m_d->gridConfig.lineTypeMain()));
     ui->selectSubdivisionStyle->setCurrentIndex(int(m_d->gridConfig.lineTypeSubdivision()));
     ui->gridTypeCombobox->setCurrentIndex(m_d->gridConfig.gridType());
 
     ui->colorMain->setColor(m_d->gridConfig.colorMain());
     ui->colorSubdivision->setColor(m_d->gridConfig.colorSubdivision());
 
     m_d->guiSignalsBlocked = false;
 
     emit gridValueChanged();
 }
 
 void GridConfigWidget::setGuidesConfigImpl(const KisGuidesConfig &value)
 {
     m_d->guidesConfig = value;
     m_d->guiSignalsBlocked = true;
 
     ui->chkShowGuides->setChecked(m_d->guidesConfig.showGuides());
     ui->chkSnapToGuides->setChecked(m_d->guidesConfig.snapToGuides());
     ui->chkLockGuides->setChecked(m_d->guidesConfig.lockGuides());
 
     ui->selectGuidesStyle->setCurrentIndex(int(m_d->guidesConfig.guidesLineType()));
     ui->colorGuides->setColor(m_d->guidesConfig.guidesColor());
 
     m_d->guiSignalsBlocked = false;
 
     emit guidesValueChanged();
 }
 
 KisGridConfig GridConfigWidget::gridConfig() const
 {
     return m_d->gridConfig;
 }
 
 KisGuidesConfig GridConfigWidget::guidesConfig() const
 {
     return m_d->guidesConfig;
 }
 
 void GridConfigWidget::setGridDivision(int w, int h)
 {
     ui->intHSpacing->setMaximum(w);
     ui->intVSpacing->setMaximum(h);
 }
 
 KisGridConfig GridConfigWidget::fetchGuiGridConfig() const
 {
     KisGridConfig config;
 
     config.setShowGrid(ui->chkShowGrid->isChecked());
     config.setSnapToGrid(ui->chkSnapToGrid->isChecked());
 
     QPoint pt;
 
     pt.rx() = ui->intHSpacing->value();
     pt.ry() = ui->intVSpacing->value();
     config.setSpacing(pt);
 
     pt.rx() = ui->intXOffset->value();
     pt.ry() = ui->intYOffset->value();
     config.setOffset(pt);
 
     config.setSubdivision(ui->intSubdivision->value());
     config.setAngleLeft(ui->angleLeftSpinbox->value());
     config.setAngleRight(ui->angleRightSpinbox->value());
     config.setCellSpacing(ui->cellSpacingSpinbox->value());
     config.setGridType(ui->gridTypeCombobox->currentIndex());
 
     config.setOffsetAspectLocked(ui->offsetAspectButton->keepAspectRatio());
     config.setSpacingAspectLocked(ui->spacingAspectButton->keepAspectRatio());
 
     config.setLineTypeMain(KisGridConfig::LineTypeInternal(ui->selectMainStyle->currentIndex()));
     config.setLineTypeSubdivision(KisGridConfig::LineTypeInternal(ui->selectSubdivisionStyle->currentIndex()));
 
     config.setColorMain(ui->colorMain->color());
     config.setColorSubdivision(ui->colorSubdivision->color());
 
     return config;
 }
 
 KisGuidesConfig GridConfigWidget::fetchGuiGuidesConfig() const
 {
     KisGuidesConfig config = m_d->guidesConfig;
 
     config.setShowGuides(ui->chkShowGuides->isChecked());
     config.setSnapToGuides(ui->chkSnapToGuides->isChecked());
     config.setLockGuides(ui->chkLockGuides->isChecked());
 
     config.setGuidesLineType(KisGuidesConfig::LineTypeInternal(ui->selectGuidesStyle->currentIndex()));
     config.setGuidesColor(ui->colorGuides->color());
 
     return config;
 }
 
 void GridConfigWidget::slotGridGuiChanged()
 {
     if (m_d->guiSignalsBlocked) return;
 
     KisGridConfig currentConfig = fetchGuiGridConfig();
     if (currentConfig == m_d->gridConfig) return;
 
     setGridConfigImpl(currentConfig);
 }
 
 void GridConfigWidget::slotPreferencesUpdated()
 {
     KisConfig cfg(true);
     enableIsometricGrid(cfg.useOpenGL()); // Isometric view needs OpenGL
 }
 
 void GridConfigWidget::slotGuidesGuiChanged()
 {
     if (m_d->guiSignalsBlocked) return;
 
     KisGuidesConfig currentConfig = fetchGuiGuidesConfig();
     if (currentConfig == m_d->guidesConfig) return;
 
     setGuidesConfigImpl(currentConfig);
 }
 
 void GridConfigWidget::slotGridTypeChanged() {
 
 
     bool showRectangleControls = ui->gridTypeCombobox->currentIndex() == 0;
 
 
     // specific rectangle UI controls
     ui->lblXSpacing->setVisible(showRectangleControls);
     ui->lblYSpacing->setVisible(showRectangleControls);
     ui->intHSpacing->setVisible(showRectangleControls);
     ui->intVSpacing->setVisible(showRectangleControls);
     ui->spacingAspectButton->setVisible(showRectangleControls);
 
     ui->lblSubdivision->setVisible(showRectangleControls);
     ui->intSubdivision->setVisible(showRectangleControls);
     ui->lblSubdivisionStyle->setVisible(showRectangleControls);
     ui->selectSubdivisionStyle->setVisible(showRectangleControls);
     ui->colorSubdivision->setVisible(showRectangleControls);
 
 
     // specific isometric UI controls
     ui->leftAngleLabel->setVisible(!showRectangleControls);
     ui->rightAngleLabel->setVisible(!showRectangleControls);
     ui->angleLeftSpinbox->setVisible(!showRectangleControls);
     ui->angleRightSpinbox->setVisible(!showRectangleControls);
     ui->cellSpacingLabel->setVisible(!showRectangleControls);
     ui->cellSpacingSpinbox->setVisible(!showRectangleControls);
 
 
 
     // disable snapping for isometric grid type for now
     // remember if we had snapping enabled if it was on the rectangule mode
     if (!showRectangleControls) {
         m_isGridEnabled = ui->chkSnapToGrid->isChecked();
         ui->chkSnapToGrid->setEnabled(false);
         ui->chkSnapToGrid->setChecked(false);
     } else {
         ui->chkSnapToGrid->setEnabled(true);
         ui->chkSnapToGrid->setChecked(m_isGridEnabled);
     }
 
 
 
     slotGridGuiChanged();
 }
 
 bool GridConfigWidget::showRulers() const
 {
     return ui->chkShowRulers->isChecked();
 }
 
 void GridConfigWidget::enableIsometricGrid(bool value)
 {
     m_isIsometricGridEnabled = value;
 
     // Isometric grids disabled if OpenGL is disabled
     QStandardItemModel *model = qobject_cast<QStandardItemModel*>(ui->gridTypeCombobox->model());
     QStandardItem *item = model->item(1); // isometric option
 
    // item->setFlags(m_isIsometricGridEnabled ? item->flags() & ~Qt::ItemIsEnabled:
      //                                         item->flags() | Qt::ItemIsEnabled);
 
 
      item->setEnabled(m_isIsometricGridEnabled);
 
     if (m_isIsometricGridEnabled) {
         item->setText(i18n("Isometric"));
     } else {
         item->setText(i18n("Isometric (requires OpenGL)"));
 
         // change drop down index to Rectangular in case it was previously set to isometric
         ui->gridTypeCombobox->setCurrentIndex(0);
     }
 }
 
 void GridConfigWidget::setShowRulers(bool value)
 {
     ui->chkShowRulers->setChecked(value);
 }
 
diff --git a/plugins/dockers/griddocker/griddocker_dock.cpp b/plugins/dockers/griddocker/griddocker_dock.cpp
index 01729c7592..c05f17ea37 100644
--- a/plugins/dockers/griddocker/griddocker_dock.cpp
+++ b/plugins/dockers/griddocker/griddocker_dock.cpp
@@ -1,130 +1,130 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@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 "griddocker_dock.h"
 //#include "gridwidget.h"
 
 // #include <QLabel>
 // #include <QVBoxLayout>
 #include <QStatusBar>
 #include <klocalizedstring.h>
 
 #include <kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_zoom_manager.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_signal_compressor.h>
 #include <kis_grid_manager.h>
 #include <kis_grid_config.h>
 #include <kis_guides_manager.h>
 #include <kis_guides_config.h>
 #include <kis_action.h>
 #include <KisDocument.h>
 
 #include "grid_config_widget.h"
 
 
 GridDockerDock::GridDockerDock( )
     : QDockWidget(i18n("Grid and Guides"))
     , m_canvas(0)
 {
     m_configWidget = new GridConfigWidget(this);
     connect(m_configWidget, SIGNAL(gridValueChanged()), SLOT(slotGuiGridConfigChanged()));
     connect(m_configWidget, SIGNAL(guidesValueChanged()), SLOT(slotGuiGuidesConfigChanged()));
     setWidget(m_configWidget);
     setEnabled(m_canvas);
 }
 
 GridDockerDock::~GridDockerDock()
 {
 }
 
 void GridDockerDock::setCanvas(KoCanvasBase * canvas)
 {
     if(canvas && m_canvas == canvas)
         return;
 
     if (m_canvas) {
         m_canvasConnections.clear();
         m_canvas->disconnectCanvasObserver(this);
         m_canvas->image()->disconnect(this);
     }
 
     m_canvas = canvas ? dynamic_cast<KisCanvas2*>(canvas) : 0;
     setEnabled(m_canvas);
 
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->document()) {
         m_canvasConnections.addConnection(
             m_canvas->viewManager()->gridManager(),
-            SIGNAL(sigRequestUpdateGridConfig(const KisGridConfig&)),
+            SIGNAL(sigRequestUpdateGridConfig(KisGridConfig)),
             this,
-            SLOT(slotGridConfigUpdateRequested(const KisGridConfig&)));
+            SLOT(slotGridConfigUpdateRequested(KisGridConfig)));
 
         slotGridConfigUpdateRequested(m_canvas->viewManager()->document()->gridConfig());
 
         KisAction* action = m_canvas->viewManager()->actionManager()->actionByName("view_ruler");
 
         m_canvasConnections.addConnection(m_configWidget,SIGNAL(showRulersChanged(bool)),action,SLOT(setChecked(bool)));
         m_canvasConnections.addConnection(action,SIGNAL(toggled(bool)),m_configWidget,SLOT(setShowRulers(bool)));
         m_configWidget->setShowRulers(action->isChecked());
 
         m_canvasConnections.addConnection(
             m_canvas->viewManager()->guidesManager(),
-            SIGNAL(sigRequestUpdateGuidesConfig(const KisGuidesConfig&)),
+            SIGNAL(sigRequestUpdateGuidesConfig(KisGuidesConfig)),
             this,
-            SLOT(slotGuidesConfigUpdateRequested(const KisGuidesConfig&)));
+            SLOT(slotGuidesConfigUpdateRequested(KisGuidesConfig)));
         slotGuidesConfigUpdateRequested(m_canvas->viewManager()->document()->guidesConfig());
         QRect rc = m_canvas->image()->bounds();
         m_configWidget->setGridDivision(rc.width() / 2, rc.height() / 2);
 
         // isometric grid only available with OpenGL
         if (m_canvas->canvasIsOpenGL()) {
             m_configWidget->enableIsometricGrid(true);
         } else {
             m_configWidget->enableIsometricGrid(false);
         }
 
     }
 }
 
 void GridDockerDock::unsetCanvas()
 {
     setCanvas(0);
 }
 
 void GridDockerDock::slotGuiGridConfigChanged()
 {
     if (!m_canvas) return;
     m_canvas->viewManager()->gridManager()->setGridConfig(m_configWidget->gridConfig());
 }
 
 void GridDockerDock::slotGridConfigUpdateRequested(const KisGridConfig &config)
 {
     m_configWidget->setGridConfig(config);
 }
 
 void GridDockerDock::slotGuiGuidesConfigChanged()
 {
     if (!m_canvas) return;
     m_canvas->viewManager()->guidesManager()->setGuidesConfig(m_configWidget->guidesConfig());
 }
 
 void GridDockerDock::slotGuidesConfigUpdateRequested(const KisGuidesConfig &config)
 {
     m_configWidget->setGuidesConfig(config);
 }
diff --git a/plugins/dockers/tasksetdocker/tasksetdocker_dock.cpp b/plugins/dockers/tasksetdocker/tasksetdocker_dock.cpp
index a00eaff6be..16f7c0b6b9 100644
--- a/plugins/dockers/tasksetdocker/tasksetdocker_dock.cpp
+++ b/plugins/dockers/tasksetdocker/tasksetdocker_dock.cpp
@@ -1,241 +1,241 @@
 /*
  *  Copyright (c) 2011 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 "tasksetdocker_dock.h"
 
 #include <QGridLayout>
 #include <QListView>
 #include <QHeaderView>
 #include <QStyledItemDelegate>
 #include <QPainter>
 #include <QInputDialog>
 #include <QAction>
 
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 
 #include <kis_icon.h>
 
 #include <KoCanvasBase.h>
 #include <KoResourceItemChooser.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceServerProvider.h>
 
 #include <KisResourceServerProvider.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <KisMainWindow.h>
 #include "tasksetmodel.h"
 
 
 class KisTasksetDelegate : public QStyledItemDelegate
 {
 public:
     KisTasksetDelegate(QObject * parent = 0) : QStyledItemDelegate(parent) {}
     ~KisTasksetDelegate() override {}
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const override {
         return QSize(QStyledItemDelegate::sizeHint(option, index).width(),
                      qMin(QStyledItemDelegate::sizeHint(option, index).width(), 25));
     }
 };
 
 class KisTasksetResourceDelegate : public QStyledItemDelegate
 {
 public:
     KisTasksetResourceDelegate(QObject * parent = 0) : QStyledItemDelegate(parent) {}
     ~KisTasksetResourceDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
 };
 
 void KisTasksetResourceDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     if (! index.isValid())
         return;
 
     TasksetResource* taskset = static_cast<TasksetResource*>(index.internalPointer());
 
     if (option.state & QStyle::State_Selected) {
         painter->setPen(QPen(option.palette.highlight(), 2.0));
         painter->fillRect(option.rect, option.palette.highlight());
         painter->setBrush(option.palette.highlightedText());
     }
     else {
         painter->setBrush(option.palette.text());
     }
 
     painter->drawText(option.rect.x() + 5, option.rect.y() + painter->fontMetrics().ascent() + 5, taskset->name());
 
 }
 
 TasksetDockerDock::TasksetDockerDock( ) : QDockWidget(i18n("Task Sets")), m_canvas(0), m_blocked(false)
 {
     QWidget* widget = new QWidget(this);
     setupUi(widget);
     m_model = new TasksetModel(this);
     tasksetView->setModel(m_model);
     tasksetView->setItemDelegate(new KisTasksetDelegate(this));
     recordButton->setIcon(KisIconUtils::loadIcon("media-record"));
     recordButton->setCheckable(true);
     clearButton->setIcon(KisIconUtils::loadIcon("edit-delete"));
     saveButton->setIcon(KisIconUtils::loadIcon("document-save"));
     saveButton->setEnabled(false);
 
     chooserButton->setIcon(KisIconUtils::loadIcon("edit-copy"));
 
     m_rserver = new KoResourceServerSimpleConstruction<TasksetResource>("kis_taskset", "*.kts");
     if (!QFileInfo(m_rserver->saveLocation()).exists()) {
         QDir().mkpath(m_rserver->saveLocation());
     }
     QSharedPointer<KoAbstractResourceServerAdapter> adapter (new KoResourceServerAdapter<TasksetResource>(m_rserver));
     m_rserver->loadResources(KoResourceServerProvider::blacklistFileNames(m_rserver->fileNames(), m_rserver->blackListedFiles()));
     m_rserver->loadTags();
 
     KoResourceItemChooser* itemChooser = new KoResourceItemChooser(adapter, this);
     itemChooser->setItemDelegate(new KisTasksetResourceDelegate(this));
     itemChooser->setFixedSize(500, 250);
     itemChooser->setRowHeight(30);
     itemChooser->setColumnCount(1);
     itemChooser->showTaggingBar(true);
     chooserButton->setPopupWidget(itemChooser);
 
     connect(itemChooser, SIGNAL(resourceSelected(KoResource*)), this, SLOT(resourceSelected(KoResource*)));
 
     setWidget(widget);
 
-    connect( tasksetView, SIGNAL(clicked( const QModelIndex & ) ),
-            this, SLOT(activated ( const QModelIndex & ) ) );
+    connect( tasksetView, SIGNAL(clicked(QModelIndex)),
+            this, SLOT(activated(QModelIndex)) );
 
     connect( recordButton, SIGNAL(toggled(bool)), this, SLOT(recordClicked()));
     connect( clearButton, SIGNAL(clicked(bool)), this, SLOT(clearClicked()));
     connect( saveButton, SIGNAL(clicked(bool)), this, SLOT(saveClicked()));
 }
 
 TasksetDockerDock::~TasksetDockerDock()
 {
     delete m_rserver;
 }
 
 void TasksetDockerDock::setCanvas(KoCanvasBase * canvas)
 {
     if (m_canvas && m_canvas->viewManager()) {
          m_canvas->viewManager()->actionCollection()->disconnect(this);
          Q_FOREACH (KXMLGUIClient* client, m_canvas->viewManager()->mainWindow()->childClients()) {
             client->actionCollection()->disconnect(this);
         }
     }
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 }
 
 void TasksetDockerDock::unsetCanvas()
 {
     m_canvas = 0;
     m_model->clear();
 }
 
 void TasksetDockerDock::actionTriggered(QAction* action)
 {
     if(action && !action->objectName().isEmpty() &&
        !m_blocked && recordButton->isChecked()) {
         m_model->addAction(action);
         saveButton->setEnabled(true);
     }
 }
 
 void TasksetDockerDock::activated(const QModelIndex& index)
 {
     QAction* action = m_model->actionFromIndex(index);
     m_blocked = true;
     action->trigger();
     m_blocked = false;
 }
 
 void TasksetDockerDock::recordClicked()
 {
     if(m_canvas) {
         KisViewManager* view = m_canvas->viewManager();
         connect(view->actionCollection(), SIGNAL(actionTriggered(QAction*)),
                 this, SLOT(actionTriggered(QAction*)), Qt::UniqueConnection);
         Q_FOREACH (KXMLGUIClient* client, view->mainWindow()->childClients()) {
             connect(client->actionCollection(), SIGNAL(actionTriggered(QAction*)),
                     this, SLOT(actionTriggered(QAction*)), Qt::UniqueConnection);
         }
     }
 }
 
 void TasksetDockerDock::saveClicked()
 {
     bool ok;
     QString name = QInputDialog::getText(this, i18n("Taskset Name"),
                                          i18n("Name:"), QLineEdit::Normal,
                                          QString(), &ok);
     if (!ok) {
         return;
     }
 
     TasksetResource* taskset = new TasksetResource(QString());
 
     QStringList actionNames;
     Q_FOREACH (QAction* action, m_model->actions()) {
         actionNames.append(action->objectName());
     }
     taskset->setActionList(actionNames);
     taskset->setValid(true);
     QString saveLocation = m_rserver->saveLocation();
 
     bool newName = false;
     if(name.isEmpty()) {
         newName = true;
         name = i18n("Taskset");
     }
     QFileInfo fileInfo(saveLocation + name + taskset->defaultFileExtension());
 
     int i = 1;
     while (fileInfo.exists()) {
         fileInfo.setFile(saveLocation + name + QString("%1").arg(i) + taskset->defaultFileExtension());
         i++;
     }
     taskset->setFilename(fileInfo.filePath());
     if(newName) {
         name = i18n("Taskset %1", i);
     }
     taskset->setName(name);
     m_rserver->addResource(taskset);
 }
 
 void TasksetDockerDock::clearClicked()
 {
     saveButton->setEnabled(false);
     m_model->clear();
 }
 
 void TasksetDockerDock::resourceSelected(KoResource* resource)
 {
     if(!m_canvas) {
         return;
     }
     m_model->clear();
     saveButton->setEnabled(true);
     Q_FOREACH (const QString& actionName, static_cast<TasksetResource*>(resource)->actionList()) {
         QAction* action = m_canvas->viewManager()->actionCollection()->action(actionName);
         if(action) {
             m_model->addAction(action);
         }
     }
 }
 
diff --git a/plugins/extensions/qmic/QMic.cpp b/plugins/extensions/qmic/QMic.cpp
index 3454f30da2..dd3193769b 100644
--- a/plugins/extensions/qmic/QMic.cpp
+++ b/plugins/extensions/qmic/QMic.cpp
@@ -1,464 +1,464 @@
 /*
  * Copyright (c) 2017 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 "QMic.h"
 
 #include <QApplication>
 #include <QDebug>
 #include <QFileInfo>
 #include <QLocalSocket>
 #include <QBuffer>
 #include <QByteArray>
 #include <QDataStream>
 #include <QProcess>
 #include <QLocalServer>
 #include <QVBoxLayout>
 #include <QUuid>
 #include <QList>
 #include <QSharedPointer>
 #include <QMultiMap>
 #include <QSharedMemory>
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KoDialog.h>
 #include <KoColorSpaceConstants.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceTraits.h>
 
 #include <KisPart.h>
 #include <KisViewManager.h>
 #include <kis_action.h>
 #include <kis_config.h>
 #include <kis_preference_set_registry.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_selection.h>
 #include <kis_paint_layer.h>
 #include <kis_algebra_2d.h>
 
 #include "kis_input_output_mapper.h"
 #include "kis_qmic_simple_convertor.h"
 #include "kis_import_qmic_processing_visitor.h"
 #include <PluginSettings.h>
 
 #include "kis_qmic_applicator.h"
 
 static const char ack[] = "ack";
 
 K_PLUGIN_FACTORY_WITH_JSON(QMicFactory, "kritaqmic.json", registerPlugin<QMic>();)
 
 QMic::QMic(QObject *parent, const QVariantList &)
     : KisActionPlugin(parent)
     , m_gmicApplicator(0)
 {
 #ifndef Q_OS_MAC
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     PluginSettingsFactory* settingsFactory = new PluginSettingsFactory();
     preferenceSetRegistry->add("QMicPluginSettingsFactory", settingsFactory);
 
     m_qmicAction = createAction("QMic");
     m_qmicAction->setActivationFlags(KisAction::ACTIVE_DEVICE);
 
     connect(m_qmicAction ,  SIGNAL(triggered()), this, SLOT(slotQMic()));
 
     m_againAction = createAction("QMicAgain");
     m_againAction->setActivationFlags(KisAction::ACTIVE_DEVICE);
     m_againAction->setEnabled(false);
     connect(m_againAction,  SIGNAL(triggered()), this, SLOT(slotQMicAgain()));
 
     m_gmicApplicator = new KisQmicApplicator();
-    connect(m_gmicApplicator, SIGNAL(gmicFinished(bool, int, QString)), this, SLOT(slotGmicFinished(bool, int, QString)));
+    connect(m_gmicApplicator, SIGNAL(gmicFinished(bool,int,QString)), this, SLOT(slotGmicFinished(bool,int,QString)));
 #endif
 }
 
 QMic::~QMic()
 {
     Q_FOREACH(QSharedMemory *memorySegment, m_sharedMemorySegments) {
 //        dbgPlugins << "detaching" << memorySegment->key();
         memorySegment->detach();
     }
     qDeleteAll(m_sharedMemorySegments);
     m_sharedMemorySegments.clear();
 
     if (m_pluginProcess) {
         m_pluginProcess->close();
     }
 
     delete m_gmicApplicator;
     delete m_localServer;
 }
 
 void QMic::slotQMicAgain()
 {
     slotQMic(true);
 }
 
 void QMic::slotQMic(bool again)
 {
     m_qmicAction->setEnabled(false);
     m_againAction->setEnabled(false);
 
     // find the krita-gmic-qt plugin
     QString pluginPath = PluginSettings::gmicQtPath();
     if (pluginPath.isEmpty() || !QFileInfo(pluginPath).exists() || !QFileInfo(pluginPath).isFile()) {
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Krita cannot find the gmic-qt plugin. You can set the location of the gmic-qt plugin in Settings/Configure Krita."));
         return;
     }
 
     m_key = QUuid::createUuid().toString();
     m_localServer = new QLocalServer();
     m_localServer->listen(m_key);
     connect(m_localServer, SIGNAL(newConnection()), SLOT(connected()));
     m_pluginProcess = new QProcess(this);
-    connect(viewManager(), SIGNAL(destroyed(QObject *o)), m_pluginProcess, SLOT(terminate()));
+    connect(viewManager(), SIGNAL(destroyed(QObject*o)), m_pluginProcess, SLOT(terminate()));
     m_pluginProcess->setProcessChannelMode(QProcess::ForwardedChannels);
-    connect(m_pluginProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(pluginFinished(int,QProcess::ExitStatus)));
+    connect(m_pluginProcess, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(pluginFinished(int,QProcess::ExitStatus)));
     connect(m_pluginProcess, SIGNAL(stateChanged(QProcess::ProcessState)), this, SLOT(pluginStateChanged(QProcess::ProcessState)));
     m_pluginProcess->start(pluginPath, QStringList() << m_key << (again ? QString(" reapply") : QString()));
 
     bool r = m_pluginProcess->waitForStarted();
     while (m_pluginProcess->waitForFinished(10)) {
         qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
     }
     dbgPlugins << "Plugin started" << r << m_pluginProcess->state();
 }
 
 void QMic::connected()
 {
     dbgPlugins << "connected";
     if (!viewManager()) return;
 
     QLocalSocket *socket = m_localServer->nextPendingConnection();
     if (!socket) { return; }
 
     while (socket->bytesAvailable() < static_cast<int>(sizeof(quint32))) {
         if (!socket->isValid()) { // stale request
             return;
         }
         socket->waitForReadyRead(1000);
     }
     QDataStream ds(socket);
 
     QByteArray msg;
     quint32 remaining;
     ds >> remaining;
     msg.resize(remaining);
     int got = 0;
     char* uMsgBuf = msg.data();
     // FIXME: Should use read transaction for Qt >= 5.7:
     //        https://doc.qt.io/qt-5/qdatastream.html#using-read-transactions
     do {
         got = ds.readRawData(uMsgBuf, remaining);
         remaining -= got;
         uMsgBuf += got;
     }
     while (remaining && got >= 0 && socket->waitForReadyRead(2000));
 
     if (got < 0) {
         qWarning() << "Message reception failed" << socket->errorString();
         delete socket;
         m_localServer->close();
         delete m_localServer;
         m_localServer = 0;
         return;
     }
 
     QString message = QString::fromUtf8(msg);
     dbgPlugins << "Received" << message;
 
     // Check the message: we can get three different ones
     QMultiMap<QString, QString> messageMap;
     Q_FOREACH(QString line, message.split('\n', QString::SkipEmptyParts)) {
         QList<QString> kv = line.split('=', QString::SkipEmptyParts);
         if (kv.size() == 2) {
             messageMap.insert(kv[0], kv[1]);
         }
         else {
             qWarning() << "line" << line << "is invalid.";
         }
     }
 
     if (!messageMap.contains("command")) {
         qWarning() << "Message did not contain a command";
         return;
     }
 
     int mode = 0;
     if (messageMap.contains("mode")) {
         mode = messageMap.values("mode").first().toInt();
     }
 
     QByteArray ba;
     QString messageBoxWarningText;
 
     if (messageMap.values("command").first() == "gmic_qt_get_image_size") {
         KisSelectionSP selection = viewManager()->image()->globalSelection();
 
         if (selection) {
             QRect selectionRect = selection->selectedExactRect();
             ba = QByteArray::number(selectionRect.width()) + "," + QByteArray::number(selectionRect.height());
         }
         else {
             ba = QByteArray::number(viewManager()->image()->width()) + "," + QByteArray::number(viewManager()->image()->height());
         }
     }
     else if (messageMap.values("command").first() == "gmic_qt_get_cropped_images") {
         // Parse the message, create the shared memory segments, and create a new message to send back and waid for ack
         QRectF cropRect(0.0, 0.0, 1.0, 1.0);
         if (!messageMap.contains("croprect") || messageMap.values("croprect").first().split(',', QString::SkipEmptyParts).size() != 4) {
             qWarning() << "gmic-qt didn't send a croprect or not a valid croprect";
         }
         else {
             QStringList cr = messageMap.values("croprect").first().split(',', QString::SkipEmptyParts);
             cropRect.setX(cr[0].toFloat());
             cropRect.setY(cr[1].toFloat());
             cropRect.setWidth(cr[2].toFloat());
             cropRect.setHeight(cr[3].toFloat());
         }
         if (!prepareCroppedImages(&ba, cropRect, mode)) {
             qWarning() << "Failed to prepare images for gmic-qt";
         }
     }
     else if (messageMap.values("command").first() == "gmic_qt_output_images") {
         // Parse the message. read the shared memory segments, fix up the current image and send an ack
         dbgPlugins << "gmic_qt_output_images";
         QStringList layers = messageMap.values("layer");
         m_outputMode = (OutputMode)mode;
         if (m_outputMode != IN_PLACE) {
             messageBoxWarningText = i18n("Sorry, this output mode is not implemented yet.");
             m_outputMode = IN_PLACE;
         }
         slotStartApplicator(layers);
     }
     else if (messageMap.values("command").first() == "gmic_qt_detach") {
         Q_FOREACH(QSharedMemory *memorySegment, m_sharedMemorySegments) {
             dbgPlugins << "detaching" << memorySegment->key() << memorySegment->isAttached();
             if (memorySegment->isAttached()) {
                 if (!memorySegment->detach()) {
                     dbgPlugins << "\t" << memorySegment->error() << memorySegment->errorString();
                 }
             }
         }
         qDeleteAll(m_sharedMemorySegments);
         m_sharedMemorySegments.clear();
     }
     else {
         qWarning() << "Received unknown command" << messageMap.values("command");
     }
 
     dbgPlugins << "Sending" << QString::fromUtf8(ba);
 
     // HACK: Make sure QDataStream does not refuse to write!
     // Proper fix: Change the above read to use read transaction
     ds.resetStatus();
     ds.writeBytes(ba.constData(), ba.length());
     // Flush the socket because we might not return to the event loop!
     if (!socket->waitForBytesWritten(2000)) {
         qWarning() << "Failed to write response:" << socket->error();
     }
 
     // Wait for the ack
     bool r = true;
     r &= socket->waitForReadyRead(2000); // wait for ack
     r &= (socket->read(qstrlen(ack)) == ack);
     if (!socket->waitForDisconnected(2000)) {
         qWarning() << "Remote not disconnected:" << socket->error();
         // Wait again
         socket->disconnectFromServer();
         if (socket->waitForDisconnected(2000)) {
             qWarning() << "Disconnect timed out:" << socket->error();
         }
     }
 
     if (!messageBoxWarningText.isEmpty()) {
         // Defer the message box to the event loop
         QTimer::singleShot(0, [messageBoxWarningText]() {
             QMessageBox::warning(KisPart::instance()->currentMainwindow(), i18nc("@title:window", "Krita"), messageBoxWarningText);
         });
     }
 }
 
 void QMic::pluginStateChanged(QProcess::ProcessState state)
 {
     dbgPlugins << "stateChanged" << state;
 }
 
 void QMic::pluginFinished(int exitCode, QProcess::ExitStatus exitStatus)
 {
     dbgPlugins << "pluginFinished" << exitCode << exitStatus;
     delete m_pluginProcess;
     m_pluginProcess = 0;
     delete m_localServer;
     m_localServer = 0;
     m_qmicAction->setEnabled(true);
     m_againAction->setEnabled(true);
 }
 
 void QMic::slotGmicFinished(bool successfully, int milliseconds, const QString &msg)
 {
     dbgPlugins << "slotGmicFinished();" << successfully << milliseconds << msg;
     if (successfully) {
         m_gmicApplicator->finish();
     }
     else {
         m_gmicApplicator->cancel();
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("G'Mic failed, reason:") + msg);
     }
 }
 
 void QMic::slotStartApplicator(QStringList gmicImages)
 {
     dbgPlugins << "slotStartApplicator();" << gmicImages;
     if (!viewManager()) return;
     // Create a vector of gmic images
 
     QVector<gmic_image<float> *> images;
 
     Q_FOREACH(const QString &image, gmicImages) {
         QStringList parts = image.split(',', QString::SkipEmptyParts);
         Q_ASSERT(parts.size() == 4);
         QString key = parts[0];
         QString layerName = QByteArray::fromHex(parts[1].toLatin1());
         int spectrum = parts[2].toInt();
         int width = parts[3].toInt();
         int height = parts[4].toInt();
 
         dbgPlugins << key << layerName << width << height;
 
         QSharedMemory m(key);
         if (!m.attach(QSharedMemory::ReadOnly)) {
             qWarning() << "Could not attach to shared memory area." << m.error() << m.errorString();
         }
         if (m.isAttached()) {
             if (!m.lock()) {
                 dbgPlugins << "Could not lock memory segment"  << m.error() << m.errorString();
             }
             dbgPlugins << "Memory segment" << key << m.size() << m.constData() << m.data();
             gmic_image<float> *gimg = new gmic_image<float>();
             gimg->assign(width, height, 1, spectrum);
             gimg->name = layerName;
 
             gimg->_data = new float[width * height * spectrum * sizeof(float)];
             dbgPlugins << "width" << width << "height" << height << "size" << width * height * spectrum * sizeof(float) << "shared memory size" << m.size();
             memcpy(gimg->_data, m.constData(), width * height * spectrum * sizeof(float));
 
             dbgPlugins << "created gmic image" << gimg->name << gimg->_width << gimg->_height;
 
             if (!m.unlock()) {
                 dbgPlugins << "Could not unlock memory segment"  << m.error() << m.errorString();
             }
             if (!m.detach()) {
                 dbgPlugins << "Could not detach from memory segment"  << m.error() << m.errorString();
             }
             images.append(gimg);
         }
     }
 
     dbgPlugins << "Got" << images.size() << "gmic images";
 
     // Start the applicator
     KUndo2MagicString actionName = kundo2_i18n("Gmic filter");
     KisNodeSP rootNode = viewManager()->image()->root();
     KisInputOutputMapper mapper(viewManager()->image(), viewManager()->activeNode());
     KisNodeListSP layers = mapper.inputNodes(m_inputMode);
 
     m_gmicApplicator->setProperties(viewManager()->image(), rootNode, images, actionName, layers);
     m_gmicApplicator->apply();
     m_gmicApplicator->finish();
 }
 
 bool QMic::prepareCroppedImages(QByteArray *message, QRectF &rc, int inputMode)
 {
     if (!viewManager()) return false;
 
     viewManager()->image()->lock();
 
     m_inputMode = (InputLayerMode)inputMode;
 
     dbgPlugins << "prepareCroppedImages()" << QString::fromUtf8(*message) << rc << inputMode;
 
     KisInputOutputMapper mapper(viewManager()->image(), viewManager()->activeNode());
     KisNodeListSP nodes = mapper.inputNodes(m_inputMode);
     if (nodes->isEmpty()) {
         viewManager()->image()->unlock();
         return false;
     }
 
     for (int i = 0; i < nodes->size(); ++i) {
         KisNodeSP node = nodes->at(i);
         if (node && node->paintDevice()) {
             QRect cropRect;
 
             KisSelectionSP selection = viewManager()->image()->globalSelection();
 
             if (selection) {
                 cropRect = selection->selectedExactRect();
             }
             else {
                 cropRect = viewManager()->image()->bounds();
             }
 
             dbgPlugins << "Converting node" << node->name() << cropRect;
 
             const QRectF mappedRect = KisAlgebra2D::mapToRect(cropRect).mapRect(rc);
             const QRect resultRect = mappedRect.toAlignedRect();
 
             QSharedMemory *m = new QSharedMemory(QString("key_%1").arg(QUuid::createUuid().toString()));
             m_sharedMemorySegments.append(m);
             if (!m->create(resultRect.width() * resultRect.height() * 4 * sizeof(float))) {  //buf.size())) {
                 qWarning() << "Could not create shared memory segment" << m->error() << m->errorString();
                 return false;
             }
             m->lock();
 
             gmic_image<float> img;
             img.assign(resultRect.width(), resultRect.height(), 1, 4);
             img._data = reinterpret_cast<float*>(m->data());
 
             KisQmicSimpleConvertor::convertToGmicImageFast(node->paintDevice(), &img, resultRect);
 
             message->append(m->key().toUtf8());
 
             m->unlock();
 
             message->append(",");
             message->append(node->name().toUtf8().toHex());
             message->append(",");
             message->append(QByteArray::number(resultRect.width()));
             message->append(",");
             message->append(QByteArray::number(resultRect.height()));
 
             message->append("\n");
         }
     }
 
     dbgPlugins << QString::fromUtf8(*message);
 
     viewManager()->image()->unlock();
 
     return true;
 }
 
 
 #include "QMic.moc"
diff --git a/plugins/filters/asccdl/kis_wdg_asccdl.cpp b/plugins/filters/asccdl/kis_wdg_asccdl.cpp
index bb34da1c29..5ad76ce753 100644
--- a/plugins/filters/asccdl/kis_wdg_asccdl.cpp
+++ b/plugins/filters/asccdl/kis_wdg_asccdl.cpp
@@ -1,116 +1,116 @@
 /*
  * Copyright (c) 2017 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_wdg_asccdl.h"
 #include <kis_config.h>
 #include <kis_color_button.h>
 #include <kis_filter_configuration.h>
 #include <KisVisualColorSelectorShape.h>
 #include <KisVisualRectangleSelectorShape.h>
 #include <KisVisualEllipticalSelectorShape.h>
 
 KisASCCDLConfigWidget::KisASCCDLConfigWidget(QWidget *parent, const KoColorSpace *cs)
     :KisConfigWidget(parent),
     m_page(new Ui_WdgASCCDL),
     m_cs(cs)
 
 {
     KoColor black(Qt::black, cs);
     m_page->setupUi(this);
     m_page->btnSlope->setColor(black);
     m_page->btnOffset->setColor(black);
     m_page->btnPower->setColor(black);
 
-    connect(m_page->btnSlope , SIGNAL(changed(const KoColor)), this,  SLOT(slopeColorChanged(const KoColor)));
-    connect(m_page->btnOffset, SIGNAL(changed(const KoColor)), this,  SLOT(offsetColorChanged(const KoColor)));
-    connect(m_page->btnPower , SIGNAL(changed(const KoColor)), this,  SLOT(powerColorChanged(const KoColor)));
-    connect(m_page->slopeSelector, SIGNAL(sigNewColor(const KoColor)), this, SLOT(slopeColorChanged(const KoColor)));
-    connect(m_page->offsetSelector, SIGNAL(sigNewColor(const KoColor)), this, SLOT(offsetColorChanged(const KoColor)));
-    connect(m_page->powerSelector, SIGNAL(sigNewColor(const KoColor)), this, SLOT(powerColorChanged(const KoColor)));
+    connect(m_page->btnSlope , SIGNAL(changed(KoColor)), this,  SLOT(slopeColorChanged(KoColor)));
+    connect(m_page->btnOffset, SIGNAL(changed(KoColor)), this,  SLOT(offsetColorChanged(KoColor)));
+    connect(m_page->btnPower , SIGNAL(changed(KoColor)), this,  SLOT(powerColorChanged(KoColor)));
+    connect(m_page->slopeSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(slopeColorChanged(KoColor)));
+    connect(m_page->offsetSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(offsetColorChanged(KoColor)));
+    connect(m_page->powerSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(powerColorChanged(KoColor)));
 }
 
 KisASCCDLConfigWidget::~KisASCCDLConfigWidget()
 {
     delete m_page;
 }
 
 KisPropertiesConfigurationSP KisASCCDLConfigWidget::configuration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration("asc-cdl", 0);
     QVariant colorVariant("KoColor");
     colorVariant.setValue(m_page->btnSlope->color());
     config->setProperty("slope", colorVariant);
     colorVariant.setValue(m_page->btnOffset->color());
     config->setProperty("offset", colorVariant);
     colorVariant.setValue(m_page->btnPower->color());
     config->setProperty("power", colorVariant);
     return config;
 }
 
 void KisASCCDLConfigWidget::setConfiguration(const KisPropertiesConfigurationSP config)
 {
     KoColor white(m_cs);
     QVector<float> channels(m_cs->channelCount());
     m_cs->normalisedChannelsValue(white.data(), channels);
     channels.fill(1.0);
     m_cs->fromNormalisedChannelsValue(white.data(), channels);
     KoColor black(Qt::black, m_cs);
     KoColor slope = config->getColor("slope", white);
     slope.convertTo(m_cs);
     KoColor offset = config->getColor("offset", black);
     offset.convertTo(m_cs);
     KoColor power = config->getColor("power", white);
     power.convertTo(m_cs);
 
     m_page->btnSlope->setColor(slope);
     m_page->slopeSelector->slotSetColor(slope);
     m_page->btnOffset->setColor(offset);
     m_page->offsetSelector->slotSetColor(offset);
     m_page->btnPower->setColor (power);
     m_page->powerSelector->slotSetColor(power);
 }
 
 void KisASCCDLConfigWidget::slopeColorChanged(const KoColor &c)
 {
     if (QObject::sender() == m_page->btnSlope) {
         m_page->slopeSelector->slotSetColor(c);
     } else {
         m_page->btnSlope->setColor(c);
     }
     emit sigConfigurationItemChanged();
 }
 
 void KisASCCDLConfigWidget::offsetColorChanged(const KoColor &c)
 {
     if (QObject::sender() == m_page->btnOffset) {
         m_page->offsetSelector->slotSetColor(c);
     } else {
         m_page->btnOffset->setColor(c);
     }
     emit sigConfigurationItemChanged();
 }
 
 void KisASCCDLConfigWidget::powerColorChanged(const KoColor &c)
 {
     if (QObject::sender() == m_page->btnPower) {
         m_page->powerSelector->slotSetColor(c);
     } else {
         m_page->btnPower->setColor(c);
     }
     emit sigConfigurationItemChanged();
 }
diff --git a/plugins/filters/colors/kis_wdg_color_to_alpha.cpp b/plugins/filters/colors/kis_wdg_color_to_alpha.cpp
index c07b3d7a6c..215db8e805 100644
--- a/plugins/filters/colors/kis_wdg_color_to_alpha.cpp
+++ b/plugins/filters/colors/kis_wdg_color_to_alpha.cpp
@@ -1,125 +1,125 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 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_wdg_color_to_alpha.h"
 #include <QCheckBox>
 #include <QLayout>
 #include <QSpinBox>
 
 #include <KoColor.h>
 #include <KoToolManager.h>
 
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_selection.h>
 #include <kis_paint_device.h>
 #include <kis_processing_information.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "ui_wdgcolortoalphabase.h"
 
 KisWdgColorToAlpha::KisWdgColorToAlpha(QWidget * parent)
     : KisConfigWidget(parent),
       m_view(0)
 {
     m_widget = new Ui_WdgColorToAlphaBase();
     m_widget->setupUi(this);
 
     m_widget->textLabel1->hide();
 
     m_widget->intThreshold->setRange(1, 255, 0);
 
-    connect(m_widget->colorSelector, SIGNAL(sigNewColor(KoColor)), SLOT(slotColorSelectorChanged(const KoColor&)));
+    connect(m_widget->colorSelector, SIGNAL(sigNewColor(KoColor)), SLOT(slotColorSelectorChanged(KoColor)));
     connect(m_widget->intThreshold, SIGNAL(valueChanged(qreal)), SIGNAL(sigConfigurationItemChanged()));
-    connect(m_widget->btnCustomColor, SIGNAL(changed(const KoColor)), SLOT(slotCustomColorSelected(const KoColor&)));
+    connect(m_widget->btnCustomColor, SIGNAL(changed(KoColor)), SLOT(slotCustomColorSelected(KoColor)));
 
     KoColor c(Qt::white, KoColorSpaceRegistry::instance()->rgb8());
     m_widget->btnCustomColor->setColor(c);
 }
 
 KisWdgColorToAlpha::~KisWdgColorToAlpha()
 {
     delete m_widget;
 }
 
 void KisWdgColorToAlpha::setView(KisViewManager *view)
 {
     m_view = view;
 }
 
 void KisWdgColorToAlpha::slotFgColorChanged(const KoColor &color)
 {
     m_widget->btnCustomColor->setColor(color);
 }
 
 void KisWdgColorToAlpha::slotColorSelectorChanged(const KoColor &color)
 {
     m_widget->btnCustomColor->setColor(color);
 }
 
 void KisWdgColorToAlpha::slotCustomColorSelected(const KoColor &color)
 {
     KoColor c(color, KoColorSpaceRegistry::instance()->rgb8());
     m_widget->colorSelector->slotSetColor(color);
     emit sigConfigurationItemChanged();
 }
 
 void KisWdgColorToAlpha::setConfiguration(const KisPropertiesConfigurationSP config)
 {
     QVariant value;
     if (config->getProperty("targetcolor", value)) {
         KoColor c;
         if (value.value<QColor>().isValid()) {
             c = KoColor(value.value<QColor>(), KoColorSpaceRegistry::instance()->rgb8());
         } else {
             c = value.value<KoColor>();
         }
         m_widget->colorSelector->slotSetColor(c);
     }
     if (config->getProperty("threshold", value)) {
         m_widget->intThreshold->setValue(value.toInt());
     }
 }
 
 KisPropertiesConfigurationSP KisWdgColorToAlpha::configuration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration("colortoalpha", 1);
     config->setProperty("targetcolor", widget()->colorSelector->getCurrentColor().toQColor());
     config->setProperty("threshold", widget()->intThreshold->value());
     return config;
 }
 
 void KisWdgColorToAlpha::hideEvent(QHideEvent *)
 {
     if (m_view) {
-        disconnect(m_view->resourceProvider(), SIGNAL(sigFGColorChanged(const KoColor&)), this, SLOT(slotFgColorChanged(const KoColor&)));
+        disconnect(m_view->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), this, SLOT(slotFgColorChanged(KoColor)));
     }
 }
 
 void KisWdgColorToAlpha::showEvent(QShowEvent *)
 {
     if (m_view) {
-        connect(m_view->resourceProvider(), SIGNAL(sigFGColorChanged(const KoColor&)), this, SLOT(slotFgColorChanged(const KoColor&)));
+        connect(m_view->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), this, SLOT(slotFgColorChanged(KoColor)));
     }
 }
 
 
diff --git a/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp b/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
index ce91729532..596d5f7715 100644
--- a/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
+++ b/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
@@ -1,145 +1,145 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 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_wdg_fastcolortransfer.h"
 
 #include <QLayout>
 
 #include <KisImportExportFilter.h>
 #include <KisImportExportManager.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_paint_device.h>
 #include <kundo2command.h>
 #include <KoColorSpaceRegistry.h>
 #include <kis_file_name_requester.h>
 #include "ui_wdgfastcolortransfer.h"
 
 KisWdgFastColorTransfer::KisWdgFastColorTransfer(QWidget * parent) : KisConfigWidget(parent)
 {
     m_widget = new Ui_WdgFastColorTransfer();
     m_widget->setupUi(this);
     m_widget->fileNameURLRequester->setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
-    connect(m_widget->fileNameURLRequester, SIGNAL(textChanged(const QString&)), this, SIGNAL(sigConfigurationItemChanged()));
+    connect(m_widget->fileNameURLRequester, SIGNAL(textChanged(QString)), this, SIGNAL(sigConfigurationItemChanged()));
 }
 
 
 KisWdgFastColorTransfer::~KisWdgFastColorTransfer()
 {
     delete m_widget;
 }
 
 void KisWdgFastColorTransfer::setConfiguration(const KisPropertiesConfigurationSP config)
 {
     QVariant value;
     if (config->getProperty("filename", value)) {
         widget()->fileNameURLRequester->setFileName(value.toString());
     }
 
 }
 
 KisPropertiesConfigurationSP KisWdgFastColorTransfer::configuration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration("colortransfer", 1);
     QString fileName = this->widget()->fileNameURLRequester->fileName();
 
     if (fileName.isEmpty()) return config;
 
     KisPaintDeviceSP ref;
 
     dbgPlugins << "Use as reference file : " << fileName;
 
     KisDocument *d = KisPart::instance()->createDocument();
 
     KisImportExportManager manager(d);
     KisImportExportFilter::ConversionStatus status = manager.importDocument(fileName, QString());
     dbgPlugins << "import returned status" << status;
     KisImageWSP importedImage = d->image();
 
     if (importedImage) {
         ref = importedImage->projection();
     }
     if (!ref) {
         dbgPlugins << "No reference image was specified.";
         delete d;
         return config;
     }
 
     // Convert ref to LAB
     const KoColorSpace* labCS = KoColorSpaceRegistry::instance()->lab16();
     if (!labCS) {
         dbgPlugins << "The LAB colorspace is not available.";
         delete d;
         return config;
     }
 
     dbgPlugins << "convert ref to lab";
     KUndo2Command* cmd = ref->convertTo(labCS, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     delete cmd;
 
     // Compute the means and sigmas of ref
     double meanL_ref = 0., meanA_ref = 0., meanB_ref = 0.;
     double sigmaL_ref = 0., sigmaA_ref = 0., sigmaB_ref = 0.;
 
     KisSequentialConstIterator refIt(ref, importedImage->bounds());
     while (refIt.nextPixel()) {
         const quint16* data = reinterpret_cast<const quint16*>(refIt.oldRawData());
 
         quint32 L = data[0];
         quint32 A = data[1];
         quint32 B = data[2];
 
         meanL_ref += L;
         meanA_ref += A;
         meanB_ref += B;
 
         sigmaL_ref += L * L;
         sigmaA_ref += A * A;
         sigmaB_ref += B * B;
 
     }
 
     double totalSize = 1. / (importedImage->width() * importedImage->height());
 
     meanL_ref *= totalSize;
     meanA_ref *= totalSize;
     meanB_ref *= totalSize;
     sigmaL_ref *= totalSize;
     sigmaA_ref *= totalSize;
     sigmaB_ref *= totalSize;
 
     dbgPlugins << totalSize << "" << meanL_ref << "" << meanA_ref << "" << meanB_ref << "" << sigmaL_ref << "" << sigmaA_ref << "" << sigmaB_ref;
 
     config->setProperty("filename", fileName);
     config->setProperty("meanL", meanL_ref);
     config->setProperty("meanA", meanA_ref);
     config->setProperty("meanB", meanB_ref);
     config->setProperty("sigmaL", sigmaL_ref);
     config->setProperty("sigmaA", sigmaA_ref);
     config->setProperty("sigmaB", sigmaB_ref);
 
     delete d;
 
     return config;
 }
diff --git a/plugins/filters/levelfilter/kis_level_filter.cpp b/plugins/filters/levelfilter/kis_level_filter.cpp
index 4374171f46..e824af18db 100644
--- a/plugins/filters/levelfilter/kis_level_filter.cpp
+++ b/plugins/filters/levelfilter/kis_level_filter.cpp
@@ -1,345 +1,345 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 Frederic Coiffier <fcoiffie@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_level_filter.h"
 
 #include <cmath>
 
 #include <klocalizedstring.h>
 
 #include <QtGlobal>
 #include <QLayout>
 #include <QPixmap>
 #include <QPainter>
 #include <QLabel>
 #include <QSpinBox>
 
 #include <KoBasicHistogramProducers.h>
 #include <KoColorSpace.h>
 #include <KoColorTransformation.h>
 
 #include "kis_paint_device.h"
 #include "kis_histogram.h"
 #include "kis_painter.h"
 #include "KisGradientSlider.h"
 #include "kis_processing_information.h"
 #include "kis_selection.h"
 #include "kis_types.h"
 #include <filter/kis_filter_category_ids.h>
 #include "filter/kis_color_transformation_configuration.h"
 
 KisLevelFilter::KisLevelFilter()
         : KisColorTransformationFilter(id(), FiltersCategoryAdjustId, i18n("&Levels..."))
 {
     setShortcut(QKeySequence(Qt::CTRL + Qt::Key_L));
     setSupportsPainting(false);
     setColorSpaceIndependence(TO_LAB16);
 }
 
 KisLevelFilter::~KisLevelFilter()
 {
 }
 
 KisConfigWidget * KisLevelFilter::createConfigurationWidget(QWidget* parent, const KisPaintDeviceSP dev) const
 {
     return new KisLevelConfigWidget(parent, dev);
 }
 
 KoColorTransformation* KisLevelFilter::createTransformation(const KoColorSpace* cs, const KisFilterConfigurationSP config) const
 {
     if (!config) {
         warnKrita << "No configuration object for level filter\n";
         return 0;
     }
 
     Q_ASSERT(config);
 
     int blackvalue = config->getInt("blackvalue");
     int whitevalue = config->getInt("whitevalue", 255);
     double gammavalue = config->getDouble("gammavalue", 1.0);
     int outblackvalue = config->getInt("outblackvalue");
     int outwhitevalue = config->getInt("outwhitevalue", 255);
 
     quint16 transfer[256];
     for (int i = 0; i < 256; i++) {
         if (i <= blackvalue)
             transfer[i] = outblackvalue;
         else if (i < whitevalue) {
             double a = (double)(i - blackvalue) / (double)(whitevalue - blackvalue);
             a = (double)(outwhitevalue - outblackvalue) * pow(a, (1.0 / gammavalue));
             transfer[i] = int(outblackvalue + a);
         } else
             transfer[i] = outwhitevalue;
         // TODO use floats instead of integer in the configuration
         transfer[i] = ((int)transfer[i] * 0xFFFF) / 0xFF ;
     }
     return cs->createBrightnessContrastAdjustment(transfer);
 }
 
 KisLevelConfigWidget::KisLevelConfigWidget(QWidget * parent, KisPaintDeviceSP dev)
         : KisConfigWidget(parent)
 {
     Q_ASSERT(dev);
     m_page.setupUi(this);
 
     m_page.ingradient->enableGamma(true);
     m_page.blackspin->setValue(0);
     m_page.whitespin->setValue(255);
     m_page.gammaspin->setValue(1.0);
     m_page.ingradient->slotModifyGamma(1.0);
     m_page.outblackspin->setValue(0);
     m_page.outwhitespin->setValue(255);
 
     connect(m_page.blackspin, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page.whitespin, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page.ingradient, SIGNAL(sigModifiedGamma(double)), SIGNAL(sigConfigurationItemChanged()));
 
     connect(m_page.blackspin, SIGNAL(valueChanged(int)), m_page.ingradient, SLOT(slotModifyBlack(int)));
     connect(m_page.whitespin, SIGNAL(valueChanged(int)), m_page.ingradient, SLOT(slotModifyWhite(int)));
     connect(m_page.gammaspin, SIGNAL(valueChanged(double)), m_page.ingradient, SLOT(slotModifyGamma(double)));
 
     connect(m_page.blackspin, SIGNAL(valueChanged(int)), this, SLOT(slotModifyInWhiteLimit(int)));
     connect(m_page.whitespin, SIGNAL(valueChanged(int)), this, SLOT(slotModifyInBlackLimit(int)));
 
     connect(m_page.ingradient, SIGNAL(sigModifiedBlack(int)), m_page.blackspin, SLOT(setValue(int)));
     connect(m_page.ingradient, SIGNAL(sigModifiedWhite(int)), m_page.whitespin, SLOT(setValue(int)));
     connect(m_page.ingradient, SIGNAL(sigModifiedGamma(double)), m_page.gammaspin, SLOT(setValue(double)));
 
 
     connect(m_page.outblackspin, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page.outwhitespin, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
 
     connect(m_page.outblackspin, SIGNAL(valueChanged(int)), m_page.outgradient, SLOT(slotModifyBlack(int)));
     connect(m_page.outwhitespin, SIGNAL(valueChanged(int)), m_page.outgradient, SLOT(slotModifyWhite(int)));
 
     connect(m_page.outblackspin, SIGNAL(valueChanged(int)), this, SLOT(slotModifyOutWhiteLimit(int)));
     connect(m_page.outwhitespin, SIGNAL(valueChanged(int)), this, SLOT(slotModifyOutBlackLimit(int)));
 
     connect(m_page.outgradient, SIGNAL(sigModifiedBlack(int)), m_page.outblackspin, SLOT(setValue(int)));
     connect(m_page.outgradient, SIGNAL(sigModifiedWhite(int)), m_page.outwhitespin, SLOT(setValue(int)));
 
-    connect(m_page.butauto, SIGNAL(clicked(bool)), this, SLOT(slotAutoLevel(void)));
-    connect(m_page.butinvert, SIGNAL(clicked(bool)), this, SLOT(slotInvert(void)));
+    connect(m_page.butauto, SIGNAL(clicked(bool)), this, SLOT(slotAutoLevel()));
+    connect(m_page.butinvert, SIGNAL(clicked(bool)), this, SLOT(slotInvert()));
 
     connect((QObject*)(m_page.chkLogarithmic), SIGNAL(toggled(bool)), this, SLOT(slotDrawHistogram(bool)));
 
     KoHistogramProducer *producer = new KoGenericLabHistogramProducer();
     m_histogram.reset( new KisHistogram(dev, dev->exactBounds(), producer, LINEAR) );
     m_histlog = false;
     m_page.histview->resize(288,100);
     m_inverted = false;
     slotDrawHistogram();
 
 }
 
 KisLevelConfigWidget::~KisLevelConfigWidget()
 {
 }
 
 void KisLevelConfigWidget::slotDrawHistogram(bool logarithmic)
 {
     int wHeight = m_page.histview->height();
     int wHeightMinusOne = wHeight - 1;
     int wWidth = m_page.histview->width();
 
     if (m_histlog != logarithmic) {
         // Update the m_histogram
         if (logarithmic)
             m_histogram->setHistogramType(LOGARITHMIC);
         else
             m_histogram->setHistogramType(LINEAR);
         m_histlog = logarithmic;
     }
 
     QPalette appPalette = QApplication::palette();
     QPixmap pix(wWidth-100, wHeight);
 
     pix.fill(QColor(appPalette.color(QPalette::Base)));
     QPainter p(&pix);
 
     p.setPen(QPen(Qt::gray, 1, Qt::SolidLine));
 
     double highest = (double)m_histogram->calculations().getHighest();
     qint32 bins = m_histogram->producer()->numberOfBins();
 
     // use nearest neighbour interpolation
     if (m_histogram->getHistogramType() == LINEAR) {
         double factor = (double)(wHeight - wHeight / 5.0) / highest;
         for (int i = 0; i < wWidth; i++) {
             int binNo = qRound((double)i / wWidth * (bins - 1));
             if ((int)m_histogram->getValue(binNo) != 0)
                 p.drawLine(i, wHeightMinusOne, i, wHeightMinusOne - (int)m_histogram->getValue(binNo) * factor);
         }
     } else {
         double factor = (double)(wHeight - wHeight / 5.0) / (double)log(highest);
         for (int i = 0; i < wWidth; i++) {
             int binNo = qRound((double)i / wWidth * (bins - 1)) ;
             if ((int)m_histogram->getValue(binNo) != 0)
                 p.drawLine(i, wHeightMinusOne, i, wHeightMinusOne - log((double)m_histogram->getValue(binNo)) * factor);
         }
     }
 
     m_page.histview->setPixmap(pix);
 }
 
 void KisLevelConfigWidget::slotModifyInBlackLimit(int limit)
 {
     m_page.blackspin->setMaximum(limit - 1);
 }
 
 void KisLevelConfigWidget::slotModifyInWhiteLimit(int limit)
 {
     m_page.whitespin->setMinimum(limit + 1);
 }
 
 void KisLevelConfigWidget::slotModifyOutBlackLimit(int limit)
 {
     if (m_inverted) {
         m_page.outblackspin->setMinimum(limit + 1);
     } else {
         m_page.outblackspin->setMaximum(limit - 1);
     }
 }
 
 void KisLevelConfigWidget::slotModifyOutWhiteLimit(int limit)
 {
     if (m_inverted) {
         m_page.outwhitespin->setMaximum(limit - 1);
     } else {
         m_page.outwhitespin->setMinimum(limit + 1);
     }
 }
 
 void KisLevelConfigWidget::slotAutoLevel(void)
 {
     Q_ASSERT(m_histogram);
 
     qint32 num_bins = m_histogram->producer()->numberOfBins();
 
     Q_ASSERT(num_bins > 1);
 
     int chosen_low_bin = 0, chosen_high_bin = num_bins-1;
     int count_thus_far = m_histogram->getValue(0);
     const int total_count = m_histogram->producer()->count();
     const double threshold = 0.006;
 
     // find the low and hi point/bins based on summing count percentages
     //
     // this implementation is a port of GIMP's auto level implementation
     // (use a GPLv2 version as reference, specifically commit 51bfd07f18ef045a3e43632218fd92cae9ff1e48)
 
     for (int bin=0; bin<(num_bins-1); ++bin) {
         int next_count_thus_far = count_thus_far + m_histogram->getValue(bin+1);
 
         double this_percentage = static_cast<double>(count_thus_far) /  total_count;
         double next_percentage = static_cast<double>(next_count_thus_far) / total_count;
 
         //dbgKrita << "bin" << bin << "this_percentage" << this_percentage << "next_percentage" << next_percentage;
         if (fabs(this_percentage - threshold) < fabs(next_percentage - threshold)) {
             chosen_low_bin = bin;
             break;
         }
 
         count_thus_far = next_count_thus_far;
     }
 
     count_thus_far = m_histogram->getValue(num_bins-1);
     for (int bin=(num_bins-1); bin>0; --bin) {
         int next_count_thus_far = count_thus_far + m_histogram->getValue(bin-1);
 
         double this_percentage = static_cast<double>(count_thus_far) /  total_count;
         double next_percentage = static_cast<double>(next_count_thus_far) / total_count;
 
         //dbgKrita << "hi-bin" << bin << "this_percentage" << this_percentage << "next_percentage" << next_percentage;
         if (fabs(this_percentage - threshold) < fabs(next_percentage - threshold)) {
             chosen_high_bin = bin;
             break;
         }
 
         count_thus_far = next_count_thus_far;
     }
 
     if (chosen_low_bin < chosen_high_bin) {
         m_page.blackspin->setValue(chosen_low_bin);
         m_page.ingradient->slotModifyBlack(chosen_low_bin);
 
         m_page.whitespin->setValue(chosen_high_bin);
         m_page.ingradient->slotModifyWhite(chosen_high_bin);
     }
 }
 
 void KisLevelConfigWidget::slotInvert(void)
 {
     m_inverted = !m_inverted;
     int white = m_page.outwhitespin->value();
     int black = m_page.outblackspin->value();
 
     resetOutSpinLimit();
     m_page.outgradient->setInverted(m_inverted);
     m_page.outwhitespin->setValue(black);
     m_page.outblackspin->setValue(white);
 }
 
 KisPropertiesConfigurationSP  KisLevelConfigWidget::configuration() const
 {
     KisColorTransformationConfiguration * config = new KisColorTransformationConfiguration(KisLevelFilter::id().id(), 1);
 
     config->setProperty("blackvalue", m_page.blackspin->value());
     config->setProperty("whitevalue", m_page.whitespin->value());
     config->setProperty("gammavalue", m_page.gammaspin->value());
     config->setProperty("outblackvalue", m_page.outblackspin->value());
     config->setProperty("outwhitevalue", m_page.outwhitespin->value());
 
     return config;
 }
 
 void KisLevelConfigWidget::setConfiguration(const KisPropertiesConfigurationSP  config)
 {
     QVariant value;
     if (config->getProperty("blackvalue", value)) {
         m_page.blackspin->setValue(value.toUInt());
         m_page.ingradient->slotModifyBlack(value.toUInt());
     }
     if (config->getProperty("whitevalue", value)) {
         m_page.whitespin->setValue(value.toUInt());
         m_page.ingradient->slotModifyWhite(value.toUInt());
     }
     if (config->getProperty("gammavalue", value)) {
         m_page.gammaspin->setValue(value.toUInt());
         m_page.ingradient->slotModifyGamma(value.toDouble());
     }
     if (config->getProperty("outblackvalue", value)) {
         m_page.outblackspin->setValue(value.toUInt());
         m_page.outgradient->slotModifyBlack(value.toUInt());
     }
     if (config->getProperty("outwhitevalue", value)) {
         m_page.outwhitespin->setValue(value.toUInt());
         m_page.outgradient->slotModifyWhite(value.toUInt());
     }
 }
 
 void KisLevelConfigWidget::resetOutSpinLimit() {
     if (m_inverted) {
         m_page.outblackspin->setMaximum(255);
         m_page.outwhitespin->setMinimum(0);
     } else {
         m_page.outblackspin->setMinimum(0);
         m_page.outwhitespin->setMaximum(255);
     }
 }
diff --git a/plugins/filters/phongbumpmap/kis_phong_bumpmap_config_widget.cpp b/plugins/filters/phongbumpmap/kis_phong_bumpmap_config_widget.cpp
index d0011fe093..8fbfe0775d 100644
--- a/plugins/filters/phongbumpmap/kis_phong_bumpmap_config_widget.cpp
+++ b/plugins/filters/phongbumpmap/kis_phong_bumpmap_config_widget.cpp
@@ -1,186 +1,186 @@
 /*
  *  Copyright (c) 2010-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_phong_bumpmap_config_widget.h"
 #include <filter/kis_filter_configuration.h>
 #include <kis_size_group.h>
 #include "phong_bumpmap_constants.h"
 #include "KoChannelInfo.h"
 #include "KoColorSpace.h"
 
 KisPhongBumpmapConfigWidget::KisPhongBumpmapConfigWidget(const KisPaintDeviceSP dev, QWidget *parent, Qt::WindowFlags f)
                             : KisConfigWidget(parent, f)
                             , m_device(dev)
 {
     Q_ASSERT(m_device);
     m_page = new KisPhongBumpmapWidget(this);
 
     KisSizeGroup *matPropLabelsGroup = new KisSizeGroup(this);
     matPropLabelsGroup->addWidget(m_page->lblAmbientReflectivity);
     matPropLabelsGroup->addWidget(m_page->lblDiffuseReflectivity);
     matPropLabelsGroup->addWidget(m_page->lblSpecularReflectivity);
     matPropLabelsGroup->addWidget(m_page->lblSpecularShinyExp);
 
     // Connect widgets to each other
     connect(m_page->azimuthDial1, SIGNAL(valueChanged(int)), m_page->azimuthSpinBox1, SLOT(setValue(int)));
     connect(m_page->azimuthDial2, SIGNAL(valueChanged(int)), m_page->azimuthSpinBox2, SLOT(setValue(int)));
     connect(m_page->azimuthDial3, SIGNAL(valueChanged(int)), m_page->azimuthSpinBox3, SLOT(setValue(int)));
     connect(m_page->azimuthDial4, SIGNAL(valueChanged(int)), m_page->azimuthSpinBox4, SLOT(setValue(int)));
     connect(m_page->azimuthSpinBox1, SIGNAL(valueChanged(int)), m_page->azimuthDial1, SLOT(setValue(int)));
     connect(m_page->azimuthSpinBox2, SIGNAL(valueChanged(int)), m_page->azimuthDial2, SLOT(setValue(int)));
     connect(m_page->azimuthSpinBox3, SIGNAL(valueChanged(int)), m_page->azimuthDial3, SLOT(setValue(int)));
     connect(m_page->azimuthSpinBox4, SIGNAL(valueChanged(int)), m_page->azimuthDial4, SLOT(setValue(int)));
 
     //Let widgets warn the preview of when they are updated
     connect(m_page->azimuthDial1, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->azimuthDial2, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->azimuthDial3, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->azimuthDial4, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
         
     connect(m_page->lightKColorCombo1, SIGNAL(currentIndexChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->lightKColorCombo2, SIGNAL(currentIndexChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->lightKColorCombo3, SIGNAL(currentIndexChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->lightKColorCombo4, SIGNAL(currentIndexChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     
     connect(m_page->inclinationSpinBox1, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->inclinationSpinBox2, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->inclinationSpinBox3, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->inclinationSpinBox4, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
 
     connect(m_page->useNormalMap, SIGNAL(toggled(bool)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->diffuseReflectivityGroup, SIGNAL(toggled(bool)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->specularReflectivityGroup, SIGNAL(toggled(bool)), SIGNAL(sigConfigurationItemChanged()));
     
     connect(m_page->ambientReflectivityKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->diffuseReflectivityKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->specularReflectivityKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->shinynessExponentKisSliderSpinBox, SIGNAL(valueChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     
     connect(m_page->heightChannelComboBox, SIGNAL(currentIndexChanged(int)), SIGNAL(sigConfigurationItemChanged()));
     
     connect(m_page->lightSourceGroupBox1, SIGNAL(toggled(bool)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->lightSourceGroupBox2, SIGNAL(toggled(bool)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->lightSourceGroupBox3, SIGNAL(toggled(bool)), SIGNAL(sigConfigurationItemChanged()));
     connect(m_page->lightSourceGroupBox4, SIGNAL(toggled(bool)), SIGNAL(sigConfigurationItemChanged()));
 
 
     QVBoxLayout *l = new QVBoxLayout(this);
     Q_CHECK_PTR(l);
 
     l->addWidget(m_page);
 
     /* fill in the channel chooser */
     QList<KoChannelInfo *> channels = m_device->colorSpace()->channels();
     for (quint8 ch = 0; ch < m_device->colorSpace()->colorChannelCount(); ch++)
         m_page->heightChannelComboBox->addItem(channels.at(ch)->name());
     
-    connect(m_page->useNormalMap, SIGNAL(toggled(bool)), this, SLOT(slotDisableHeightChannelCombobox(bool) ) );
+    connect(m_page->useNormalMap, SIGNAL(toggled(bool)), this, SLOT(slotDisableHeightChannelCombobox(bool)) );
 
 
 }
 
 void KisPhongBumpmapConfigWidget::setConfiguration(const KisPropertiesConfigurationSP config)
 {
     if (!config) return;
     
     QVariant tempcolor;
     if (config->getBool(USE_NORMALMAP_IS_ENABLED))  {
         m_page->heightChannelComboBox->setEnabled(false);
     } else {
         m_page->heightChannelComboBox->setEnabled(true);
     }
     m_page->ambientReflectivityKisDoubleSliderSpinBox->setValue( config->getDouble(PHONG_AMBIENT_REFLECTIVITY) );
     m_page->diffuseReflectivityKisDoubleSliderSpinBox->setValue( config->getDouble(PHONG_DIFFUSE_REFLECTIVITY) );
     m_page->specularReflectivityKisDoubleSliderSpinBox->setValue( config->getDouble(PHONG_SPECULAR_REFLECTIVITY) );
     m_page->shinynessExponentKisSliderSpinBox->setValue( config->getInt(PHONG_SHINYNESS_EXPONENT) );
     m_page->useNormalMap->setChecked( config->getBool(USE_NORMALMAP_IS_ENABLED) );
     m_page->diffuseReflectivityGroup->setChecked( config->getBool(PHONG_DIFFUSE_REFLECTIVITY_IS_ENABLED) );
     m_page->specularReflectivityGroup->setChecked( config->getBool(PHONG_SPECULAR_REFLECTIVITY_IS_ENABLED) );
     // NOTE: Indexes are off by 1 simply because arrays start at 0 and the GUI naming scheme started at 1
     m_page->lightSourceGroupBox1->setChecked( config->getBool(PHONG_ILLUMINANT_IS_ENABLED[0]) );
     m_page->lightSourceGroupBox2->setChecked( config->getBool(PHONG_ILLUMINANT_IS_ENABLED[1]) );
     m_page->lightSourceGroupBox3->setChecked( config->getBool(PHONG_ILLUMINANT_IS_ENABLED[2]) );
     m_page->lightSourceGroupBox4->setChecked( config->getBool(PHONG_ILLUMINANT_IS_ENABLED[3]) );
     config->getProperty(PHONG_ILLUMINANT_COLOR[0], tempcolor);
     m_page->lightKColorCombo1->setColor(tempcolor.value<QColor>());
     config->getProperty(PHONG_ILLUMINANT_COLOR[1], tempcolor);
     m_page->lightKColorCombo2->setColor(tempcolor.value<QColor>());
     config->getProperty(PHONG_ILLUMINANT_COLOR[2], tempcolor);
     m_page->lightKColorCombo3->setColor(tempcolor.value<QColor>());
     config->getProperty(PHONG_ILLUMINANT_COLOR[3], tempcolor);
     m_page->lightKColorCombo4->setColor(tempcolor.value<QColor>());
     m_page->azimuthSpinBox1->setValue( config->getDouble(PHONG_ILLUMINANT_AZIMUTH[0]) );
     m_page->azimuthSpinBox2->setValue( config->getDouble(PHONG_ILLUMINANT_AZIMUTH[1]) );
     m_page->azimuthSpinBox3->setValue( config->getDouble(PHONG_ILLUMINANT_AZIMUTH[2]) );
     m_page->azimuthSpinBox4->setValue( config->getDouble(PHONG_ILLUMINANT_AZIMUTH[3]) );
     m_page->inclinationSpinBox1->setValue( config->getDouble(PHONG_ILLUMINANT_INCLINATION[0]) );
     m_page->inclinationSpinBox2->setValue( config->getDouble(PHONG_ILLUMINANT_INCLINATION[1]) );
     m_page->inclinationSpinBox3->setValue( config->getDouble(PHONG_ILLUMINANT_INCLINATION[2]) );
     m_page->inclinationSpinBox4->setValue( config->getDouble(PHONG_ILLUMINANT_INCLINATION[3]) );
 }
 
 KisPropertiesConfigurationSP KisPhongBumpmapConfigWidget::configuration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration("phongbumpmap", 2);
     config->setProperty(PHONG_HEIGHT_CHANNEL, m_page->heightChannelComboBox->currentText());
     config->setProperty(USE_NORMALMAP_IS_ENABLED, m_page->useNormalMap->isChecked());
     
     config->setProperty(PHONG_AMBIENT_REFLECTIVITY, m_page->ambientReflectivityKisDoubleSliderSpinBox->value());
     config->setProperty(PHONG_DIFFUSE_REFLECTIVITY, m_page->diffuseReflectivityKisDoubleSliderSpinBox->value());
     config->setProperty(PHONG_SPECULAR_REFLECTIVITY, m_page->specularReflectivityKisDoubleSliderSpinBox->value());
     config->setProperty(PHONG_SHINYNESS_EXPONENT, m_page->shinynessExponentKisSliderSpinBox->value());
     config->setProperty(PHONG_DIFFUSE_REFLECTIVITY_IS_ENABLED, m_page->diffuseReflectivityGroup->isChecked());
     config->setProperty(PHONG_SPECULAR_REFLECTIVITY_IS_ENABLED, m_page->specularReflectivityGroup->isChecked());
     //config->setProperty(PHONG_SHINYNESS_EXPONENT_IS_ENABLED, m_page->specularReflectivityCheckBox->isChecked());
     // Indexes are off by 1 simply because arrays start at 0 and the GUI naming scheme started at 1
     config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[0], m_page->lightSourceGroupBox1->isChecked());
     config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[1], m_page->lightSourceGroupBox2->isChecked());
     config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[2], m_page->lightSourceGroupBox3->isChecked());
     config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[3], m_page->lightSourceGroupBox4->isChecked());
     config->setProperty(PHONG_ILLUMINANT_COLOR[0], m_page->lightKColorCombo1->color());
     config->setProperty(PHONG_ILLUMINANT_COLOR[1], m_page->lightKColorCombo2->color());
     config->setProperty(PHONG_ILLUMINANT_COLOR[2], m_page->lightKColorCombo3->color());
     config->setProperty(PHONG_ILLUMINANT_COLOR[3], m_page->lightKColorCombo4->color());
     config->setProperty(PHONG_ILLUMINANT_AZIMUTH[0], m_page->azimuthSpinBox1->value());
     config->setProperty(PHONG_ILLUMINANT_AZIMUTH[1], m_page->azimuthSpinBox2->value());
     config->setProperty(PHONG_ILLUMINANT_AZIMUTH[2], m_page->azimuthSpinBox3->value());
     config->setProperty(PHONG_ILLUMINANT_AZIMUTH[3], m_page->azimuthSpinBox4->value());
     config->setProperty(PHONG_ILLUMINANT_INCLINATION[0], m_page->inclinationSpinBox1->value());
     config->setProperty(PHONG_ILLUMINANT_INCLINATION[1], m_page->inclinationSpinBox2->value());
     config->setProperty(PHONG_ILLUMINANT_INCLINATION[2], m_page->inclinationSpinBox3->value());
     config->setProperty(PHONG_ILLUMINANT_INCLINATION[3], m_page->inclinationSpinBox4->value());
 
     // Read configuration
     /*
     QMap<QString, QVariant> rofl = QMap<QString, QVariant>(config->getProperties());
 
     QMap<QString, QVariant>::const_iterator i;
     for (i = rofl.constBegin(); i != rofl.constEnd(); ++i)
         dbgKrita << i.key() << ":" << i.value();
     */
     return config;
 }
 
 void KisPhongBumpmapConfigWidget::slotDisableHeightChannelCombobox(bool normalmapchecked) {
     if (normalmapchecked)  {
         m_page->heightChannelComboBox->setEnabled(false);
     } else {
         m_page->heightChannelComboBox->setEnabled(true);
     }
 }
 
diff --git a/plugins/flake/textshape/kotext/OdfTextTrackStyles.cpp b/plugins/flake/textshape/kotext/OdfTextTrackStyles.cpp
index bcf91f1d87..5dac209872 100644
--- a/plugins/flake/textshape/kotext/OdfTextTrackStyles.cpp
+++ b/plugins/flake/textshape/kotext/OdfTextTrackStyles.cpp
@@ -1,120 +1,120 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2009 Thomas Zander <zander@kde.org>
  * Copyright (C) 2012-2014 C. Boemann <cbo@boemann.dk>
  *
  * 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 "OdfTextTrackStyles.h"
 #include "KoTextDocument.h"
 #include "KoParagraphStyle.h"
 #include "KoCharacterStyle.h"
 
 #include <QTextDocument>
 #include "TextDebug.h"
 
 
 QMap<QObject *, OdfTextTrackStyles *> OdfTextTrackStyles::instances;
 
 OdfTextTrackStyles *OdfTextTrackStyles::instance(KoStyleManager *manager)
 {
     if (! instances.contains(manager)) {
         instances[manager] = new OdfTextTrackStyles(manager);
-        connect(manager,SIGNAL(destroyed(QObject *)),instances[manager], SLOT(styleManagerDied(QObject *)));
+        connect(manager,SIGNAL(destroyed(QObject*)),instances[manager], SLOT(styleManagerDied(QObject*)));
     }
 
     return instances[manager];
 }
 
 void OdfTextTrackStyles::registerDocument(QTextDocument *qDoc)
 {
     if (! m_documents.contains(qDoc)) {
         m_documents.append(qDoc);
-        connect(qDoc,SIGNAL(destroyed(QObject *)), this, SLOT(documentDied(QObject *)));
+        connect(qDoc,SIGNAL(destroyed(QObject*)), this, SLOT(documentDied(QObject*)));
     }
 }
 
 void OdfTextTrackStyles::unregisterDocument(QTextDocument *qDoc)
 {
     if (m_documents.contains(qDoc)) {
         m_documents.removeOne(qDoc);
     }
 }
 
 OdfTextTrackStyles::OdfTextTrackStyles(KoStyleManager *manager)
         : QObject(manager)
         , m_styleManager(manager)
         , m_changeCommand(0)
 {
     connect(manager, SIGNAL(editHasBegun()), this, SLOT(beginEdit()));
     connect(manager, SIGNAL(editHasEnded()), this, SLOT(endEdit()));
-    connect(manager, SIGNAL(styleHasChanged(int, const KoCharacterStyle *, const KoCharacterStyle *)), this, SLOT(recordStyleChange(int, const KoCharacterStyle *, const KoCharacterStyle *)));
-    connect(manager, SIGNAL(styleHasChanged(int, const KoParagraphStyle *, const KoParagraphStyle *)), this, SLOT(recordStyleChange(int, const KoParagraphStyle *, const KoParagraphStyle *)));
+    connect(manager, SIGNAL(styleHasChanged(int,const KoCharacterStyle*,const KoCharacterStyle*)), this, SLOT(recordStyleChange(int,const KoCharacterStyle*,const KoCharacterStyle*)));
+    connect(manager, SIGNAL(styleHasChanged(int,const KoParagraphStyle*,const KoParagraphStyle*)), this, SLOT(recordStyleChange(int,const KoParagraphStyle*,const KoParagraphStyle*)));
 }
 
 OdfTextTrackStyles::~OdfTextTrackStyles()
 {
     delete m_changeCommand;
 }
 
 void OdfTextTrackStyles::beginEdit()
 {
     Q_ASSERT(m_changeCommand == 0);
     m_changeCommand = new ChangeStylesMacroCommand(m_documents, m_styleManager.data());
 }
 
 void OdfTextTrackStyles::endEdit()
 {
     if (m_documents.length() > 0) {
         KUndo2Stack *undoStack= KoTextDocument(m_documents.first()).undoStack();
         if (undoStack) {
             undoStack->push(m_changeCommand);
         }
     } else
         delete m_changeCommand;
 
     m_changeCommand = 0;
 }
 
 void OdfTextTrackStyles::recordStyleChange(int id, const KoParagraphStyle *origStyle, const KoParagraphStyle *newStyle)
 {
     m_changeCommand->changedStyle(id);
 
     if (origStyle != newStyle) {
         m_changeCommand->origStyle(origStyle->clone());
         m_changeCommand->changedStyle(newStyle->clone());
     }
 }
 
 void OdfTextTrackStyles::recordStyleChange(int id, const KoCharacterStyle *origStyle, const KoCharacterStyle *newStyle)
 {
    m_changeCommand->changedStyle(id);
 
     if (origStyle != newStyle) {
         m_changeCommand->origStyle(origStyle->clone());
         m_changeCommand->changedStyle(newStyle->clone());
     }
 }
 
 void OdfTextTrackStyles::styleManagerDied(QObject *manager)
 {
     OdfTextTrackStyles::instances.remove(manager);
 }
 
 void OdfTextTrackStyles::documentDied(QObject *document)
 {
     unregisterDocument(static_cast<QTextDocument *>(document));
 }
diff --git a/plugins/impex/video/video_saver.cpp b/plugins/impex/video/video_saver.cpp
index 4521d300dc..91bd8e9a2b 100644
--- a/plugins/impex/video/video_saver.cpp
+++ b/plugins/impex/video/video_saver.cpp
@@ -1,365 +1,365 @@
 /*
  *  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 "video_saver.h"
 
 #include <QDebug>
 
 #include <QFileInfo>
 
 #include <KisDocument.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoResourcePaths.h>
 
 
 #include <kis_image.h>
 #include <kis_image_animation_interface.h>
 #include <kis_time_range.h>
 
 #include "kis_config.h"
 
 #include <QFileSystemWatcher>
 #include <QProcess>
 #include <QProgressDialog>
 #include <QEventLoop>
 #include <QTemporaryFile>
 #include <QTemporaryDir>
 #include <QTime>
 
 #include "KisPart.h"
 
 class KisFFMpegProgressWatcher : public QObject {
     Q_OBJECT
 public:
     KisFFMpegProgressWatcher(QFile &progressFile, int totalFrames)
         : m_progressFile(progressFile),
           m_totalFrames(totalFrames)
         {
             connect(&m_progressWatcher, SIGNAL(fileChanged(QString)), SLOT(slotFileChanged()));
 
 
             m_progressWatcher.addPath(m_progressFile.fileName());
         }
 
 private Q_SLOTS:
     void slotFileChanged() {
         int currentFrame = -1;
         bool isEnded = false;
 
         while(!m_progressFile.atEnd()) {
             QString line = QString(m_progressFile.readLine()).remove(QChar('\n'));
             QStringList var = line.split("=");
 
             if (var[0] == "frame") {
                 currentFrame = var[1].toInt();
             } else if (var[0] == "progress") {
                 isEnded = var[1] == "end";
             }
         }
 
         if (isEnded) {
             emit sigProgressChanged(100);
             emit sigProcessingFinished();
         } else {
 
             emit sigProgressChanged(100 * currentFrame / m_totalFrames);
         }
     }
 
 Q_SIGNALS:
     void sigProgressChanged(int percent);
     void sigProcessingFinished();
 
 private:
     QFileSystemWatcher m_progressWatcher;
     QFile &m_progressFile;
     int m_totalFrames;
 };
 
 
 class KisFFMpegRunner
 {
 public:
     KisFFMpegRunner(const QString &ffmpegPath)
         : m_cancelled(false),
           m_ffmpegPath(ffmpegPath) {}
 public:
     KisImageBuilder_Result runFFMpeg(const QStringList &specialArgs,
                                      const QString &actionName,
                                      const QString &logPath,
                                      int totalFrames)
     {
         dbgFile << "runFFMpeg: specialArgs" << specialArgs
                 << "actionName" << actionName
                 << "logPath" << logPath
                 << "totalFrames" << totalFrames;
 
         QTemporaryFile progressFile(QDir::tempPath() + QDir::separator() + "KritaFFmpegProgress.XXXXXX");
         progressFile.open();
 
         m_process.setStandardOutputFile(logPath);
         m_process.setProcessChannelMode(QProcess::MergedChannels);
         QStringList args;
         args << "-v" << "debug"
              << "-nostdin"
              << "-progress" << progressFile.fileName()
              << specialArgs;
 
         qDebug() << "\t" << m_ffmpegPath << args.join(" ");
 
         m_cancelled = false;
         m_process.start(m_ffmpegPath, args);
         return waitForFFMpegProcess(actionName, progressFile, m_process, totalFrames);
     }
 
     void cancel() {
         m_cancelled = true;
         m_process.kill();
     }
 
 private:
     KisImageBuilder_Result waitForFFMpegProcess(const QString &message,
                                                 QFile &progressFile,
                                                 QProcess &ffmpegProcess,
                                                 int totalFrames)
     {
 
         KisFFMpegProgressWatcher watcher(progressFile, totalFrames);
 
         QProgressDialog progress(message, "", 0, 0, KisPart::instance()->currentMainwindow());
         progress.setWindowModality(Qt::ApplicationModal);
         progress.setCancelButton(0);
         progress.setMinimumDuration(0);
         progress.setValue(0);
         progress.setRange(0, 100);
 
         QEventLoop loop;
         loop.connect(&watcher, SIGNAL(sigProcessingFinished()), SLOT(quit()));
-        loop.connect(&ffmpegProcess, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(quit()));
+        loop.connect(&ffmpegProcess, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(quit()));
         loop.connect(&ffmpegProcess, SIGNAL(error(QProcess::ProcessError)), SLOT(quit()));
         loop.connect(&watcher, SIGNAL(sigProgressChanged(int)), &progress, SLOT(setValue(int)));
 
         if (ffmpegProcess.state() != QProcess::NotRunning) {
             loop.exec();
 
             // wait for some erroneous case
             ffmpegProcess.waitForFinished(5000);
         }
 
         KisImageBuilder_Result retval = KisImageBuilder_RESULT_OK;
 
         if (ffmpegProcess.state() != QProcess::NotRunning) {
             // sorry...
             ffmpegProcess.kill();
             retval = KisImageBuilder_RESULT_FAILURE;
         } else if (m_cancelled) {
             retval = KisImageBuilder_RESULT_CANCEL;
         } else if (ffmpegProcess.exitCode()) {
             retval = KisImageBuilder_RESULT_FAILURE;
         }
 
         return retval;
     }
 
 private:
     QProcess m_process;
     bool m_cancelled;
     QString m_ffmpegPath;
 };
 
 
 VideoSaver::VideoSaver(KisDocument *doc, const QString &ffmpegPath, bool batchMode)
     : m_image(doc->image())
     , m_doc(doc)
     , m_batchMode(batchMode)
     , m_ffmpegPath(ffmpegPath)
     , m_runner(new KisFFMpegRunner(ffmpegPath))
 {
 }
 
 VideoSaver::~VideoSaver()
 {
 }
 
 KisImageSP VideoSaver::image()
 {
     return m_image;
 }
 
 bool VideoSaver::hasFFMpeg() const
 {
     return !m_ffmpegPath.isEmpty();
 }
 
 KisImageBuilder_Result VideoSaver::encode(const QString &filename, KisPropertiesConfigurationSP configuration)
 {
 
     qDebug() << "ffmpeg" << m_ffmpegPath << "filename" << filename << "configuration" << configuration->toXML();
 
     if (m_ffmpegPath.isEmpty()) {
         m_ffmpegPath = configuration->getString("ffmpeg_path");
         if (!QFileInfo(m_ffmpegPath).exists()) {
             return KisImageBuilder_RESULT_FAILURE;
         }
     }
 
     KisImageBuilder_Result result = KisImageBuilder_RESULT_OK;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("first_frame"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("last_frame"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("height"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("width"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("include_audio"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("directory"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("framerate"));
 
     KisImageAnimationInterface *animation = m_image->animationInterface();
     const KisTimeRange fullRange = animation->fullClipRange();
     const int frameRate = configuration->getInt("framerate", animation->framerate());
 
     const int sequenceNumberingOffset = configuration->getInt("sequence_start", 0);
     const KisTimeRange clipRange(sequenceNumberingOffset + configuration->getInt("first_frame", fullRange.start()),
                                  sequenceNumberingOffset + configuration->getInt("last_frame", fullRange.end())
     );
 
     const bool includeAudio = configuration->getBool("include_audio", true);
 
     const int exportHeight = configuration->getInt("height", int(m_image->height()));
     const int exportWidth = configuration->getInt("width", int(m_image->width()));
 
      // export dimensions could be off a little bit, so the last force option tweaks the pixels for the export to work
     const QString exportDimensions = QString("scale=w=").append(QString::number(exportWidth)).append(":h=")
             .append(QString::number(exportHeight)).append(":force_original_aspect_ratio=decrease");
 
 
     const QDir framesDir(configuration->getString("directory"));
 
     QString resultFile;
     if (QFileInfo(filename).isAbsolute()) {
         resultFile = filename;
     }
     else {
         resultFile = framesDir.absolutePath() + "/" + filename;
     }
     const QFileInfo info(resultFile);
     const QString suffix = info.suffix().toLower();
 
     const QString palettePath = framesDir.filePath("palette.png");
 
     const QString savedFilesMask = configuration->getString("savedFilesMask");
 
     const QStringList additionalOptionsList = configuration->getString("customUserOptions").split(' ', QString::SkipEmptyParts);
 
     if (suffix == "gif") {
         {
             QStringList args;
             args << "-r" << QString::number(frameRate)
                  << "-start_number" << QString::number(clipRange.start())
                  << "-i" << savedFilesMask
                  << "-vf" << "palettegen"
                  << "-y" << palettePath;
 
             KisImageBuilder_Result result =
                 m_runner->runFFMpeg(args, i18n("Fetching palette..."),
                                     framesDir.filePath("log_generate_palette_gif.log"),
                                     clipRange.duration());
 
             if (result != KisImageBuilder_RESULT_OK) {
                 return result;
             }
         }
 
         {
             QStringList args;
             args << "-r" << QString::number(frameRate)
                  << "-start_number" << QString::number(clipRange.start())
                  << "-i" << savedFilesMask
                  << "-i" << palettePath
                  << "-lavfi" << "[0:v][1:v] paletteuse"
                  << additionalOptionsList
                  << "-y" << resultFile;
 
             // if we are exporting out at a different image size, we apply scaling filter
             if (m_image->height() != exportHeight || m_image->width() != exportWidth) {
                 args << "-vf" << exportDimensions;
             }
 
 
             dbgFile << "savedFilesMask" << savedFilesMask << "start" << QString::number(clipRange.start()) << "duration" << clipRange.duration();
 
             KisImageBuilder_Result result =
                 m_runner->runFFMpeg(args, i18n("Encoding frames..."),
                                     framesDir.filePath("log_encode_gif.log"),
                                     clipRange.duration());
 
             if (result != KisImageBuilder_RESULT_OK) {
                 return result;
             }
         }
     } else {
         QStringList args;
         args << "-r" << QString::number(frameRate)
              << "-start_number" << QString::number(clipRange.start())
              << "-i" << savedFilesMask;
 
 
 
         QFileInfo audioFileInfo = animation->audioChannelFileName();
         if (includeAudio && audioFileInfo.exists()) {
             const int msecStart = clipRange.start() * 1000 / animation->framerate();
             const int msecDuration = clipRange.duration() * 1000 / animation->framerate();
 
             const QTime startTime = QTime::fromMSecsSinceStartOfDay(msecStart);
             const QTime durationTime = QTime::fromMSecsSinceStartOfDay(msecDuration);
             const QString ffmpegTimeFormat("H:m:s.zzz");
 
             args << "-ss" << startTime.toString(ffmpegTimeFormat);
             args << "-t" << durationTime.toString(ffmpegTimeFormat);
 
             args << "-i" << audioFileInfo.absoluteFilePath();
         }
 
 
         // if we are exporting out at a different image size, we apply scaling filter
         // export options HAVE to go after input options, so make sure this is after the audio import
         if (m_image->height() != exportHeight || m_image->width() != exportWidth) {
             args << "-vf" << exportDimensions;
         }
 
 
         args << additionalOptionsList
              << "-y" << resultFile;
 
 
         result = m_runner->runFFMpeg(args, i18n("Encoding frames..."),
                                      framesDir.filePath("log_encode.log"),
                                      clipRange.duration());
     }
 
     return result;
 }
 
 void VideoSaver::cancel()
 {
     m_runner->cancel();
 }
 
 #include "video_saver.moc"
diff --git a/plugins/paintops/libpaintop/kis_brush_chooser.cpp b/plugins/paintops/libpaintop/kis_brush_chooser.cpp
index 697011c0d6..d6dcf17de2 100644
--- a/plugins/paintops/libpaintop/kis_brush_chooser.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_chooser.cpp
@@ -1,427 +1,427 @@
 /*
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2009 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_brush_chooser.h"
 
 #include <QLabel>
 #include <QLayout>
 #include <QCheckBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QPainter>
 #include <QAbstractItemDelegate>
 #include <klocalizedstring.h>
 
 #include <kconfig.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoResourceItemChooser.h>
 
 #include <kis_icon.h>
 #include "kis_brush_server.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_multipliers_double_slider_spinbox.h"
 #include "kis_spacing_selection_widget.h"
 #include "kis_signals_blocker.h"
 
 #include "kis_imagepipe_brush.h"
 #include "kis_custom_brush_widget.h"
 #include "kis_clipboard_brush_widget.h"
 #include <kis_config.h>
 
 #include "kis_global.h"
 #include "kis_gbr_brush.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 
 /// The resource item delegate for rendering the resource preview
 class KisBrushDelegate : public QAbstractItemDelegate
 {
 public:
     KisBrushDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent) {}
     ~KisBrushDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 };
 
 void KisBrushDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     if (! index.isValid())
         return;
 
     KisBrush *brush = static_cast<KisBrush*>(index.internalPointer());
 
     QRect itemRect = option.rect;
     QImage thumbnail = brush->image();
 
     if (thumbnail.height() > itemRect.height() || thumbnail.width() > itemRect.width()) {
         thumbnail = thumbnail.scaled(itemRect.size() , Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
 
     painter->save();
     int dx = (itemRect.width() - thumbnail.width()) / 2;
     int dy = (itemRect.height() - thumbnail.height()) / 2;
     painter->drawImage(itemRect.x() + dx, itemRect.y() + dy, thumbnail);
 
     if (option.state & QStyle::State_Selected) {
         painter->setPen(QPen(option.palette.highlight(), 2.0));
         painter->drawRect(option.rect);
         painter->setCompositionMode(QPainter::CompositionMode_HardLight);
         painter->setOpacity(0.65);
         painter->fillRect(option.rect, option.palette.highlight());
     }
 
     painter->restore();
 }
 
 
 KisPredefinedBrushChooser::KisPredefinedBrushChooser(QWidget *parent, const char *name)
     : QWidget(parent),
       m_stampBrushWidget(0),
       m_clipboardBrushWidget(0)
 {
     setObjectName(name);
 
     setupUi(this);
 
     brushSizeSpinBox->setRange(0, KSharedConfig::openConfig()->group("").readEntry("maximumBrushSize", 1000), 2);
     brushSizeSpinBox->setValue(5);
     brushSizeSpinBox->setExponentRatio(3.0);
     brushSizeSpinBox->setSuffix(i18n(" px"));
     brushSizeSpinBox->setExponentRatio(3.0);
 
     QObject::connect(brushSizeSpinBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetItemSize(qreal)));
 
 
     brushRotationSpinBox->setRange(0, 360, 0);
     brushRotationSpinBox->setValue(0);
     brushRotationSpinBox->setSuffix(QChar(Qt::Key_degree));
     QObject::connect(brushRotationSpinBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetItemRotation(qreal)));
 
     brushSpacingSelectionWidget->setSpacing(true, 1.0);
     connect(brushSpacingSelectionWidget, SIGNAL(sigSpacingChanged()), SLOT(slotSpacingChanged()));
 
 
     QObject::connect(useColorAsMaskCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetItemUseColorAsMask(bool)));
 
 
     KisBrushResourceServer* rServer = KisBrushServer::instance()->brushServer();
     QSharedPointer<KisBrushResourceServerAdapter> adapter(new KisBrushResourceServerAdapter(rServer));
 
     m_itemChooser = new KoResourceItemChooser(adapter, this);
     m_itemChooser->setObjectName("brush_selector");
 
     m_itemChooser->showTaggingBar(true);
     m_itemChooser->setColumnCount(10);
     m_itemChooser->setRowHeight(30);
     m_itemChooser->setItemDelegate(new KisBrushDelegate(this));
     m_itemChooser->setCurrentItem(0, 0);
     m_itemChooser->setSynced(true);
     m_itemChooser->setMinimumWidth(100);
     m_itemChooser->setMinimumHeight(150);
     m_itemChooser->showButtons(false); // turn the import and delete buttons since we want control over them
 
     KisConfig cfg(true);
     m_itemChooser->configureKineticScrolling(cfg.kineticScrollingGesture(),
                                          cfg.kineticScrollingSensitivity(),
                                          cfg.kineticScrollingScrollbar());
 
 
     addPresetButton->setIcon(KisIconUtils::loadIcon("list-add"));
     deleteBrushTipButton->setIcon(KisIconUtils::loadIcon("trash-empty"));
 
 
 
     connect(addPresetButton, SIGNAL(clicked(bool)), this, SLOT(slotImportNewBrushResource()));
     connect(deleteBrushTipButton, SIGNAL(clicked(bool)), this, SLOT(slotDeleteBrushResource()));
 
     presetsLayout->addWidget(m_itemChooser);
 
 
-    connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)), this, SLOT(updateBrushTip(KoResource *)));
+    connect(m_itemChooser, SIGNAL(resourceSelected(KoResource*)), this, SLOT(updateBrushTip(KoResource*)));
 
     stampButton->setIcon(KisIconUtils::loadIcon("list-add"));
     stampButton->setToolTip(i18n("Creates a brush tip from the current image selection."
                                "\n If no selection is present the whole image will be used."));
 
     clipboardButton->setIcon(KisIconUtils::loadIcon("list-add"));
     clipboardButton->setToolTip(i18n("Creates a brush tip from the image in the clipboard."));
 
 
     connect(stampButton, SIGNAL(clicked()), this,  SLOT(slotOpenStampBrush()));
     connect(clipboardButton, SIGNAL(clicked()), SLOT(slotOpenClipboardBrush()));
 
     QGridLayout *spacingLayout = new QGridLayout();
     spacingLayout->setObjectName("spacing grid layout");
 
     resetBrushButton->setToolTip(i18n("Reloads Spacing from file\nSets Scale to 1.0\nSets Rotation to 0.0"));
     connect(resetBrushButton, SIGNAL(clicked()), SLOT(slotResetBrush()));
 
     updateBrushTip(m_itemChooser->currentResource());
 }
 
 KisPredefinedBrushChooser::~KisPredefinedBrushChooser()
 {
 }
 
 void KisPredefinedBrushChooser::setBrush(KisBrushSP brush)
 {
     /**
      * Warning: since the brushes are always cloned after loading from XML or
      * fetching from the server, we cannot just ask for that brush explicitly.
      * Instead, we should search for the brush with the same filename and/or name
      * and load it. Please take it into account that after selecting the brush
      * explicitly in the chooser, m_itemChooser->currentResource() might be
      * **not** the same as the value in m_brush.
      *
      * Ideally, if the resource is not found on the server, we should add it, but
      * it might lead to a set of weird consequences. So for now we just
      * select nothing.
      */
 
     KisBrushResourceServer* server = KisBrushServer::instance()->brushServer();
     KoResource *resource = server->resourceByFilename(brush->shortFilename()).data();
 
     if (!resource) {
         resource = server->resourceByName(brush->name()).data();
     }
 
     if (!resource) {
         resource = brush.data();
     }
 
     m_itemChooser->setCurrentResource(resource);
     updateBrushTip(brush.data(), true);
 }
 
 void KisPredefinedBrushChooser::slotResetBrush()
 {
     /**
      * The slot also resets the brush on the server
      *
      * TODO: technically, after we refactored all the brushes to be forked,
      *       we can just re-update the brush from the server without reloading.
      *       But it needs testing.
      */
 
     KisBrush *brush = dynamic_cast<KisBrush *>(m_itemChooser->currentResource());
     if (brush) {
         brush->load();
         brush->setScale(1.0);
         brush->setAngle(0.0);
 
         updateBrushTip(brush);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemSize(qreal sizeValue)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     if (m_brush) {
         int brushWidth = m_brush->width();
 
         m_brush->setScale(sizeValue / qreal(brushWidth));
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemRotation(qreal rotationValue)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     if (m_brush) {
         m_brush->setAngle(rotationValue / 180.0 * M_PI);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSpacingChanged()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     if (m_brush) {
         m_brush->setSpacing(brushSpacingSelectionWidget->spacing());
         m_brush->setAutoSpacing(brushSpacingSelectionWidget->autoSpacingActive(), brushSpacingSelectionWidget->autoSpacingCoeff());
 
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemUseColorAsMask(bool useColorAsMask)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_brush);
 
     KisGbrBrush *brush = dynamic_cast<KisGbrBrush *>(m_brush.data());
     if (brush) {
         brush->setUseColorAsMask(useColorAsMask);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotOpenStampBrush()
 {
     if(!m_stampBrushWidget) {
         m_stampBrushWidget = new KisCustomBrushWidget(this, i18n("Stamp"), m_image);
         m_stampBrushWidget->setModal(false);
-        connect(m_stampBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource *)),
-                                    SLOT(slotNewPredefinedBrush(KoResource *)));
+        connect(m_stampBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource*)),
+                                    SLOT(slotNewPredefinedBrush(KoResource*)));
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_stampBrushWidget->exec();
 
     if(result) {
         updateBrushTip(m_itemChooser->currentResource());
     }
 }
 void KisPredefinedBrushChooser::slotOpenClipboardBrush()
 {
     if(!m_clipboardBrushWidget) {
         m_clipboardBrushWidget = new KisClipboardBrushWidget(this, i18n("Clipboard"), m_image);
         m_clipboardBrushWidget->setModal(true);
-        connect(m_clipboardBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource *)),
-                                        SLOT(slotNewPredefinedBrush(KoResource *)));
+        connect(m_clipboardBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource*)),
+                                        SLOT(slotNewPredefinedBrush(KoResource*)));
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_clipboardBrushWidget->exec();
 
     if(result) {
         updateBrushTip(m_itemChooser->currentResource());
     }
 }
 
 void KisPredefinedBrushChooser::updateBrushTip(KoResource * resource, bool isChangingBrushPresets)
 {
 
 
     QString animatedBrushTipSelectionMode; // incremental, random, etc
 
     {
         KisBrush* brush = dynamic_cast<KisBrush*>(resource);
         m_brush = brush ? brush->clone() : 0;
     }
 
     if (m_brush) {
         brushTipNameLabel->setText(i18n(m_brush->name().toUtf8().data()));
 
         QString brushTypeString = "";
 
         if (m_brush->brushType() == INVALID) {
             brushTypeString = i18n("Invalid");
         } else if (m_brush->brushType() == MASK) {
             brushTypeString = i18n("Mask");
         } else if (m_brush->brushType() == IMAGE) {
             brushTypeString = i18n("GBR");
         } else if (m_brush->brushType() == PIPE_MASK ) {
             brushTypeString = i18n("Animated Mask"); // GIH brush
 
             // cast to GIH brush and grab parasite name
             //m_brush
             KisImagePipeBrush* pipeBrush = dynamic_cast<KisImagePipeBrush*>(resource);
             animatedBrushTipSelectionMode =  pipeBrush->parasiteSelection();
 
 
         } else if (m_brush->brushType() == PIPE_IMAGE ) {
             brushTypeString = i18n("Animated Image");
         }
 
 
         QString brushDetailsText = QString("%1 (%2 x %3) %4")
                        .arg(brushTypeString)
                        .arg(m_brush->width())
                        .arg(m_brush->height())
                        .arg(animatedBrushTipSelectionMode);
 
         brushDetailsLabel->setText(brushDetailsText);
 
         // keep the current preset's tip settings if we are preserving it
         // this will set the brush's model data to keep what it currently has for size, spacing, etc.
         if (preserveBrushPresetSettings->isChecked() && !isChangingBrushPresets) {
             m_brush->setAutoSpacing(brushSpacingSelectionWidget->autoSpacingActive(), brushSpacingSelectionWidget->autoSpacingCoeff());
             m_brush->setAngle(brushRotationSpinBox->value() * M_PI / 180);
             m_brush->setSpacing(brushSpacingSelectionWidget->spacing());
             m_brush->setUserEffectiveSize(brushSizeSpinBox->value());
         }
 
 
         brushSpacingSelectionWidget->setSpacing(m_brush->autoSpacingActive(),
                                 m_brush->autoSpacingActive() ?
                                 m_brush->autoSpacingCoeff() : m_brush->spacing());
 
         brushRotationSpinBox->setValue(m_brush->angle() * 180 / M_PI);
         brushSizeSpinBox->setValue(m_brush->width() * m_brush->scale());
 
 
         // useColorAsMask support is only in gimp brush so far
         KisGbrBrush *gimpBrush = dynamic_cast<KisGbrBrush*>(m_brush.data());
         if (gimpBrush) {
             useColorAsMaskCheckbox->setChecked(gimpBrush->useColorAsMask());
         }
         useColorAsMaskCheckbox->setEnabled(m_brush->hasColor() && gimpBrush);
 
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotNewPredefinedBrush(KoResource *resource)
 {
     m_itemChooser->setCurrentResource(resource);
     updateBrushTip(resource);
 }
 
 void KisPredefinedBrushChooser::setBrushSize(qreal xPixels, qreal yPixels)
 {
     Q_UNUSED(yPixels);
     qreal oldWidth = m_brush->width() * m_brush->scale();
     qreal newWidth = oldWidth + xPixels;
 
     newWidth = qMax(newWidth, qreal(0.1));
 
     brushSizeSpinBox->setValue(newWidth);
 }
 
 void KisPredefinedBrushChooser::setImage(KisImageWSP image)
 {
     m_image = image;
 }
 
 void KisPredefinedBrushChooser::slotImportNewBrushResource() {
     m_itemChooser->slotButtonClicked(KoResourceItemChooser::Button_Import);
 }
 
 void KisPredefinedBrushChooser::slotDeleteBrushResource() {
     m_itemChooser->slotButtonClicked(KoResourceItemChooser::Button_Remove);
 }
 
 
 
 #include "moc_kis_brush_chooser.cpp"
 
 
diff --git a/plugins/paintops/libpaintop/kis_compositeop_option.cpp b/plugins/paintops/libpaintop/kis_compositeop_option.cpp
index 4fdf17527c..e96c68c23f 100644
--- a/plugins/paintops/libpaintop/kis_compositeop_option.cpp
+++ b/plugins/paintops/libpaintop/kis_compositeop_option.cpp
@@ -1,113 +1,113 @@
 /*
  *  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_compositeop_option.h"
 
 #include <klocalizedstring.h>
 #include <kis_icon.h>
 
 #include <kis_cmb_composite.h>
 #include <KoCompositeOpRegistry.h>
 #include <kis_types.h>
 #include <KoID.h>
 #include <ui_wdgCompositeOpOption.h>
 #include <kis_composite_ops_model.h>
 #include "kis_signals_blocker.h"
 
 KisCompositeOpOption::KisCompositeOpOption(bool createConfigWidget):
     KisPaintOpOption(KisPaintOpOption::GENERAL, true),
     m_createConfigWidget(createConfigWidget),
     m_eraserMode(false)
 {
     m_checkable         = false;
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     if (createConfigWidget) {
         QWidget* widget = new QWidget();
 
         Ui_wdgCompositeOpOption ui;
         ui.setupUi(widget);
         ui.bnEraser->setIcon(KisIconUtils::loadIcon("draw-eraser"));
 
         m_label    = ui.lbChoosenMode;
         m_list     = ui.list;
         m_bnEraser = ui.bnEraser;
 
         setConfigurationPage(widget);
 
-        connect(ui.list    , SIGNAL(clicked(const QModelIndex&)), this, SLOT(slotCompositeOpChanged(const QModelIndex&)));
+        connect(ui.list    , SIGNAL(clicked(QModelIndex)), this, SLOT(slotCompositeOpChanged(QModelIndex)));
         connect(ui.bnEraser, SIGNAL(toggled(bool))                , this, SLOT(slotEraserToggled(bool)));
     }
 
     setObjectName("KisCompositeOpOption");
 
 }
 
 KisCompositeOpOption::~KisCompositeOpOption()
 {
 }
 
 void KisCompositeOpOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     setting->setProperty("CompositeOp", m_currCompositeOpID);
     setting->setProperty("EraserMode", m_eraserMode);
 }
 
 void KisCompositeOpOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     QString ompositeOpID = setting->getString("CompositeOp", KoCompositeOpRegistry::instance().getDefaultCompositeOp().id());
     KoID    compositeOp = KoCompositeOpRegistry::instance().getKoID(ompositeOpID);
     changeCompositeOp(compositeOp);
 
     const bool eraserMode = setting->getBool("EraserMode", false);
     slotEraserToggled(eraserMode);
 }
 
 void KisCompositeOpOption::changeCompositeOp(const KoID& compositeOp)
 {
     if (compositeOp.id() == m_currCompositeOpID)
         return;
 
     m_currCompositeOpID = compositeOp.id();
 
     if (m_createConfigWidget) {
         m_label->setText(compositeOp.name());
     }
 
     emitSettingChanged();
 }
 
 
 void KisCompositeOpOption::slotCompositeOpChanged(const QModelIndex& index)
 {
     Q_UNUSED(index);
 
     KoID compositeOp = m_list->selectedCompositeOp();
     changeCompositeOp(compositeOp);
 }
 
 void KisCompositeOpOption::slotEraserToggled(bool toggled)
 {
     if (m_bnEraser->isChecked() != toggled) {
         KisSignalsBlocker b(m_bnEraser);
         m_bnEraser->setChecked(toggled);
     }
 
     m_eraserMode = toggled;
 
     emitSettingChanged();
 }
diff --git a/plugins/paintops/libpaintop/kis_curve_option_widget.cpp b/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
index 22483bd198..53ef65852e 100644
--- a/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
@@ -1,303 +1,303 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2009 Sven Langkamp   <sven.langkamp@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 "kis_curve_option_widget.h"
 
 #include "ui_wdgcurveoption.h"
 #include "widgets/kis_curve_widget.h"
 #include "kis_dynamic_sensor.h"
 #include "kis_global.h"
 #include "kis_curve_option.h"
 #include "kis_signals_blocker.h"
 #include "kis_icon_utils.h"
 
 inline void setLabel(QLabel* label, const KisCurveLabel& curve_label)
 {
     if (curve_label.icon().isNull()) {
         label->setText(curve_label.name());
     }
     else {
         label->setPixmap(QPixmap::fromImage(curve_label.icon()));
     }
 }
 
 KisCurveOptionWidget::KisCurveOptionWidget(KisCurveOption* curveOption, const QString &minLabel, const QString &maxLabel, bool hideSlider)
     : KisPaintOpOption(curveOption->category(), curveOption->isChecked())
     , m_widget(new QWidget)
     , m_curveOptionWidget(new Ui_WdgCurveOption())
     , m_curveOption(curveOption)
 {
     setObjectName("KisCurveOptionWidget");
 
     m_curveOptionWidget->setupUi(m_widget);
     setConfigurationPage(m_widget);
 
     m_curveOptionWidget->sensorSelector->setCurveOption(curveOption);
 
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
 
     connect(m_curveOptionWidget->curveWidget, SIGNAL(modified()), this, SLOT(transferCurve()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(parametersChanged()), SLOT(emitSettingChanged()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(parametersChanged()), SLOT(updateLabelsOfCurrentSensor()));
-    connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP )), SLOT(updateSensorCurveLabels(KisDynamicSensorSP )));
-    connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP )), SLOT(updateCurve(KisDynamicSensorSP )));
+    connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP)), SLOT(updateSensorCurveLabels(KisDynamicSensorSP)));
+    connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP)), SLOT(updateCurve(KisDynamicSensorSP)));
     connect(m_curveOptionWidget->checkBoxUseSameCurve, SIGNAL(stateChanged(int)), SLOT(transferCurve()));
 
 
     // set all the icons for the curve preset shapes
     updateThemedIcons();
 
     // various curve preset buttons with predefined curves
     connect(m_curveOptionWidget->linearCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveLinear()));
     connect(m_curveOptionWidget->revLinearButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveReverseLinear()));
     connect(m_curveOptionWidget->jCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveJShape()));
     connect(m_curveOptionWidget->lCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveLShape()));
     connect(m_curveOptionWidget->sCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveSShape()));
     connect(m_curveOptionWidget->reverseSCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveReverseSShape()));
     connect(m_curveOptionWidget->uCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveUShape()));
     connect(m_curveOptionWidget->revUCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveArchShape()));
 
 
     m_curveOptionWidget->label_ymin->setText(minLabel);
     m_curveOptionWidget->label_ymax->setText(maxLabel);
 
     // strength settings is shown as 0-100%
     m_curveOptionWidget->strengthSlider->setRange(curveOption->minValue()*100, curveOption->maxValue()*100, 0);
     m_curveOptionWidget->strengthSlider->setValue(curveOption->value()*100);
     m_curveOptionWidget->strengthSlider->setPrefix(i18n("Strength: "));
     m_curveOptionWidget->strengthSlider->setSuffix(i18n("%"));
 
 
     if (hideSlider) {
          m_curveOptionWidget->strengthSlider->hide();
     }
 
     connect(m_curveOptionWidget->checkBoxUseCurve, SIGNAL(stateChanged(int))  , SLOT(updateValues()));
     connect(m_curveOptionWidget->curveMode, SIGNAL(currentIndexChanged(int)), SLOT(updateMode()));
     connect(m_curveOptionWidget->strengthSlider, SIGNAL(valueChanged(qreal)), SLOT(updateValues()));
 }
 
 KisCurveOptionWidget::~KisCurveOptionWidget()
 {
     delete m_curveOption;
     delete m_curveOptionWidget;
 }
 
 void KisCurveOptionWidget::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     m_curveOption->writeOptionSetting(setting);
 }
 
 void KisCurveOptionWidget::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     //setting->dump();
 
     m_curveOption->readOptionSetting(setting);
 
     m_curveOptionWidget->checkBoxUseCurve->setChecked(m_curveOption->isCurveUsed());
     m_curveOptionWidget->strengthSlider->setValue(m_curveOption->value()*100);
     m_curveOptionWidget->checkBoxUseSameCurve->setChecked(m_curveOption->isSameCurveUsed());
     m_curveOptionWidget->curveMode->setCurrentIndex(m_curveOption->getCurveMode());
 
     disableWidgets(!m_curveOption->isCurveUsed());
 
     m_curveOptionWidget->sensorSelector->reload();
     m_curveOptionWidget->sensorSelector->setCurrent(m_curveOption->activeSensors().first());
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
 }
 
 void KisCurveOptionWidget::lodLimitations(KisPaintopLodLimitations *l) const
 {
     m_curveOption->lodLimitations(l);
 }
 
 bool KisCurveOptionWidget::isCheckable() const
 {
     return m_curveOption->isCheckable();
 }
 
 bool KisCurveOptionWidget::isChecked() const
 {
     return m_curveOption->isChecked();
 }
 
 void KisCurveOptionWidget::setChecked(bool checked)
 {
     m_curveOption->setChecked(checked);
 }
 
 KisCurveOption* KisCurveOptionWidget::curveOption()
 {
     return m_curveOption;
 }
 
 QWidget* KisCurveOptionWidget::curveWidget()
 {
     return m_widget;
 }
 
 void KisCurveOptionWidget::transferCurve()
 {
     m_curveOptionWidget->sensorSelector->setCurrentCurve(m_curveOptionWidget->curveWidget->curve(), m_curveOptionWidget->checkBoxUseSameCurve->isChecked());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::updateSensorCurveLabels(KisDynamicSensorSP sensor)
 {
     if (sensor) {
         m_curveOptionWidget->label_xmin->setText(KisDynamicSensor::minimumLabel(sensor->sensorType()));
         m_curveOptionWidget->label_xmax->setText(KisDynamicSensor::maximumLabel(sensor->sensorType(), sensor->length()));
     }
 }
 
 void KisCurveOptionWidget::updateCurve(KisDynamicSensorSP sensor)
 {
     if (sensor) {
         bool blockSignal = m_curveOptionWidget->curveWidget->blockSignals(true);
         m_curveOptionWidget->curveWidget->setCurve(sensor->curve());
         m_curveOptionWidget->curveWidget->blockSignals(blockSignal);
     }
 }
 
 void KisCurveOptionWidget::updateLabelsOfCurrentSensor()
 {
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
 }
 
 void KisCurveOptionWidget::updateValues()
 {
     m_curveOption->setValue(m_curveOptionWidget->strengthSlider->value()/100.0); // convert back to 0-1 for data
     m_curveOption->setCurveUsed(m_curveOptionWidget->checkBoxUseCurve->isChecked());
     disableWidgets(!m_curveOptionWidget->checkBoxUseCurve->isChecked());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::updateMode()
 {
     m_curveOption->setCurveMode(m_curveOptionWidget->curveMode->currentIndex());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::changeCurveLinear()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveReverseLinear()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,1));
         points.push_back(QPointF(1,0));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveSShape()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,0));
         points.push_back(QPointF(0.25,0.1));
         points.push_back(QPointF(0.75,0.9));
         points.push_back(QPointF(1, 1));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 
 void KisCurveOptionWidget::changeCurveReverseSShape()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,1));
         points.push_back(QPointF(0.25,0.9));
         points.push_back(QPointF(0.75,0.1));
         points.push_back(QPointF(1,0));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveJShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(0.35,0.1));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveLShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,1));
     points.push_back(QPointF(0.25,0.48));
     points.push_back(QPointF(1,0));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveUShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,1));
     points.push_back(QPointF(0.5,0));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveArchShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(0.5,1));
     points.push_back(QPointF(1,0));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 
 
 
 void KisCurveOptionWidget::disableWidgets(bool disable)
 {
     m_curveOptionWidget->checkBoxUseSameCurve->setDisabled(disable);
     m_curveOptionWidget->curveWidget->setDisabled(disable);
     m_curveOptionWidget->sensorSelector->setDisabled(disable);
     m_curveOptionWidget->label_xmax->setDisabled(disable);
     m_curveOptionWidget->label_xmin->setDisabled(disable);
     m_curveOptionWidget->label_ymax->setDisabled(disable);
     m_curveOptionWidget->label_ymin->setDisabled(disable);
 
 }
 
 
 void KisCurveOptionWidget::updateThemedIcons()
 {
     // set all the icons for the curve preset shapes
     m_curveOptionWidget->linearCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-linear"));
     m_curveOptionWidget->revLinearButton->setIcon(KisIconUtils::loadIcon("curve-preset-linear-reverse"));
     m_curveOptionWidget->jCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-j"));
     m_curveOptionWidget->lCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-l"));
     m_curveOptionWidget->sCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-s"));
     m_curveOptionWidget->reverseSCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-s-reverse"));
     m_curveOptionWidget->uCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-u"));
     m_curveOptionWidget->revUCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-arch"));
 }
 
diff --git a/plugins/paintops/libpaintop/kis_filter_option.cpp b/plugins/paintops/libpaintop/kis_filter_option.cpp
index eddff6d354..7d915abe8f 100644
--- a/plugins/paintops/libpaintop/kis_filter_option.cpp
+++ b/plugins/paintops/libpaintop/kis_filter_option.cpp
@@ -1,215 +1,215 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2008
  *
  * 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_filter_option.h"
 
 #include <QRect>
 #include <QGridLayout>
 #include <QLabel>
 
 #include <klocalizedstring.h>
 
 #include <KoCompositeOp.h>
 #include <KoID.h>
 
 #include <filter/kis_filter_registry.h>
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_config_widget.h>
 
 #include "ui_wdgfilteroption.h"
 
 #include <brushengine/kis_paintop_lod_limitations.h>
 
 class KisFilterOptionWidget : public QWidget, public Ui::FilterOpOptions
 {
 public:
     KisFilterOptionWidget(QWidget* parent = 0)
         : QWidget(parent) {
         setupUi(this);
     }
 };
 
 KisFilterOption::KisFilterOption()
     : KisPaintOpOption(KisPaintOpOption::FILTER, true)
 {
     setObjectName("KisFilterOption");
 
     m_checkable = false;
 
     m_filterOptionWidget = new KisFilterOptionWidget();
     m_filterOptionWidget->hide();
     setConfigurationPage(m_filterOptionWidget);
 
     m_layout = new QGridLayout(m_filterOptionWidget->grpFilterOptions);
 
     // Check which filters support painting
     QList<QString> l = KisFilterRegistry::instance()->keys();
     QList<KoID> l2;
     QList<QString>::iterator it;
     for (it = l.begin(); it !=  l.end(); ++it) {
         KisFilterSP f = KisFilterRegistry::instance()->value((*it));
         if (f->supportsPainting()) {
             l2.push_back(KoID(*it, f->name()));
         }
     }
     m_filterOptionWidget->filtersList->setIDList(l2);
-    connect(m_filterOptionWidget->filtersList, SIGNAL(activated(const KoID &)), SLOT(setCurrentFilter(const KoID &)));
+    connect(m_filterOptionWidget->filtersList, SIGNAL(activated(KoID)), SLOT(setCurrentFilter(KoID)));
     if (!l2.empty()) {
         setCurrentFilter(l2.first());
     }
 
     connect(m_filterOptionWidget->checkBoxSmudgeMode, SIGNAL(stateChanged(int)), this, SLOT(emitSettingChanged()));
 }
 
 KisFilterOption::~KisFilterOption()
 {
 }
 
 const KisFilterSP KisFilterOption::filter() const
 {
     return m_currentFilter;
 }
 
 KisFilterConfigurationSP KisFilterOption::filterConfig() const
 {
     if (!m_currentFilterConfigWidget) return 0;
     return static_cast<KisFilterConfiguration*>(m_currentFilterConfigWidget->configuration().data());
 }
 
 bool KisFilterOption::smudgeMode() const
 {
     return m_filterOptionWidget->checkBoxSmudgeMode->isChecked();
 }
 
 void KisFilterOption::setNode(KisNodeWSP node)
 {
     if (node && node->paintDevice()) {
         m_paintDevice = node->paintDevice();
 
         // The "not m_currentFilterConfigWidget" is a corner case
         // which happens because the first configuration settings is
         // created before any layer is selected in the view
         if (!m_currentFilterConfigWidget
                 || (m_currentFilterConfigWidget
                     && static_cast<KisFilterConfiguration*>(m_currentFilterConfigWidget->configuration().data())->isCompatible(m_paintDevice)
                    )
            ) {
             if (m_currentFilter) {
                 KisPropertiesConfigurationSP configuration = 0;
                 if (m_currentFilterConfigWidget) {
                     configuration = m_currentFilterConfigWidget->configuration();
                 }
                 setCurrentFilter(KoID(m_currentFilter->id()));
                 if (configuration) {
                     m_currentFilterConfigWidget->setConfiguration(configuration);
                 }
             }
         }
     }
     else {
         m_paintDevice = 0;
     }
 }
 
 void KisFilterOption::setImage(KisImageWSP image)
 {
     m_image = image;
     if (!m_currentFilterConfigWidget) {
         updateFilterConfigWidget();
     }
 }
 
 void KisFilterOption::setCurrentFilter(const KoID& id)
 {
     m_currentFilter = KisFilterRegistry::instance()->get(id.id());
     m_filterOptionWidget->filtersList->setCurrent(id);
     updateFilterConfigWidget();
     emitSettingChanged();
 }
 
 
 void KisFilterOption::updateFilterConfigWidget()
 {
     if (m_currentFilterConfigWidget) {
         m_currentFilterConfigWidget->hide();
         m_layout->removeWidget(m_currentFilterConfigWidget);
         m_layout->invalidate();
         delete m_currentFilterConfigWidget;
     }
     m_currentFilterConfigWidget = 0;
 
     if (m_currentFilter && m_image && m_paintDevice) {
 
         m_currentFilterConfigWidget =
             m_currentFilter->createConfigurationWidget(m_filterOptionWidget->grpFilterOptions, m_paintDevice);
 
         if (m_currentFilterConfigWidget) {
             m_layout->addWidget(m_currentFilterConfigWidget);
             m_filterOptionWidget->grpFilterOptions->updateGeometry();
             m_currentFilterConfigWidget->show();
             connect(m_currentFilterConfigWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(emitSettingChanged()));
         }
     }
     m_layout->update();
 }
 
 void KisFilterOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     if (!m_currentFilter) return;
 
     setting->setProperty(FILTER_ID, m_currentFilter->id());
     setting->setProperty(FILTER_SMUDGE_MODE, smudgeMode());
     if (filterConfig()) {
         setting->setProperty(FILTER_CONFIGURATION, filterConfig()->toXML());
     }
 }
 
 void KisFilterOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     KoID id(setting->getString(FILTER_ID), QString());
     if (id.id() != m_currentFilter->id()) {
         setCurrentFilter(id);
     }
     m_filterOptionWidget->checkBoxSmudgeMode->setChecked(setting->getBool(FILTER_SMUDGE_MODE));
     KisFilterConfigurationSP configuration = filterConfig();
     if (configuration && m_currentFilterConfigWidget) {
         configuration->fromXML(setting->getString(FILTER_CONFIGURATION));
         m_currentFilterConfigWidget->blockSignals(true);
         m_currentFilterConfigWidget->setConfiguration(configuration);
         m_currentFilterConfigWidget->blockSignals(false);
     }
 }
 
 void KisFilterOption::lodLimitations(KisPaintopLodLimitations *l) const
 {
     KisFilterConfigurationSP config = filterConfig();
 
     if (m_currentFilter && config) {
         QRect testRect(0,0,100,100);
         if (m_currentFilter->neededRect(testRect, config, 0) != testRect ||
             m_currentFilter->changedRect(testRect, config, 0) != testRect) {
 
             l->blockers << KoID("filter-nonlinear", i18nc("PaintOp instant preview limitation", "\"%1\" does not support scaled preview (non-linear filter)", config->name()));
         }
     }
 }
 
 #include "moc_kis_filter_option.cpp"
diff --git a/plugins/paintops/libpaintop/kis_multi_sensors_selector.cpp b/plugins/paintops/libpaintop/kis_multi_sensors_selector.cpp
index d8a7eccbf8..d345d350d0 100644
--- a/plugins/paintops/libpaintop/kis_multi_sensors_selector.cpp
+++ b/plugins/paintops/libpaintop/kis_multi_sensors_selector.cpp
@@ -1,103 +1,103 @@
 /*
  *  Copyright (c) 2011 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_multi_sensors_selector.h"
 
 #include "ui_wdgmultisensorsselector.h"
 #include "kis_multi_sensors_model_p.h"
 #include "kis_dynamic_sensor.h"
 #include "kis_curve_option.h"
 
 struct KisMultiSensorsSelector::Private {
     Ui_WdgMultiSensorsSelector form;
     KisMultiSensorsModel* model;
     QWidget* currentConfigWidget;
     QHBoxLayout* layout;
 };
 
 KisMultiSensorsSelector::KisMultiSensorsSelector(QWidget* parent)
     : QWidget(parent)
     , d(new Private)
 {
     d->currentConfigWidget = 0;
     d->form.setupUi(this);
     d->model = new KisMultiSensorsModel(this);
-    connect(d->model, SIGNAL(sensorChanged(KisDynamicSensorSP )), SIGNAL(sensorChanged(KisDynamicSensorSP )));
+    connect(d->model, SIGNAL(sensorChanged(KisDynamicSensorSP)), SIGNAL(sensorChanged(KisDynamicSensorSP)));
     connect(d->model, SIGNAL(parametersChanged()), SIGNAL(parametersChanged()));
     connect(d->form.sensorsList, SIGNAL(activated(QModelIndex)), SLOT(sensorActivated(QModelIndex)));
     connect(d->form.sensorsList, SIGNAL(clicked(QModelIndex)), SLOT(sensorActivated(QModelIndex)));
     d->form.sensorsList->setModel(d->model);
     d->layout = new QHBoxLayout(d->form.widgetConfiguration);
 }
 
 KisMultiSensorsSelector::~KisMultiSensorsSelector()
 {
     delete d;
 }
 
 void KisMultiSensorsSelector::setCurveOption(KisCurveOption *curveOption)
 {
     d->model->setCurveOption(curveOption);
     KisDynamicSensorSP s = curveOption->activeSensors().first();
     if (!s) {
         s = curveOption->sensors().first();
     }
     setCurrent(s);
 }
 
 void KisMultiSensorsSelector::setCurrent(KisDynamicSensorSP _sensor)
 {
     d->form.sensorsList->setCurrentIndex(d->model->sensorIndex(_sensor)); // make sure the first element is selected
 
     // HACK ALERT: make sure the signal is delivered to us. Without this line it isn't.
     sensorActivated(d->model->sensorIndex(_sensor));
 
     KisDynamicSensorSP sensor = currentHighlighted();
     if (!sensor) {
         sensor = d->model->getSensor(d->model->index(0, 0));
     }
     emit(highlightedSensorChanged(sensor));
 }
 
 KisDynamicSensorSP KisMultiSensorsSelector::currentHighlighted()
 {
     return d->model->getSensor(d->form.sensorsList->currentIndex());
 }
 
 void KisMultiSensorsSelector::sensorActivated(const QModelIndex& index)
 {
     delete d->currentConfigWidget;
     KisDynamicSensorSP sensor = d->model->getSensor(index);
     if (sensor) {
         d->currentConfigWidget = sensor->createConfigurationWidget(d->form.widgetConfiguration, this);
         if (d->currentConfigWidget) {
             d->layout->addWidget(d->currentConfigWidget);
         }
         emit(highlightedSensorChanged(sensor));
     }
 }
 
 void KisMultiSensorsSelector::setCurrentCurve(const KisCubicCurve& curve, bool useSameCurve)
 {
     d->model->setCurrentCurve(d->form.sensorsList->currentIndex(), curve, useSameCurve);
 }
 
 void KisMultiSensorsSelector::reload()
 {
     d->model->resetCurveOption();
 }
diff --git a/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp b/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
index 5e313af525..03e40df7c5 100644
--- a/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
+++ b/plugins/paintops/libpaintop/kis_text_brush_chooser.cpp
@@ -1,104 +1,104 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 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_text_brush_chooser.h"
 
 #include <QSpinBox>
 #include <QCheckBox>
 #include <QLabel>
 #include <QPixmap>
 #include <QLineEdit>
 #include <QString>
 #include <QFontDialog>
 
 #define showSlider(input) input->setRange(input->minimum(), input->maximum())
 
 KisTextBrushChooser::KisTextBrushChooser(QWidget *parent, const char* name, const QString& caption)
     : QWidget(parent)
     , m_textBrush(new KisTextBrush())
 {
     setObjectName(name);
     setupUi(this);
 
     setWindowTitle(caption);
-    connect((QObject*)lineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(rebuildTextBrush()));
+    connect((QObject*)lineEdit, SIGNAL(textChanged(QString)), this, SLOT(rebuildTextBrush()));
     connect((QObject*)bnFont, SIGNAL(clicked()), this, SLOT(getFont()));
     connect(pipeModeChbox, SIGNAL(toggled(bool)), this, SLOT(rebuildTextBrush()));
     m_font = font();
     inputSpacing->setRange(0.0, 10, 2);
     inputSpacing->setValue(0.1);
     rebuildTextBrush();
     connect(inputSpacing, SIGNAL(valueChanged(qreal)), this, SLOT(rebuildTextBrush()));
 }
 
 
 void KisTextBrushChooser::getFont()
 {
     bool ok = false;
     QFont f = QFontDialog::getFont(&ok, m_font);
     if (ok) {
         m_font = f;
         rebuildTextBrush();
     }
 }
 
 void KisTextBrushChooser::rebuildTextBrush()
 {
     pipeModeChbox->setEnabled(!lineEdit->text().isEmpty());
     if (lineEdit->text().isEmpty()) {
         pipeModeChbox->setChecked(false);
     }
 
     lblFont->setText(QString(m_font.family() + ", %1").arg(m_font.pointSize()));
     lblFont->setFont(m_font);
 
     KisTextBrush* textBrush = dynamic_cast<KisTextBrush*>(m_textBrush.data());
     textBrush->setFont(m_font);
     textBrush->setText(lineEdit->text());
     textBrush->setPipeMode(pipeModeChbox->isChecked());
     textBrush->setSpacing(inputSpacing->value());
     textBrush->updateBrush();
 
     emit sigBrushChanged();
 }
 
 void KisTextBrushChooser::setBrush(KisBrushSP brush)
 {
     bool b;
 
     m_textBrush = brush;
 
     KisTextBrush *textBrush = dynamic_cast<KisTextBrush*>(brush.data());
 
     m_font = textBrush->font();
 
     // we want to set all the gui widgets without triggering any signals
     // (and thus calling rebuildTextBrush)
     b = lineEdit->blockSignals(true);
     lineEdit->setText(textBrush->text());
     lineEdit->blockSignals(b);
 
     b = pipeModeChbox->blockSignals(true);
     pipeModeChbox->setChecked(textBrush->pipeMode());
     pipeModeChbox->blockSignals(b);
 
     // trigger rebuildTextBrush on the last change
     inputSpacing->setValue(textBrush->spacing());
 }
 
diff --git a/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp b/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp
index ecb5cf77b8..b6edb053b0 100644
--- a/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp
+++ b/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp
@@ -1,269 +1,269 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 
 #include "kis_tangent_tilt_option.h"
 #include <cmath>
 #include <QColor>
 #include <QPoint>
 
 #include "ui_wdgtangenttiltoption.h"
 
 #include "kis_global.h"
 
 class KisTangentTiltOptionWidget: public QWidget, public Ui::WdgTangentTiltOptions
 {
 public:
     KisTangentTiltOptionWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
     }
 };
 
 KisTangentTiltOption::KisTangentTiltOption()
 : KisPaintOpOption(KisPaintOpOption::GENERAL, false),
             m_canvasAngle(0.0),
             m_canvasAxisXMirrored(false),
             m_canvasAxisYMirrored(false)
 {
     m_checkable = false;
     m_options = new KisTangentTiltOptionWidget();
     //Setup tangent tilt.
     m_options->comboRed->setCurrentIndex(0);
     m_options->comboGreen->setCurrentIndex(2);
     m_options->comboBlue->setCurrentIndex(4);
 
     m_options->sliderElevationSensitivity->setRange(0, 100, 0);
     m_options->sliderElevationSensitivity->setValue(100);
     m_options->sliderElevationSensitivity->setSuffix("%");
 
     m_options->sliderMixValue->setRange(0, 100, 0);
     m_options->sliderMixValue->setValue(50);
     m_options->sliderMixValue->setSuffix("%");
 
     connect(m_options->comboRed, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->comboGreen, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->comboBlue, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
-    connect(m_options->comboRed, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setRedChannel(int) ));
-    connect(m_options->comboGreen, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setGreenChannel(int) ));
-    connect(m_options->comboBlue, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setBlueChannel(int) ));
+    connect(m_options->comboRed, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setRedChannel(int)));
+    connect(m_options->comboGreen, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setGreenChannel(int)));
+    connect(m_options->comboBlue, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setBlueChannel(int)));
 
     connect(m_options->optionTilt, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->optionDirection, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->optionRotation, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->optionMix, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
 
     connect(m_options->sliderElevationSensitivity, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->sliderMixValue, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     m_options->sliderMixValue->setVisible(false);
 
     setConfigurationPage(m_options);
 
 }
 
 KisTangentTiltOption::~KisTangentTiltOption()
 {
     delete m_options;
 }
 
 //options
 int KisTangentTiltOption::redChannel() const
 {
     return m_options->comboRed->currentIndex();
 }
 int KisTangentTiltOption::greenChannel() const
 {
     return m_options->comboGreen->currentIndex();
 }
 int KisTangentTiltOption::blueChannel() const
 {
     return m_options->comboBlue->currentIndex();
 }
 
 int KisTangentTiltOption::directionType() const
 {
     int type=0;
 
     if (m_options->optionTilt->isChecked()==true) {
         type=0;
     }
     else if (m_options->optionDirection->isChecked()==true) {
         type=1;
     }
     else if (m_options->optionRotation->isChecked()==true) {
         type=2;
     }
     else if (m_options->optionMix->isChecked()==true) {
         type=3;
     }
     else {
         warnKrita<<"There's something odd with the radio buttons. We'll use Tilt";
     }
 
     return type;
 }
 
 double KisTangentTiltOption::elevationSensitivity() const
 {
     return m_options->sliderElevationSensitivity->value(); 
 }
 
 double KisTangentTiltOption::mixValue() const
 {
     return m_options->sliderMixValue->value();
 }
 
 void KisTangentTiltOption::swizzleAssign(qreal const horizontal, qreal const vertical, qreal const depth, qreal *component, int index, qreal maxvalue)
 {
     switch(index) {
     case 0: *component = horizontal; break;
     case 1: *component = maxvalue-horizontal; break;
     case 2: *component = vertical; break;
     case 3: *component = maxvalue-vertical; break;
     case 4: *component = depth; break;
     case 5: *component = maxvalue-depth; break;
     }
 }
 
 void KisTangentTiltOption::apply(const KisPaintInformation& info,qreal *r,qreal *g,qreal *b)
 {
     //formula based on http://www.cerebralmeltdown.com/programming_projects/Altitude%20and%20Azimuth%20to%20Vector/index.html
 
     /* It doesn't make sense of have higher than 8bit color depth.
      * Instead we make sure in the paintAt function of kis_tangent_normal_paintop to pick an 8bit space of the current
      * color space if the space is an RGB space. If not, it'll pick sRGB 8bit.
      */
     qreal halfvalue = 0.5;
     qreal maxvalue = 1.0;
 
     //have the azimuth and altitude in degrees.
     qreal direction = KisPaintInformation::tiltDirection(info, true)*360.0;
     qreal elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
     if (directionType()==0) {
         direction = KisPaintInformation::tiltDirection(info, true)*360.0;
 	elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
     } else if (directionType()==1) {
         direction = (0.75 + info.drawingAngle() / (2.0 * M_PI))*360.0;
 	elevation= 0;//turns out that tablets that don't support tilt just return 90 degrees for elevation.
     } else if (directionType()==2) {
         direction = info.rotation();
 	elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);//artpens have tilt-recognition, so this should work.
     } else if (directionType()==3) {//mix of tilt+direction
 	qreal mixamount = mixValue()/100.0;
         direction = (KisPaintInformation::tiltDirection(info, true)*360.0*(1.0-mixamount))+((0.75 + info.drawingAngle() / (2.0 * M_PI))*360.0*(mixamount));
 	elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
     }
 
     //subtract/add the rotation of the canvas.
 
     if (info.canvasRotation()!=m_canvasAngle && info.canvasMirroredH()==m_canvasAxisXMirrored) {
        m_canvasAngle=info.canvasRotation();
     }
     if (directionType()!=1) {
         direction = direction-m_canvasAngle;
     }
 
     //limit the direction/elevation
 
     //qreal elevationMax = (elevationSensitivity()*90.0)/100.0;
     qreal elevationT = elevation*(elevationSensitivity()/100.0)+(90-(elevationSensitivity()*90.0)/100.0);
     elevation = static_cast<int>(elevationT);
 
     //convert to radians.
     // Convert this to kis_global's radian function.
     direction = kisDegreesToRadians(direction);
     elevation = kisDegreesToRadians(elevation);
 
     //make variables for axes for easy switching later on.
     qreal horizontal, vertical, depth;
 
     //spherical coordinates always center themselves around the origin, leading to values. We need to work around those...
 
     horizontal = cos(elevation)*sin(direction);
     if (horizontal>0.0) {
         horizontal= halfvalue+(fabs(horizontal)*halfvalue);
     }
     else {
         horizontal= halfvalue-(fabs(horizontal)*halfvalue);
     }
     vertical = cos(elevation)*cos(direction);
     if (vertical>0.0) {
         vertical = halfvalue+(fabs(vertical)*halfvalue);
     }
     else {
         vertical = halfvalue-(fabs(vertical)*halfvalue);
     }
 
     if (m_canvasAxisXMirrored && info.canvasMirroredH()) {horizontal = maxvalue-horizontal;}
     if (m_canvasAxisYMirrored && info.canvasMirroredH()) {vertical = maxvalue-vertical;}
 
     depth = sin(elevation)*maxvalue;
 
     //assign right components to correct axes.
     swizzleAssign(horizontal, vertical, depth, r, redChannel(), maxvalue);
     swizzleAssign(horizontal, vertical, depth, g, greenChannel(), maxvalue);
     swizzleAssign(horizontal, vertical, depth, b, blueChannel(), maxvalue);
 
 }
 
 /*settings*/
 void KisTangentTiltOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     setting->setProperty(TANGENT_RED, redChannel());
     setting->setProperty(TANGENT_GREEN, greenChannel());
     setting->setProperty(TANGENT_BLUE, blueChannel());
     setting->setProperty(TANGENT_TYPE, directionType());
     setting->setProperty(TANGENT_EV_SEN, elevationSensitivity());
     setting->setProperty(TANGENT_MIX_VAL, mixValue());
 }
 
 void KisTangentTiltOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     m_options->comboRed->setCurrentIndex(setting->getInt(TANGENT_RED, 0));
     m_options->comboGreen->setCurrentIndex(setting->getInt(TANGENT_GREEN, 2));
     m_options->comboBlue->setCurrentIndex(setting->getInt(TANGENT_BLUE, 4));
     
     //The comboboxes are connected to the TangentTiltPreview, so that gets automatically updated by them.
 
     if (setting->getInt(TANGENT_TYPE)== 0){
         m_options->optionTilt->setChecked(true);
 	m_options->sliderMixValue->setVisible(false);
     }
     else if (setting->getInt(TANGENT_TYPE)== 1) {
         m_options->optionDirection->setChecked(true);
 	m_options->sliderMixValue->setVisible(false);
     }
     else if (setting->getInt(TANGENT_TYPE)== 2) {
         m_options->optionRotation->setChecked(true);
 	m_options->sliderMixValue->setVisible(false);
     }
     else if (setting->getInt(TANGENT_TYPE)== 3) {
         m_options->optionMix->setChecked(true);
 	m_options->sliderMixValue->setVisible(true);
     }
 
     m_canvasAngle = setting->getDouble("runtimeCanvasRotation", 0.0);//in degrees please.
     m_canvasAxisXMirrored = setting->getBool("runtimeCanvasMirroredX", false);
     m_canvasAxisYMirrored = setting->getBool("runtimeCanvasMirroredY", false);
 
     m_options->sliderElevationSensitivity->setValue(setting->getDouble(TANGENT_EV_SEN, 100));
     m_options->sliderMixValue->setValue(setting->getDouble(TANGENT_MIX_VAL, 50));
 
 }
diff --git a/plugins/tools/basictools/kis_tool_multihand.cpp b/plugins/tools/basictools/kis_tool_multihand.cpp
index bfc025155f..059d558a53 100644
--- a/plugins/tools/basictools/kis_tool_multihand.cpp
+++ b/plugins/tools/basictools/kis_tool_multihand.cpp
@@ -1,421 +1,421 @@
 /*
  *  Copyright (c) 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_multihand.h"
 
 #include <QTransform>
 
 #include <QPushButton>
 #include <QComboBox>
 #include <QFormLayout>
 #include <QStackedWidget>
 #include <kis_slider_spin_box.h>
 #include <QLabel>
 #include "kis_canvas2.h"
 #include "kis_cursor.h"
 
 #include "kis_tool_multihand_helper.h"
 
 
 static const int MAXIMUM_BRUSHES = 50;
 
 #include <QtGlobal>
 #ifdef Q_OS_WIN
 // quoting DRAND48(3) man-page:
 // These functions are declared obsolete by  SVID  3,
 // which  states  that rand(3) should be used instead.
 #define drand48() (static_cast<double>(qrand()) / static_cast<double>(RAND_MAX))
 #endif
 
 
 KisToolMultihand::KisToolMultihand(KoCanvasBase *canvas)
     : KisToolBrush(canvas),
       m_transformMode(SYMMETRY),
       m_angle(0),
       m_handsCount(6),
       m_mirrorVertically(false),
       m_mirrorHorizontally(false),
       m_showAxes(false),
       m_translateRadius(100),
       m_setupAxesFlag(false)
     , customUI(0)
 {
 
 
     m_helper =
         new KisToolMultihandHelper(paintingInformationBuilder(),
                                    kundo2_i18n("Multibrush Stroke"));
     resetHelper(m_helper);
     if (image()) {
         m_axesPoint = QPointF(0.5 * image()->width(), 0.5 * image()->height());
     }
 
 }
 
 KisToolMultihand::~KisToolMultihand()
 {
 }
 
 
 
 void KisToolMultihand::beginPrimaryAction(KoPointerEvent *event)
 {
     if(m_setupAxesFlag) {
         setMode(KisTool::OTHER);
         m_axesPoint = convertToPixelCoord(event->point);
         requestUpdateOutline(event->point, 0);
         updateCanvas();
     }
     else {
         initTransformations();
         KisToolFreehand::beginPrimaryAction(event);
     }
 }
 
 void KisToolMultihand::continuePrimaryAction(KoPointerEvent *event)
 {
     if(mode() == KisTool::OTHER) {
         m_axesPoint = convertToPixelCoord(event->point);
         requestUpdateOutline(event->point, 0);
         updateCanvas();
     }
     else {
         KisToolFreehand::continuePrimaryAction(event);
     }
 }
 
 void KisToolMultihand::endPrimaryAction(KoPointerEvent *event)
 {
     if(mode() == KisTool::OTHER) {
         setMode(KisTool::HOVER_MODE);
         requestUpdateOutline(event->point, 0);
         finishAxesSetup();
     }
     else {
         KisToolFreehand::endPrimaryAction(event);
     }
 }
 
 void KisToolMultihand::paint(QPainter& gc, const KoViewConverter &converter)
 {
     if(m_setupAxesFlag) {
         int diagonal = (currentImage()->height() + currentImage()->width());
 
         QPainterPath path;
         path.moveTo(m_axesPoint.x()-diagonal*cos(m_angle), m_axesPoint.y()-diagonal*sin(m_angle));
         path.lineTo(m_axesPoint.x()+diagonal*cos(m_angle), m_axesPoint.y()+diagonal*sin(m_angle));
         path.moveTo(m_axesPoint.x()-diagonal*cos(m_angle+M_PI_2), m_axesPoint.y()-diagonal*sin(m_angle+M_PI_2));
         path.lineTo(m_axesPoint.x()+diagonal*cos(m_angle+M_PI_2), m_axesPoint.y()+diagonal*sin(m_angle+M_PI_2));
         paintToolOutline(&gc, pixelToView(path));
     }
     else {
         KisToolFreehand::paint(gc, converter);
         if(m_showAxes){
             int diagonal = (currentImage()->height() + currentImage()->width());
 
             QPainterPath path;
             path.moveTo(m_axesPoint.x()-diagonal*cos(m_angle), m_axesPoint.y()-diagonal*sin(m_angle));
             path.lineTo(m_axesPoint.x()+diagonal*cos(m_angle), m_axesPoint.y()+diagonal*sin(m_angle));
             path.moveTo(m_axesPoint.x()-diagonal*cos(m_angle+M_PI_2), m_axesPoint.y()-diagonal*sin(m_angle+M_PI_2));
             path.lineTo(m_axesPoint.x()+diagonal*cos(m_angle+M_PI_2), m_axesPoint.y()+diagonal*sin(m_angle+M_PI_2));
             paintToolOutline(&gc, pixelToView(path));
         }
     }
 }
 
 void KisToolMultihand::initTransformations()
 {
     QVector<QTransform> transformations;
     QTransform m;
 
     if(m_transformMode == SYMMETRY) {
         qreal angle = 0;
         qreal angleStep = (2 * M_PI) / m_handsCount;
 
         for(int i = 0; i < m_handsCount; i++) {
             m.translate(m_axesPoint.x(), m_axesPoint.y());
             m.rotateRadians(angle);
             m.translate(-m_axesPoint.x(), -m_axesPoint.y());
 
             transformations << m;
             m.reset();
             angle += angleStep;
         }
     }
     else if(m_transformMode == MIRROR) {
         transformations << m;
 
         if (m_mirrorHorizontally) {
             m.translate(m_axesPoint.x(),m_axesPoint.y());
             m.rotateRadians(m_angle);
             m.scale(-1,1);
             m.rotateRadians(-m_angle);
             m.translate(-m_axesPoint.x(), -m_axesPoint.y());
             transformations << m;
             m.reset();
         }
 
         if (m_mirrorVertically) {
             m.translate(m_axesPoint.x(),m_axesPoint.y());
             m.rotateRadians(m_angle);
             m.scale(1,-1);
             m.rotateRadians(-m_angle);
             m.translate(-m_axesPoint.x(), -m_axesPoint.y());
             transformations << m;
             m.reset();
         }
 
         if (m_mirrorVertically && m_mirrorHorizontally){
             m.translate(m_axesPoint.x(),m_axesPoint.y());
             m.rotateRadians(m_angle);
             m.scale(-1,-1);
             m.rotateRadians(-m_angle);
             m.translate(-m_axesPoint.x(), -m_axesPoint.y());
             transformations << m;
             m.reset();
         }
 
     }
     else if(m_transformMode == SNOWFLAKE) {
         qreal angle = 0;
         qreal angleStep = (2 * M_PI) / m_handsCount/4;
 
         for(int i = 0; i < m_handsCount*4; i++) {
            if ((i%2)==1) {
 
                m.translate(m_axesPoint.x(), m_axesPoint.y());
                m.rotateRadians(m_angle-angleStep);
                m.rotateRadians(angle);
                m.scale(-1,1);
                m.rotateRadians(-m_angle+angleStep);
                m.translate(-m_axesPoint.x(), -m_axesPoint.y());
 
                transformations << m;
                m.reset();
                angle += angleStep*2;
            } else {
                m.translate(m_axesPoint.x(), m_axesPoint.y());
                m.rotateRadians(m_angle-angleStep);
                m.rotateRadians(angle);
                m.rotateRadians(-m_angle+angleStep);
                m.translate(-m_axesPoint.x(), -m_axesPoint.y());
 
                transformations << m;
                m.reset();
                angle += angleStep*2;
             }
         }
     }
     else /* if(m_transformationNode == TRANSLATE) */ {
         /**
          * TODO: currently, the seed is the same for all the
          * strokes
          */
         for (int i = 0; i < m_handsCount; i++){
             qreal angle = drand48() * M_PI * 2;
             qreal length = drand48();
 
             // convert the Polar coordinates to Cartesian coordinates
             qreal nx = (m_translateRadius * cos(angle) * length);
             qreal ny = (m_translateRadius * sin(angle) * length);
 
             m.translate(m_axesPoint.x(),m_axesPoint.y());
             m.rotateRadians(m_angle);
             m.translate(nx,ny);
             m.rotateRadians(-m_angle);
             m.translate(-m_axesPoint.x(), -m_axesPoint.y());
             transformations << m;
             m.reset();
         }
     }
 
     m_helper->setupTransformations(transformations);
 }
 
 QWidget* KisToolMultihand::createOptionWidget()
 {
     QWidget *widget = KisToolBrush::createOptionWidget();
 
     customUI = new KisToolMultiHandConfigWidget();
 
     // brush smoothing option.
     customUI->layout()->addWidget(widget);
     customUI->smoothingOptionsLayout->addWidget(widget);
 
 
     // setup common parameters that all of the modes will see
     connect(customUI->showAxesCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetAxesVisible(bool)));
     customUI->showAxesCheckbox->setChecked((bool)m_configGroup.readEntry("showAxes", false));
 
-    connect(image(), SIGNAL(sigSizeChanged(const QPointF &, const QPointF &)), this, SLOT(resetAxes(const QPointF &, const QPointF &)));
+    connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SLOT(resetAxes(QPointF,QPointF)));
 
     customUI->moveOriginButton->setCheckable(true);
     connect(customUI->moveOriginButton, SIGNAL(clicked(bool)),this, SLOT(activateAxesPointModeSetup()));
 
     connect(customUI->resetOriginButton, SIGNAL(released()), this, SLOT(resetAxes()));
 
     customUI->multihandTypeCombobox->addItem(i18n("Symmetry"),int(SYMMETRY));  // axis mode
     customUI->multihandTypeCombobox->addItem(i18n("Mirror"),int(MIRROR));
     customUI->multihandTypeCombobox->addItem(i18n("Translate"),int(TRANSLATE));
     customUI->multihandTypeCombobox->addItem(i18n("Snowflake"),int(SNOWFLAKE));
     connect(customUI->multihandTypeCombobox,SIGNAL(currentIndexChanged(int)),this, SLOT(slotSetTransformMode(int)));
     customUI->multihandTypeCombobox->setCurrentIndex(m_configGroup.readEntry("transformMode", 0));
     slotSetTransformMode(customUI->multihandTypeCombobox->currentIndex());
 
 
     customUI->axisRotationSpinbox->setSuffix(QChar(Qt::Key_degree));   // origin rotation
     customUI->axisRotationSpinbox->setSingleStep(0.5);
     customUI->axisRotationSpinbox->setRange(0.0, 90.0, 1);
     customUI->axisRotationSpinbox->setValue(m_configGroup.readEntry("axesAngle", 0.0));
     connect( customUI->axisRotationSpinbox, SIGNAL(valueChanged(qreal)),this, SLOT(slotSetAxesAngle(qreal)));
 
 
 
 
     // symmetry mode options
     customUI->brushCountSpinBox->setRange(1, MAXIMUM_BRUSHES);
     connect(customUI->brushCountSpinBox, SIGNAL(valueChanged(int)),this, SLOT(slotSetHandsCount(int)));
     customUI->brushCountSpinBox->setValue(m_configGroup.readEntry("handsCount", 4));
 
     // mirror mode specific options
     connect(customUI->horizontalCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetMirrorHorizontally(bool)));
     customUI->horizontalCheckbox->setChecked((bool)m_configGroup.readEntry("mirrorHorizontally", false));
 
     connect(customUI->verticalCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetMirrorVertically(bool)));
     customUI->verticalCheckbox->setChecked((bool)m_configGroup.readEntry("mirrorVertically", false));
 
     // translate mode options
     customUI->translationRadiusSpinbox->setRange(0, 200);
     customUI->translationRadiusSpinbox->setSuffix(i18n(" px"));
     customUI->translationRadiusSpinbox->setValue(m_configGroup.readEntry("translateRadius", 0));
 
     connect(customUI->translationRadiusSpinbox,SIGNAL(valueChanged(int)),this,SLOT(slotSetTranslateRadius(int)));
 
 
     // snowflake re-uses the existing options, so there is no special parameters for that...
 
 
     return static_cast<QWidget*>(customUI); // keeping it in the native class until the end allows us to access the UI components
 }
 
 void KisToolMultihand::activateAxesPointModeSetup()
 {
     if (customUI->moveOriginButton->isChecked()){
         m_setupAxesFlag = true;
         useCursor(KisCursor::crossCursor());
         updateCanvas();
     } else {
         finishAxesSetup();
     }
 }
 
 void KisToolMultihand::resetAxes()
 {
     m_axesPoint = QPointF(0.5 * image()->width(), 0.5 * image()->height());
     finishAxesSetup();
 }
 
 
 void KisToolMultihand::finishAxesSetup()
 {
     m_setupAxesFlag = false;
     customUI->moveOriginButton->setChecked(false);
     resetCursorStyle();
     updateCanvas();
 }
 
 void KisToolMultihand::updateCanvas()
 {
     KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kisCanvas);
     kisCanvas->updateCanvas();
 }
 
 void KisToolMultihand::slotSetHandsCount(int count)
 {
     m_handsCount = count;
     m_configGroup.writeEntry("handsCount", count);
 }
 
 void KisToolMultihand::slotSetAxesAngle(qreal angle)
 {
     //negative so axes rotates counter clockwise
     m_angle = -angle*M_PI/180;
     updateCanvas();
     m_configGroup.writeEntry("axesAngle", angle);
 }
 
 void KisToolMultihand::slotSetTransformMode(int index)
 {
     m_transformMode = enumTransforModes(customUI->multihandTypeCombobox->itemData(index).toInt());
     m_configGroup.writeEntry("transformMode", index);
 
 
     // hide all of the UI elements by default
     customUI->horizontalCheckbox->setVisible(false);
     customUI->verticalCheckbox->setVisible(false);
     customUI->translationRadiusSpinbox->setVisible(false);
     customUI->radiusLabel->setVisible(false);
     customUI->brushCountSpinBox->setVisible(false);
     customUI->brushesLabel->setVisible(false);
 
     // turn on what we need
     if (index == int(MIRROR)) {
          customUI->horizontalCheckbox->setVisible(true);
          customUI->verticalCheckbox->setVisible(true);
     }
 
      if (index == int(TRANSLATE)) {
          customUI->translationRadiusSpinbox->setVisible(true);
          customUI->radiusLabel->setVisible(true);
      }
 
      if (index == int(SYMMETRY) || index == int(SNOWFLAKE) || index == int(TRANSLATE) ) {
         customUI->brushCountSpinBox->setVisible(true);
         customUI->brushesLabel->setVisible(true);
      }
 
 }
 
 void KisToolMultihand::slotSetAxesVisible(bool vis)
 {
     m_showAxes = vis;
     updateCanvas();
     m_configGroup.writeEntry("showAxes", vis);
 }
 
 
 void KisToolMultihand::slotSetMirrorVertically(bool mirror)
 {
     m_mirrorVertically = mirror;
     m_configGroup.writeEntry("mirrorVertically", mirror);
 }
 
 void KisToolMultihand::slotSetMirrorHorizontally(bool mirror)
 {
     m_mirrorHorizontally = mirror;
     m_configGroup.writeEntry("mirrorHorizontally", mirror);
 }
 
 void KisToolMultihand::slotSetTranslateRadius(int radius)
 {
     m_translateRadius = radius;
     m_configGroup.writeEntry("translateRadius", radius);
 }
 
diff --git a/plugins/tools/svgtexttool/SvgTextTool.cpp b/plugins/tools/svgtexttool/SvgTextTool.cpp
index 8960346405..bb4161e831 100644
--- a/plugins/tools/svgtexttool/SvgTextTool.cpp
+++ b/plugins/tools/svgtexttool/SvgTextTool.cpp
@@ -1,401 +1,401 @@
 /* This file is part of the KDE project
 
    Copyright 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 "SvgTextTool.h"
 #include "KoSvgTextShape.h"
 #include "SvgTextChangeCommand.h"
 
 #include <QLabel>
 #include <QToolButton>
 #include <QGridLayout>
 #include <QVBoxLayout>
 #include <QDesktopServices>
 #include <QApplication>
 #include <QGroupBox>
 #include <QFontDatabase>
 #include <QButtonGroup>
 
 #include <klocalizedstring.h>
 
 #include <KisPart.h>
 #include <kis_canvas2.h>
 #include <KSharedConfig>
 #include "kis_assert.h"
 
 #include <KoFileDialog.h>
 #include <KoIcon.h>
 #include <KoCanvasBase.h>
 #include <KoImageCollection.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoShapeController.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeFactoryBase.h>
 #include <KoPointerEvent.h>
 #include <KoProperties.h>
 #include <KoSelectedShapesProxy.h>
 
 #include "SvgTextEditor.h"
 #include "KisHandlePainterHelper.h"
 #include <commands/KoKeepShapesSelectedCommand.h>
 
 
 SvgTextTool::SvgTextTool(KoCanvasBase *canvas)
     : KoToolBase(canvas)
     , m_editor(0)
     , m_dragStart( 0, 0)
     , m_dragEnd( 0, 0)
     , m_dragging(false)
 {
 }
 
 SvgTextTool::~SvgTextTool()
 {
 }
 
 void SvgTextTool::activate(ToolActivation activation, const QSet<KoShape *> &shapes)
 {
     KoToolBase::activate(activation, shapes);
     useCursor(Qt::ArrowCursor);
 
     if (shapes.size() == 1) {
         KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(*shapes.constBegin());
         if (!textShape) {
             koSelection()->deselectAll();
         }
     } else if (shapes.size() > 1) {
         KoSvgTextShape *foundTextShape = 0;
 
         Q_FOREACH (KoShape *shape, shapes) {
             KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
             if (textShape) {
                 foundTextShape = textShape;
                 break;
             }
         }
 
         koSelection()->deselectAll();
         if (foundTextShape) {
             koSelection()->select(foundTextShape);
         }
     }
 }
 
 void SvgTextTool::deactivate()
 {
     KoToolBase::deactivate();
 
     QRectF updateRect = m_hoveredShapeHighlightRect;
 
     KoSvgTextShape *shape = selectedShape();
     if (shape) {
         updateRect |= shape->boundingRect();
     }
     m_hoveredShapeHighlightRect = QRectF();
 
     canvas()->updateCanvas(updateRect);
 }
 
 QWidget *SvgTextTool::createOptionWidget()
 {
     QWidget *optionWidget = new QWidget();
     QGridLayout *layout = new QGridLayout(optionWidget);
     m_configGroup = KSharedConfig::openConfig()->group(toolId());
 
     QGroupBox *defsOptions = new QGroupBox(i18n("Create new texts with..."));
     QVBoxLayout *defOptionsLayout = new QVBoxLayout();
     defsOptions->setLayout(defOptionsLayout);
     m_defFont = new QFontComboBox();
     QString storedFont = m_configGroup.readEntry<QString>("defaultFont", QApplication::font().family());
     m_defFont->setCurrentFont(QFont(storedFont));
     defsOptions->layout()->addWidget(m_defFont);
     m_defPointSize = new QComboBox();
     Q_FOREACH (int size, QFontDatabase::standardSizes()) {
         m_defPointSize->addItem(QString::number(size)+" pt");
     }
     int storedSize = m_configGroup.readEntry<int>("defaultSize", QApplication::font().pointSize());
     m_defPointSize->setCurrentIndex(QFontDatabase::standardSizes().indexOf(storedSize));
 
     int checkedAlignment = m_configGroup.readEntry<int>("defaultAlignment", 0);
 
     m_defAlignment = new QButtonGroup();
     QHBoxLayout *alignButtons = new QHBoxLayout();
     alignButtons->addWidget(m_defPointSize);
     QToolButton *alignLeft = new QToolButton();
     alignLeft->setIcon(KisIconUtils::loadIcon("format-justify-left"));
     alignLeft->setCheckable(true);
 
     alignLeft->setToolTip(i18n("Anchor text to the left."));
     m_defAlignment->addButton(alignLeft, 0);
     alignButtons->addWidget(alignLeft);
 
     QToolButton *alignCenter = new QToolButton();
     alignCenter->setIcon(KisIconUtils::loadIcon("format-justify-center"));
     alignCenter->setCheckable(true);
     m_defAlignment->addButton(alignCenter, 1);
     alignCenter->setToolTip(i18n("Anchor text to the middle."));
 
     alignButtons->addWidget(alignCenter);
 
     QToolButton *alignRight = new QToolButton();
     alignRight->setIcon(KisIconUtils::loadIcon("format-justify-right"));
     alignRight->setCheckable(true);
     m_defAlignment->addButton(alignRight, 2);
     alignRight->setToolTip(i18n("Anchor text to the right."));
     alignButtons->addWidget(alignRight);
 
     m_defAlignment->setExclusive(true);
     if (checkedAlignment<1) {
         alignLeft->setChecked(true);
     } else if (checkedAlignment==1) {
         alignCenter->setChecked(true);
     } else if (checkedAlignment==2) {
         alignRight->setChecked(true);
     } else {
         alignLeft->setChecked(true);
     }
 
     defOptionsLayout->addLayout(alignButtons);
     layout->addWidget(defsOptions);
     connect(m_defAlignment, SIGNAL(buttonClicked(int)), this, SLOT(storeDefaults()));
     connect(m_defFont, SIGNAL(currentFontChanged(QFont)), this, SLOT(storeDefaults()));
     connect(m_defPointSize, SIGNAL(currentIndexChanged(int)), this, SLOT(storeDefaults()));
 
     m_edit = new QPushButton(optionWidget);
     m_edit->setText(i18n("Edit Text"));
     connect(m_edit, SIGNAL(clicked(bool)), SLOT(showEditor()));
     layout->addWidget(m_edit);
 
     return optionWidget;
 }
 
 KoSelection *SvgTextTool::koSelection() const
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas(), 0);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas()->selectedShapesProxy(), 0);
 
     return canvas()->selectedShapesProxy()->selection();
 }
 
 KoSvgTextShape *SvgTextTool::selectedShape() const
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas(), 0);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas()->selectedShapesProxy(), 0);
 
     QList<KoShape*> shapes = koSelection()->selectedEditableShapes();
     if (shapes.isEmpty()) return 0;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(shapes.size() == 1);
     KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shapes.first());
 
     return textShape;
 }
 
 void SvgTextTool::showEditor()
 {
     KoSvgTextShape *shape = selectedShape();
     if (!shape) return;
 
     if (!m_editor) {
         m_editor = new SvgTextEditor();
         m_editor->setWindowModality(Qt::ApplicationModal);
-        connect(m_editor, SIGNAL(textUpdated(KoSvgTextShape*, QString, QString, bool)), SLOT(textUpdated(KoSvgTextShape*, QString, QString, bool)));
+        connect(m_editor, SIGNAL(textUpdated(KoSvgTextShape*,QString,QString,bool)), SLOT(textUpdated(KoSvgTextShape*,QString,QString,bool)));
     }
 
     m_editor->setShape(shape);
     m_editor->show();
     m_editor->activateWindow();
 }
 
 void SvgTextTool::textUpdated(KoSvgTextShape *shape, const QString &svg, const QString &defs, bool richTextUpdated)
 {
     SvgTextChangeCommand *cmd = new SvgTextChangeCommand(shape, svg, defs, richTextUpdated);
     canvas()->addCommand(cmd);
 }
 
 QString SvgTextTool::generateDefs()
 {
     QString font = m_defFont->currentFont().family();
     QString size = QString::number(QFontDatabase::standardSizes().at(m_defPointSize->currentIndex()));
     QString textAnchor = "middle";
     if (m_defAlignment->button(0)->isChecked()) {
         textAnchor = "start";
     }
     if (m_defAlignment->button(2)->isChecked()) {
         textAnchor = "end";
     }
 
     return QString("<defs>\n <style>\n  text {\n   font-family:'%1';\n   font-size:%2 ;   text-anchor:%3;\n  }\n </style>\n</defs>").arg(font, size, textAnchor);
 }
 
 void SvgTextTool::storeDefaults()
 {
     m_configGroup = KSharedConfig::openConfig()->group(toolId());
     m_configGroup.writeEntry("defaultFont", m_defFont->currentFont().family());
     m_configGroup.writeEntry("defaultSize", QFontDatabase::standardSizes().at(m_defPointSize->currentIndex()));
     m_configGroup.writeEntry("defaultAlignment", m_defAlignment->checkedId());
 }
 
 void SvgTextTool::paint(QPainter &gc, const KoViewConverter &converter)
 {
     if (!isActivated()) return;
 
     KoShape::applyConversion(gc, converter);
 
     KisHandlePainterHelper handlePainter(&gc);
 
     if (m_dragging) {
         QPolygonF poly(QRectF(m_dragStart, m_dragEnd));
         handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
         handlePainter.drawRubberLine(poly);
     }
 
     KoSvgTextShape *shape = selectedShape();
     if (shape) {
         handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
         QPainterPath path;
         path.addRect(shape->boundingRect());
         handlePainter.drawPath(path);
     }
 
     if (!m_hoveredShapeHighlightRect.isEmpty()) {
         handlePainter.setHandleStyle(KisHandleStyle::highlightedPrimaryHandlesWithSolidOutline());
         QPainterPath path;
         path.addRect(m_hoveredShapeHighlightRect);
         handlePainter.drawPath(path);
     }
 }
 
 void SvgTextTool::mousePressEvent(KoPointerEvent *event)
 {
     KoSvgTextShape *selectedShape = this->selectedShape();
     KoSvgTextShape *hoveredShape = dynamic_cast<KoSvgTextShape *>(canvas()->shapeManager()->shapeAt(event->point));
 
     if (!selectedShape || hoveredShape != selectedShape) {
         canvas()->shapeManager()->selection()->deselectAll();
 
         if (hoveredShape) {
             canvas()->shapeManager()->selection()->select(hoveredShape);
         } else {
             m_dragStart = m_dragEnd = event->point;
             m_dragging = true;
         }
 
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 void SvgTextTool::mouseMoveEvent(KoPointerEvent *event)
 {
     QRectF updateRect = m_hoveredShapeHighlightRect;
 
     if (m_dragging) {
         m_dragEnd = event->point;
         m_hoveredShapeHighlightRect = QRectF();
         updateRect |= QRectF(m_dragStart, m_dragEnd).normalized().toAlignedRect();
         event->accept();
     } else {
         KoSvgTextShape *hoveredShape = dynamic_cast<KoSvgTextShape *>(canvas()->shapeManager()->shapeAt(event->point));
         if (hoveredShape) {
             m_hoveredShapeHighlightRect = hoveredShape->boundingRect();
             updateRect |= m_hoveredShapeHighlightRect;
         } else {
             m_hoveredShapeHighlightRect = QRect();
         }
         event->ignore();
     }
 
     if (!updateRect.isEmpty()) {
         canvas()->updateCanvas(kisGrowRect(updateRect, 100));
     }
 }
 
 void SvgTextTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     if (m_dragging) {
         QRectF rectangle = QRectF(m_dragStart, m_dragEnd).normalized();
         if (rectangle.width() < 4 && rectangle.height() < 4) {
             m_dragging = false;
             event->accept();
             return;
         }
         KoShapeFactoryBase *factory = KoShapeRegistry::instance()->value("KoSvgTextShapeID");
         KoProperties *params = new KoProperties();//Fill these with "svgText", "defs" and "shapeRect"
         params->setProperty("defs", QVariant(generateDefs()));
         if (m_dragging) {
             m_dragEnd = event->point;
             m_dragging = false;
 
             //The following show only happen when we're creating preformatted text. If we're making
             //Word-wrapped text, it should take the rectangle unmodified.
             int size = QFontDatabase::standardSizes().at(m_defPointSize->currentIndex());
             QFont font = m_defFont->currentFont();
             font.setPointSize(size);
             rectangle.setTop(rectangle.top()+QFontMetrics(font).lineSpacing());
             if (m_defAlignment->button(1)->isChecked()) {
                 rectangle.setLeft(rectangle.center().x());
             } else if (m_defAlignment->button(2)->isChecked()) {
                 qreal right = rectangle.right();
                 rectangle.setRight(right+10);
                 rectangle.setLeft(right);
             }
 
             params->setProperty("shapeRect", QVariant(rectangle));
         }
         KoShape *textShape = factory->createShape( params, canvas()->shapeController()->resourceManager());
 
         KUndo2Command *parentCommand = new KUndo2Command();
 
         new KoKeepShapesSelectedCommand(koSelection()->selectedShapes(), {}, canvas()->selectedShapesProxy(), false, parentCommand);
 
         KUndo2Command *cmd = canvas()->shapeController()->addShape(textShape, 0, parentCommand);
         parentCommand->setText(cmd->text());
 
         new KoKeepShapesSelectedCommand({}, {textShape}, canvas()->selectedShapesProxy(), true, parentCommand);
 
         canvas()->addCommand(parentCommand);
 
         showEditor();
     }
     event->accept();
 }
 
 void SvgTextTool::keyPressEvent(QKeyEvent *event)
 {
     if (event->key()==Qt::Key_Enter || event->key()==Qt::Key_Return) {
         showEditor();
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 
 void SvgTextTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     if (canvas()->shapeManager()->shapeAt(event->point) != selectedShape()) {
         event->ignore(); // allow the event to be used by another
         return;
     }
     showEditor();
 }
 
diff --git a/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp b/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp
index 9321f28d58..1d29b56e8b 100644
--- a/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp
+++ b/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp
@@ -1,377 +1,377 @@
 /*
  *  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_tool_lazy_brush_options_widget.h"
 
 #include "ui_kis_tool_lazy_brush_options_widget.h"
 
 #include <KoColorSpaceRegistry.h>
 #include "KisPaletteModel.h"
 
 #include "kis_config.h"
 #include <resources/KoColorSet.h>
 #include "kis_canvas_resource_provider.h"
 #include "kis_signal_auto_connection.h"
 #include "lazybrush/kis_colorize_mask.h"
 #include "kis_image.h"
 #include "kis_signals_blocker.h"
 #include "kis_signal_compressor.h"
 #include "kis_layer_properties_icons.h"
 
 
 struct KisToolLazyBrushOptionsWidget::Private
 {
     Private()
         : transparentColorIndex(-1),
           baseNodeChangedCompressor(500, KisSignalCompressor::FIRST_ACTIVE)
     {
     }
 
     Ui_KisToolLazyBrushOptionsWidget *ui;
     KisPaletteModel *colorModel;
     KisCanvasResourceProvider *provider;
 
     KisSignalAutoConnectionsStore providerSignals;
     KisSignalAutoConnectionsStore maskSignals;
     KisColorizeMaskSP activeMask;
 
     KoColorSet colorSet;
     int transparentColorIndex = -1;
 
     KisSignalCompressor baseNodeChangedCompressor;
 };
 
 KisToolLazyBrushOptionsWidget::KisToolLazyBrushOptionsWidget(KisCanvasResourceProvider *provider, QWidget *parent)
     : QWidget(parent),
       m_d(new Private)
 {
     m_d->ui = new Ui_KisToolLazyBrushOptionsWidget();
     m_d->ui->setupUi(this);
 
     m_d->colorModel = new KisPaletteModel(this);
     m_d->ui->colorView->setPaletteModel(m_d->colorModel);
     m_d->ui->colorView->setAllowModification(false); //people proly shouldn't be able to edit the colorentries themselves.
     m_d->ui->colorView->setCrossedKeyword("transparent");
 
     connect(m_d->ui->chkUseEdgeDetection, SIGNAL(toggled(bool)), SLOT(slotUseEdgeDetectionChanged(bool)));
     connect(m_d->ui->intEdgeDetectionSize, SIGNAL(valueChanged(int)), SLOT(slotEdgeDetectionSizeChanged(int)));
     connect(m_d->ui->intRadius, SIGNAL(valueChanged(int)), SLOT(slotRadiusChanged(int)));
     connect(m_d->ui->intCleanUp, SIGNAL(valueChanged(int)), SLOT(slotCleanUpChanged(int)));
     connect(m_d->ui->chkLimitToDevice, SIGNAL(toggled(bool)), SLOT(slotLimitToDeviceChanged(bool)));
 
     m_d->ui->intEdgeDetectionSize->setRange(0, 100);
     m_d->ui->intEdgeDetectionSize->setExponentRatio(2.0);
     m_d->ui->intEdgeDetectionSize->setSuffix(i18n(" px"));
     m_d->ui->intEdgeDetectionSize->setPrefix(i18n("Edge detection: "));
     m_d->ui->intEdgeDetectionSize->setToolTip(
         i18nc("@info:tooltip",
               "Activate for images with vast solid areas. "
               "Set the value to the width of the thinnest "
               "lines on the image"));
 
     m_d->ui->intRadius->setRange(0, 1000);
     m_d->ui->intRadius->setExponentRatio(3.0);
     m_d->ui->intRadius->setSuffix(i18n(" px"));
     m_d->ui->intRadius->setPrefix(i18n("Gap close hint: "));
     m_d->ui->intRadius->setToolTip(
         i18nc("@info:tooltip",
               "The mask will try to close non-closed contours "
               "if the gap is smaller than \"Gap close hint\" value"));
 
     m_d->ui->intCleanUp->setRange(0, 100);
     m_d->ui->intCleanUp->setSuffix(i18n(" %"));
     m_d->ui->intCleanUp->setPrefix(i18n("Clean up: "));
     m_d->ui->intCleanUp->setToolTip(
         i18nc("@info:tooltip",
               "The mask will try to remove parts of the key strokes "
               "that are placed outside the closed contours. 0% - no effect, 100% - max effect"));
 
 
     connect(m_d->ui->colorView, SIGNAL(indexEntrySelected(QModelIndex)), this, SLOT(entrySelected(QModelIndex)));
     connect(m_d->ui->btnTransparent, SIGNAL(toggled(bool)), this, SLOT(slotMakeTransparent(bool)));
     connect(m_d->ui->btnRemove, SIGNAL(clicked()), this, SLOT(slotRemove()));
 
     connect(m_d->ui->chkAutoUpdates, SIGNAL(toggled(bool)), m_d->ui->btnUpdate, SLOT(setDisabled(bool)));
 
     connect(m_d->ui->btnUpdate, SIGNAL(clicked()), this, SLOT(slotUpdate()));
     connect(m_d->ui->chkAutoUpdates, SIGNAL(toggled(bool)), this, SLOT(slotSetAutoUpdates(bool)));
     connect(m_d->ui->chkShowKeyStrokes, SIGNAL(toggled(bool)), this, SLOT(slotSetShowKeyStrokes(bool)));
     connect(m_d->ui->chkShowOutput, SIGNAL(toggled(bool)), this, SLOT(slotSetShowOutput(bool)));
 
     connect(&m_d->baseNodeChangedCompressor, SIGNAL(timeout()), this, SLOT(slotUpdateNodeProperties()));
 
 
     m_d->provider = provider;
 
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
 
     m_d->colorSet.add(KoColorSetEntry(KoColor(Qt::red, cs), "color1"));
     m_d->colorSet.add(KoColorSetEntry(KoColor(Qt::green, cs), "color2"));
     m_d->colorSet.add(KoColorSetEntry(KoColor(Qt::blue, cs), "color3"));
 
     m_d->colorModel->setColorSet(&m_d->colorSet);
 }
 
 KisToolLazyBrushOptionsWidget::~KisToolLazyBrushOptionsWidget()
 {
 }
 
 void KisToolLazyBrushOptionsWidget::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     m_d->providerSignals.addConnection(
         m_d->provider, SIGNAL(sigNodeChanged(KisNodeSP)),
         this, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
     m_d->providerSignals.addConnection(
-        m_d->provider, SIGNAL(sigFGColorChanged(const KoColor&)),
-        this, SLOT(slotCurrentFgColorChanged(const KoColor&)));
+        m_d->provider, SIGNAL(sigFGColorChanged(KoColor)),
+        this, SLOT(slotCurrentFgColorChanged(KoColor)));
 
     slotCurrentNodeChanged(m_d->provider->currentNode());
     slotCurrentFgColorChanged(m_d->provider->fgColor());
 }
 
 void KisToolLazyBrushOptionsWidget::hideEvent(QHideEvent *event)
 {
     QWidget::hideEvent(event);
 
     m_d->providerSignals.clear();
 }
 
 void KisToolLazyBrushOptionsWidget::entrySelected(QModelIndex index)
 {
     if (!index.isValid()) return;
 
     const int i = m_d->colorModel->idFromIndex(index);
 
     if (i >= 0 && i < (int)m_d->colorSet.nColors()) {
         KoColorSetEntry entry = m_d->colorModel->colorSetEntryFromIndex(index);
         m_d->provider->setFGColor(entry.color());
     }
 
     const bool transparentChecked = i >= 0 && i == m_d->transparentColorIndex;
     KisSignalsBlocker b(m_d->ui->btnTransparent);
     m_d->ui->btnTransparent->setChecked(transparentChecked);
 }
 
 void KisToolLazyBrushOptionsWidget::slotCurrentFgColorChanged(const KoColor &color)
 {
     int selectedIndex = -1;
 
     for (quint32 i = 0; i < m_d->colorSet.nColors(); i++) {
         KoColorSetEntry entry = m_d->colorSet.getColorGlobal(i);
         if (entry.color() == color) {
             selectedIndex = (int)i;
             break;
         }
     }
 
     m_d->ui->btnRemove->setEnabled(selectedIndex >= 0);
     m_d->ui->btnTransparent->setEnabled(selectedIndex >= 0);
 
     if (selectedIndex < 0) {
         KisSignalsBlocker b(m_d->ui->btnTransparent);
         m_d->ui->btnTransparent->setChecked(false);
     }
 
     QModelIndex newIndex =
         selectedIndex >= 0 ?
         m_d->colorModel->indexFromId(selectedIndex) : QModelIndex();
 
     if (newIndex != m_d->ui->colorView->currentIndex()) {
         m_d->ui->colorView->setCurrentIndex(newIndex);
     }
 }
 
 void KisToolLazyBrushOptionsWidget::slotColorLabelsChanged()
 {
     m_d->colorSet.clear();
     m_d->transparentColorIndex = -1;
 
     if (m_d->activeMask) {
         KisColorizeMask::KeyStrokeColors colors = m_d->activeMask->keyStrokesColors();
         m_d->transparentColorIndex = colors.transparentIndex;
 
         for (int i = 0; i < colors.colors.size(); i++) {
             const QString name = i == m_d->transparentColorIndex ? "transparent" : "";
             m_d->colorSet.add(KoColorSetEntry(colors.colors[i], name));
         }
     }
 
     m_d->colorModel->setColorSet(&m_d->colorSet);
     slotCurrentFgColorChanged(m_d->provider->fgColor());
 }
 
 void KisToolLazyBrushOptionsWidget::slotUpdateNodeProperties()
 {
     KisSignalsBlocker b1(m_d->ui->chkAutoUpdates,
                          m_d->ui->btnUpdate,
                          m_d->ui->chkShowKeyStrokes,
                          m_d->ui->chkShowOutput);
     KisSignalsBlocker b2(m_d->ui->chkUseEdgeDetection,
                          m_d->ui->intEdgeDetectionSize,
                          m_d->ui->intRadius,
                          m_d->ui->intCleanUp,
                          m_d->ui->chkLimitToDevice);
 
     // not implemented yet!
     //m_d->ui->chkAutoUpdates->setEnabled(m_d->activeMask);
     m_d->ui->chkAutoUpdates->setEnabled(false);
     m_d->ui->chkAutoUpdates->setVisible(false);
 
     bool value = false;
 
     value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeNeedsUpdate, true).toBool();
     m_d->ui->btnUpdate->setEnabled(m_d->activeMask && !m_d->ui->chkAutoUpdates->isChecked() && value);
 
     value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool();
     m_d->ui->chkShowKeyStrokes->setEnabled(m_d->activeMask);
     m_d->ui->chkShowKeyStrokes->setChecked(value);
 
     value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeShowColoring, true).toBool();
     m_d->ui->chkShowOutput->setEnabled(m_d->activeMask);
     m_d->ui->chkShowOutput->setChecked(value);
 
     m_d->ui->chkUseEdgeDetection->setEnabled(m_d->activeMask);
     m_d->ui->chkUseEdgeDetection->setChecked(m_d->activeMask && m_d->activeMask->useEdgeDetection());
 
     m_d->ui->intEdgeDetectionSize->setEnabled(m_d->activeMask && m_d->ui->chkUseEdgeDetection->isChecked());
     m_d->ui->intEdgeDetectionSize->setValue(m_d->activeMask ? m_d->activeMask->edgeDetectionSize() : 4.0);
     m_d->ui->intRadius->setEnabled(m_d->activeMask);
     m_d->ui->intRadius->setValue(2 * (m_d->activeMask ? m_d->activeMask->fuzzyRadius() : 15));
     m_d->ui->intCleanUp->setEnabled(m_d->activeMask);
     m_d->ui->intCleanUp->setValue(100 * (m_d->activeMask ? m_d->activeMask->cleanUpAmount() : 0.7));
 
     m_d->ui->chkLimitToDevice->setEnabled(m_d->activeMask);
     m_d->ui->chkLimitToDevice->setChecked(m_d->activeMask && m_d->activeMask->limitToDeviceBounds());
 }
 
 void KisToolLazyBrushOptionsWidget::slotCurrentNodeChanged(KisNodeSP node)
 {
     m_d->maskSignals.clear();
 
     KisColorizeMask *mask = dynamic_cast<KisColorizeMask*>(node.data());
     m_d->activeMask = mask;
 
     if (m_d->activeMask) {
         m_d->maskSignals.addConnection(
             m_d->activeMask, SIGNAL(sigKeyStrokesListChanged()),
             this, SLOT(slotColorLabelsChanged()));
 
         m_d->maskSignals.addConnection(
             m_d->provider->currentImage(), SIGNAL(sigNodeChanged(KisNodeSP)),
             this, SLOT(slotUpdateNodeProperties()));
     }
 
     slotColorLabelsChanged();
     slotUpdateNodeProperties();
     m_d->ui->colorView->setEnabled(m_d->activeMask);
 }
 
 void KisToolLazyBrushOptionsWidget::slotMakeTransparent(bool value)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->activeMask);
 
     QModelIndex index = m_d->ui->colorView->currentIndex();
     if (!index.isValid()) return;
 
     const int activeIndex = m_d->colorModel->idFromIndex(index);
     KIS_ASSERT_RECOVER_RETURN(activeIndex >= 0);
 
     KisColorizeMask::KeyStrokeColors colors;
 
     for (quint32 i = 0; i < m_d->colorSet.nColors(); i++) {
         colors.colors << m_d->colorSet.getColorGlobal(i).color();
     }
 
     colors.transparentIndex = value ? activeIndex : -1;
 
     m_d->activeMask->setKeyStrokesColors(colors);
 }
 
 void KisToolLazyBrushOptionsWidget::slotRemove()
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->activeMask);
 
     QModelIndex index = m_d->ui->colorView->currentIndex();
     if (!index.isValid()) return;
 
     const int activeIndex = m_d->colorModel->idFromIndex(index);
     KIS_ASSERT_RECOVER_RETURN(activeIndex >= 0);
 
 
     const KoColor color = m_d->colorSet.getColorGlobal((quint32)activeIndex).color();
     m_d->activeMask->removeKeyStroke(color);
 }
 
 void KisToolLazyBrushOptionsWidget::slotUpdate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     KisLayerPropertiesIcons::setNodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeNeedsUpdate, false, m_d->provider->currentImage());
 }
 
 void KisToolLazyBrushOptionsWidget::slotSetAutoUpdates(bool value)
 {
     // not implemented yet!
     ENTER_FUNCTION() << ppVar(value);
 }
 
 void KisToolLazyBrushOptionsWidget::slotSetShowKeyStrokes(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     KisLayerPropertiesIcons::setNodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, value, m_d->provider->currentImage());
 }
 
 void KisToolLazyBrushOptionsWidget::slotSetShowOutput(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     KisLayerPropertiesIcons::setNodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeShowColoring, value, m_d->provider->currentImage());
 }
 
 void KisToolLazyBrushOptionsWidget::slotUseEdgeDetectionChanged(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     m_d->activeMask->setUseEdgeDetection(value);
     m_d->ui->intEdgeDetectionSize->setEnabled(value);
 }
 
 void KisToolLazyBrushOptionsWidget::slotEdgeDetectionSizeChanged(int value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     m_d->activeMask->setEdgeDetectionSize(value);
 }
 
 void KisToolLazyBrushOptionsWidget::slotRadiusChanged(int value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     m_d->activeMask->setFuzzyRadius(0.5 * value);
 }
 
 void KisToolLazyBrushOptionsWidget::slotCleanUpChanged(int value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     m_d->activeMask->setCleanUpAmount(qreal(value) / 100.0);
 }
 
 void KisToolLazyBrushOptionsWidget::slotLimitToDeviceChanged(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     m_d->activeMask->setLimitToDeviceBounds(value);
 }
 
diff --git a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
index 12ede4bd95..0e4ac11dca 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
@@ -1,1297 +1,1297 @@
 /*
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_transform_config_widget.h"
 
 #include <kis_icon.h>
 #include "rotation_icons.h"
 #include "kis_canvas2.h"
 #include <QSignalMapper>
 #include "kis_liquify_properties.h"
 
 #include "KisMainWindow.h"
 #include "KisViewManager.h"
 #include "kis_transform_utils.h"
 
 
 template<typename T> inline T sign(T x) {
     return x > 0 ? 1 : x == (T)0 ? 0 : -1;
 }
 
 const int KisToolTransformConfigWidget::DEFAULT_POINTS_PER_LINE = 3;
 
 
 KisToolTransformConfigWidget::KisToolTransformConfigWidget(TransformTransactionProperties *transaction, KisCanvas2 *canvas, bool workRecursively, QWidget *parent)
     : QWidget(parent),
       m_transaction(transaction),
       m_notificationsBlocked(0),
       m_uiSlotsBlocked(0),
       m_configChanged(false)
 {
     setupUi(this);
     showDecorationsBox->setIcon(KisIconUtils::loadIcon("krita_tool_transform"));
     chkWorkRecursively->setIcon(KisIconUtils::loadIcon("krita_tool_transform_recursive"));
     flipXButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_x"));
     flipYButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_y"));
     rotateCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_cw"));
     rotateCCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_ccw"));
 
     chkWorkRecursively->setChecked(workRecursively);
     connect(chkWorkRecursively, SIGNAL(toggled(bool)), this, SIGNAL(sigRestartTransform()));
 
     // Init Filter  combo
     cmbFilter->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     cmbFilter->setCurrent("Bicubic");
     cmbFilter->setToolTip(i18nc("@info:tooltip",
                                 "<p>Select filtering mode:\n"
                                 "<ul>"
                                 "<li><b>Bilinear</b> for areas with uniform color to avoid artifacts</li>"
                                 "<li><b>Bicubic</b> for smoother results</li>"
                                 "<li><b>Lanczos3</b> for sharp results. May produce aerials.</li>"
                                 "</ul></p>"));
-    connect(cmbFilter, SIGNAL(activated(const KoID &)),
-            this, SLOT(slotFilterChanged(const KoID &)));
+    connect(cmbFilter, SIGNAL(activated(KoID)),
+            this, SLOT(slotFilterChanged(KoID)));
 
     // Init Warp Type combo
     cmbWarpType->insertItem(KisWarpTransformWorker::AFFINE_TRANSFORM,i18n("Default (Affine)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::RIGID_TRANSFORM,i18n("Strong (Rigid)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::SIMILITUDE_TRANSFORM,i18n("Strongest (Similitude)"));
     cmbWarpType->setCurrentIndex(KisWarpTransformWorker::AFFINE_TRANSFORM);
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotWarpTypeChanged(int)));
 
     // Init Rotation Center buttons
     m_handleDir[0] = QPointF(1, 0);
     m_handleDir[1] = QPointF(1, -1);
     m_handleDir[2] = QPointF(0, -1);
     m_handleDir[3] = QPointF(-1, -1);
     m_handleDir[4] = QPointF(-1, 0);
     m_handleDir[5] = QPointF(-1, 1);
     m_handleDir[6] = QPointF(0, 1);
     m_handleDir[7] = QPointF(1, 1);
     m_handleDir[8] = QPointF(0, 0); // also add the center
 
     m_rotationCenterButtons = new QButtonGroup(0);
     // we set the ids to match m_handleDir
     m_rotationCenterButtons->addButton(middleRightButton, 0);
     m_rotationCenterButtons->addButton(topRightButton, 1);
     m_rotationCenterButtons->addButton(middleTopButton, 2);
     m_rotationCenterButtons->addButton(topLeftButton, 3);
     m_rotationCenterButtons->addButton(middleLeftButton, 4);
     m_rotationCenterButtons->addButton(bottomLeftButton, 5);
     m_rotationCenterButtons->addButton(middleBottomButton, 6);
     m_rotationCenterButtons->addButton(bottomRightButton, 7);
     m_rotationCenterButtons->addButton(centerButton, 8);
 
     QToolButton *nothingSelected = new QToolButton(0);
     nothingSelected->setCheckable(true);
     nothingSelected->setAutoExclusive(true);
     nothingSelected->hide(); // a convenient button for when no button is checked in the group
     m_rotationCenterButtons->addButton(nothingSelected, 9);
 
 
     // initialize values for free transform sliders
     shearXBox->setSuffix(i18n(" px"));
     shearYBox->setSuffix(i18n(" px"));
     shearXBox->setRange(-5.0, 5.0, 2);
     shearYBox->setRange(-5.0, 5.0, 2);
     shearXBox->setSingleStep(0.01);
     shearYBox->setSingleStep(0.01);
     shearXBox->setValue(0.0);
     shearYBox->setValue(0.0);
 
 
     translateXBox->setSuffix(i18n(" px"));
     translateYBox->setSuffix(i18n(" px"));
     translateXBox->setRange(-10000, 10000);
     translateYBox->setRange(-10000, 10000);
 
 
     scaleXBox->setSuffix("%");
     scaleYBox->setSuffix("%");
     scaleXBox->setRange(-10000, 10000);
     scaleYBox->setRange(-10000, 10000);
     scaleXBox->setValue(100.0);
     scaleYBox->setValue(100.0);
 
     m_scaleRatio = 1.0;
 
     aXBox->setSuffix(QChar(Qt::Key_degree));
     aYBox->setSuffix(QChar(Qt::Key_degree));
     aZBox->setSuffix(QChar(Qt::Key_degree));
     aXBox->setRange(0.0, 360.0, 2);
     aYBox->setRange(0.0, 360.0, 2);
     aZBox->setRange(0.0, 360.0, 2);
     aXBox->setValue(0.0);
     aYBox->setValue(0.0);
     aZBox->setValue(0.0);
     aXBox->setSingleStep(1.0);
     aYBox->setSingleStep(1.0);
     aZBox->setSingleStep(1.0);
 
 
 
 
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(slotRotationCenterChanged(int)));
     connect(btnTransformAroundPivotPoint, SIGNAL(clicked(bool)), this, SLOT(slotTransformAroundRotationCenter(bool)));
 
     // Init Free Transform Values
     connect(scaleXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleX(int)));
     connect(scaleYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleY(int)));
     connect(shearXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearX(qreal)));
     connect(shearYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearY(qreal)));
     connect(translateXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateX(int)));
     connect(translateYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateY(int)));
     connect(aXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAX(qreal)));
     connect(aYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAY(qreal)));
     connect(aZBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAZ(qreal)));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotSetKeepAspectRatio(bool)));
     connect(flipXButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipX()));
     connect(flipYButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipY()));
     connect(rotateCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCW()));
     connect(rotateCCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCCW()));
 
     // toggle visibility of different free buttons
     connect(freeMoveRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeRotationRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeScaleRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeShearRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
 
     // only first group for free transform
     rotationGroup->hide();
     moveGroup->show();
     scaleGroup->hide();
     shearGroup->hide();
 
 
 
     // Init Warp Transform Values
     alphaBox->setSingleStep(0.1);
     alphaBox->setRange(0, 10, 1);
 
     connect(alphaBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetWarpAlpha(qreal)));
     connect(densityBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetWarpDensity(int)));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpDefaultPointsButtonClicked(bool)));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpCustomPointsButtonClicked(bool)));
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpLockPointsButtonClicked()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpResetPointsButtonClicked()));
 
     // Init Cage Transform Values
     cageTransformButtonGroup->setId(cageAddEditRadio, 0); // we need to set manually since Qt Designer generates negative by default
     cageTransformButtonGroup->setId(cageDeformRadio, 1);
     connect(cageTransformButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(slotCageOptionsChanged(int)));
 
     // Init Liquify Transform Values
     liquifySizeSlider->setRange(KisLiquifyProperties::minSize(),
                                 KisLiquifyProperties::maxSize(), 2);
     liquifySizeSlider->setExponentRatio(4);
     liquifySizeSlider->setValue(60.0);
     connect(liquifySizeSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySizeChanged(qreal)));
     liquifySizeSlider->setToolTip(i18nc("@info:tooltip", "Size of the deformation brush"));
 
     liquifyAmountSlider->setRange(0.0, 1.0, 2);
     liquifyAmountSlider->setValue(0.05);
     connect(liquifyAmountSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyAmountChanged(qreal)));
     liquifyAmountSlider->setToolTip(i18nc("@info:tooltip", "Amount of the deformation you get"));
 
     liquifyFlowSlider->setRange(0.0, 1.0, 2);
     liquifyFlowSlider->setValue(1.0);
     connect(liquifyFlowSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyFlowChanged(qreal)));
     liquifyFlowSlider->setToolTip(i18nc("@info:tooltip", "When in non-buildup mode, shows how fast the deformation limit is reached."));
 
     buidupModeComboBox->setCurrentIndex(0); // set to build-up mode by default
     connect(buidupModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(liquifyBuildUpChanged(int)));
     buidupModeComboBox->setToolTip(i18nc("@info:tooltip", "Switch between Build Up and Wash mode of painting. Build Up mode adds deformations one on top of the other without any limits. Wash mode gradually deforms the piece to the selected deformation level."));
 
     liquifySpacingSlider->setRange(0.0, 3.0, 2);
     liquifySizeSlider->setExponentRatio(3);
     liquifySpacingSlider->setSingleStep(0.01);
     liquifySpacingSlider->setValue(0.2);
     connect(liquifySpacingSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySpacingChanged(qreal)));
     liquifySpacingSlider->setToolTip(i18nc("@info:tooltip", "Space between two sequential applications of the deformation"));
 
     liquifySizePressureBox->setChecked(true);
     connect(liquifySizePressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifySizePressureChanged(bool)));
     liquifySizePressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Size</b> value according to current stylus pressure"));
 
     liquifyAmountPressureBox->setChecked(true);
     connect(liquifyAmountPressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifyAmountPressureChanged(bool)));
     liquifyAmountPressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Amount</b> value according to current stylus pressure"));
 
     liquifyReverseDirectionChk->setChecked(false);
     connect(liquifyReverseDirectionChk, SIGNAL(toggled(bool)), this, SLOT(liquifyReverseDirectionChanged(bool)));
     liquifyReverseDirectionChk->setToolTip(i18nc("@info:tooltip", "Reverse direction of the current deformation tool"));
 
     QSignalMapper *liquifyModeMapper = new QSignalMapper(this);
     connect(liquifyMove, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyScale, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyRotate, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyOffset, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyUndo, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     liquifyModeMapper->setMapping(liquifyMove, (int)KisLiquifyProperties::MOVE);
     liquifyModeMapper->setMapping(liquifyScale, (int)KisLiquifyProperties::SCALE);
     liquifyModeMapper->setMapping(liquifyRotate, (int)KisLiquifyProperties::ROTATE);
     liquifyModeMapper->setMapping(liquifyOffset, (int)KisLiquifyProperties::OFFSET);
     liquifyModeMapper->setMapping(liquifyUndo, (int)KisLiquifyProperties::UNDO);
     connect(liquifyModeMapper, SIGNAL(mapped(int)), SLOT(slotLiquifyModeChanged(int)));
 
     liquifyMove->setToolTip(i18nc("@info:tooltip", "Move: drag the image along the brush stroke"));
     liquifyScale->setToolTip(i18nc("@info:tooltip", "Scale: grow/shrink image under cursor"));
     liquifyRotate->setToolTip(i18nc("@info:tooltip", "Rotate: twirl image under cursor"));
     liquifyOffset->setToolTip(i18nc("@info:tooltip", "Offset: shift the image to the right of the stroke direction"));
     liquifyUndo->setToolTip(i18nc("@info:tooltip", "Undo: erase actions of other tools"));
 
     // Connect all edit boxes to the Editing Finished signal
     connect(densityBox, SIGNAL(editingFinished()), this, SLOT(notifyEditingFinished()));
 
 
 
     // Connect other widget (not having editingFinished signal) to
     // the same slot. From Qt 4.6 onwards the sequence of the signal
     // delivery is definite.
-    connect(cmbFilter, SIGNAL(activated(const KoID &)), this, SLOT(notifyEditingFinished()));
+    connect(cmbFilter, SIGNAL(activated(KoID)), this, SLOT(notifyEditingFinished()));
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(notifyEditingFinished()));
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(notifyEditingFinished()));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(notifyEditingFinished()));
 
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
 
     // Liquify
     //
     // liquify brush options do not affect the image directly and are not
     // saved to undo, so we don't emit notifyEditingFinished() for them
 
     // Connect Apply/Reset buttons
-    connect(buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(slotButtonBoxClicked(QAbstractButton *)));
+    connect(buttonBox, SIGNAL(clicked(QAbstractButton*)), this, SLOT(slotButtonBoxClicked(QAbstractButton*)));
 
     // Mode switch buttons
     connect(freeTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetFreeTransformModeButtonClicked(bool)));
     connect(warpButton, SIGNAL(clicked(bool)), this, SLOT(slotSetWarpModeButtonClicked(bool)));
     connect(cageButton, SIGNAL(clicked(bool)), this, SLOT(slotSetCageModeButtonClicked(bool)));
     connect(perspectiveTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetPerspectiveModeButtonClicked(bool)));
     connect(liquifyButton, SIGNAL(clicked(bool)), this, SLOT(slotSetLiquifyModeButtonClicked(bool)));
 
     // Connect Decorations switcher
     connect(showDecorationsBox, SIGNAL(toggled(bool)), canvas, SLOT(updateCanvas()));
 
     tooBigLabelWidget->hide();
 
     connect(canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), SLOT(slotUpdateIcons()), Qt::UniqueConnection);
     slotUpdateIcons();
 }
 
 void KisToolTransformConfigWidget::slotUpdateIcons()
 {
     freeTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_main"));
     warpButton->setIcon(KisIconUtils::loadIcon("transform_icons_warp"));
     cageButton->setIcon(KisIconUtils::loadIcon("transform_icons_cage"));
     perspectiveTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_perspective"));
     liquifyButton->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_main"));
 
     liquifyMove->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_move"));
     liquifyScale->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_resize"));
     liquifyRotate->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_rotate"));
     liquifyOffset->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_offset"));
     liquifyUndo->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_erase"));
 
 
 
     middleRightButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     topRightButton->setIcon(KisIconUtils::loadIcon("arrow-topright"));
     middleTopButton->setIcon(KisIconUtils::loadIcon("arrow-up"));
     topLeftButton->setIcon(KisIconUtils::loadIcon("arrow-topleft"));
     middleLeftButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     bottomLeftButton->setIcon(KisIconUtils::loadIcon("arrow-downleft"));
     middleBottomButton->setIcon(KisIconUtils::loadIcon("arrow-down"));
     bottomRightButton->setIcon(KisIconUtils::loadIcon("arrow-downright"));
 
     btnTransformAroundPivotPoint->setIcon(KisIconUtils::loadIcon("pivot-point"));
 
 
     // pressure icons
     liquifySizePressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     liquifyAmountPressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
 }
 
 double KisToolTransformConfigWidget::radianToDegree(double rad)
 {
     double piX2 = 2 * M_PI;
 
     if (rad < 0 || rad >= piX2) {
         rad = fmod(rad, piX2);
         if (rad < 0) {
             rad += piX2;
         }
     }
 
     return (rad * 360. / piX2);
 }
 
 double KisToolTransformConfigWidget::degreeToRadian(double degree)
 {
     if (degree < 0. || degree >= 360.) {
         degree = fmod(degree, 360.);
         if (degree < 0)
             degree += 360.;
     }
 
     return (degree * M_PI / 180.);
 }
 
 void KisToolTransformConfigWidget::updateLiquifyControls()
 {
     blockUiSlots();
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     const bool useWashMode = props->useWashMode();
 
     liquifySizeSlider->setValue(props->size());
     liquifyAmountSlider->setValue(props->amount());
     liquifyFlowSlider->setValue(props->flow());
     buidupModeComboBox->setCurrentIndex(useWashMode);
 
     liquifySpacingSlider->setValue(props->spacing());
     liquifySizePressureBox->setChecked(props->sizeHasPressure());
     liquifyAmountPressureBox->setChecked(props->amountHasPressure());
     liquifyReverseDirectionChk->setChecked(props->reverseDirection());
 
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(props->mode());
 
     bool canInverseDirection =
         mode != KisLiquifyProperties::UNDO;
 
     bool canUseWashMode = mode != KisLiquifyProperties::UNDO;
 
     liquifyReverseDirectionChk->setEnabled(canInverseDirection);
     liquifyFlowSlider->setEnabled(canUseWashMode && useWashMode);
     buidupModeComboBox->setEnabled(canUseWashMode);
 
     const qreal maxAmount = canUseWashMode ? 5.0 : 1.0;
     liquifyAmountSlider->setRange(0.0, maxAmount, 2);
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::slotLiquifyModeChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(value);
 
     if (mode == props->mode()) return;
 
     props->setMode(mode);
     props->loadMode();
 
     updateLiquifyControls();
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizeChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSize(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmount(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyFlowChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setFlow(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyBuildUpChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setUseWashMode(value); // 0 == build up mode / 1 == wash mode
 
     notifyConfigChanged();
 
     // we need to enable/disable flow slider
     updateLiquifyControls();
 }
 
 void KisToolTransformConfigWidget::liquifySpacingChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSpacing(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizePressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSizeHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountPressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmountHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyReverseDirectionChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setReverseDirection(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::updateConfig(const ToolTransformArgs &config)
 {
     blockUiSlots();
 
     if (config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
         config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) {
 
         quickTransformGroup->setEnabled(config.mode() == ToolTransformArgs::FREE_TRANSFORM);
 
         stackedWidget->setCurrentIndex(0);
 
         bool freeTransformIsActive = config.mode() == ToolTransformArgs::FREE_TRANSFORM;
 
         if (freeTransformIsActive)
         {
             freeTransformButton->setChecked(true);
         }
         else
         {
             perspectiveTransformButton->setChecked(true);
         }
 
         aXBox->setEnabled(freeTransformIsActive);
         aYBox->setEnabled(freeTransformIsActive);
         aZBox->setEnabled(freeTransformIsActive);
         freeRotationRadioButton->setEnabled(freeTransformIsActive);
 
         scaleXBox->setValue(config.scaleX() * 100.);
         scaleYBox->setValue(config.scaleY() * 100.);
         shearXBox->setValue(config.shearX());
         shearYBox->setValue(config.shearY());
 
         const QPointF anchorPoint = config.originalCenter() + config.rotationCenterOffset();
         const KisTransformUtils::MatricesPack m(config);
         const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
 
         translateXBox->setValue(anchorPointView.x());
         translateYBox->setValue(anchorPointView.y());
 
         aXBox->setValue(radianToDegree(config.aX()));
         aYBox->setValue(radianToDegree(config.aY()));
         aZBox->setValue(radianToDegree(config.aZ()));
         aspectButton->setKeepAspectRatio(config.keepAspectRatio());
         cmbFilter->setCurrent(config.filterId());
 
         QPointF pt = m_transaction->currentConfig()->rotationCenterOffset();
         pt.rx() /= m_transaction->originalHalfWidth();
         pt.ry() /= m_transaction->originalHalfHeight();
 
         for (int i = 0; i < 9; i++) {
             if (qFuzzyCompare(m_handleDir[i].x(), pt.x()) &&
                 qFuzzyCompare(m_handleDir[i].y(), pt.y())) {
 
                 m_rotationCenterButtons->button(i)->setChecked(true);
                 break;
             }
         }
 
         btnTransformAroundPivotPoint->setChecked(config.transformAroundRotationCenter());
 
     } else if (config.mode() == ToolTransformArgs::WARP) {
 
         stackedWidget->setCurrentIndex(1);
         warpButton->setChecked(true);
 
         if (config.defaultPoints()) {
             densityBox->setValue(std::sqrt(config.numPoints()));
         }
 
         cmbWarpType->setCurrentIndex((int)config.warpType());
         defaultRadioButton->setChecked(config.defaultPoints());
         customRadioButton->setChecked(!config.defaultPoints());
         densityBox->setEnabled(config.defaultPoints());
         customWarpWidget->setEnabled(!config.defaultPoints());
 
         updateLockPointsButtonCaption();
 
     } else if (config.mode() == ToolTransformArgs::CAGE) {
 
         // default UI options
         resetUIOptions();
 
         // we need at least 3 point before we can start actively deforming
         if (config.origPoints().size() >= 3)
         {
             cageTransformDirections->setText(i18n("Switch between editing and deforming cage"));
             cageAddEditRadio->setVisible(true);
             cageDeformRadio->setVisible(true);
 
             // update to correct radio button
             if (config.isEditingTransformPoints())
                 cageAddEditRadio->setChecked(true);
             else
                  cageDeformRadio->setChecked(true);
 
         }
 
     } else if (config.mode() == ToolTransformArgs::LIQUIFY) {
 
         stackedWidget->setCurrentIndex(3);
         liquifyButton->setChecked(true);
 
         const KisLiquifyProperties *props =
             config.liquifyProperties();
 
         switch (props->mode()) {
         case KisLiquifyProperties::MOVE:
             liquifyMove->setChecked(true);
             break;
         case KisLiquifyProperties::SCALE:
             liquifyScale->setChecked(true);
             break;
         case KisLiquifyProperties::ROTATE:
             liquifyRotate->setChecked(true);
             break;
         case KisLiquifyProperties::OFFSET:
             liquifyOffset->setChecked(true);
             break;
         case KisLiquifyProperties::UNDO:
             liquifyUndo->setChecked(true);
             break;
         case KisLiquifyProperties::N_MODES:
             qFatal("Unsupported mode");
         }
 
         updateLiquifyControls();
     }
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::updateLockPointsButtonCaption()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     if (config->isEditingTransformPoints()) {
         lockUnlockPointsButton->setText(i18n("Lock Points"));
     } else {
         lockUnlockPointsButton->setText(i18n("Unlock Points"));
     }
 }
 
 void KisToolTransformConfigWidget::setApplyResetDisabled(bool disabled)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     Q_ASSERT(applyButton);
     Q_ASSERT(resetButton);
 
     applyButton->setDisabled(disabled);
     resetButton->setDisabled(disabled);
 }
 
 void KisToolTransformConfigWidget::resetRotationCenterButtons()
 {
     int checkedId = m_rotationCenterButtons->checkedId();
 
     if (checkedId >= 0 && checkedId <= 8) {
         // uncheck the current checked button
         m_rotationCenterButtons->button(9)->setChecked(true);
     }
 }
 
 bool KisToolTransformConfigWidget::workRecursively() const
 {
     return chkWorkRecursively->isChecked();
 }
 
 void KisToolTransformConfigWidget::setTooBigLabelVisible(bool value)
 {
     tooBigLabelWidget->setVisible(value);
 }
 
 bool KisToolTransformConfigWidget::showDecorations() const
 {
     return showDecorationsBox->isChecked();
 }
 
 void KisToolTransformConfigWidget::blockNotifications()
 {
     m_notificationsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockNotifications()
 {
     m_notificationsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyConfigChanged()
 {
     if (!m_notificationsBlocked) {
         emit sigConfigChanged();
     }
     m_configChanged = true;
 }
 
 void KisToolTransformConfigWidget::blockUiSlots()
 {
     m_uiSlotsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockUiSlots()
 {
     m_uiSlotsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyEditingFinished()
 {
     if (m_uiSlotsBlocked || m_notificationsBlocked || !m_configChanged) return;
 
     emit sigEditingFinished();
     m_configChanged = false;
 }
 
 
 void KisToolTransformConfigWidget::resetUIOptions()
 {
     // reset tool states since we are done (probably can encapsulate this later)
     ToolTransformArgs *config = m_transaction->currentConfig();
     if (config->mode() == ToolTransformArgs::CAGE)
     {
         cageAddEditRadio->setVisible(false);
         cageAddEditRadio->setChecked(true);
         cageDeformRadio->setVisible(false);
         cageTransformDirections->setText(i18n("Create 3 points on the canvas to begin"));
 
         // ensure we are on the right options view
         stackedWidget->setCurrentIndex(2);
     }
 
 
 
 }
 
 void KisToolTransformConfigWidget::slotButtonBoxClicked(QAbstractButton *button)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     resetUIOptions();
 
     if (button == applyButton) {
         emit sigApplyTransform();
     }
     else if (button == resetButton) {
         emit sigResetTransform();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetFreeTransformModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(freeTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::FREE_TRANSFORM);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(warpButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::WARP);
     config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::GRID);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetCageModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(cageButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::CAGE);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetLiquifyModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(liquifyButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::LIQUIFY);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetPerspectiveModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(perspectiveTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::PERSPECTIVE_4POINT);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotFilterChanged(const KoID &filterId)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setFilterId(filterId.id());
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotRotationCenterChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     if (index >= 0 && index <= 8) {
         ToolTransformArgs *config = m_transaction->currentConfig();
 
         double i = m_handleDir[index].x();
         double j = m_handleDir[index].y();
 
         config->setRotationCenterOffset(QPointF(i * m_transaction->originalHalfWidth(),
                                                 j * m_transaction->originalHalfHeight()));
 
         notifyConfigChanged();
         updateConfig(*config);
     }
 }
 
 void KisToolTransformConfigWidget::slotTransformAroundRotationCenter(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setTransformAroundRotationCenter(value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
 
         blockNotifications();
          int calculatedValue = int( value/ m_scaleRatio );
 
         scaleYBox->blockSignals(true);
         scaleYBox->setValue(calculatedValue);
         {
             KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
             config->setScaleY(calculatedValue / 100.);
         }
         scaleYBox->blockSignals(false);
 
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
         blockNotifications();
         int calculatedValue = int(m_scaleRatio * value);
         scaleXBox->blockSignals(true);
         scaleXBox->setValue(calculatedValue);
         {
             KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
             config->setScaleX(calculatedValue / 100.);
         }
         scaleXBox->blockSignals(false);
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearX((double)value);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearY((double)value);
     }
 
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(value, anchorPointView.y());
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(anchorPointView.x(), value);
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetAX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAX(degreeToRadian((double)value));
     }
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAY(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAZ(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipX()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(config->scaleX() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipY()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(config->scaleY() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() + M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() - M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 
 // change free transform setting we want to alter (all radio buttons call this)
 void KisToolTransformConfigWidget::slotTransformAreaVisible(bool value)
 {
     Q_UNUSED(value);
 
     //QCheckBox sender = (QCheckBox)(*)(QObject::sender());
     QString senderName = QObject::sender()->objectName();
 
 
     // only show setting with what we have selected
     rotationGroup->hide();
     shearGroup->hide();
     scaleGroup->hide();
     moveGroup->hide();
 
 
     if ("freeMoveRadioButton" == senderName)
     {
         moveGroup->show();
     }
     else  if ("freeShearRadioButton" == senderName)
     {
         shearGroup->show();
     }
     else if ("freeScaleRadioButton" == senderName)
     {
         scaleGroup->show();
     }
     else
     {
         rotationGroup->show();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetKeepAspectRatio(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setKeepAspectRatio(value);
 
     if (value) {
        blockNotifications();
        int tmpXScaleBox = scaleXBox->value();
        int tmpYScaleBox = scaleYBox->value();
        m_scaleRatio = (tmpXScaleBox / (double) tmpYScaleBox);
        unblockNotifications();
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpAlpha(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setAlpha((double)value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpDensity(int value)
 {
     if (m_uiSlotsBlocked) return;
     setDefaultWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::setDefaultWarpPoints(int pointsPerLine)
 {
     if (pointsPerLine < 0) {
         pointsPerLine = DEFAULT_POINTS_PER_LINE;
     }
 
     int nbPoints = pointsPerLine * pointsPerLine;
     QVector<QPointF> origPoints(nbPoints);
     QVector<QPointF> transfPoints(nbPoints);
     qreal gridSpaceX, gridSpaceY;
 
     if (nbPoints == 1) {
         //there is actually no grid
         origPoints[0] = m_transaction->originalCenterGeometric();
         transfPoints[0] = m_transaction->originalCenterGeometric();
     }
     else if (nbPoints > 1) {
         gridSpaceX = m_transaction->originalRect().width() / (pointsPerLine - 1);
         gridSpaceY = m_transaction->originalRect().height() / (pointsPerLine - 1);
         double y = m_transaction->originalRect().top();
         for (int i = 0; i < pointsPerLine; ++i) {
             double x = m_transaction->originalRect().left();
             for (int j = 0 ; j < pointsPerLine; ++j) {
                 origPoints[i * pointsPerLine + j] = QPointF(x, y);
                 transfPoints[i * pointsPerLine + j] = QPointF(x, y);
                 x += gridSpaceX;
             }
             y += gridSpaceY;
         }
     }
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setDefaultPoints(nbPoints > 0);
     config->setPoints(origPoints, transfPoints);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::activateCustomWarpPoints(bool enabled)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     densityBox->setEnabled(!enabled);
     customWarpWidget->setEnabled(enabled);
 
     if (!enabled) {
         config->setEditingTransformPoints(false);
         setDefaultWarpPoints(densityBox->value());
         config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::GRID);
     } else {
         config->setEditingTransformPoints(true);
         config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::DRAW);
         setDefaultWarpPoints(0);
     }
 
 
 
 
     updateLockPointsButtonCaption();
 }
 
 void KisToolTransformConfigWidget::slotWarpDefaultPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(!value);
 }
 
 void KisToolTransformConfigWidget::slotWarpCustomPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::slotWarpResetPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(true);
 }
 
 void KisToolTransformConfigWidget::slotWarpLockPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setEditingTransformPoints(!config->isEditingTransformPoints());
 
     if (config->isEditingTransformPoints()) {
         // reinit the transf points to their original value
         ToolTransformArgs *config = m_transaction->currentConfig();
         int nbPoints = config->origPoints().size();
         for (int i = 0; i < nbPoints; ++i) {
             config->transfPoint(i) = config->origPoint(i);
         }
     }
 
     updateLockPointsButtonCaption();
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotWarpTypeChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     switch (index) {
     case KisWarpTransformWorker::AFFINE_TRANSFORM:
     case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
     case KisWarpTransformWorker::RIGID_TRANSFORM:
         config->setWarpType((KisWarpTransformWorker::WarpType)index);
         break;
     default:
         config->setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
         break;
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotCageOptionsChanged(int value)
 {
     if ( value == 0)
     {
         slotEditCagePoints(true);
     }
     else
     {
         slotEditCagePoints(false);
     }
 
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotEditCagePoints(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->refTransformedPoints() = config->origPoints();
 
     config->setEditingTransformPoints(value);
     notifyConfigChanged();
 }