diff --git a/libs/basicflakes/tools/KoPencilTool.cpp b/libs/basicflakes/tools/KoPencilTool.cpp
index ac331d3839..edb7c9ba40 100644
--- a/libs/basicflakes/tools/KoPencilTool.cpp
+++ b/libs/basicflakes/tools/KoPencilTool.cpp
@@ -1,581 +1,581 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007,2009,2011 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 "KoPencilTool.h"
 #include "KoCurveFit.h"
 
 #include <KoPathShape.h>
 #include <KoParameterShape.h>
 #include <KoShapeStroke.h>
 #include <KoPointerEvent.h>
 #include <KoCanvasBase.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoColor.h>
 #include <KoPathPoint.h>
 #include <KoPathPointData.h>
 #include <KoPathPointMergeCommand.h>
 #include <KoShapePaintingContext.h>
 #include <widgets/KoStrokeConfigWidget.h>
 #include <KisHandlePainterHelper.h>
 
 #include <klocalizedstring.h>
 
 #include <QDoubleSpinBox>
 #include <QComboBox>
 #include <QStackedWidget>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QLabel>
 
 #include <math.h>
 
 #include "KoCreatePathTool_p.h"
 #include "kis_double_parse_spin_box.h"
 
 KoPencilTool::KoPencilTool(KoCanvasBase *canvas)
     : KoToolBase(canvas)
     , m_mode(ModeCurve)
     , m_optimizeRaw(false)
     , m_optimizeCurve(false)
     , m_combineAngle(15.0)
     , m_fittingError(5.0)
     , m_close(false)
     , m_shape(0)
     , m_existingStartPoint(0)
     , m_existingEndPoint(0)
     , m_hoveredPoint(0)
     , m_strokeWidget(0)
 {
 }
 
 KoPencilTool::~KoPencilTool()
 {
 }
 
 void KoPencilTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     if (m_shape) {
         painter.save();
 
         painter.setTransform(m_shape->absoluteTransformation(&converter) * painter.transform());
 
         painter.save();
         KoShapePaintingContext paintContext; //FIXME
         m_shape->paint(painter, converter, paintContext);
         painter.restore();
 
         if (m_shape->stroke()) {
             painter.save();
             m_shape->stroke()->paint(m_shape, painter, converter);
             painter.restore();
         }
 
         painter.restore();
     }
 
     if (m_hoveredPoint) {
         KisHandlePainterHelper helper =
             KoShape::createHandlePainterHelper(&painter, m_hoveredPoint->parent(), converter, handleRadius());
 
         helper.setHandleStyle(KisHandleStyle::primarySelection());
         m_hoveredPoint->paint(helper, KoPathPoint::Node);
     }
 }
 
 void KoPencilTool::repaintDecorations()
 {
 }
 
 void KoPencilTool::mousePressEvent(KoPointerEvent *event)
 {
     KoShapeStrokeSP stroke = createStroke();
 
     if (!m_shape && stroke && stroke->isVisible()) {
         m_shape = new KoPathShape();
         m_shape->setShapeId(KoPathShapeId);
         m_shape->setStroke(createStroke());
         m_points.clear();
 
         QPointF point = event->point;
         m_existingStartPoint = endPointAtPosition(point);
         if (m_existingStartPoint)
             point = m_existingStartPoint->parent()->shapeToDocument(m_existingStartPoint->point());
 
         addPoint(point);
     }
 }
 
 void KoPencilTool::mouseMoveEvent(KoPointerEvent *event)
 {
     if (event->buttons() & Qt::LeftButton)
         addPoint(event->point);
 
     KoPathPoint * endPoint = endPointAtPosition(event->point);
     if (m_hoveredPoint != endPoint) {
         if (m_hoveredPoint) {
             QPointF nodePos = m_hoveredPoint->parent()->shapeToDocument(m_hoveredPoint->point());
             canvas()->updateCanvas(handlePaintRect(nodePos));
         }
         m_hoveredPoint = endPoint;
         if (m_hoveredPoint) {
             QPointF nodePos = m_hoveredPoint->parent()->shapeToDocument(m_hoveredPoint->point());
             canvas()->updateCanvas(handlePaintRect(nodePos));
         }
     }
 }
 
 void KoPencilTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     if (! m_shape)
         return;
 
     QPointF point = event->point;
     m_existingEndPoint = endPointAtPosition(point);
     if (m_existingEndPoint)
         point = m_existingEndPoint->parent()->shapeToDocument(m_existingEndPoint->point());
 
     addPoint(point);
     finish(event->modifiers() & Qt::ShiftModifier);
 
     m_existingStartPoint = 0;
     m_existingEndPoint = 0;
     m_hoveredPoint = 0;
 
     // the original path may be different from the one added
     canvas()->updateCanvas(m_shape->boundingRect());
     delete m_shape;
     m_shape = 0;
     m_points.clear();
 }
 
 void KoPencilTool::keyPressEvent(QKeyEvent *event)
 {
     if (m_shape) {
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 void KoPencilTool::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KoToolBase::activate(activation, shapes);
 
     m_points.clear();
     m_close = false;
     slotUpdatePencilCursor();
 
     if (m_strokeWidget) {
         m_strokeWidget->activate();
     }
 }
 
 void KoPencilTool::deactivate()
 {
     m_points.clear();
     delete m_shape;
     m_shape = 0;
     m_existingStartPoint = 0;
     m_existingEndPoint = 0;
     m_hoveredPoint = 0;
 
     if (m_strokeWidget) {
         m_strokeWidget->deactivate();
     }
 
     KoToolBase::deactivate();
 }
 
 void KoPencilTool::slotUpdatePencilCursor()
 {
     KoShapeStrokeSP stroke = createStroke();
     useCursor((stroke && stroke->isVisible()) ? Qt::ArrowCursor : Qt::ForbiddenCursor);
 }
 
 void KoPencilTool::addPoint(const QPointF & point)
 {
     if (! m_shape)
         return;
 
     // do a moveTo for the first point added
     if (m_points.empty())
         m_shape->moveTo(point);
     // do not allow coincident points
     else if (point != m_points.last())
         m_shape->lineTo(point);
     else
         return;
 
     m_points.append(point);
     canvas()->updateCanvas(m_shape->boundingRect());
 }
 
 qreal KoPencilTool::lineAngle(const QPointF &p1, const QPointF &p2)
 {
     qreal angle = atan2(p2.y() - p1.y(), p2.x() - p1.x());
     if (angle < 0.0)
         angle += 2 * M_PI;
 
     return angle * 180.0 / M_PI;
 }
 
 void KoPencilTool::finish(bool closePath)
 {
     if (m_points.count() < 2)
         return;
 
     KoPathShape * path = 0;
     QList<QPointF> complete;
     QList<QPointF> *points = &m_points;
 
     if (m_mode == ModeStraight || m_optimizeRaw || m_optimizeCurve) {
         float combineAngle;
 
         if (m_mode == ModeStraight)
             combineAngle = m_combineAngle;
         else
             combineAngle = 0.50f;
 
         //Add the first two points
         complete.append(m_points[0]);
         complete.append(m_points[1]);
 
         //Now we need to get the angle of the first line
         float lastAngle = lineAngle(complete[0], complete[1]);
 
         uint pointCount = m_points.count();
         for (uint i = 2; i < pointCount; ++i) {
             float angle = lineAngle(complete.last(), m_points[i]);
             if (qAbs(angle - lastAngle) < combineAngle)
                 complete.removeLast();
             complete.append(m_points[i]);
             lastAngle = angle;
         }
 
         m_points.clear();
         points = &complete;
     }
 
     switch (m_mode) {
     case ModeCurve: {
         path = bezierFit(*points, m_fittingError);
     }
     break;
     case ModeStraight:
     case ModeRaw: {
         path = new KoPathShape();
         uint pointCount = points->count();
         path->moveTo(points->at(0));
         for (uint i = 1; i < pointCount; ++i)
             path->lineTo(points->at(i));
     }
     break;
     }
 
     if (! path)
         return;
 
     path->setShapeId(KoPathShapeId);
     path->setStroke(createStroke());
     addPathShape(path, closePath);
 }
 
 QList<QPointer<QWidget> > KoPencilTool::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgets;
     QWidget *optionWidget = new QWidget();
     QVBoxLayout * layout = new QVBoxLayout(optionWidget);
 
     QHBoxLayout *modeLayout = new QHBoxLayout;
     modeLayout->setSpacing(3);
     QLabel *modeLabel = new QLabel(i18n("Precision:"), optionWidget);
     QComboBox * modeBox = new QComboBox(optionWidget);
     modeBox->addItem(i18nc("The raw line data", "Raw"));
     modeBox->addItem(i18n("Curve"));
     modeBox->addItem(i18n("Straight"));
     modeLayout->addWidget(modeLabel);
     modeLayout->addWidget(modeBox, 1);
     layout->addLayout(modeLayout);
 
     QStackedWidget * stackedWidget = new QStackedWidget(optionWidget);
 
     QWidget * rawBox = new QWidget(stackedWidget);
     QVBoxLayout * rawLayout = new QVBoxLayout(rawBox);
     QCheckBox * optimizeRaw = new QCheckBox(i18n("Optimize"), rawBox);
     rawLayout->addWidget(optimizeRaw);
     rawLayout->setContentsMargins(0, 0, 0, 0);
 
     QWidget * curveBox = new QWidget(stackedWidget);
     QHBoxLayout * curveLayout = new QHBoxLayout(curveBox);
     QCheckBox * optimizeCurve = new QCheckBox(i18n("Optimize"), curveBox);
     QDoubleSpinBox * fittingError = new KisDoubleParseSpinBox(curveBox);
     fittingError->setValue(0.50);
     fittingError->setMaximum(400.0);
     fittingError->setMinimum(0.0);
     fittingError->setSingleStep(m_fittingError);
     fittingError->setToolTip(i18n("Exactness:"));
     curveLayout->addWidget(optimizeCurve);
     curveLayout->addWidget(fittingError);
     curveLayout->setContentsMargins(0, 0, 0, 0);
 
     QWidget *straightBox = new QWidget(stackedWidget);
     QVBoxLayout *straightLayout = new QVBoxLayout(straightBox);
     QDoubleSpinBox *combineAngle = new KisDoubleParseSpinBox(straightBox);
     combineAngle->setValue(0.50);
     combineAngle->setMaximum(360.0);
     combineAngle->setMinimum(0.0);
     combineAngle->setSingleStep(m_combineAngle);
     combineAngle->setSuffix(" deg");
     // QT5TODO
     //combineAngle->setLabel(i18n("Combine angle:"), Qt::AlignLeft | Qt::AlignVCenter);
     straightLayout->addWidget(combineAngle);
     straightLayout->setContentsMargins(0, 0, 0, 0);
 
     stackedWidget->addWidget(rawBox);
     stackedWidget->addWidget(curveBox);
     stackedWidget->addWidget(straightBox);
     layout->addWidget(stackedWidget);
     layout->addStretch(1);
 
     connect(modeBox, SIGNAL(activated(int)), stackedWidget, SLOT(setCurrentIndex(int)));
     connect(modeBox, SIGNAL(activated(int)), this, SLOT(selectMode(int)));
     connect(optimizeRaw, SIGNAL(stateChanged(int)), this, SLOT(setOptimize(int)));
     connect(optimizeCurve, SIGNAL(stateChanged(int)), this, SLOT(setOptimize(int)));
     connect(fittingError, SIGNAL(valueChanged(double)), this, SLOT(setDelta(double)));
     connect(combineAngle, SIGNAL(valueChanged(double)), this, SLOT(setDelta(double)));
 
     modeBox->setCurrentIndex(m_mode);
     stackedWidget->setCurrentIndex(m_mode);
     optionWidget->setObjectName(i18n("Pencil"));
     optionWidget->setWindowTitle(i18n("Pencil"));
     widgets.append(optionWidget);
 
     m_strokeWidget = new KoStrokeConfigWidget(canvas(), 0);
     m_strokeWidget->setNoSelectionTrackingMode(true);
     m_strokeWidget->setWindowTitle(i18n("Line"));
     connect(m_strokeWidget, SIGNAL(sigStrokeChanged()), SLOT(slotUpdatePencilCursor()));
     if (isActivated()) {
         m_strokeWidget->activate();
     }
     widgets.append(m_strokeWidget);
     return widgets;
 }
 
 void KoPencilTool::addPathShape(KoPathShape* path, bool closePath)
 {
     KoShape * startShape = 0;
     KoShape * endShape = 0;
 
     if (closePath) {
         path->close();
         path->normalize();
     } else {
         path->normalize();
         if (connectPaths(path, m_existingStartPoint, m_existingEndPoint)) {
             if (m_existingStartPoint)
                 startShape = m_existingStartPoint->parent();
             if (m_existingEndPoint && m_existingEndPoint != m_existingStartPoint)
                 endShape = m_existingEndPoint->parent();
         }
     }
 
     KUndo2Command * cmd = canvas()->shapeController()->addShape(path, 0);
     if (cmd) {
         KoSelection *selection = canvas()->shapeManager()->selection();
         selection->deselectAll();
         selection->select(path);
 
         if (startShape)
             canvas()->shapeController()->removeShape(startShape, cmd);
         if (endShape && startShape != endShape)
             canvas()->shapeController()->removeShape(endShape, cmd);
 
         canvas()->addCommand(cmd);
     } else {
         canvas()->updateCanvas(path->boundingRect());
         delete path;
     }
 }
 
 void KoPencilTool::selectMode(int mode)
 {
     m_mode = static_cast<PencilMode>(mode);
 }
 
 void KoPencilTool::setOptimize(int state)
 {
     if (m_mode == ModeRaw)
         m_optimizeRaw = state == Qt::Checked ? true : false;
     else
         m_optimizeCurve = state == Qt::Checked ? true : false;
 }
 
 void KoPencilTool::setDelta(double delta)
 {
     if (m_mode == ModeCurve)
         m_fittingError = delta;
     else if (m_mode == ModeStraight)
         m_combineAngle = delta;
 }
 
 KoShapeStrokeSP KoPencilTool::createStroke()
 {
     KoShapeStrokeSP stroke;
     if (m_strokeWidget) {
         stroke = m_strokeWidget->createShapeStroke();
     }
     return stroke;
 }
 
 KoPathPoint* KoPencilTool::endPointAtPosition(const QPointF &position)
 {
     QRectF roi = handleGrabRect(position);
     QList<KoShape *> shapes = canvas()->shapeManager()->shapesAt(roi);
 
     KoPathPoint * nearestPoint = 0;
     qreal minDistance = HUGE_VAL;
     qreal maxDistance = canvas()->viewConverter()->viewToDocumentX(grabSensitivity());
 
     Q_FOREACH(KoShape * shape, shapes) {
         KoPathShape * path = dynamic_cast<KoPathShape*>(shape);
         if (!path)
             continue;
         KoParameterShape *paramShape = dynamic_cast<KoParameterShape*>(shape);
         if (paramShape && paramShape->isParametricShape())
             continue;
 
         KoPathPoint * p = 0;
         uint subpathCount = path->subpathCount();
         for (uint i = 0; i < subpathCount; ++i) {
             if (path->isClosedSubpath(i))
                 continue;
             p = path->pointByIndex(KoPathPointIndex(i, 0));
             // check start of subpath
             qreal d = squareDistance(position, path->shapeToDocument(p->point()));
             if (d < minDistance && d < maxDistance) {
                 nearestPoint = p;
                 minDistance = d;
             }
             // check end of subpath
             p = path->pointByIndex(KoPathPointIndex(i, path->subpathPointCount(i) - 1));
             d = squareDistance(position, path->shapeToDocument(p->point()));
             if (d < minDistance && d < maxDistance) {
                 nearestPoint = p;
                 minDistance = d;
             }
         }
     }
 
     return nearestPoint;
 }
 
 bool KoPencilTool::connectPaths(KoPathShape *pathShape, KoPathPoint *pointAtStart, KoPathPoint *pointAtEnd)
 {
     // at least one point must be valid
     if (!pointAtStart && !pointAtEnd)
         return false;
     // do not allow connecting to the same point twice
     if (pointAtStart == pointAtEnd)
         pointAtEnd = 0;
 
     // we have hit an existing path point on start/finish
     // what we now do is:
     // 1. combine the new created path with the ones we hit on start/finish
     // 2. merge the endpoints of the corresponding subpaths
 
     uint newPointCount = pathShape->subpathPointCount(0);
     KoPathPointIndex newStartPointIndex(0, 0);
     KoPathPointIndex newEndPointIndex(0, newPointCount - 1);
     KoPathPoint * newStartPoint = pathShape->pointByIndex(newStartPointIndex);
     KoPathPoint * newEndPoint = pathShape->pointByIndex(newEndPointIndex);
 
     KoPathShape * startShape = pointAtStart ? pointAtStart->parent() : 0;
     KoPathShape * endShape = pointAtEnd ? pointAtEnd->parent() : 0;
 
     // combine with the path we hit on start
     KoPathPointIndex startIndex(-1, -1);
     if (pointAtStart) {
         startIndex = startShape->pathPointIndex(pointAtStart);
         pathShape->combine(startShape);
         pathShape->moveSubpath(0, pathShape->subpathCount() - 1);
     }
     // combine with the path we hit on finish
     KoPathPointIndex endIndex(-1, -1);
     if (pointAtEnd) {
         endIndex = endShape->pathPointIndex(pointAtEnd);
         if (endShape != startShape) {
             endIndex.first += pathShape->subpathCount();
             pathShape->combine(endShape);
         }
     }
     // do we connect twice to a single subpath ?
     bool connectToSingleSubpath = (startShape == endShape && startIndex.first == endIndex.first);
 
     if (startIndex.second == 0 && !connectToSingleSubpath) {
         pathShape->reverseSubpath(startIndex.first);
         startIndex.second = pathShape->subpathPointCount(startIndex.first) - 1;
     }
     if (endIndex.second > 0 && !connectToSingleSubpath) {
         pathShape->reverseSubpath(endIndex.first);
         endIndex.second = 0;
     }
 
     // after combining we have a path where with the subpaths in the following
     // order:
     // 1. the subpaths of the pathshape we started the new path at
     // 2. the subpath we just created
     // 3. the subpaths of the pathshape we finished the new path at
 
     // get the path points we want to merge, as these are not going to
     // change while merging
     KoPathPoint * existingStartPoint = pathShape->pointByIndex(startIndex);
     KoPathPoint * existingEndPoint = pathShape->pointByIndex(endIndex);
 
     // merge first two points
     if (existingStartPoint) {
         KoPathPointData pd1(pathShape, pathShape->pathPointIndex(existingStartPoint));
         KoPathPointData pd2(pathShape, pathShape->pathPointIndex(newStartPoint));
         KoPathPointMergeCommand cmd1(pd1, pd2);
         cmd1.redo();
     }
     // merge last two points
     if (existingEndPoint) {
         KoPathPointData pd3(pathShape, pathShape->pathPointIndex(newEndPoint));
         KoPathPointData pd4(pathShape, pathShape->pathPointIndex(existingEndPoint));
         KoPathPointMergeCommand cmd2(pd3, pd4);
         cmd2.redo();
     }
 
     return true;
 }
 
 qreal KoPencilTool::getFittingError()
 {
     return this->m_fittingError;
 }
 
 void KoPencilTool::setFittingError(qreal fittingError)
 {
     this->m_fittingError = fittingError;
 }
diff --git a/libs/flake/CMakeLists.txt b/libs/flake/CMakeLists.txt
index 0547d07dc9..7511b52524 100644
--- a/libs/flake/CMakeLists.txt
+++ b/libs/flake/CMakeLists.txt
@@ -1,251 +1,251 @@
 project(kritaflake)
 
 include_directories(
     ${CMAKE_SOURCE_DIR}/libs/flake/commands
     ${CMAKE_SOURCE_DIR}/libs/flake/tools
     ${CMAKE_SOURCE_DIR}/libs/flake/svg
     ${CMAKE_SOURCE_DIR}/libs/flake/text
     ${CMAKE_BINARY_DIR}/libs/flake
 )
 
 add_subdirectory(styles)
 add_subdirectory(tests)
 
 set(kritaflake_SRCS
     KoGradientHelper.cpp
     KoFlake.cpp
     KoCanvasBase.cpp
     KoResourceManager_p.cpp
     KoDerivedResourceConverter.cpp
     KoResourceUpdateMediator.cpp
-    KoCanvasResourceManager.cpp
+    KoCanvasResourceProvider.cpp
     KoDocumentResourceManager.cpp
     KoCanvasObserverBase.cpp
     KoCanvasSupervisor.cpp
     KoDockFactoryBase.cpp
     KoDockRegistry.cpp
     KoDataCenterBase.cpp
     KoInsets.cpp
     KoPathShape.cpp
     KoPathPoint.cpp
     KoPathSegment.cpp
     KoSelection.cpp
     KoSelectedShapesProxy.cpp
     KoSelectedShapesProxySimple.cpp
     KoShape.cpp
     KoShapeAnchor.cpp
     KoShapeControllerBase.cpp
     KoShapeApplicationData.cpp
     KoShapeContainer.cpp
     KoShapeContainerModel.cpp
     KoShapeGroup.cpp
     KoShapeManager.cpp
     KoShapePaintingContext.cpp
     KoFrameShape.cpp
     KoMarker.cpp
     KoMarkerCollection.cpp
     KoToolBase.cpp
     KoCanvasController.cpp
     KoCanvasControllerWidget.cpp
     KoCanvasControllerWidgetViewport_p.cpp
     KoShapeRegistry.cpp
     KoDeferredShapeFactoryBase.cpp
     KoToolFactoryBase.cpp
     KoPathShapeFactory.cpp
     KoShapeFactoryBase.cpp
     KoShapeUserData.cpp
     KoParameterShape.cpp
     KoPointerEvent.cpp
     KoShapeController.cpp
     KoToolSelection.cpp
     KoShapeLayer.cpp
     KoPostscriptPaintDevice.cpp
     KoInputDevice.cpp
     KoToolManager_p.cpp
     KoToolManager.cpp
     KoToolRegistry.cpp
     KoToolProxy.cpp
     KoShapeSavingContext.cpp
     KoShapeLoadingContext.cpp
     KoLoadingShapeUpdater.cpp
     KoPathShapeLoader.cpp
     KoShapeStrokeModel.cpp
     KoShapeStroke.cpp
     KoShapeBackground.cpp
     KoColorBackground.cpp
     KoGradientBackground.cpp
     KoOdfGradientBackground.cpp
     KoHatchBackground.cpp
     KoPatternBackground.cpp
     KoVectorPatternBackground.cpp
     KoShapeFillWrapper.cpp
     KoShapeFillResourceConnector.cpp
     KoShapeConfigWidgetBase.cpp
     KoDrag.cpp
     KoSvgPaste.cpp
     KoDragOdfSaveHelper.cpp
     KoShapeOdfSaveHelper.cpp
     KoConnectionPoint.cpp
     KoConnectionShape.cpp
     KoConnectionShapeLoadingUpdater.cpp
     KoConnectionShapeFactory.cpp
     KoConnectionShapeConfigWidget.cpp
     KoSnapGuide.cpp
     KoSnapProxy.cpp
     KoSnapStrategy.cpp
     KoSnapData.cpp
     KoShapeShadow.cpp
     KoSharedLoadingData.cpp
     KoSharedSavingData.cpp
     KoViewConverter.cpp
     KoInputDeviceHandler.cpp
     KoInputDeviceHandlerEvent.cpp
     KoInputDeviceHandlerRegistry.cpp
     KoImageData.cpp
     KoImageData_p.cpp
     KoImageCollection.cpp
     KoOdfWorkaround.cpp
     KoFilterEffect.cpp
     KoFilterEffectStack.cpp
     KoFilterEffectFactoryBase.cpp
     KoFilterEffectRegistry.cpp
     KoFilterEffectConfigWidgetBase.cpp
     KoFilterEffectRenderContext.cpp
     KoFilterEffectLoadingContext.cpp
     KoTextShapeDataBase.cpp
     KoTosContainer.cpp
     KoTosContainerModel.cpp
     KoClipPath.cpp
     KoClipMask.cpp
     KoClipMaskPainter.cpp
     KoCurveFit.cpp
     KisGamutMaskViewConverter.cpp
 
     commands/KoShapeGroupCommand.cpp
     commands/KoShapeAlignCommand.cpp
     commands/KoShapeBackgroundCommand.cpp
     commands/KoShapeCreateCommand.cpp
     commands/KoShapeDeleteCommand.cpp
     commands/KoShapeDistributeCommand.cpp
     commands/KoShapeLockCommand.cpp
     commands/KoShapeMoveCommand.cpp
     commands/KoShapeResizeCommand.cpp
     commands/KoShapeShearCommand.cpp
     commands/KoShapeSizeCommand.cpp
     commands/KoShapeStrokeCommand.cpp
     commands/KoShapeUngroupCommand.cpp
     commands/KoShapeReorderCommand.cpp
     commands/KoShapeKeepAspectRatioCommand.cpp
     commands/KoPathBaseCommand.cpp
     commands/KoPathPointMoveCommand.cpp
     commands/KoPathControlPointMoveCommand.cpp
     commands/KoPathPointTypeCommand.cpp
     commands/KoPathPointRemoveCommand.cpp
     commands/KoPathPointInsertCommand.cpp
     commands/KoPathSegmentBreakCommand.cpp
     commands/KoPathBreakAtPointCommand.cpp
     commands/KoPathSegmentTypeCommand.cpp
     commands/KoPathCombineCommand.cpp
     commands/KoSubpathRemoveCommand.cpp
     commands/KoSubpathJoinCommand.cpp
     commands/KoParameterHandleMoveCommand.cpp
     commands/KoParameterToPathCommand.cpp
     commands/KoShapeTransformCommand.cpp
     commands/KoPathFillRuleCommand.cpp
     commands/KoConnectionShapeTypeCommand.cpp
     commands/KoShapeShadowCommand.cpp
     commands/KoPathReverseCommand.cpp
     commands/KoShapeRenameCommand.cpp
     commands/KoShapeRunAroundCommand.cpp
     commands/KoPathPointMergeCommand.cpp
     commands/KoShapeTransparencyCommand.cpp
     commands/KoShapeClipCommand.cpp
     commands/KoShapeUnclipCommand.cpp
     commands/KoPathShapeMarkerCommand.cpp
     commands/KoShapeConnectionChangeCommand.cpp
     commands/KoMultiPathPointMergeCommand.cpp
     commands/KoMultiPathPointJoinCommand.cpp
     commands/KoKeepShapesSelectedCommand.cpp
     commands/KoPathMergeUtils.cpp
 
     html/HtmlSavingContext.cpp
     html/HtmlWriter.cpp
 
     tools/KoCreateShapeStrategy.cpp
     tools/KoPathToolFactory.cpp
     tools/KoPathTool.cpp
     tools/KoPathToolSelection.cpp
     tools/KoPathToolHandle.cpp
     tools/PathToolOptionWidget.cpp
     tools/KoPathPointRubberSelectStrategy.cpp
     tools/KoPathPointMoveStrategy.cpp
     tools/KoPathConnectionPointStrategy.cpp
     tools/KoPathControlPointMoveStrategy.cpp
     tools/KoParameterChangeStrategy.cpp
     tools/KoZoomTool.cpp
     tools/KoZoomToolFactory.cpp
     tools/KoZoomToolWidget.cpp
     tools/KoZoomStrategy.cpp
     tools/KoInteractionTool.cpp
     tools/KoInteractionStrategy.cpp
     tools/KoInteractionStrategyFactory.cpp
     tools/KoCreateShapesTool.cpp
     tools/KoCreateShapesToolFactory.cpp
     tools/KoShapeRubberSelectStrategy.cpp
     tools/KoPathSegmentChangeStrategy.cpp
 
     svg/KoShapePainter.cpp
     svg/SvgUtil.cpp
     svg/SvgGraphicContext.cpp
     svg/SvgSavingContext.cpp
     svg/SvgWriter.cpp
     svg/SvgStyleWriter.cpp
     svg/SvgShape.cpp
     svg/SvgParser.cpp
     svg/SvgStyleParser.cpp
     svg/SvgGradientHelper.cpp
     svg/SvgFilterHelper.cpp
     svg/SvgCssHelper.cpp
     svg/SvgClipPathHelper.cpp
     svg/SvgLoadingContext.cpp
     svg/SvgShapeFactory.cpp
     svg/parsers/SvgTransformParser.cpp
 
     text/KoSvgText.cpp
     text/KoSvgTextProperties.cpp
     text/KoSvgTextChunkShape.cpp
     text/KoSvgTextShape.cpp
     text/KoSvgTextShapeMarkupConverter.cpp
 
     resources/KoSvgSymbolCollectionResource.cpp
     resources/KoGamutMask.cpp
 
     FlakeDebug.cpp
     tests/MockShapes.cpp
 )
 
 ki18n_wrap_ui(kritaflake_SRCS
     tools/PathToolOptionWidgetBase.ui
     KoConnectionShapeConfigWidget.ui
     tools/KoZoomToolWidget.ui
 )
 
 add_library(kritaflake SHARED ${kritaflake_SRCS})
 generate_export_header(kritaflake BASE_NAME kritaflake)
 
 target_include_directories(kritaflake
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/commands>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tools>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/svg>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/text>
 )
 
 target_link_libraries(kritaflake kritapigment kritawidgetutils kritaodf kritacommand KF5::WidgetsAddons Qt5::Svg)
 
 set_target_properties(kritaflake PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 
 install(TARGETS kritaflake  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
diff --git a/libs/flake/KoCanvasBase.cpp b/libs/flake/KoCanvasBase.cpp
index 051031f8bf..939fa8dc4d 100644
--- a/libs/flake/KoCanvasBase.cpp
+++ b/libs/flake/KoCanvasBase.cpp
@@ -1,131 +1,131 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006 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 <QRectF>
 #include <QPointer>
 #include <QDebug>
 
 #include "KoCanvasBase.h"
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 #include "KoShapeController.h"
 #include "KoCanvasController.h"
 #include "KoViewConverter.h"
 #include "KoSnapGuide.h"
 #include "KoShapeManager.h"
 #include "KoToolProxy.h"
 #include "KoSelection.h"
 #include "KoSelectedShapesProxy.h"
 
 class Q_DECL_HIDDEN KoCanvasBase::Private
 {
 public:
     Private()
         : shapeController(0),
         resourceManager(0),
         isResourceManagerShared(false),
         controller(0),
         snapGuide(0)
     {
     }
 
     ~Private() {
         delete shapeController;
         if (!isResourceManagerShared) {
             delete resourceManager;
         }
         delete snapGuide;
     }
     QPointer<KoShapeController> shapeController;
-    QPointer<KoCanvasResourceManager> resourceManager;
+    QPointer<KoCanvasResourceProvider> resourceManager;
     bool isResourceManagerShared;
     KoCanvasController *controller;
     KoSnapGuide *snapGuide;
 };
 
-KoCanvasBase::KoCanvasBase(KoShapeControllerBase *shapeController, KoCanvasResourceManager *sharedResourceManager)
+KoCanvasBase::KoCanvasBase(KoShapeControllerBase *shapeController, KoCanvasResourceProvider *sharedResourceManager)
         : d(new Private())
 {
     d->resourceManager = sharedResourceManager ?
-        sharedResourceManager : new KoCanvasResourceManager();
+        sharedResourceManager : new KoCanvasResourceProvider();
     d->isResourceManagerShared = sharedResourceManager;
 
     d->shapeController = new KoShapeController(this, shapeController);
     d->snapGuide = new KoSnapGuide(this);
 }
 
 KoCanvasBase::~KoCanvasBase()
 {
     d->shapeController->reset();
     delete d;
 }
 
 QPointF KoCanvasBase::viewToDocument(const QPointF &viewPoint) const
 {
     return viewConverter()->viewToDocument(viewPoint - documentOrigin());
 }
 
 KoShapeController *KoCanvasBase::shapeController() const
 {
     if (d->shapeController)
         return d->shapeController;
     else
         return 0;
 }
 
 void KoCanvasBase::disconnectCanvasObserver(QObject *object)
 {
     if (shapeManager()) shapeManager()->selection()->disconnect(object);
     if (resourceManager()) resourceManager()->disconnect(object);
     if (shapeManager()) shapeManager()->disconnect(object);
     if (toolProxy()) toolProxy()->disconnect(object);
     if (selectedShapesProxy()) selectedShapesProxy()->disconnect(object);
 }
 
 
-KoCanvasResourceManager *KoCanvasBase::resourceManager() const
+KoCanvasResourceProvider *KoCanvasBase::resourceManager() const
 {
     return d->resourceManager;
 }
 
 void KoCanvasBase::ensureVisible(const QRectF &rect)
 {
     if (d->controller && d->controller->canvas())
         d->controller->ensureVisible(
                 d->controller->canvas()->viewConverter()->documentToView(rect));
 }
 
 void KoCanvasBase::setCanvasController(KoCanvasController *controller)
 {
     d->controller = controller;
 }
 
 KoCanvasController *KoCanvasBase::canvasController() const
 {
     return d->controller;
 }
 
 void KoCanvasBase::clipToDocument(const KoShape *, QPointF &) const
 {
 }
 
 KoSnapGuide * KoCanvasBase::snapGuide() const
 {
     return d->snapGuide;
 }
diff --git a/libs/flake/KoCanvasBase.h b/libs/flake/KoCanvasBase.h
index 140095eee4..2650f5c7f5 100644
--- a/libs/flake/KoCanvasBase.h
+++ b/libs/flake/KoCanvasBase.h
@@ -1,254 +1,254 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
    Copyright (C) 2006, 2010 Thomas Zander <zander@kde.org>
    Copyright (C) 2006 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.
 */
 
 #ifndef KOCANVASBASE_H
 #define KOCANVASBASE_H
 
 #include <QPoint>
 
 #include "kritaflake_export.h"
 
 class KUndo2Command;
 
 class KoUnit;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 class KoShapeManager;
 class KoToolProxy;
 class KoViewConverter;
 class KoShapeController;
 class KoShapeControllerBase;
 class KoCanvasController;
 class KoShape;
 class KoSnapGuide;
 class KoSelectedShapesProxy;
 
 class QWidget;
 class QCursor;
 class QPointF;
 class QRectF;
 class QSizeF;
 
 #include <QObject>
 
 /**
  * KoCanvasBase is the interface actual application canvas classes
  * should implement. Flake tools know about the canvas, so they can
  * do things like scroll, redraw, set a cursor etc.
  */
 class KRITAFLAKE_EXPORT KoCanvasBase : public QObject
 {
     Q_OBJECT
 public:
 
     /**
      * The constructor.
      * @param shapeController the implementation of the shapeController that the
      *   application provides to allow shapes to be added in multiple views.
      */
-    explicit KoCanvasBase(KoShapeControllerBase *shapeController, KoCanvasResourceManager *sharedResourceManager = 0);
+    explicit KoCanvasBase(KoShapeControllerBase *shapeController, KoCanvasResourceProvider *sharedResourceManager = 0);
     ~KoCanvasBase() override;
 
 public:
 
     /**
      * @return true if opengl can be used directly on the canvas
      */
     virtual bool canvasIsOpenGL() const { return false; }
 
     /**
      * retrieve the grid size setting.
      * The grid spacing will be provided in pt.
      * @param horizontal a pointer to a qreal that will be filled with the horizontal grid-spacing
      * @param vertical a pointer to a qreal that will be filled with the vertical grid-spacing
      */
     virtual void gridSize(QPointF *offset, QSizeF *spacing) const = 0;
 
     /**
      * return if snap to grid is enabled.
      * @return if snap to grid is enabled.
      */
     virtual bool snapToGrid() const = 0;
 
 
     /**
      * set the specified cursor on this canvas
      *
      * @param cursor the new cursor
      * @return the old cursor
      */
     virtual void setCursor(const QCursor &cursor) = 0;
 
     /**
      * Adds a command to the history. Call this for each @p command you create.
      * This will also execute the command.
      * This means, most of the application's code will look like
      *    MyCommand * cmd = new MyCommand( parameters );
      *    canvas.addCommand( cmd );
      *
      * Note that the command history takes ownership of the command, it will delete
      * it when the undo limit is reached, or when deleting the command history itself.
      * @param command the command to add
      */
     virtual void addCommand(KUndo2Command *command) = 0;
 
     /**
      * Return the current shapeManager. WARNING: the shape manager can switch
      * in time, e.g. when a layer is changed. Please don't keep any persistent
      * connections to it. Instead please use selectedShapesProxy(),
      * which is guaranteed to be the same throughout the life of the canvas.
      *
      * @return the current shapeManager
      */
     virtual KoShapeManager *shapeManager() const = 0;
 
     /**
      * @brief selectedShapesProxy() is a special interface for keeping a persistent connections
      * to selectionChanged() and selectionContentChanged() signals. While shapeManager() can change
      * throughout the life time of the cavas, selectedShapesProxy() is guaranteed to stay the same.
      * @return persistent KoSelectedShapesProxy object
      */
     virtual KoSelectedShapesProxy *selectedShapesProxy() const = 0;
 
     /**
      * Tell the canvas to repaint the specified rectangle. The coordinates
      * are document coordinates, not view coordinates.
      */
     virtual void updateCanvas(const QRectF &rc) = 0;
 
     /**
      * Return the proxy to the active tool (determining which tool
      * is really, really active is hard when tablets are involved,
      * so leave that to others.
      */
     virtual KoToolProxy *toolProxy() const = 0;
 
     /**
      * Return the viewConverter for this view.
      * @return the viewConverter for this view.
      */
     virtual KoViewConverter *viewConverter() const = 0;
 
     /**
      * Convert a coordinate in pixels to pt.
      * @param viewPoint the point in the coordinate system of the widget, or window.
      */
     virtual QPointF viewToDocument(const QPointF &viewPoint) const;
 
     /**
      * Return the widget that will be added to the scrollArea.
      */
     virtual QWidget *canvasWidget() = 0;
 
     /**
      * Return the widget that will be added to the scrollArea.
      */
     virtual const QWidget *canvasWidget() const = 0;
 
     /**
      * Return the unit of the current document for initialization of the widgets created
      * by the flake framework.
      * @see KoDocument::unit()
      */
     virtual KoUnit unit() const = 0;
 
     /**
      * Called when the user tries to move the argument shape to allow the application to limit the
      * users movement to stay within the document bounds.
      * An implementation can alter the parameter move to make sure that if the distance moved
      * is applied to the shape it will not become unreachable for the user.
      * The default implementation does not restrict movement.
      * @param shape the shape that will be moved soon.
      * @param move the distance the caller intends to move the shape.
      */
     virtual void clipToDocument(const KoShape *shape, QPointF &move) const;
 
     /**
      * Return the position of the document origin inside the canvas widget, in pixels.
      * By default the origin of the canvas widget and the position of the
      * document origin are coincident, thus an empty point is returned.
      */
     virtual QPoint documentOrigin() const {
         return QPoint(0, 0);
     }
 
     /**
      * This method should somehow call QWidget::updateMicroFocus() on the canvas widget.
      */
     virtual void updateInputMethodInfo() = 0;
 
     /**
      * disconnect the given QObject completely and utterly from any and all
      * connections it has to any QObject owned by the canvas. Do this in
      * the setCanvas of every KoCanvasObserver.
      */
     virtual void disconnectCanvasObserver(QObject *object);
 
     /**
      * Return a pointer to the resource manager associated with this
      * canvas. The resource manager contains per-canvas settings such
      * as current foreground and background color.
      * If instead of per-canvas resources you need per-document resources
      * you can by going via the shapeController instead;
      * @code
      *   canvasBase->shapeController()->resourceManager();
      * @endcode
      * @see KoShapeController::resourceManager()
      */
-    KoCanvasResourceManager *resourceManager() const;
+    KoCanvasResourceProvider *resourceManager() const;
 
     /**
      * Return the shape controller for this canvas.
      * A shape controller is used to create or delete shapes and show the relevant dialogs to the user.
      */
     KoShapeController *shapeController() const;
 
     /**
      * Return the canvas controller for this canvas.
      */
     KoCanvasController *canvasController() const;
 
     /**
      * @brief Scrolls the content of the canvas so that the given rect is visible.
      *
      * The rect is to be specified in document coordinates.
      *
      * @param rect the rectangle to make visible
      */
     virtual void ensureVisible(const QRectF &rect);
 
     /**
      * Returns the snap guide of the canvas
      */
     KoSnapGuide *snapGuide() const;
 
     /// called by KoCanvasController to set the controller that handles this canvas.
     void setCanvasController(KoCanvasController *controller);
 
 private:
     // we need a KoShapeControllerBase so that it can work
     KoCanvasBase();
 
     class Private;
     Private * const d;
 };
 
 #endif // KOCANVASBASE_H
diff --git a/libs/flake/KoCanvasResourceManager.cpp b/libs/flake/KoCanvasResourceProvider.cpp
similarity index 59%
rename from libs/flake/KoCanvasResourceManager.cpp
rename to libs/flake/KoCanvasResourceProvider.cpp
index 3ae7cfcb44..a22efe99a6 100644
--- a/libs/flake/KoCanvasResourceManager.cpp
+++ b/libs/flake/KoCanvasResourceProvider.cpp
@@ -1,180 +1,180 @@
 /*
    Copyright (c) 2006 Boudewijn Rempt (boud@valdyas.org)
    Copyright (C) 2007, 2010 Thomas Zander <zander@kde.org>
    Copyright (c) 2008 Carlos Licea <carlos.licea@kdemail.net>
    Copyright (c) 2011 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 "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 
 #include <QVariant>
 #include <FlakeDebug.h>
 
 #include "KoShape.h"
 #include "KoShapeStroke.h"
 #include "KoResourceManager_p.h"
 #include <KoColorSpaceRegistry.h>
 
-class Q_DECL_HIDDEN KoCanvasResourceManager::Private
+class Q_DECL_HIDDEN KoCanvasResourceProvider::Private
 {
 public:
     KoResourceManager manager;
 };
 
-KoCanvasResourceManager::KoCanvasResourceManager(QObject *parent)
+KoCanvasResourceProvider::KoCanvasResourceProvider(QObject *parent)
     : QObject(parent)
     , d(new Private())
 {
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     setForegroundColor(KoColor(Qt::black, cs));
     setBackgroundColor(KoColor(Qt::white, cs));
     setResource(ApplicationSpeciality, NoSpecial);
 
     connect(&d->manager, &KoResourceManager::resourceChanged,
-            this, &KoCanvasResourceManager::canvasResourceChanged);
+            this, &KoCanvasResourceProvider::canvasResourceChanged);
 }
 
-KoCanvasResourceManager::~KoCanvasResourceManager()
+KoCanvasResourceProvider::~KoCanvasResourceProvider()
 {
     delete d;
 }
 
-void KoCanvasResourceManager::setResource(int key, const QVariant &value)
+void KoCanvasResourceProvider::setResource(int key, const QVariant &value)
 {
     d->manager.setResource(key, value);
 }
 
-QVariant KoCanvasResourceManager::resource(int key) const
+QVariant KoCanvasResourceProvider::resource(int key) const
 {
     return d->manager.resource(key);
 }
 
-void KoCanvasResourceManager::setResource(int key, const KoColor &color)
+void KoCanvasResourceProvider::setResource(int key, const KoColor &color)
 {
     QVariant v;
     v.setValue(color);
     setResource(key, v);
 }
 
-void KoCanvasResourceManager::setResource(int key, KoShape *shape)
+void KoCanvasResourceProvider::setResource(int key, KoShape *shape)
 {
     QVariant v;
     v.setValue(shape);
     setResource(key, v);
 }
 
-void KoCanvasResourceManager::setResource(int key, const KoUnit &unit)
+void KoCanvasResourceProvider::setResource(int key, const KoUnit &unit)
 {
     QVariant v;
     v.setValue(unit);
     setResource(key, v);
 }
 
-KoColor KoCanvasResourceManager::koColorResource(int key) const
+KoColor KoCanvasResourceProvider::koColorResource(int key) const
 {
     return d->manager.koColorResource(key);
 }
 
-void KoCanvasResourceManager::setForegroundColor(const KoColor &color)
+void KoCanvasResourceProvider::setForegroundColor(const KoColor &color)
 {
     setResource(ForegroundColor, color);
 }
 
-KoColor KoCanvasResourceManager::foregroundColor() const
+KoColor KoCanvasResourceProvider::foregroundColor() const
 {
     return koColorResource(ForegroundColor);
 }
 
-void KoCanvasResourceManager::setBackgroundColor(const KoColor &color)
+void KoCanvasResourceProvider::setBackgroundColor(const KoColor &color)
 {
     setResource(BackgroundColor, color);
 }
 
-KoColor KoCanvasResourceManager::backgroundColor() const
+KoColor KoCanvasResourceProvider::backgroundColor() const
 {
     return koColorResource(BackgroundColor);
 }
 
-KoShape *KoCanvasResourceManager::koShapeResource(int key) const
+KoShape *KoCanvasResourceProvider::koShapeResource(int key) const
 {
     return d->manager.koShapeResource(key);
 }
 
-KoUnit KoCanvasResourceManager::unitResource(int key) const
+KoUnit KoCanvasResourceProvider::unitResource(int key) const
 {
     return resource(key).value<KoUnit>();
 }
 
-bool KoCanvasResourceManager::boolResource(int key) const
+bool KoCanvasResourceProvider::boolResource(int key) const
 {
     return d->manager.boolResource(key);
 }
 
-int KoCanvasResourceManager::intResource(int key) const
+int KoCanvasResourceProvider::intResource(int key) const
 {
     return d->manager.intResource(key);
 }
 
-QString KoCanvasResourceManager::stringResource(int key) const
+QString KoCanvasResourceProvider::stringResource(int key) const
 {
     return d->manager.stringResource(key);
 }
 
-QSizeF KoCanvasResourceManager::sizeResource(int key) const
+QSizeF KoCanvasResourceProvider::sizeResource(int key) const
 {
     return d->manager.sizeResource(key);
 }
 
-bool KoCanvasResourceManager::hasResource(int key) const
+bool KoCanvasResourceProvider::hasResource(int key) const
 {
     return d->manager.hasResource(key);
 }
 
-void KoCanvasResourceManager::clearResource(int key)
+void KoCanvasResourceProvider::clearResource(int key)
 {
     d->manager.clearResource(key);
 }
 
-void KoCanvasResourceManager::addDerivedResourceConverter(KoDerivedResourceConverterSP converter)
+void KoCanvasResourceProvider::addDerivedResourceConverter(KoDerivedResourceConverterSP converter)
 {
     d->manager.addDerivedResourceConverter(converter);
 }
 
-bool KoCanvasResourceManager::hasDerivedResourceConverter(int key)
+bool KoCanvasResourceProvider::hasDerivedResourceConverter(int key)
 {
     return d->manager.hasDerivedResourceConverter(key);
 }
 
-void KoCanvasResourceManager::removeDerivedResourceConverter(int key)
+void KoCanvasResourceProvider::removeDerivedResourceConverter(int key)
 {
     d->manager.removeDerivedResourceConverter(key);
 }
 
-void KoCanvasResourceManager::addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator)
+void KoCanvasResourceProvider::addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator)
 {
     d->manager.addResourceUpdateMediator(mediator);
 }
 
-bool KoCanvasResourceManager::hasResourceUpdateMediator(int key)
+bool KoCanvasResourceProvider::hasResourceUpdateMediator(int key)
 {
     return d->manager.hasResourceUpdateMediator(key);
 }
 
-void KoCanvasResourceManager::removeResourceUpdateMediator(int key)
+void KoCanvasResourceProvider::removeResourceUpdateMediator(int key)
 {
     d->manager.removeResourceUpdateMediator(key);
 }
diff --git a/libs/flake/KoCanvasResourceManager.h b/libs/flake/KoCanvasResourceProvider.h
similarity index 88%
rename from libs/flake/KoCanvasResourceManager.h
rename to libs/flake/KoCanvasResourceProvider.h
index f22ad32dd5..98b968d68c 100644
--- a/libs/flake/KoCanvasResourceManager.h
+++ b/libs/flake/KoCanvasResourceProvider.h
@@ -1,281 +1,281 @@
 /*
    Copyright (c) 2006, 2011 Boudewijn Rempt (boud@valdyas.org)
    Copyright (C) 2007, 2009, 2010 Thomas Zander <zander@kde.org>
    Copyright (c) 2008 Carlos Licea <carlos.licea@kdemail.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.
  */
 #ifndef KO_CANVASRESOURCEMANAGER_H
 #define KO_CANVASRESOURCEMANAGER_H
 
 #include <QObject>
 
 #include "kritaflake_export.h"
 #include "KoDerivedResourceConverter.h"
 #include "KoResourceUpdateMediator.h"
 
 class KoShape;
 class KoShapeStroke;
 class KoColor;
 class KoUnit;
 
 class QVariant;
 class QSizeF;
 
 /**
- * The KoCanvasResourceManager contains a set of per-canvas
+ * The KoCanvasResourceProvider contains a set of per-canvas
  * properties, like current foreground color, current background
  * color and more. All tools belonging to the current canvas are
  * notified when a Resource changes (is set).
  *
  * The manager can contain all sorts of variable types and there are accessors
  * for the most common ones.  All variables are always stored inside a QVariant
  * instance internally and you can always just use the resource() method to get
  * that directly.
  * The way to store arbitairy data objects that are stored as pointers you can use
  * the following code snippets;
  * @code
  *  QVariant variant;
  *  variant.setValue<void*>(textShapeData->document());
  *  resourceManager->setResource(KoText::CurrentTextDocument, variant);
  *  // and get it out again.
  *  QVariant var = resourceManager->resource(KoText::CurrentTextDocument);
  *  document = static_cast<QTextDocument*>(var.value<void*>());
  * @endcode
  */
-class KRITAFLAKE_EXPORT KoCanvasResourceManager : public QObject
+class KRITAFLAKE_EXPORT KoCanvasResourceProvider : public QObject
 {
     Q_OBJECT
 
 public:
 
     /**
      * This enum holds identifiers to the resources that can be stored in here.
      */
     enum CanvasResource {
         ForegroundColor,    ///< The active foreground color selected for this canvas.
         BackgroundColor,    ///< The active background color selected for this canvas.
         PageSize,           ///< The size of the (current) page in postscript points.
         Unit,               ///< The unit of this canvas
         CurrentPage,        ///< The current page number
         ActiveStyleType,    ///< the actual active style type see KoFlake::StyleType for valid values
         ActiveRange,        ///< The area where the rulers should show white
         ShowTextShapeOutlines,     ///< Paint of text shape outlines ?
         ShowFormattingCharacters,  ///< Paint of formatting characters ?
         ShowTableBorders,  ///< Paint of table borders (when not really there) ?
         ShowSectionBounds, ///< Paint of sections bounds ?
         ShowInlineObjectVisualization, ///< paint a different  background for inline objects
         ApplicationSpeciality, ///< Special features and limitations of the application
         KarbonStart = 1000,      ///< Base number for Karbon specific values.
         KexiStart = 2000,        ///< Base number for Kexi specific values.
         FlowStart = 3000,        ///< Base number for Flow specific values.
         PlanStart = 4000,        ///< Base number for Plan specific values.
         StageStart = 5000,       ///< Base number for Stage specific values.
         KritaStart = 6000,       ///< Base number for Krita specific values.
         SheetsStart = 7000,      ///< Base number for Sheets specific values.
         WordsStart = 8000,       ///< Base number for Words specific values.
         KoPageAppStart = 9000    ///< Base number for KoPageApp specific values.
     };
 
     enum ApplicationSpecial {
         NoSpecial = 0,
         NoAdvancedText = 1
     };
 
     /**
      * Constructor.
      * @param parent the parent QObject, used for memory management.
      */
-    explicit KoCanvasResourceManager(QObject *parent = 0);
-    ~KoCanvasResourceManager() override;
+    explicit KoCanvasResourceProvider(QObject *parent = 0);
+    ~KoCanvasResourceProvider() override;
 
 public Q_SLOTS:
     /**
      * Set a resource of any type.
      * @param key the integer key
      * @param value the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     void setResource(int key, const QVariant &value);
 
     /**
      * Set a resource of type KoColor.
      * @param key the integer key
      * @param color the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     void setResource(int key, const KoColor &color);
 
     /**
      * Set a resource of type KoShape*.
      * @param key the integer key
      * @param id the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     void setResource(int key, KoShape *shape);
 
     /**
      * Set a resource of type KoUnit
      * @param key the integer key
      * @param id the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     void setResource(int key, const KoUnit &unit);
 
 public:
     /**
      * Returns a qvariant containing the specified resource or a standard one if the
      * specified resource does not exist.
      * @param key the key
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     QVariant resource(int key) const;
 
     /**
      * Set the foregroundColor resource.
      * @param color the new foreground color
      */
     void setForegroundColor(const KoColor &color);
 
     /**
      * Return the foregroundColor
      */
     KoColor foregroundColor() const;
 
     /**
      * Set the backgroundColor resource.
      * @param color the new background color
      */
     void setBackgroundColor(const KoColor &color);
     /**
      * Return the backgroundColor
      */
     KoColor backgroundColor() const;
 
     /**
      * Return the resource determined by param key as a boolean.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     bool boolResource(int key) const;
 
     /**
      * Return the resource determined by param key as an integer.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     int intResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoColor.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     KoColor koColorResource(int key) const;
 
     /**
      * Return the resource determined by param key as a pointer to a KoShape.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     KoShape *koShapeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QString .
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     QString stringResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QSizeF.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     QSizeF sizeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoUnit.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     KoUnit unitResource(int key) const;
 
     /**
      * Returns true if there is a resource set with the requested key.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     bool hasResource(int key) const;
 
     /**
      * Remove the resource with @p key from the provider.
      * @param key the key that will be used to remove the resource
      * There will be a signal emitted with a variable that will return true on QVariable::isNull();
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     void clearResource(int key);
 
     /**
      * @see KoReosurceManager::addDerivedResourceConverter()
      */
     void addDerivedResourceConverter(KoDerivedResourceConverterSP converter);
 
     /**
      * @see KoReosurceManager::hasDerivedResourceConverter()
      */
     bool hasDerivedResourceConverter(int key);
 
     /**
      * @see KoReosurceManager::removeDerivedResourceConverter()
      */
     void removeDerivedResourceConverter(int key);
 
     /**
      * @see KoReosurceManager::addResourceUpdateMediator
      */
     void addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator);
 
     /**
      * @see KoReosurceManager::hasResourceUpdateMediator
      */
     bool hasResourceUpdateMediator(int key);
 
     /**
 
      * @see KoReosurceManager::removeResourceUpdateMediator
      */
     void removeResourceUpdateMediator(int key);
 
 Q_SIGNALS:
     /**
      * This signal is emitted every time a resource is set that is either
      * new or different from the previous set value.
      * @param key the identifying key for the resource
      * @param value the variants new value.
-     * @see KoCanvasResourceManager::CanvasResource
+     * @see KoCanvasResourceProvider::CanvasResource
      */
     void canvasResourceChanged(int key, const QVariant &value);
 
 private:
-    KoCanvasResourceManager(const KoCanvasResourceManager&);
-    KoCanvasResourceManager& operator=(const KoCanvasResourceManager&);
+    KoCanvasResourceProvider(const KoCanvasResourceProvider&);
+    KoCanvasResourceProvider& operator=(const KoCanvasResourceProvider&);
 
     class Private;
     Private *const d;
 };
 
 #endif
diff --git a/libs/flake/KoResourceManager_p.h b/libs/flake/KoResourceManager_p.h
index 0565606bce..af17591a57 100644
--- a/libs/flake/KoResourceManager_p.h
+++ b/libs/flake/KoResourceManager_p.h
@@ -1,220 +1,220 @@
 /*
    Copyright (c) 2006, 2011 Boudewijn Rempt (boud@valdyas.org)
    Copyright (C) 2007, 2009, 2010 Thomas Zander <zander@kde.org>
    Copyright (c) 2008 Carlos Licea <carlos.licea@kdemail.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.
  */
 #ifndef KO_RESOURCEMANAGER_P_H
 #define KO_RESOURCEMANAGER_P_H
 
 #include <QObject>
 #include <QSizeF>
 #include <QHash>
 
 #include "kritaflake_export.h"
 #include <KoColor.h>
 #include <KoUnit.h>
 #include "KoDerivedResourceConverter.h"
 #include "KoResourceUpdateMediator.h"
 
 
 class KoShape;
 class QVariant;
 
 class KRITAFLAKE_EXPORT KoResourceManager : public QObject
 {
     Q_OBJECT
 public:
 
     KoResourceManager() {}
 
     /**
      * Set a resource of any type.
      * @param key the integer key
      * @param value the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, const QVariant &value);
 
     /**
      * Set a resource of type KoColor.
      * @param key the integer key
      * @param color the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, const KoColor &color);
 
     /**
      * Set a resource of type KoShape*.
      * @param key the integer key
      * @param id the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, KoShape *shape);
 
     /**
      * Set a resource of type KoUnit
      * @param key the integer key
      * @param id the new value for the key.
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, const KoUnit &unit);
 
     /**
      * Returns a qvariant containing the specified resource or a standard one if the
      * specified resource does not exist.
      * @param key the key
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     QVariant resource(int key) const;
 
     /**
      * Return the resource determined by param key as a boolean.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     bool boolResource(int key) const;
 
     /**
      * Return the resource determined by param key as an integer.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     int intResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoColor.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     KoColor koColorResource(int key) const;
 
     /**
      * Return the resource determined by param key as a pointer to a KoShape.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     KoShape *koShapeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QString .
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     QString stringResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QSizeF.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     QSizeF sizeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoUnit.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     KoUnit unitResource(int key) const;
 
     /**
      * Returns true if there is a resource set with the requested key.
      * @param key the identifying key for the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     bool hasResource(int key) const;
 
     /**
      * Remove the resource with @p key from the provider.
      * @param key the key that will be used to remove the resource
-     * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
+     * @see KoCanvasResourceProvider::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void clearResource(int key);
 
     /**
      * Some of the resources may be "derived" from the others. For
      * example opacity, composite op and erase mode properties are
      * contained inside a paintop preset, so we need not create a
      * separate resource for them. Instead we created a derived resource,
      * that loads/saves values from/to another resource, but has its own
      * "resource changed" signal (via a different key).
      *
      * When a parent resource changes, the resource manager emits
      * update signals for all its derived resources.
      */
     void addDerivedResourceConverter(KoDerivedResourceConverterSP converter);
 
     /**
      * @return true if the resource with \p key is a derived resource
      *         (has a converter installed)
      *
      * @see addDerivedResourceConverter()
      */
     bool hasDerivedResourceConverter(int key);
 
     /**
      * Removes a derived resource converter. If you rty to add a
      * resource with \p key it will be treated as a usual resource.
      *
      * @see addDerivedResourceConverter()
      */
     void removeDerivedResourceConverter(int key);
 
     /**
      * Some resources can "mutate", that is their value doesn't change
      * (a pointer), whereas the contents changes. But we should still
      * notify all the derived resources subscribers that the resource
      * has changed. For that purpose we use a special mediator class
      * that connects the resource (which is not a QObject at all) and
      * the resource manager controls that connection.
      */
     void addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator);
 
     /**
      * \see addResourceUpdateMediator()
      */
     bool hasResourceUpdateMediator(int key);
 
     /**
      * \see addResourceUpdateMediator()
      */
     void removeResourceUpdateMediator(int key);
 
 Q_SIGNALS:
     void resourceChanged(int key, const QVariant &value);
 
 private:
     void notifyResourceChanged(int key, const QVariant &value);
     void notifyDerivedResourcesChanged(int key, const QVariant &value);
 
 private Q_SLOTS:
     void slotResourceInternalsChanged(int key);
 
 private:
     KoResourceManager(const KoResourceManager&);
     KoResourceManager& operator=(const KoResourceManager&);
 
     QHash<int, QVariant> m_resources;
 
     QHash<int, KoDerivedResourceConverterSP> m_derivedResources;
     QMultiHash<int, KoDerivedResourceConverterSP> m_derivedFromSource;
 
     QHash<int, KoResourceUpdateMediatorSP> m_updateMediators;
 };
 
 #endif
 
diff --git a/libs/flake/KoShapeConfigWidgetBase.cpp b/libs/flake/KoShapeConfigWidgetBase.cpp
index 7ae8f69a3f..78eaefbe88 100644
--- a/libs/flake/KoShapeConfigWidgetBase.cpp
+++ b/libs/flake/KoShapeConfigWidgetBase.cpp
@@ -1,53 +1,53 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 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 "KoShapeConfigWidgetBase.h"
 
 KoShapeConfigWidgetBase::KoShapeConfigWidgetBase()
         : m_resourceManager(0)
 {
 }
 
 KoShapeConfigWidgetBase::~KoShapeConfigWidgetBase()
 {
 }
 
 void KoShapeConfigWidgetBase::setUnit(const KoUnit &)
 {
 }
 
-void KoShapeConfigWidgetBase::setResourceManager(KoCanvasResourceManager *rm)
+void KoShapeConfigWidgetBase::setResourceManager(KoCanvasResourceProvider *rm)
 {
     m_resourceManager = rm;
 }
 
 bool KoShapeConfigWidgetBase::showOnShapeCreate()
 {
     return false;
 }
 
 bool KoShapeConfigWidgetBase::showOnShapeSelect()
 {
     return true;
 }
 
 KUndo2Command * KoShapeConfigWidgetBase::createCommand()
 {
     return 0;
 }
diff --git a/libs/flake/KoShapeConfigWidgetBase.h b/libs/flake/KoShapeConfigWidgetBase.h
index 06e193566a..79c79f7214 100644
--- a/libs/flake/KoShapeConfigWidgetBase.h
+++ b/libs/flake/KoShapeConfigWidgetBase.h
@@ -1,99 +1,99 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006-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.
  */
 
 #ifndef KOSHAPECONFIGWIDGETBASE_H
 #define KOSHAPECONFIGWIDGETBASE_H
 
 #include <QWidget>
 
 #include "kritaflake_export.h"
 
 class KoShape;
 class KUndo2Command;
 class KoUnit;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 /**
  * Base widget for shape-configuration panels.
  * This is an interface type class used by classes that intend to provide
  * a GUI for configuring newly created shapes as created by a KoShapeFactoryBase.
  *
  * Every time after a shape is created the KoShapeFactoryBase for that shape-type
  * will be queried for all the config widgets; both factory specific as well as
  * those set by the hosting application.
  * A dialog will be shown with all those panels, each extending this class.
  * The framework will then call open() to populate the widget with data from
  * the param shape.  After the user ok-ed the dialog the save() will be called
  * to allow the widget to apply all settings from the widget to the shape.
  */
 class KRITAFLAKE_EXPORT KoShapeConfigWidgetBase : public QWidget
 {
     Q_OBJECT
 public:
     /**
      * Default constructor
      */
     KoShapeConfigWidgetBase();
     ~KoShapeConfigWidgetBase() override;
 
     /**
      * Open the argument shape by interpreting the data and setting that data on this
      * widget.
      * @param shape the shape that is to be queried for the data this widget can edit.
      */
     virtual void open(KoShape *shape) = 0;
     /**
      * Save the data  of this widget to the shape passed to open earlier to
      * apply any user changed options.
      * Called by the tool that created the shape.
      */
     virtual void save() = 0;
 
     /**
      * Overwrite this method to set the application unit type and update all unit-widgets
      * in this panel.
      * Called by the tool that created the shape using KoCavasBase::unit()
      * @param unit the new unit to show data in.
      */
     virtual void setUnit(const KoUnit &unit);
 
     /// called to set the canvas resource manager of the canvas the user used to insert the new shape.
-    void setResourceManager(KoCanvasResourceManager *rm);
+    void setResourceManager(KoCanvasResourceProvider *rm);
 
     /// Return true if the shape config panel should be shown after the shape is created
     virtual bool showOnShapeCreate();
 
     /// Return true if the shape config panel should be shown when the shape is selected
     virtual bool showOnShapeSelect();
 
     /// Creates a command which applies all changes to the opened shape
     virtual KUndo2Command * createCommand();
 
 Q_SIGNALS:
     /// is emitted after one of the config options has changed
     void propertyChanged();
 
     /// is emitted when the dialog should be accepted ie a file double clicked in a filebrowser
     void accept();
 
 protected:
-    KoCanvasResourceManager *m_resourceManager; ///< the resource provider with data for this canvas
+    KoCanvasResourceProvider *m_resourceManager; ///< the resource provider with data for this canvas
 };
 
 #endif
diff --git a/libs/flake/KoShapeFillResourceConnector.cpp b/libs/flake/KoShapeFillResourceConnector.cpp
index 5da240ccc2..80c74dbb76 100644
--- a/libs/flake/KoShapeFillResourceConnector.cpp
+++ b/libs/flake/KoShapeFillResourceConnector.cpp
@@ -1,101 +1,101 @@
 /*
  *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KoShapeFillResourceConnector.h"
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoSelectedShapesProxy.h>
 
 #include "kis_assert.h"
 #include "kis_signal_auto_connection.h"
 
 #include <KoColor.h>
 #include <KoFlake.h>
 #include <KoShapeFillWrapper.h>
 #include <KoSelection.h>
 #include <KoCanvasBase.h>
 
 
 
 struct KoShapeFillResourceConnector::Private
 {
     KoCanvasBase *canvas;
     KisSignalAutoConnectionsStore resourceManagerConnections;
 
     void applyShapeColoring(KoFlake::FillVariant fillVariant, const KoColor &color);
 };
 
 KoShapeFillResourceConnector::KoShapeFillResourceConnector(QObject *parent)
     : QObject(parent),
       m_d(new Private())
 {
 }
 
 KoShapeFillResourceConnector::~KoShapeFillResourceConnector()
 {
 }
 
 void KoShapeFillResourceConnector::connectToCanvas(KoCanvasBase *canvas)
 {
     m_d->resourceManagerConnections.clear();
     m_d->canvas = 0;
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(!canvas || canvas->resourceManager());
     KIS_SAFE_ASSERT_RECOVER_RETURN(!canvas || canvas->selectedShapesProxy());
 
     m_d->canvas = canvas;
 
     if (m_d->canvas) {
         m_d->resourceManagerConnections.addConnection(
             canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
     }
 }
 
 void KoShapeFillResourceConnector::disconnect()
 {
     connectToCanvas(0);
 }
 
 void KoShapeFillResourceConnector::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->canvas);
 
-    if (key == KoCanvasResourceManager::ForegroundColor) {
+    if (key == KoCanvasResourceProvider::ForegroundColor) {
         m_d->applyShapeColoring(KoFlake::Fill, value.value<KoColor>());
-    } else if (key == KoCanvasResourceManager::BackgroundColor) {
+    } else if (key == KoCanvasResourceProvider::BackgroundColor) {
         m_d->applyShapeColoring(KoFlake::StrokeFill, value.value<KoColor>());
     }
 }
 
 
 void KoShapeFillResourceConnector::Private::applyShapeColoring(KoFlake::FillVariant fillVariant, const KoColor &color)
 {
     QList<KoShape *> selectedEditableShapes = canvas->selectedShapesProxy()->selection()->selectedEditableShapes();
 
     if (selectedEditableShapes.isEmpty()) {
         return;
     }
 
     KoShapeFillWrapper wrapper(selectedEditableShapes, fillVariant);
     KUndo2Command *command = wrapper.setColor(color.toQColor()); // TODO: do the conversion in a better way!
 
     if (command) {
         canvas->addCommand(command);
     }
 }
diff --git a/libs/flake/KoShapePaintingContext.cpp b/libs/flake/KoShapePaintingContext.cpp
index e03878c790..b114a29a6e 100644
--- a/libs/flake/KoShapePaintingContext.cpp
+++ b/libs/flake/KoShapePaintingContext.cpp
@@ -1,69 +1,69 @@
 /* This file is part of the KDE project
    Copyright (C) 2011 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 "KoShapePaintingContext.h"
 
 #include "KoCanvasBase.h"
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 
 KoShapePaintingContext::KoShapePaintingContext()
     : showFormattingCharacters(false)
     , showTextShapeOutlines(false)
     , showTableBorders(true)
     , showSectionBounds(false)
     , showSpellChecking(false)
     , showSelections(true)
     , showInlineObjectVisualization(false)
     , showAnnotations(false)
 {
 }
 
 KoShapePaintingContext::KoShapePaintingContext(KoCanvasBase *canvas, bool forPrint)
 {
-    KoCanvasResourceManager *rm = canvas->resourceManager();
+    KoCanvasResourceProvider *rm = canvas->resourceManager();
 
-    showFormattingCharacters = rm->boolResource(KoCanvasResourceManager::ShowFormattingCharacters);
+    showFormattingCharacters = rm->boolResource(KoCanvasResourceProvider::ShowFormattingCharacters);
     if (forPrint) {
         showTextShapeOutlines = false;
         showFormattingCharacters = false;
         showTableBorders = false;
         showSectionBounds = false;
         showInlineObjectVisualization = false;
     } else {
-        showTextShapeOutlines = rm->boolResource(KoCanvasResourceManager::ShowTextShapeOutlines);
-        showInlineObjectVisualization = rm->boolResource(KoCanvasResourceManager::ShowInlineObjectVisualization);
-        if (rm->hasResource(KoCanvasResourceManager::ShowTableBorders)) {
-            showTableBorders = rm->boolResource(KoCanvasResourceManager::ShowTableBorders);
+        showTextShapeOutlines = rm->boolResource(KoCanvasResourceProvider::ShowTextShapeOutlines);
+        showInlineObjectVisualization = rm->boolResource(KoCanvasResourceProvider::ShowInlineObjectVisualization);
+        if (rm->hasResource(KoCanvasResourceProvider::ShowTableBorders)) {
+            showTableBorders = rm->boolResource(KoCanvasResourceProvider::ShowTableBorders);
         } else {
             showTableBorders = true;
         }
-        if (rm->hasResource(KoCanvasResourceManager::ShowSectionBounds)) {
-            showSectionBounds = rm->boolResource(KoCanvasResourceManager::ShowSectionBounds);
+        if (rm->hasResource(KoCanvasResourceProvider::ShowSectionBounds)) {
+            showSectionBounds = rm->boolResource(KoCanvasResourceProvider::ShowSectionBounds);
         } else {
             showSectionBounds = true;
         }
     }
     showSpellChecking = !forPrint;
     showSelections = !forPrint;
     showAnnotations = !forPrint;
 }
 
 KoShapePaintingContext::~KoShapePaintingContext()
 {
 }
diff --git a/libs/flake/KoToolBase.cpp b/libs/flake/KoToolBase.cpp
index ac2e495cae..dc3ef76143 100644
--- a/libs/flake/KoToolBase.cpp
+++ b/libs/flake/KoToolBase.cpp
@@ -1,429 +1,429 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2010 Thomas Zander <zander@kde.org>
  * Copyright (C) 2011 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 <QDebug>
 
 #include <QAction>
 
 #include "KoToolBase.h"
 #include "KoToolBase_p.h"
 #include "KoCanvasBase.h"
 #include "KoPointerEvent.h"
 #include "KoDocumentResourceManager.h"
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 #include "KoViewConverter.h"
 #include "KoShapeController.h"
 #include "KoShapeControllerBase.h"
 #include "KoToolSelection.h"
 
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <QWidget>
 #include <QFile>
 #include <QDomDocument>
 #include <QDomElement>
 
 KoToolBase::KoToolBase(KoCanvasBase *canvas)
     : d_ptr(new KoToolBasePrivate(this, canvas))
 {
     Q_D(KoToolBase);
     d->connectSignals();
 }
 
 KoToolBase::KoToolBase(KoToolBasePrivate &dd)
     : d_ptr(&dd)
 {
     Q_D(KoToolBase);
     d->connectSignals();
 }
 
 KoToolBase::~KoToolBase()
 {
 // Enable this to easily generate action files for tools
 
    //  if (actions().size() > 0) {
 
    //     QDomDocument doc;
    //     QDomElement e = doc.createElement("Actions");
    //     e.setAttribute("name", toolId());
    //     e.setAttribute("version", "2");
    //     doc.appendChild(e);
 
    //     Q_FOREACH (QAction *action, actions().values()) {
    //         QDomElement a = doc.createElement("Action");
    //         a.setAttribute("name", action->objectName());
 
    //         // But seriously, XML is the worst format ever designed
    //         auto addElement = [&](QString title, QString content) {
    //             QDomElement newNode = doc.createElement(title);
    //             QDomText    newText = doc.createTextNode(content);
    //             newNode.appendChild(newText);
    //             a.appendChild(newNode);
    //         };
 
    //         addElement("icon", action->icon().name());
    //         addElement("text", action->text());
    //         addElement("whatsThis" , action->whatsThis());
    //         addElement("toolTip" , action->toolTip());
    //         addElement("iconText" , action->iconText());
    //         addElement("shortcut" , action->shortcut().toString());
    //         addElement("isCheckable" , QString((action->isChecked() ? "true" : "false")));
    //         addElement("statusTip", action->statusTip());
    //         e.appendChild(a);
    //     }
    //     QFile f(toolId() + ".action");
    //     f.open(QFile::WriteOnly);
    //     f.write(doc.toString().toUtf8());
    //     f.close();
 
    // }
 
 //    else {
 //        debugFlake << "Tool" << toolId() << "has no actions";
 //    }
     qDeleteAll(d_ptr->optionWidgets);
     delete d_ptr;
 }
 
 
 bool KoToolBase::isActivated() const
 {
     Q_D(const KoToolBase);
     return d->isActivated;
 }
 
 
 void KoToolBase::activate(KoToolBase::ToolActivation toolActivation, const QSet<KoShape *> &shapes)
 {
     Q_UNUSED(toolActivation);
     Q_UNUSED(shapes);
 
     Q_D(KoToolBase);
     d->isActivated = true;
 }
 
 void KoToolBase::deactivate()
 {
     Q_D(KoToolBase);
     d->isActivated = false;
 }
 
 void KoToolBase::canvasResourceChanged(int key, const QVariant & res)
 {
     Q_UNUSED(key);
     Q_UNUSED(res);
 }
 
 void KoToolBase::documentResourceChanged(int key, const QVariant &res)
 {
     Q_UNUSED(key);
     Q_UNUSED(res);
 }
 
 bool KoToolBase::wantsAutoScroll() const
 {
     return true;
 }
 
 void KoToolBase::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     event->ignore();
 }
 
 void KoToolBase::mouseTripleClickEvent(KoPointerEvent *event)
 {
     event->ignore();
 }
 
 void KoToolBase::keyPressEvent(QKeyEvent *e)
 {
     e->ignore();
 }
 
 void KoToolBase::keyReleaseEvent(QKeyEvent *e)
 {
     e->ignore();
 }
 
 
 void KoToolBase::explicitUserStrokeEndRequest()
 {
 }
 
 QVariant KoToolBase::inputMethodQuery(Qt::InputMethodQuery query, const KoViewConverter &) const
 {
     Q_D(const KoToolBase);
     if (d->canvas->canvasWidget() == 0)
         return QVariant();
 
     switch (query) {
     case Qt::ImMicroFocus:
         return QRect(d->canvas->canvasWidget()->width() / 2, 0, 1, d->canvas->canvasWidget()->height());
     case Qt::ImFont:
         return d->canvas->canvasWidget()->font();
     default:
         return QVariant();
     }
 }
 
 void KoToolBase::inputMethodEvent(QInputMethodEvent * event)
 {
     if (! event->commitString().isEmpty()) {
         QKeyEvent ke(QEvent::KeyPress, -1, 0, event->commitString());
         keyPressEvent(&ke);
     }
     event->accept();
 }
 
 void KoToolBase::customPressEvent(KoPointerEvent * event)
 {
     event->ignore();
 }
 
 void KoToolBase::customReleaseEvent(KoPointerEvent * event)
 {
     event->ignore();
 }
 
 void KoToolBase::customMoveEvent(KoPointerEvent * event)
 {
     event->ignore();
 }
 
 void KoToolBase::useCursor(const QCursor &cursor)
 {
     Q_D(KoToolBase);
     d->currentCursor = cursor;
     emit cursorChanged(d->currentCursor);
 }
 
 QList<QPointer<QWidget> > KoToolBase::optionWidgets()
 {
     Q_D(KoToolBase);
     if (d->optionWidgets.empty()) {
         d->optionWidgets = createOptionWidgets();
     }
     return d->optionWidgets;
 }
 
 void KoToolBase::addAction(const QString &name, QAction *action)
 {
     Q_D(KoToolBase);
     if (action->objectName().isEmpty()) {
         action->setObjectName(name);
     }
     d->actions.insert(name, action);
 }
 
 QHash<QString, QAction *> KoToolBase::actions() const
 {
     Q_D(const KoToolBase);
     return d->actions;
 }
 
 QAction *KoToolBase::action(const QString &name) const
 {
     Q_D(const KoToolBase);
     return d->actions.value(name);
 }
 
 QWidget * KoToolBase::createOptionWidget()
 {
     return 0;
 }
 
 QList<QPointer<QWidget> >  KoToolBase::createOptionWidgets()
 {
     QList<QPointer<QWidget> > ow;
     if (QWidget *widget = createOptionWidget()) {
         if (widget->objectName().isEmpty()) {
             widget->setObjectName(toolId());
         }
         ow.append(widget);
     }
     return ow;
 }
 
 void KoToolBase::setToolId(const QString &id)
 {
     Q_D(KoToolBase);
     d->toolId = id;
 }
 
 QString KoToolBase::toolId() const
 {
     Q_D(const KoToolBase);
     return d->toolId;
 }
 
 QCursor KoToolBase::cursor() const
 {
     Q_D(const KoToolBase);
     return d->currentCursor;
 }
 
 void KoToolBase::deleteSelection()
 {
 }
 
 void KoToolBase::cut()
 {
     copy();
     deleteSelection();
 }
 
 QMenu *KoToolBase::popupActionsMenu()
 {
     return 0;
 }
 
 KoCanvasBase * KoToolBase::canvas() const
 {
     Q_D(const KoToolBase);
     return d->canvas;
 }
 
 void KoToolBase::setStatusText(const QString &statusText)
 {
     emit statusTextChanged(statusText);
 }
 
 uint KoToolBase::handleRadius() const
 {
     Q_D(const KoToolBase);
     if(d->canvas->shapeController()->resourceManager())
     {
         return d->canvas->shapeController()->resourceManager()->handleRadius();
     } else {
         return 3;
     }
 }
 
 uint KoToolBase::grabSensitivity() const
 {
     Q_D(const KoToolBase);
     if(d->canvas->shapeController()->resourceManager())
     {
         return d->canvas->shapeController()->resourceManager()->grabSensitivity();
     } else {
         return 3;
     }
 }
 
 QRectF KoToolBase::handleGrabRect(const QPointF &position) const
 {
     Q_D(const KoToolBase);
     const KoViewConverter * converter = d->canvas->viewConverter();
     uint handleSize = 2*grabSensitivity();
     QRectF r = converter->viewToDocument(QRectF(0, 0, handleSize, handleSize));
     r.moveCenter(position);
     return r;
 }
 
 QRectF KoToolBase::handlePaintRect(const QPointF &position) const
 {
     Q_D(const KoToolBase);
     const KoViewConverter * converter = d->canvas->viewConverter();
     uint handleSize = 2*handleRadius();
     QRectF r = converter->viewToDocument(QRectF(0, 0, handleSize, handleSize));
     r.moveCenter(position);
     return r;
 }
 
 void KoToolBase::setTextMode(bool value)
 {
     Q_D(KoToolBase);
     d->isInTextMode=value;
 }
 
 bool KoToolBase::paste()
 {
     return false;
 }
 
 void KoToolBase::copy() const
 {
 }
 
 void KoToolBase::dragMoveEvent(QDragMoveEvent *event, const QPointF &point)
 {
     Q_UNUSED(event);
     Q_UNUSED(point);
 }
 
 void KoToolBase::dragLeaveEvent(QDragLeaveEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KoToolBase::dropEvent(QDropEvent *event, const QPointF &point)
 {
     Q_UNUSED(event);
     Q_UNUSED(point);
 }
 
 bool KoToolBase::hasSelection()
 {
     KoToolSelection *sel = selection();
     return (sel && sel->hasSelection());
 }
 
 KoToolSelection *KoToolBase::selection()
 {
     return 0;
 }
 
 void KoToolBase::repaintDecorations()
 {
 }
 
 bool KoToolBase::isInTextMode() const
 {
     Q_D(const KoToolBase);
     return d->isInTextMode;
 }
 
 void KoToolBase::requestUndoDuringStroke()
 {
     /**
      * Default implementation just cancells the stroke
      */
     requestStrokeCancellation();
 }
 
 void KoToolBase::requestStrokeCancellation()
 {
 }
 
 void KoToolBase::requestStrokeEnd()
 {
 }
 
 bool KoToolBase::maskSyntheticEvents() const
 {
     Q_D(const KoToolBase);
     return d->maskSyntheticEvents;
 }
 
 void KoToolBase::setMaskSyntheticEvents(bool value)
 {
     Q_D(KoToolBase);
     d->maskSyntheticEvents = value;
 }
diff --git a/libs/flake/KoToolBase_p.h b/libs/flake/KoToolBase_p.h
index 7ddd61fef9..91cf2b5089 100644
--- a/libs/flake/KoToolBase_p.h
+++ b/libs/flake/KoToolBase_p.h
@@ -1,89 +1,89 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
  * Copyright (C) 2010 KO GmbH <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KOTOOLBASE_P_H
 #define KOTOOLBASE_P_H
 
 #include "KoDocumentResourceManager.h"
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 #include "KoCanvasBase.h"
 #include "KoShapeController.h"
 #include <QHash>
 #include <QWidget>
 #include <QString>
 #include <QPointer>
 #include <string.h> // for the qt version check
 
 class QAction;
 class KoToolBase;
 
 class KoToolBasePrivate
 {
 public:
     KoToolBasePrivate(KoToolBase *qq, KoCanvasBase *canvas_)
         : currentCursor(Qt::ArrowCursor),
         q(qq),
         canvas(canvas_),
         isInTextMode(false),
         isActivated(false)
     {
     }
 
     ~KoToolBasePrivate()
     {
         Q_FOREACH (QPointer<QWidget> optionWidget, optionWidgets) {
             if (optionWidget) {
                 optionWidget->setParent(0);
                 delete optionWidget;
             }
         }
         optionWidgets.clear();
     }
 
     void connectSignals()
     {
         if (canvas) { // in the case of KoToolManagers dummytool it can be zero :(
-            KoCanvasResourceManager * crp = canvas->resourceManager();
+            KoCanvasResourceProvider * crp = canvas->resourceManager();
             Q_ASSERT_X(crp, "KoToolBase::KoToolBase", "No Canvas KoResourceManager");
             if (crp)
                 q->connect(crp, SIGNAL(canvasResourceChanged(int, const QVariant &)),
                         SLOT(canvasResourceChanged(int, const QVariant &)));
 
             // can be 0 in the case of Calligra Sheets
             KoDocumentResourceManager *scrm = canvas->shapeController()->resourceManager();
             if (scrm) {
                 q->connect(scrm, SIGNAL(resourceChanged(int, const QVariant &)),
                         SLOT(documentResourceChanged(int, const QVariant &)));
             }
         }
     }
 
     QList<QPointer<QWidget> > optionWidgets; ///< the optionwidgets associated with this tool
     QCursor currentCursor;
     QHash<QString, QAction *> actions;
     QString toolId;
     KoToolBase *q;
     KoCanvasBase *canvas; ///< the canvas interface this tool will work for.
     bool isInTextMode;
     bool maskSyntheticEvents{false}; ///< Whether this tool masks synthetic events
     bool isActivated;
 };
 
 #endif
diff --git a/libs/flake/tests/TestResourceManager.cpp b/libs/flake/tests/TestResourceManager.cpp
index 9fcbfbd9b2..abc908c967 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 "KoCanvasResourceProvider.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 );
+    KoCanvasResourceProvider rp( 0 );
     rp.setResource( key, shape );
     QVERIFY( shape == rp.koShapeResource( key ) );
 }
 
 void TestResourceManager::testUnitChanged()
 {
-    KoCanvasResourceManager rm(0);
+    KoCanvasResourceProvider rm(0);
     QSignalSpy spy(&rm, SIGNAL(canvasResourceChanged(int,QVariant)));
 
     KoUnit a;
-    rm.setResource(KoCanvasResourceManager::Unit, a);
+    rm.setResource(KoCanvasResourceProvider::Unit, a);
     QCOMPARE(spy.count(), 1);
 
     KoUnit b(KoUnit::Millimeter);
-    rm.setResource(KoCanvasResourceManager::Unit, b);
+    rm.setResource(KoCanvasResourceProvider::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);
+    KoCanvasResourceProvider 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,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);
+    KoCanvasResourceProvider 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,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/libkis/Filter.cpp b/libs/libkis/Filter.cpp
index 6c945e09ee..a0f9a4c8a0 100644
--- a/libs/libkis/Filter.cpp
+++ b/libs/libkis/Filter.cpp
@@ -1,174 +1,174 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Filter.h"
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 
 #include <kis_canvas_resource_provider.h>
 #include <kis_filter.h>
 #include <kis_properties_configuration.h>
 #include <kis_filter_configuration.h>
 #include <kis_filter_manager.h>
 #include <kis_filter_registry.h>
 #include <KisPart.h>
 #include <KisView.h>
 
 #include <strokes/kis_filter_stroke_strategy.h>
 #include <krita_utils.h>
 
 #include "Krita.h"
 #include "Document.h"
 #include "InfoObject.h"
 #include "Node.h"
 
 struct Filter::Private {
     Private() {}
     QString name;
     InfoObject *configuration {0};
 };
 
 Filter::Filter()
     : QObject(0)
     , d(new Private)
 {
 }
 
 Filter::~Filter()
 {
     delete d->configuration;
     delete d;
 }
 
 bool Filter::operator==(const Filter &other) const
 {
     return (d->name == other.d->name
             && d->configuration == other.d->configuration);
 }
 
 bool Filter::operator!=(const Filter &other) const
 {
     return !(operator==(other));
 }
 
 
 QString Filter::name() const
 {
     return d->name;
 }
 
 void Filter::setName(const QString &name)
 {
     d->name = name;
     delete d->configuration;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     d->configuration = new InfoObject(filter->defaultConfiguration());
 }
 
 InfoObject* Filter::configuration() const
 {
     return d->configuration;
 }
 
 void Filter::setConfiguration(InfoObject* value)
 {
     d->configuration = value;
 }
 
 bool Filter::apply(Node *node, int x, int y, int w, int h)
 {
     if (node->locked()) return false;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     if (!filter) return false;
 
     KisPaintDeviceSP dev = node->paintDevice();
     if (!dev) return false;
 
     QRect applyRect = QRect(x, y, w, h);
     KisFilterConfigurationSP config = static_cast<KisFilterConfiguration*>(d->configuration->configuration().data());
     filter->process(dev, applyRect, config);
     return true;
 }
 
 bool Filter::startFilter(Node *node, int x, int y, int w, int h)
 {
     if (node->locked()) return false;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     if (!filter) return false;
 
     KisImageWSP image = node->image();
     if (!image) return false;
 
     KisFilterConfigurationSP filterConfig = static_cast<KisFilterConfiguration*>(d->configuration->configuration().data());
 
     image->waitForDone();
     QRect initialApplyRect = QRect(x, y, w, h);
 
     QRect applyRect = initialApplyRect;
 
     KisPaintDeviceSP paintDevice = node->paintDevice();
     if (paintDevice && filter->needsTransparentPixels(filterConfig.data(), paintDevice->colorSpace())) {
         applyRect |= image->bounds();
     }
 
     KisResourcesSnapshotSP resources = new KisResourcesSnapshot(image, node->node());
 
     Document *document = Krita::instance()->activeDocument();
     if (document && KisPart::instance()->viewCount(document->document()) > 0) {
         Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
             if (view && view->document() == document->document()) {
                 resources = new KisResourcesSnapshot(image, node->node(), view->resourceProvider()->resourceManager());
                 break;
             }
         }
     }
     delete document;
 
     KisStrokeId currentStrokeId = image->startStroke(new KisFilterStrokeStrategy(filter,
                                                                                  KisFilterConfigurationSP(filterConfig),
                                                                                  resources));
 
     QRect processRect = filter->changedRect(applyRect, filterConfig.data(), 0);
     processRect &= image->bounds();
 
     if (filter->supportsThreading()) {
         QSize size = KritaUtils::optimalPatchSize();
         QVector<QRect> rects = KritaUtils::splitRectIntoPatches(processRect, size);
         Q_FOREACH (const QRect &rc, rects) {
             image->addJob(currentStrokeId, new KisFilterStrokeStrategy::Data(rc, true));
         }
     } else {
         image->addJob(currentStrokeId, new KisFilterStrokeStrategy::Data(processRect, false));
     }
 
     image->endStroke(currentStrokeId);
     image->waitForDone();
 
     return true;
 }
 
 KisFilterConfigurationSP Filter::filterConfig()
 {
     KisFilterConfigurationSP config = KisFilterRegistry::instance()->get(d->name)->defaultConfiguration();
     Q_FOREACH(const QString property, d->configuration->properties().keys()) {
         config->setProperty(property, d->configuration->property(property));
     }
     return config;
 }
diff --git a/libs/libqml/plugins/kritasketchplugin/ColorSelectorItem.cpp b/libs/libqml/plugins/kritasketchplugin/ColorSelectorItem.cpp
index 2577dfe677..9e99d65d89 100644
--- a/libs/libqml/plugins/kritasketchplugin/ColorSelectorItem.cpp
+++ b/libs/libqml/plugins/kritasketchplugin/ColorSelectorItem.cpp
@@ -1,337 +1,337 @@
 /* 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 "ColorSelectorItem.h"
 #include <plugins/dockers/advancedcolorselector/kis_color_selector_component.h>
 #include <plugins/dockers/advancedcolorselector/kis_color_selector_ring.h>
 #include <plugins/dockers/advancedcolorselector/kis_color_selector_triangle.h>
 #include <plugins/dockers/advancedcolorselector/kis_color_selector_simple.h>
 #include <plugins/dockers/advancedcolorselector/kis_color_selector_wheel.h>
 #include <kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <QPainter>
 #include <QMouseEvent>
 #include <QTimer>
 #include "kis_display_color_converter.h"
 
 #include <math.h>
 
 class ColorSelectorItem::Private
 {
 public:
     Private(ColorSelectorItem* qq)
         : q(qq)
         , selector(new KisColorSelector)
         , view(0)
         , colorRole(Acs::Foreground)
         , grabbingComponent(0)
         , colorUpdateAllowed(true)
         , changeBackground(false)
         , shown(true)
         , repaintTimer(new QTimer)
     {
         ring = new KisColorSelectorRing(selector);
         ring->setInnerRingRadiusFraction(0.7);
         triangle = new KisColorSelectorTriangle(selector);
         slider = new KisColorSelectorSimple(selector);
         square = new KisColorSelectorSimple(selector);
         wheel = new KisColorSelectorWheel(selector);
         main = triangle;
         sub = ring;
         connect(main, SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
                 sub,  SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
         connect(sub,  SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
                 main, SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
 
         main->setConfiguration(selector->configuration().mainTypeParameter, selector->configuration().mainType);
         sub->setConfiguration(selector->configuration().subTypeParameter, selector->configuration().subType);
 
         repaintTimer->setInterval(50);
         repaintTimer->setSingleShot(true);
         connect(repaintTimer, SIGNAL(timeout()), q, SLOT(repaint()));
     }
     ~Private()
     {
         selector->deleteLater();
     }
     void repaint();
     QImage paintedItem;
 
     ColorSelectorItem* q;
 
     KisColorSelector* selector;
 
     KisColorSelectorRing* ring;
     KisColorSelectorTriangle* triangle;
     KisColorSelectorSimple* slider;
     KisColorSelectorSimple* square;
     KisColorSelectorWheel* wheel;
 
     KisColorSelectorComponent* main;
     KisColorSelectorComponent* sub;
 
     KisViewManager* view;
     Acs::ColorRole colorRole;
     KoColor currentColor;
     KisColorSelectorComponent* grabbingComponent;
 
     void commitColor(const KoColor& color, Acs::ColorRole role);
     bool colorUpdateAllowed;
     bool changeBackground;
     bool shown;
     QTimer* repaintTimer;
 
     void colorChangedImpl(const KoColor &color, Acs::ColorRole role);
 };
 
 void ColorSelectorItem::Private::commitColor(const KoColor& color, Acs::ColorRole role)
 {
     if (!view->canvas())
         return;
 
     KoColor currentColor = Acs::currentColor(view->resourceProvider(), role);
     if (color == currentColor) return;
 
     colorUpdateAllowed = false;
     Acs::setCurrentColor(view->resourceProvider(), role, color);
     QColor qcolor = selector->converter()->toQColor(currentColor);
     emit q->colorChanged(qcolor, color.opacityF(), false);
     colorUpdateAllowed = true;
 }
 
 ColorSelectorItem::ColorSelectorItem(QQuickItem* parent)
     : QQuickPaintedItem(parent)
     , d(new Private(this))
 {
     setFlag(QQuickItem::ItemHasContents, true);
     setAcceptedMouseButtons( Qt::LeftButton | Qt::RightButton );
 }
 
 ColorSelectorItem::~ColorSelectorItem()
 {
     delete d;
 }
 
 void ColorSelectorItem::paint(QPainter* painter)
 {
     if(!d->shown)
         return;
     painter->drawImage(boundingRect(), d->paintedItem);
 
 }
 
 void ColorSelectorItem::Private::repaint()
 {
     paintedItem = QImage(q->boundingRect().size().toSize(), QImage::Format_ARGB32_Premultiplied);
     if(paintedItem.isNull())
         return;
     paintedItem.fill(Qt::transparent);
     QPainter painter;
     painter.begin(&paintedItem);
     main->paintEvent(&painter);
     sub->paintEvent(&painter);
     painter.end();
     q->update();
 }
 
 void ColorSelectorItem::geometryChanged(const QRectF& newGeometry, const QRectF& oldGeometry)
 {
 //    QRectF bounds = boundingRect();
 //    if (d->selector->configuration().subType==KisColorSelector::Ring)
 //    {
 //        d->ring->setGeometry(bounds.x(),bounds.y(),bounds.width(), bounds.height());
 //        if (d->selector->configuration().mainType==KisColorSelector::Triangle)
 //        {
 //            d->triangle->setGeometry(bounds.width()/2 - d->ring->innerRadius(),
 //                                     bounds.height()/2 - d->ring->innerRadius(),
 //                                     d->ring->innerRadius()*2,
 //                                     d->ring->innerRadius()*2);
 //        }
 //        else
 //        {
 //            int size = d->ring->innerRadius()*2/sqrt(2.);
 //            d->square->setGeometry(bounds.width()/2 - size/2,
 //                                   bounds.height()/2 - size/2,
 //                                   size,
 //                                   size);
 //        }
 //    }
 //    else
 //    {
 //        // type wheel and square
 //        if (d->selector->configuration().mainType==KisColorSelector::Wheel)
 //        {
 //            d->main->setGeometry(bounds.x(), bounds.y() + height()*0.1, bounds.width(), bounds.height()*0.9);
 //            d->sub->setGeometry( bounds.x(), bounds.y(),                bounds.width(), bounds.height()*0.1);
 //        }
 //        else
 //        {
 //            if (bounds.height()>bounds.width())
 //            {
 //                d->main->setGeometry(bounds.x(), bounds.y() + bounds.height()*0.1, bounds.width(), bounds.height()*0.9);
 //                d->sub->setGeometry( bounds.x(), bounds.y(),                       bounds.width(), bounds.height()*0.1);
 //            }
 //            else
 //            {
 //                d->main->setGeometry(bounds.x(), bounds.y() + bounds.height()*0.1, bounds.width(), bounds.height()*0.9);
 //                d->sub->setGeometry( bounds.x(), bounds.y(),                       bounds.width(), bounds.height()*0.1);
 //            }
 //        }
 //    }
 
     if (d->view) {
         d->selector->setColor(Acs::currentColor(d->view->resourceProvider(), d->colorRole));
     }
 
     d->repaintTimer->start();
     QQuickPaintedItem::geometryChanged(newGeometry, oldGeometry);
 }
 
 void ColorSelectorItem::mousePressEvent(QMouseEvent* event)
 {
     d->colorRole = d->changeBackground ?
         Acs::Background : Acs::buttonToRole(event->button());
 
     if (d->main->wantsGrab(event->pos().x(), event->pos().y())) {
         d->grabbingComponent = d->main;
     } else if (d->sub->wantsGrab(event->pos().x(), event->pos().y())) {
         d->grabbingComponent = d->sub;
     }
 
     mouseEvent(event);
 }
 
 void ColorSelectorItem::mouseMoveEvent(QMouseEvent* event)
 {
     mouseEvent(event);
 }
 
 void ColorSelectorItem::mouseReleaseEvent(QMouseEvent* /*event*/)
 {
     d->grabbingComponent=0;
 }
 
 void ColorSelectorItem::mouseEvent(QMouseEvent* event)
 {
     if (d->grabbingComponent && (event->buttons()&Qt::LeftButton || event->buttons()&Qt::RightButton))
     {
         d->grabbingComponent->mouseEvent(event->pos().x(), event->pos().y());
 
         qreal alpha = d->currentColor.opacityF();
         d->currentColor = d->main->currentColor();
         d->currentColor.setOpacity(alpha);
         d->commitColor(d->currentColor, d->colorRole);
         d->repaintTimer->start();
     }
 }
 
 QObject* ColorSelectorItem::view() const
 {
     return d->view;
 }
 
 void ColorSelectorItem::setView(QObject* newView)
 {
     d->view = qobject_cast<KisViewManager*>( newView );
     if (d->view) {
         connect(d->view->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)),
                 this, SLOT(fgColorChanged(KoColor)));
         connect(d->view->resourceProvider(), SIGNAL(sigBGColorChanged(KoColor)),
                 this, SLOT(bgColorChanged(KoColor)));
 
         d->commitColor(d->currentColor, d->colorRole);
         setChangeBackground(changeBackground());
     }
     emit viewChanged();
 }
 
 bool ColorSelectorItem::changeBackground() const
 {
     return d->changeBackground;
 }
 
 void ColorSelectorItem::setChangeBackground(bool newChangeBackground)
 {
     d->changeBackground = newChangeBackground;
     d->colorRole = newChangeBackground ? Acs::Background : Acs::Foreground;
     emit changeBackgroundChanged();
     if (!d->view)
         return;
 
 
     d->currentColor = Acs::currentColor(d->view->resourceProvider(), d->colorRole);
 
     d->main->setColor(d->currentColor);
     d->sub->setColor(d->currentColor);
     d->repaintTimer->start();
 }
 
 bool ColorSelectorItem::shown() const
 {
     return d->shown;
 }
 
 void ColorSelectorItem::setShown(bool newShown)
 {
     d->shown = newShown;
     emit shownChanged();
 }
 
 void ColorSelectorItem::setAlpha(int percentValue)
 {
     qreal alpha = (float)percentValue / 100.0;
     d->currentColor.setOpacity(alpha);
     if (d->view) {
         d->commitColor(d->currentColor, d->colorRole);
     }
 }
 
 void ColorSelectorItem::Private::colorChangedImpl(const KoColor &newColor, Acs::ColorRole role)
 {
     if (colorRole != role) return;
     if (colorUpdateAllowed == false) return;
 
     if(newColor == currentColor) return;
 
     currentColor = newColor;
     main->setColor(newColor);
     sub->setColor(newColor);
     commitColor(currentColor, colorRole);
     QColor qcolor = selector->converter()->toQColor(currentColor);
     emit q->colorChanged(qcolor, currentColor.opacityF(), false);
     repaintTimer->start();
 }
 
 void ColorSelectorItem::fgColorChanged(const KoColor& newColor)
 {
     d->colorChangedImpl(newColor, Acs::Foreground);
 }
 
 void ColorSelectorItem::bgColorChanged(const KoColor& newColor)
 {
     d->colorChangedImpl(newColor, Acs::Background);
 }
 
 void ColorSelectorItem::repaint()
 {
     d->repaint();
 }
 
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index 3e7ea96626..c899f80c1b 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2669 +1,2669 @@
 /* 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> >)));
 
     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(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(QString)), this, SLOT(slotLoadCanceled(QString)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::installBundle(const QString &fileName) const
 {
     QFileInfo from(fileName);
     QFileInfo to(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
     if (to.exists()) {
         QFile::remove(to.canonicalFilePath());
     }
     return QFile::copy(fileName, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas, bool isExporting)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     }
     else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     if (document->isRecovered()) {
         saveas = true;
     }
 
     if (document->url().isEmpty()) {
         saveas = true;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     QByteArray nativeFormat = document->nativeFormatMimeType();
     QByteArray oldMimeFormat = document->mimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     if (!mimeFilter.contains(oldMimeFormat)) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).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(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
+KoCanvasResourceProvider *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());
                 action->deleteLater();
             }
         }
     }
 
     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/KisMainWindow.h b/libs/ui/KisMainWindow.h
index d4e46a06bb..36e35cfe15 100644
--- a/libs/ui/KisMainWindow.h
+++ b/libs/ui/KisMainWindow.h
@@ -1,500 +1,500 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2004 David Faure <faure@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_MAIN_WINDOW_H
 #define KIS_MAIN_WINDOW_H
 
 #include "kritaui_export.h"
 
 #include <QPointer>
 #include <QPrinter>
 #include <QUuid>
 #include <QUrl>
 
 #include <xmlgui/kxmlguiwindow.h>
 #include <KoCanvasObserverBase.h>
 #include <KoCanvasSupervisor.h>
 #include "KisView.h"
 
 class QCloseEvent;
 class QMoveEvent;
 
 struct KoPageLayout;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 class KisDocument;
 class KisPrintJob;
 class KoDockFactoryBase;
 class QDockWidget;
 class KisView;
 class KisViewManager;
 class KoCanvasController;
 class KisWorkspaceResource;
 
 /**
  * @brief Main window for Krita
  *
  * This class is used to represent a main window within a Krita session. Each
  * main window contains a menubar and some toolbars, and potentially several
  * views of several canvases.
  *
  */
 class KRITAUI_EXPORT KisMainWindow : public KXmlGuiWindow, public KoCanvasSupervisor
 {
     Q_OBJECT
 
 public:
     enum OpenFlag {
         None = 0,
         Import = 0x1,
         BatchMode = 0x2,
         RecoveryFile = 0x4
     };
     Q_DECLARE_FLAGS(OpenFlags, OpenFlag)
 
 public:
 
     /**
      *  Constructor.
      *
      *  Initializes a Calligra main window (with its basic GUI etc.).
      */
     explicit KisMainWindow(QUuid id = QUuid());
 
     /**
      *  Destructor.
      */
     ~KisMainWindow() override;
 
     QUuid id() const;
 
     /**
      * @brief showView shows the given view. Override this if you want to show
      * the view in a different way than by making it the central widget, for instance
      * as an QMdiSubWindow
      */
     virtual void showView(KisView *view);
 
     /**
      * @returns the currently active view
      */
     KisView *activeView() const;
 
     /**
      * Sets the maximum number of recent documents entries.
      */
     void setMaxRecentItems(uint _number);
 
     /**
      * The document opened a URL -> store into recent documents list.
      */
     void addRecentURL(const QUrl &url);
 
     /**
      * get list of URL strings for recent files
      */
     QList<QUrl> recentFilesUrls();
 
     /**
      * clears the list of the recent files
      */
     void clearRecentFiles();
 
 
     /**
      * Load the desired document and show it.
      * @param url the URL to open
      *
      * @return TRUE on success.
      */
     bool openDocument(const QUrl &url, OpenFlags flags);
 
     /**
      * Activate a view containing the document in this window, creating one if needed.
      */
     void showDocument(KisDocument *document);
 
 
     /**
      * Toggles between showing the welcome screen and the MDI area
      *
      *  hack: There seems to be a bug that prevents events happening to the MDI area if it
      *  isn't actively displayed (set in the widgetStack). This can cause things like the title bar
      *  not to update correctly Before doing any actions related to opening or creating documents,
      *  make sure to switch this first to make sure everything can communicate to the MDI area correctly
      */
     void showWelcomeScreen(bool show);
 
 
     /**
      * Saves the document, asking for a filename if necessary.
      *
      * @param saveas if set to TRUE the user is always prompted for a filename
      * @param silent if set to TRUE rootDocument()->setTitleModified will not be called.
      *
      * @return TRUE on success, false on error or cancel
      *         (don't display anything in this case, the error dialog box is also implemented here
      *         but restore the original URL in slotFileSaveAs)
      */
     bool saveDocument(KisDocument *document, bool saveas, bool isExporting);
 
     void setReadWrite(bool readwrite);
 
     /// Return the list of dock widgets belonging to this main window.
     QList<QDockWidget*> dockWidgets() const;
 
     QDockWidget* dockWidget(const QString &id);
 
     QList<KoCanvasObserverBase*> canvasObservers() const override;
 
-    KoCanvasResourceManager *resourceManager() const;
+    KoCanvasResourceProvider *resourceManager() const;
 
     int viewCount() const;
 
     void saveWindowState(bool restoreNormalState =false);
 
     const KConfigGroup &windowStateConfig() const;
 
     /**
      * A wrapper around restoreState
      * @param state the saved state
      * @return TRUE on success
      */
     bool restoreWorkspace(KisWorkspaceResource *workspace);
     bool restoreWorkspaceState(const QByteArray &state);
 
     static void swapWorkspaces(KisMainWindow *a, KisMainWindow *b);
 
     KisViewManager *viewManager() const;
 
     KisView *addViewAndNotifyLoadingCompleted(KisDocument *document);
 
     QStringList showOpenFileDialog(bool isImporting);
 
     /**
      * Shows if the main window is saving anything right now. If the
      * user presses Ctrl+W too fast, then the document can be close
      * before the saving is completed. I'm not sure if it is fixable
      * in any way without avoiding using porcessEvents()
      * everywhere (DK)
      *
      * Don't use it unless you have no option.
      */
     bool hackIsSaving() const;
 
     /// Copy the given file into the bundle directory.
     bool installBundle(const QString &fileName) const;
 
 Q_SIGNALS:
 
     /**
      * This signal is emitted if the document has been saved successfully.
      */
     void documentSaved();
 
     /// This signal is emitted when this windows has finished loading of a
     /// document. The document may be opened in another window in the end.
     /// In this case, the signal means there is no link between the window
     /// and the document anymore.
     void loadCompleted();
 
     /// This signal is emitted right after the docker states have been succefully restored from config
     void restoringDone();
 
     /// This signal is emitted when the color theme changes
     void themeChanged();
 
     /// This signal is emitted when the shortcut key configuration has changed
     void keyBindingsChanged();
 
     void guiLoadingFinished();
 
 public Q_SLOTS:
 
     /**
      *  Slot for opening a new document.
      *
      *  If the current document is empty, the new document replaces it.
      *  If not, a new mainwindow will be opened for showing the document.
      */
     void slotFileNew();
 
     /**
      *  Slot for opening a saved file.
      *
      *  If the current document is empty, the opened document replaces it.
      *  If not a new mainwindow will be opened for showing the opened file.
      */
     void slotFileOpen(bool isImporting = false);
 
     /**
      *  Slot for opening a file among the recently opened files.
      *
      *  If the current document is empty, the opened document replaces it.
      *  If not a new mainwindow will be opened for showing the opened file.
      */
     void slotFileOpenRecent(const QUrl &);
 
     /**
      * @brief slotPreferences open the preferences dialog
      */
     void slotPreferences();
 
     /**
      * Update caption from document info - call when document info
      * (title in the about page) changes.
      */
     void updateCaption();
 
     /**
      *  Saves the current document with the current name.
      */
     void slotFileSave();
 
 
     void slotShowSessionManager();
 
     // XXX: disabled
     KisPrintJob* exportToPdf(QString pdfFileName = QString());
 
     /**
      * Update the option widgets to the argument ones, removing the currently set widgets.
      */
     void newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > & optionWidgetList);
 
     KisView *newView(QObject *document);
 
     void notifyChildViewDestroyed(KisView *view);
 
     /// Set the active view, this will update the undo/redo actions
     void setActiveView(KisView *view);
 
     void subWindowActivated();
 
     void windowFocused();
 
     /**
      * Reloads the recent documents list.
      */
     void reloadRecentFileList();
 
 
 
 private Q_SLOTS:
     /**
      * Save the list of recent files.
      */
     void saveRecentFiles();
 
     void slotLoadCompleted();
     void slotLoadCanceled(const QString &);
     void slotSaveCompleted();
     void slotSaveCanceled(const QString &);
     void forceDockTabFonts();
 
     /**
      * @internal
      */
     void slotDocumentTitleModified();
 
     /**
      *  Prints the actual document.
      */
     void slotFilePrint();
 
     /**
      *  Saves the current document with a new name.
      */
     void slotFileSaveAs();
 
     void slotFilePrintPreview();
 
     void importAnimation();
 
     /**
      * Show a dialog with author and document information.
      */
     void slotDocumentInfo();
 
     /**
      * Closes all open documents.
      */
     bool slotFileCloseAll();
 
     /**
      * @brief showAboutApplication show the about box
      */
     virtual void showAboutApplication();
 
     /**
      *  Closes the mainwindow.
      */
     void slotFileQuit();
 
     /**
      *  Configure toolbars.
      */
     void slotConfigureToolbars();
 
     /**
      *  Post toolbar config.
      * (Plug action lists back in, etc.)
      */
     void slotNewToolbarConfig();
 
     /**
      *  Shows or hides a toolbar
      */
     void slotToolbarToggled(bool toggle);
 
     /**
      * Toggle full screen on/off.
      */
     void viewFullscreen(bool fullScreen);
 
     /**
      * Reload file
      */
     void slotReloadFile();
 
 
     /**
      * File --> Import
      *
      * This will call slotFileOpen().
      */
     void slotImportFile();
 
     /**
      * File --> Export
      *
      * This will call slotFileSaveAs().
      */
     void slotExportFile();
 
     /**
      * Hide the dockers
      */
     void toggleDockersVisibility(bool visible);
 
     /**
      * Handle theme changes from theme manager
      */
     void slotThemeChanged();
 
     void undo();
     void redo();
     void updateWindowMenu();
     void setActiveSubWindow(QWidget *window);
     void configChanged();
 
     void newWindow();
     void closeCurrentWindow();
     void checkSanity();
 
     /// Quits Krita with error message from m_errorMessage.
     void showErrorAndDie();
 
     void initializeGeometry();
     void showManual();
     void switchTab(int index);
 
 
 protected:
 
     void closeEvent(QCloseEvent * e) override;
     void resizeEvent(QResizeEvent * e) override;
 
     // QWidget overrides
     void dragEnterEvent(QDragEnterEvent * event) override;
     void dropEvent(QDropEvent * event) override;
     void dragMoveEvent(QDragMoveEvent * event) override;
     void dragLeaveEvent(QDragLeaveEvent * event) override;
 
     void moveEvent(QMoveEvent *e) override;
 
 
 private:
 
     /**
      * Add a the given view to the list of views of this mainwindow.
      * This is a private implementation. For public usage please use
      * newView() and addViewAndNotifyLoadingCompleted().
      */
     void addView(KisView *view);
 
     friend class KisPart;
 
 
     /**
      * Returns the dockwidget specified by the @p factory. If the dock widget doesn't exist yet it's created.
      * Add a "view_palette_action_menu" action to your view menu if you want to use closable dock widgets.
      * @param factory the factory used to create the dock widget if needed
      * @return the dock widget specified by @p factory (may be 0)
      */
     QDockWidget* createDockWidget(KoDockFactoryBase* factory);
 
     bool openDocumentInternal(const QUrl &url, KisMainWindow::OpenFlags flags = 0);
 
 
     /**
      * Updates the window caption based on the document info and path.
      */
     void updateCaption(const QString & caption, bool mod);
     void updateReloadFileAction(KisDocument *doc);
 
     void saveWindowSettings();
 
     QPointer<KisView> activeKisView();
 
     void applyDefaultSettings(QPrinter &printer);
 
     void createActions();
 
     void applyToolBarLayout();
 
     QByteArray borrowWorkspace(KisMainWindow *borrower);
 
 
 private:
 
     /**
      * Struct used in the list created by createCustomDocumentWidgets()
      */
     struct CustomDocumentWidgetItem {
         /// Pointer to the custom document widget
         QWidget *widget;
         /// title used in the sidebar. If left empty it will be displayed as "Custom Document"
         QString title;
         /// icon used in the sidebar. If left empty it will use the unknown icon
         QString icon;
     };
 
     class Private;
     Private * const d;
 
     QString m_errorMessage;
     bool m_dieOnError;
 
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KisMainWindow::OpenFlags)
 
 #endif
diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index 76707bb382..0d9e0de841 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,568 +1,568 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeControllerBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <kdesktopfile.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "KisResourceServerProvider.h"
 #include "kis_animation_cache_populator.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     KActionCollection *actionCollection{0};
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResource *currentSession = nullptr;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return false;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
-                             KoCanvasResourceManager *resourceManager,
+                             KoCanvasResourceProvider *resourceManager,
                              KActionCollection *actionCollection,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg(false);
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.setUseOpenGL(false);
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.setUseOpenGL(false);
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView *view  = new KisView(document, resourceManager, actionCollection, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
         KisConfig kisCfg(false);
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     //  - Shortcuts called inside of tools
     //  - Perhaps other things?
     KoToolManager::instance()->updateToolShortcuts();
 
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if(action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> * rserver = KisResourceServerProvider::instance()->sessionServer();
     auto *session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     session->restore();
 
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResource *session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/KisPart.h b/libs/ui/KisPart.h
index 2202f1f93e..79078319ee 100644
--- a/libs/ui/KisPart.h
+++ b/libs/ui/KisPart.h
@@ -1,276 +1,276 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2005 David Faure  <faure@kde.org>
    Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2010 Boudewijn Rempt   <boud@valdyas.org>
    Copyright (C) 2015 Michael Abrahams  <miabraha@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_PART_H
 #define KIS_PART_H
 
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 #include <QUuid>
 
 #include "kritaui_export.h"
 #include <KConfigCore/kconfiggroup.h>
 #include <KoConfig.h>
 #include <KisMainWindow.h>
 
 namespace KIO {
 }
 
 class KisAction;
 class KisDocument;
 class KisView;
 class KisDocument;
 class KisIdleWatcher;
 class KisAnimationCachePopulator;
 class KisSessionResource;
 
 /**
  * KisPart is the Great Deku Tree of Krita.
  *
  * It is a singleton class which provides the main entry point to the application.
  * Krita supports multiple documents, multiple main windows, and multiple
  * components.  KisPart manages these resources and provides them to the rest of
  * Krita.  It manages lists of Actions and shortcuts as well.
  *
  * The terminology comes from KParts, which is a system allowing one KDE app
  * to be run from inside another, like pressing F4 inside dophin to run konsole.
  *
  * Needless to say, KisPart hasn't got much to do with KParts anymore.
  */
 class KRITAUI_EXPORT KisPart : public QObject
 {
     Q_OBJECT
 
 public:
 
     static KisPart *instance();
 
     /**
      * Constructor.
      *
      * @param parent may be another KisDocument, or anything else.
      *        Usually passed by KPluginFactory::create.
      */
     explicit KisPart();
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisPart() override;
 
     // ----------------- Document management -----------------
 
     /**
      * create an empty document. The document is not automatically registered with the part.
      */
     KisDocument *createDocument() const;
 
     /**
      * Add the specified document to the list of documents this KisPart manages.
      */
     void addDocument(KisDocument *document);
 
     /**
      * @return a list of all documents this part manages
      */
     QList<QPointer<KisDocument> > documents() const;
 
     /**
      * @return number of documents this part manages.
      */
     int documentCount() const;
 
     void removeDocument(KisDocument *document);
 
     // ----------------- MainWindow management -----------------
 
 
     /**
      * Create a new main window.
      */
     KisMainWindow *createMainWindow(QUuid id = QUuid());
 
     /**
      * Removes a main window from the list of managed windows.
      *
      * This is called by the MainWindow after it finishes its shutdown routine.
      */
     void removeMainWindow(KisMainWindow *mainWindow);
 
     /**
      * @return the list of main windows.
      */
     const QList<QPointer<KisMainWindow> >& mainWindows() const;
 
     /**
      * @return the number of shells for the main window
      */
     int mainwindowCount() const;
 
     void addRecentURLToAllMainWindows(QUrl url);
 
     /**
      * @return the currently active main window.
      */
     KisMainWindow *currentMainwindow() const;
 
     KisMainWindow *windowById(QUuid id) const;
 
     /**
      * @return the application-wide KisIdleWatcher.
      */
     KisIdleWatcher *idleWatcher() const;
 
     /**
      * @return the application-wide AnimationCachePopulator.
      */
     KisAnimationCachePopulator *cachePopulator() const;
 
 public Q_SLOTS:
 
     /**
      * This slot loads an existing file.
      * @param url the file to load
      */
     void openExistingFile(const QUrl &url);
 
     /**
      * This slot loads a template and deletes the sender.
      * @param url the template to load
      */
     void openTemplate(const QUrl &url);
 
 
     /**
      * @brief startCustomDocument adds the given document to the document list and deletes the sender()
      * @param doc
      */
     void startCustomDocument(KisDocument *doc);
 
 private Q_SLOTS:
 
     void updateIdleWatcherConnections();
 
     void updateShortcuts();
 
 Q_SIGNALS:
     /**
      * emitted when a new document is opened. (for the idle watcher)
      */
     void documentOpened(const QString &ref);
 
     /**
      * emitted when an old document is closed. (for the idle watcher)
      */
     void documentClosed(const QString &ref);
 
     // These signals are for libkis or sketch
     void sigViewAdded(KisView *view);
     void sigViewRemoved(KisView *view);
     void sigDocumentAdded(KisDocument *document);
     void sigDocumentSaved(const QString &url);
     void sigDocumentRemoved(const QString &filename);
     void sigWindowAdded(KisMainWindow *window);
 
 public:
 
     KisInputManager *currentInputManager();
 
     //------------------ View management ------------------
 
     /**
      * Create a new view for the document. The view is added to the list of
      * views, and if the document wasn't known yet, it's registered as well.
      */
     KisView *createView(KisDocument *document,
-                        KoCanvasResourceManager *resourceManager,
+                        KoCanvasResourceProvider *resourceManager,
                         KActionCollection *actionCollection,
                         QWidget *parent);
 
     /**
      * Adds a view to the document. If the part doesn't know yet about
      * the document, it is registered.
      *
      * This calls KisView::updateReadWrite to tell the new view
      * whether the document is readonly or not.
      */
     void addView(KisView *view);
 
     /**
      * Removes a view of the document.
      */
     void removeView(KisView *view);
 
     /**
      * @return a list of views this document is displayed in
      */
     QList<QPointer<KisView> > views() const;
 
     /**
      * @return number of views this document is displayed in
      */
     int viewCount(KisDocument *doc) const;
 
     //------------------ Session management ------------------
 
     void showSessionManager();
 
     void startBlankSession();
 
     /**
      * Restores a saved session by name
      */
     bool restoreSession(const QString &sessionName);
 
     void setCurrentSession(KisSessionResource *session);
 
     /**
      * Attempts to save the session and close all windows.
      * This may involve asking the user to save open files.
      * @return false, if closing was cancelled by the user
      */
     bool closeSession(bool keepWindows = false);
 
     /**
      * Are we in the process of closing the application through closeSession().
      */
     bool closingSession() const;
 
 private Q_SLOTS:
 
     void slotDocumentSaved();
 
 private:
 
     Q_DISABLE_COPY(KisPart)
 
     class Private;
     Private *const d;
 
 };
 
 #endif
diff --git a/libs/ui/KisView.cpp b/libs/ui/KisView.cpp
index 4f26c4f5ac..dd2877f915 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,
+            KoCanvasResourceProvider *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)
+KisView::KisView(KisDocument *document, KoCanvasResourceProvider *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(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(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(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());
+                setResource(KoCanvasResourceProvider::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/KisView.h b/libs/ui/KisView.h
index a33127a0ab..480e3f94ca 100644
--- a/libs/ui/KisView.h
+++ b/libs/ui/KisView.h
@@ -1,294 +1,294 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2007 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.
 */
 #ifndef KIS_VIEW_H
 #define KIS_VIEW_H
 
 #include <QWidget>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 
 #include <kis_types.h>
 #include "kritaui_export.h"
 
 #include "widgets/kis_floating_message.h"
 
 class KisDocument;
 class KisMainWindow;
 class KisPrintJob;
 class KisCanvasController;
 class KisZoomManager;
 class KisCanvas2;
 class KisViewManager;
 class KisDocument;
 class KisCanvasResourceProvider;
 class KisCoordinatesConverter;
 class KisInputManager;
 
 class KoZoomController;
 class KoZoomController;
 struct KoPageLayout;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 // KDE classes
 class QAction;
 class KActionCollection;
 class KConfigGroup;
 
 // Qt classes
 class QDragEnterEvent;
 class QDropEvent;
 class QPrintDialog;
 class QCloseEvent;
 class QStatusBar;
 class QMdiSubWindow;
 
 /**
  * This class is used to display a @ref KisDocument.
  *
  * Multiple views can be attached to one document at a time.
  */
 class KRITAUI_EXPORT KisView : public QWidget
 {
     Q_OBJECT
 
 public:
     /**
      * Creates a new view for the document.
      */
-    KisView(KisDocument *document, KoCanvasResourceManager *resourceManager, KActionCollection *actionCollection, QWidget *parent = 0);
+    KisView(KisDocument *document, KoCanvasResourceProvider *resourceManager, KActionCollection *actionCollection, QWidget *parent = 0);
     ~KisView() override;
 
     // Temporary while teasing apart view and mainwindow
     void setViewManager(KisViewManager *view);
     KisViewManager *viewManager() const;
 
 public:
 
     /**
      *  Retrieves the document object of this view.
      */
     KisDocument *document() const;
 
     /**
      * Reset the view to show the given document.
      */
     void setDocument(KisDocument *document);
 
     /**
      * Tells this view that its document has got deleted (called internally)
      */
     void setDocumentDeleted();
 
     /**
      * In order to print the document represented by this view a new print job should
      * be constructed that is capable of doing the printing.
      * The default implementation returns 0, which silently cancels printing.
      */
     KisPrintJob * createPrintJob();
 
     /**
      * Create a QPrintDialog based on the @p printJob
      */
     QPrintDialog *createPrintDialog(KisPrintJob *printJob, QWidget *parent);
 
     /**
      * @return the KisMainWindow in which this view is currently.
      */
     KisMainWindow *mainWindow() const;
 
     /**
      * Tells this view which subwindow it is part of.
      */
     void setSubWindow(QMdiSubWindow *subWindow);
 
     /**
      * @return the statusbar of the KisMainWindow in which this view is currently.
      */
     QStatusBar *statusBar() const;
 
     /**
      * This adds a widget to the statusbar for this view.
      * If you use this method instead of using statusBar() directly,
      * KisView will take care of removing the items when the view GUI is deactivated
      * and readding them when it is reactivated.
      * The parameters are the same as QStatusBar::addWidget().
      */
     void addStatusBarItem(QWidget * widget, int stretch = 0, bool permanent = false);
 
     /**
      * Remove a widget from the statusbar for this view.
      */
     void removeStatusBarItem(QWidget * widget);
 
     /**
      * Return the zoomController for this view.
      */
     KoZoomController *zoomController() const;
 
     /// create a list of actions that when activated will change the unit on the document.
     QList<QAction*> createChangeUnitActions(bool addPixelUnit = false);
 
     void closeView();
 
 public:
 
     /**
      * The zoommanager handles everything action-related to zooming
      */
     KisZoomManager *zoomManager() const;
 
     /**
      * The CanvasController decorates the canvas with scrollbars
      * and knows where to start painting on the canvas widget, i.e.,
      * the document offset.
      */
     KisCanvasController *canvasController() const;
     KisCanvasResourceProvider *resourceProvider() const;
 
     /**
      * Filters events and sends them to canvas actions. Shared
      * among all the views/canvases
      *
      * NOTE: May be null while initialization!
      */
     KisInputManager* globalInputManager() const;
 
     /**
      * @return the canvas object
      */
     KisCanvas2 *canvasBase() const;
 
     /// @return the image this view is displaying
     KisImageWSP image() const;
 
 
     KisCoordinatesConverter *viewConverter() const;
 
     void resetImageSizeAndScroll(bool changeCentering,
                                  const QPointF &oldImageStillPoint = QPointF(),
                                  const QPointF &newImageStillPoint = QPointF());
 
     void setCurrentNode(KisNodeSP node);
     KisNodeSP currentNode() const;
     KisLayerSP currentLayer() const;
     KisMaskSP currentMask() const;
     /**
      * @brief softProofing
      * @return whether or not we're softproofing in this view.
      */
     bool softProofing();
     /**
      * @brief gamutCheck
      * @return whether or not we're using gamut warnings in this view.
      */
     bool gamutCheck();
 
     /// Convenience method to get at the active selection (the
     /// selection of the current layer, or, if that does not exist,
     /// the global selection.
     KisSelectionSP selection();
 
     void notifyCurrentStateChanged(bool isCurrent);
     bool isCurrent() const;
 
     void setShowFloatingMessage(bool show);
     void showFloatingMessageImpl(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment);
 
     bool canvasIsMirrored() const;
 
     void syncLastActiveNodeToDocument();
 
     void saveViewState(KisPropertiesConfiguration &config) const;
     void restoreViewState(const KisPropertiesConfiguration &config);
 
 public Q_SLOTS:
 
     /**
      * Display a message in the status bar (calls QStatusBar::message())
      * @todo rename to something more generic
      * @param value determines autosaving
      */
     void slotSavingStatusMessage(const QString &text, int timeout, bool isAutoSaving = false);
 
     /**
      * End of the message in the status bar (calls QStatusBar::clear())
      * @todo rename to something more generic
      */
     void slotClearStatusText();
     /**
      * @brief slotSoftProofing set whether or not we're softproofing in this view.
      * Will be setting the same in the canvas belonging to the view.
      */
     void slotSoftProofing(bool softProofing);
     /**
      * @brief slotGamutCheck set whether or not we're gamutchecking in this view.
      * Will be setting the same in the vans belonging to the view.
      */
     void slotGamutCheck(bool gamutCheck);
 
     bool queryClose();
 
 private Q_SLOTS:
     void slotImageNodeAdded(KisNodeSP node);
     void slotContinueAddNode(KisNodeSP newActiveNode);
 
     void slotImageNodeRemoved(KisNodeSP node);
     void slotContinueRemoveNode(KisNodeSP newActiveNode);
 
 Q_SIGNALS:
     // From KisImage
     void sigSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
     void sigProfileChanged(const KoColorProfile *  profile);
     void sigColorSpaceChanged(const KoColorSpace*  cs);
     void titleModified(QString,bool);
 
     void sigContinueAddNode(KisNodeSP newActiveNode);
     void sigContinueRemoveNode(KisNodeSP newActiveNode);
 
 protected:
 
     // QWidget overrides
     void dragEnterEvent(QDragEnterEvent * event) override;
     void dropEvent(QDropEvent * event) override;
     void closeEvent(QCloseEvent *event) override;
 
     /**
      * Generate a name for this view.
      */
     QString newObjectName();
 
 public Q_SLOTS:
     void slotLoadingFinished();
     void slotSavingFinished();
     void slotImageResolutionChanged();
     void slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
 
 
 private:
 
     class Private;
     Private * const d;
 
     static bool s_firstView;
 };
 
 #endif
diff --git a/libs/ui/KisViewManager.cpp b/libs/ui/KisViewManager.cpp
index ec7850c92f..e920d06808 100644
--- a/libs/ui/KisViewManager.cpp
+++ b/libs/ui/KisViewManager.cpp
@@ -1,1406 +1,1406 @@
 /*
  *  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;
+    KoCanvasResourceProvider 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)
+void KisViewManager::initializeResourceManager(KoCanvasResourceProvider *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(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(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());
 }
 
 void KisViewManager::slotActivateTransformTool()
 {
     if(KoToolManager::instance()->activeToolId() == "KisToolTransform") {
         KoToolBase* tool = KoToolManager::instance()->toolById(canvasBase(), "KisToolTransform");
 
         QSet<KoShape*> dummy;
         // Start a new stroke
         tool->deactivate();
         tool->activate(KoToolBase::DefaultActivation, dummy);
     }
 
     KoToolManager::instance()->switchToolRequested("KisToolTransform");
 }
diff --git a/libs/ui/KisViewManager.h b/libs/ui/KisViewManager.h
index a567434820..807114c603 100644
--- a/libs/ui/KisViewManager.h
+++ b/libs/ui/KisViewManager.h
@@ -1,258 +1,258 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_GUI_CLIENT_H
 #define KIS_GUI_CLIENT_H
 
 #include <QDockWidget>
 #include <QQueue>
 #include <QPointer>
 
 #include <KisMainWindow.h>
 #include <KoToolManager.h>
 
 #include <kritaui_export.h>
 #include <kis_types.h>
 
 #include "kis_floating_message.h"
 
 class QPoint;
 class KisView;
 
 class KisCanvas2;
 class KisCanvasResourceProvider;
 class KisDocument;
 class KisFilterManager;
 class KisGridManager;
 class KisGuidesManager;
 class KisImageManager;
 class KisNodeManager;
 class KisDecorationsManager;
 class KisPaintopBox;
 class KisSelectionManager;
 class KisStatusBar;
 class KisUndoAdapter;
 class KisZoomManager;
 class KisPaintopBox;
 class KisActionManager;
 class KisInputManager;
 class KoUpdater;
 class KoProgressUpdater;
 
 /**
  * KisViewManager manages the collection of views shown in a single mainwindow.
  */
 class KRITAUI_EXPORT KisViewManager : public QObject
 {
 
     Q_OBJECT
 
 public:
     /**
      * Construct a new view on the krita document.
      * @param document   the document we show.
      * @param parent   a parent widget we show ourselves in.
      */
     KisViewManager(QWidget *parent, KActionCollection *actionCollection);
     ~KisViewManager() override;
 
     /**
      * Retrieves the entire action collection.
      */
     virtual KActionCollection* actionCollection() const;
 
 public:  // Krita specific interfaces
 
     void setCurrentView(KisView *view);
 
     /// Return the image this view is displaying
     KisImageWSP image() const;
 
     KoZoomController *zoomController() const;
 
     /// The resource provider contains all per-view settings, such as
     /// current color, current paint op etc.
     KisCanvasResourceProvider *resourceProvider();
 
     /// Return the canvasbase class
     KisCanvas2 *canvasBase() const;
 
     /// Return the actual widget that is displaying the current image
     QWidget* canvas() const;
 
     /// Return the wrapper class around the statusbar
     KisStatusBar *statusBar() const;
 
     KisPaintopBox* paintOpBox() const;
 
     /// create a new progress updater
     QPointer<KoUpdater> createUnthreadedUpdater(const QString &name);
     QPointer<KoUpdater> createThreadedUpdater(const QString &name);
 
     /// The selection manager handles everything action related to
     /// selections.
     KisSelectionManager *selectionManager();
 
     /// The node manager handles everything about nodes
     KisNodeManager *nodeManager() const;
 
     KisActionManager *actionManager() const;
 
     /**
      * Convenience method to get at the active node, which may be
      * a layer or a mask or a selection
      */
     KisNodeSP activeNode();
 
     /// Convenience method to get at the active layer
     KisLayerSP activeLayer();
 
     /// Convenience method to get at the active paint device
     KisPaintDeviceSP activeDevice();
 
     /// The filtermanager handles everything action-related to filters
     KisFilterManager *filterManager();
 
     /// The image manager handles everything action-related to the
     /// current image
     KisImageManager *imageManager();
 
     /// Filters events and sends them to canvas actions
     KisInputManager *inputManager() const;
 
     /// Convenience method to get at the active selection (the
     /// selection of the current layer, or, if that does not exist,
     /// the global selection.
     KisSelectionSP selection();
 
     /// Checks if the current global or local selection is editable
     bool selectionEditable();
 
     /// The undo adapter is used to add commands to the undo stack
     KisUndoAdapter *undoAdapter();
 
     KisDocument *document() const;
 
     int viewCount() const;
 
     /**
      * @brief blockUntilOperationsFinished blocks the GUI of the application until execution
      *        of actions on \p image is finished
      * @param image the image which we should wait for
      * @return true if the image has finished execution of the actions, false if
      *         the user cancelled operation
      */
     bool blockUntilOperationsFinished(KisImageSP image);
 
 
     /**
      * @brief blockUntilOperationsFinished blocks the GUI of the application until execution
      *        of actions on \p image is finished. Does *not* provide a "Cancel" button. So the
      *        user is forced to wait.
      * @param image the image which we should wait for
      */
     void blockUntilOperationsFinishedForced(KisImageSP image);
 
 public:
 
     KisGridManager * gridManager() const;
     KisGuidesManager * guidesManager() const;
 
     /// disable and enable toolbar controls. used for disabling them during painting.
     void enableControls();
     void disableControls();
 
 
     /// shows a floating message in the top right corner of the canvas
     void showFloatingMessage(const QString &message, const QIcon& icon, int timeout = 4500,
                              KisFloatingMessage::Priority priority = KisFloatingMessage::Medium,
                              int alignment = Qt::AlignCenter | Qt::TextWordWrap);
 
     /// @return the KoMaindow this view is in, or 0
     KisMainWindow *mainWindow() const;
 
     /// The QMainWindow associated with this view. This is most likely going to be shell(), but
     /// when running as Gemini or Sketch, this will be set to the applications' own QMainWindow.
     /// This can be checked by qobject_casting to KisMainWindow to check the difference.
     QMainWindow* qtMainWindow() const;
 
     /// The mainWindow function will return the shell() value, unless this function is called
     /// with a non-null value. To make it return shell() again, simply pass null to this function.
     void setQtMainWindow(QMainWindow* newMainWindow);
 
-    static void initializeResourceManager(KoCanvasResourceManager *resourceManager);
+    static void initializeResourceManager(KoCanvasResourceProvider *resourceManager);
 
 public Q_SLOTS:
 
     void switchCanvasOnly(bool toggled);
     void setShowFloatingMessage(bool show);
     void showHideScrollbars();
 
     /// Visit all managers to update gui elements, e.g. enable / disable actions.
     /// This is heavy-duty call, so it uses a compressor.
     void updateGUI();
 
     /// Update the style of all the icons
     void updateIcons();
 
     void slotViewAdded(KisView *view);
     void slotViewRemoved(KisView *view);
     
     void slotActivateTransformTool();
 
 Q_SIGNALS:
 
     void floatingMessageRequested(const QString &message, const QString &iconName);
     /**
      * @brief viewChanged
      * sent out when the view has changed.
      */
     void viewChanged();
 
 private Q_SLOTS:
 
     void slotBlacklistCleanup();
     void slotCreateTemplate();
     void slotCreateCopy();
     void slotDocumentSaved();
     void slotSaveIncremental();
     void slotSaveIncrementalBackup();
     void showStatusBar(bool toggled);
     void toggleTabletLogger();
     void openResourcesDirectory();
     void initializeStatusBarVisibility();
     void guiUpdateTimeout();
     void changeAuthorProfile(const QString &profileName);
     void slotUpdateAuthorProfileActions();
     void slotUpdatePixelGridAction();
     void slotSaveShowRulersState(bool value);
     void slotSaveRulersTrackMouseState(bool value);
 
 private:
     void createActions();
     void setupManagers();
 
     /// The zoommanager handles everything action-related to zooming
     KisZoomManager * zoomManager();
 
 private:
     class KisViewManagerPrivate;
     KisViewManagerPrivate * const d;
 };
 
 #endif
diff --git a/libs/ui/actions/kis_selection_action_factories.cpp b/libs/ui/actions/kis_selection_action_factories.cpp
index 513f30d7ef..b00427cdad 100644
--- a/libs/ui/actions/kis_selection_action_factories.cpp
+++ b/libs/ui/actions/kis_selection_action_factories.cpp
@@ -1,649 +1,649 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_action_factories.h"
 
 #include <QMimeData>
 
 #include <klocalizedstring.h>
 #include <kundo2command.h>
 
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <KoPathShape.h>
 #include <KoShapeController.h>
 #include <KoShapeRegistry.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
 #include <KoDocumentResourceManager.h>
 #include <KoShapeStroke.h>
 #include <KoDocumentInfo.h>
 
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_pixel_selection.h"
 #include "kis_paint_layer.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_fill_painter.h"
 #include "kis_transaction.h"
 #include "kis_iterator_ng.h"
 #include "kis_processing_applicator.h"
 #include "kis_group_layer.h"
 #include "commands/kis_selection_commands.h"
 #include "commands/kis_image_layer_add_command.h"
 #include "kis_tool_proxy.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_selection_manager.h"
 #include "commands_new/kis_transaction_based_command.h"
 #include "kis_selection_filters.h"
 #include "kis_shape_selection.h"
 #include "kis_shape_layer.h"
 #include <kis_shape_controller.h>
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_keyframe_channel.h"
 
 
 #include <processing/fill_processing_visitor.h>
 #include <kis_selection_tool_helper.h>
 
 #include "kis_figure_painting_tool_helper.h"
 #include "kis_update_outline_job.h"
 
 namespace ActionHelper {
 
     void copyFromDevice(KisViewManager *view,
                         KisPaintDeviceSP device,
                         bool makeSharpClip = false,
                         const KisTimeRange &range = KisTimeRange())
     {
         KisImageWSP image = view->image();
         if (!image) return;
 
         KisSelectionSP selection = view->selection();
 
         QRect rc = (selection) ? selection->selectedExactRect() : image->bounds();
 
         KisPaintDeviceSP clip = new KisPaintDevice(device->colorSpace());
         Q_CHECK_PTR(clip);
 
         const KoColorSpace *cs = clip->colorSpace();
 
         // TODO if the source is linked... copy from all linked layers?!?
 
         // Copy image data
         KisPainter::copyAreaOptimized(QPoint(), device, clip, rc);
 
         if (selection) {
             // Apply selection mask.
             KisPaintDeviceSP selectionProjection = selection->projection();
             KisHLineIteratorSP layerIt = clip->createHLineIteratorNG(0, 0, rc.width());
             KisHLineConstIteratorSP selectionIt = selectionProjection->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 
             const KoColorSpace *selCs = selection->projection()->colorSpace();
 
             for (qint32 y = 0; y < rc.height(); y++) {
 
                 for (qint32 x = 0; x < rc.width(); x++) {
 
                     /**
                      * Sharp method is an exact reverse of COMPOSITE_OVER
                      * so if you cover the cut/copied piece over its source
                      * you get an exactly the same image without any seams
                      */
                     if (makeSharpClip) {
                         qreal dstAlpha = cs->opacityF(layerIt->rawData());
                         qreal sel = selCs->opacityF(selectionIt->oldRawData());
                         qreal newAlpha = sel * dstAlpha / (1.0 - dstAlpha + sel * dstAlpha);
                         float mask = newAlpha / dstAlpha;
 
                         cs->applyAlphaNormedFloatMask(layerIt->rawData(), &mask, 1);
                     } else {
                         cs->applyAlphaU8Mask(layerIt->rawData(), selectionIt->oldRawData(), 1);
                     }
 
                     layerIt->nextPixel();
                     selectionIt->nextPixel();
                 }
                 layerIt->nextRow();
                 selectionIt->nextRow();
             }
         }
 
         KisClipboard::instance()->setClip(clip, rc.topLeft(), range);
     }
 
 }
 
 void KisSelectAllActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
 
     KisProcessingApplicator *ap = beginAction(view, kundo2_i18n("Select All"));
 
     if (!image->globalSelection()) {
         ap->applyCommand(new KisSetEmptyGlobalSelectionCommand(image),
                          KisStrokeJobData::SEQUENTIAL,
                          KisStrokeJobData::EXCLUSIVE);
     }
 
     struct SelectAll : public KisTransactionBasedCommand {
         SelectAll(KisImageSP image) : m_image(image) {}
         KisImageSP m_image;
         KUndo2Command* paint() override {
             KisSelectionSP selection = m_image->globalSelection();
             KisSelectionTransaction transaction(selection->pixelSelection());
             selection->pixelSelection()->clear();
             selection->pixelSelection()->select(m_image->bounds());
             return transaction.endAndTake();
         }
     };
 
     ap->applyCommand(new SelectAll(image),
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::EXCLUSIVE);
 
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisDeselectActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
 
     KUndo2Command *cmd = new KisDeselectActiveSelectionCommand(view->selection(), image);
 
     KisProcessingApplicator *ap = beginAction(view, cmd->text());
     ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisReselectActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
 
     KUndo2Command *cmd = new KisReselectActiveSelectionCommand(view->activeNode(), image);
 
     KisProcessingApplicator *ap = beginAction(view, cmd->text());
     ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisFillActionFactory::run(const QString &fillSource, KisViewManager *view)
 {
     KisNodeSP node = view->activeNode();
     if (!node || !node->hasEditablePaintDevice()) return;
 
     KisSelectionSP selection = view->selection();
     QRect selectedRect = selection ?
                          selection->selectedRect() : view->image()->bounds();
     Q_UNUSED(selectedRect);
     KisPaintDeviceSP filled = node->paintDevice()->createCompositionSourceDevice();
     Q_UNUSED(filled);
     bool usePattern = false;
     bool useBgColor = false;
 
     if (fillSource.contains("pattern")) {
         usePattern = true;
     } else if (fillSource.contains("bg")) {
         useBgColor = true;
     }
 
     KisProcessingApplicator applicator(view->image(), node,
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        kundo2_i18n("Flood Fill Layer"));
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(view->image(), node, view->resourceProvider()->resourceManager());
     if (!fillSource.contains("opacity")) {
         resources->setOpacity(1.0);
     }
 
     KisProcessingVisitorSP visitor =
         new FillProcessingVisitor(QPoint(0, 0), // start position
                                   selection,
                                   resources,
                                   false, // fast mode
                                   usePattern,
                                   true, // fill only selection,
                                   0, // feathering radius
                                   0, // sizemod
                                   80, // threshold,
                                   false, // unmerged
                                   useBgColor);
 
     applicator.applyVisitor(visitor,
                             KisStrokeJobData::SEQUENTIAL,
                             KisStrokeJobData::EXCLUSIVE);
 
     applicator.end();
 }
 
 void KisClearActionFactory::run(KisViewManager *view)
 {
     // XXX: "Add saving of XML data for Clear action"
 
     view->canvasBase()->toolProxy()->deleteSelection();
 }
 
 void KisImageResizeToSelectionActionFactory::run(KisViewManager *view)
 {
     // XXX: "Add saving of XML data for Image Resize To Selection action"
 
     KisSelectionSP selection = view->selection();
     if (!selection) return;
 
     view->image()->cropImage(selection->selectedExactRect());
 }
 
 void KisCutCopyActionFactory::run(bool willCut, bool makeSharpClip, KisViewManager *view)
 {
     KisImageSP image = view->image();
     if (!image) return;
 
     bool haveShapesSelected = view->selectionManager()->haveShapesSelected();
 
     if (haveShapesSelected) {
         // XXX: "Add saving of XML data for Cut/Copy of shapes"
 
         KisImageBarrierLocker locker(image);
         if (willCut) {
             view->canvasBase()->toolProxy()->cut();
         } else {
             view->canvasBase()->toolProxy()->copy();
         }
     } else {
         KisNodeSP node = view->activeNode();
         if (!node) return;
 
         KisSelectionSP selection = view->selection();
         if (selection.isNull()) return;
 
         {
             KisImageBarrierLocker locker(image);
             KisPaintDeviceSP dev = node->paintDevice();
             if (!dev) {
                 dev = node->projection();
             }
 
             if (!dev) {
                 view->showFloatingMessage(
                     i18nc("floating message when cannot copy from a node",
                           "Cannot copy pixels from this type of layer "),
                     QIcon(), 3000, KisFloatingMessage::Medium);
 
                 return;
             }
 
             if (dev->exactBounds().isEmpty()) {
                 view->showFloatingMessage(
                     i18nc("floating message when copying empty selection",
                           "Selection is empty: no pixels were copied "),
                     QIcon(), 3000, KisFloatingMessage::Medium);
 
                 return;
             }
 
             KisTimeRange range;
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (channel) {
                 const int currentTime = image->animationInterface()->currentTime();
                 range = channel->affectedFrames(currentTime);
             }
 
             ActionHelper::copyFromDevice(view, dev, makeSharpClip, range);
         }
 
         KUndo2Command *command = 0;
 
         if (willCut && node->hasEditablePaintDevice()) {
             struct ClearSelection : public KisTransactionBasedCommand {
                 ClearSelection(KisNodeSP node, KisSelectionSP sel)
                     : m_node(node), m_sel(sel) {}
                 KisNodeSP m_node;
                 KisSelectionSP m_sel;
 
                 KUndo2Command* paint() override {
                     KisSelectionSP cutSelection = m_sel;
                     // Shrinking the cutting area was previously used
                     // for getting seamless cut-paste. Now we use makeSharpClip
                     // instead.
                     // QRect originalRect = cutSelection->selectedExactRect();
                     // static const int preciseSelectionThreshold = 16;
                     //
                     // if (originalRect.width() > preciseSelectionThreshold ||
                     //     originalRect.height() > preciseSelectionThreshold) {
                     //     cutSelection = new KisSelection(*m_sel);
                     //     delete cutSelection->flatten();
                     //
                     //     KisSelectionFilter* filter = new KisShrinkSelectionFilter(1, 1, false);
                     //
                     //     QRect processingRect = filter->changeRect(originalRect);
                     //     filter->process(cutSelection->pixelSelection(), processingRect);
                     // }
 
                     KisTransaction transaction(m_node->paintDevice());
                     m_node->paintDevice()->clearSelection(cutSelection);
                     m_node->setDirty(cutSelection->selectedRect());
                     return transaction.endAndTake();
                 }
             };
 
             command = new ClearSelection(node, selection);
         }
 
         KUndo2MagicString actionName = willCut ?
                     kundo2_i18n("Cut") :
                     kundo2_i18n("Copy");
         KisProcessingApplicator *ap = beginAction(view, actionName);
 
         if (command) {
             ap->applyCommand(command,
                              KisStrokeJobData::SEQUENTIAL,
                              KisStrokeJobData::NORMAL);
         }
 
         KisOperationConfiguration config(id());
         config.setProperty("will-cut", willCut);
         endAction(ap, config.toXML());
     }
 }
 
 void KisCopyMergedActionFactory::run(KisViewManager *view)
 {
     KisImageWSP image = view->image();
     if (!image) return;
     if (!view->blockUntilOperationsFinished(image)) return;
 
     image->barrierLock();
     KisPaintDeviceSP dev = image->root()->projection();
     ActionHelper::copyFromDevice(view, dev);
     image->unlock();
 
     KisProcessingApplicator *ap = beginAction(view, kundo2_i18n("Copy Merged"));
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisPasteNewActionFactory::run(KisViewManager *viewManager)
 {
     Q_UNUSED(viewManager);
 
     KisPaintDeviceSP clip = KisClipboard::instance()->clip(QRect(), true);
     if (!clip) return;
 
     QRect rect = clip->exactBounds();
     if (rect.isEmpty()) return;
 
     KisDocument *doc = KisPart::instance()->createDocument();
     doc->documentInfo()->setAboutInfo("title", i18n("Untitled"));
     KisImageSP image = new KisImage(doc->createUndoStore(),
                                     rect.width(),
                                     rect.height(),
                                     clip->colorSpace(),
                                     i18n("Pasted"));
     KisPaintLayerSP layer =
         new KisPaintLayer(image.data(), image->nextLayerName() + " " + i18n("(pasted)"),
                           OPACITY_OPAQUE_U8, clip->colorSpace());
 
     KisPainter::copyAreaOptimized(QPoint(), clip, layer->paintDevice(), rect);
 
     image->addNode(layer.data(), image->rootLayer());
     doc->setCurrentImage(image);
     KisPart::instance()->addDocument(doc);
 
     KisMainWindow *win = viewManager->mainWindow();
     win->addViewAndNotifyLoadingCompleted(doc);
 }
 
 void KisInvertSelectionOperation::runFromXML(KisViewManager* view, const KisOperationConfiguration& config)
 {
     KisSelectionFilter* filter = new KisInvertSelectionFilter();
     runFilter(filter, view, config);
 }
 
 void KisSelectionToVectorActionFactory::run(KisViewManager *view)
 {
     KisSelectionSP selection = view->selection();
 
     if (selection->hasShapeSelection()) {
         view->showFloatingMessage(i18nc("floating message",
                                         "Selection is already in a vector format "),
                                   QIcon(), 2000, KisFloatingMessage::Low);
         return;
     }
 
     if (!selection->outlineCacheValid()) {
         view->image()->addSpontaneousJob(new KisUpdateOutlineJob(selection, false, Qt::transparent));
         if (!view->blockUntilOperationsFinished(view->image())) {
             return;
         }
     }
 
     QPainterPath selectionOutline = selection->outlineCache();
     QTransform transform = view->canvasBase()->coordinatesConverter()->imageToDocumentTransform();
 
     KoShape *shape = KoPathShape::createShapeFromPainterPath(transform.map(selectionOutline));
     shape->setShapeId(KoPathShapeId);
 
     /**
      * Mark a shape that it belongs to a shape selection
      */
     if(!shape->userData()) {
         shape->setUserData(new KisShapeSelectionMarker);
     }
 
     KisProcessingApplicator *ap = beginAction(view, kundo2_i18n("Convert to Vector Selection"));
 
     ap->applyCommand(view->canvasBase()->shapeController()->addShape(shape, 0),
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::EXCLUSIVE);
 
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisSelectionToRasterActionFactory::run(KisViewManager *view)
 {
     KisSelectionSP selection = view->selection();
 
     if (!selection->hasShapeSelection()) {
         view->showFloatingMessage(i18nc("floating message",
                                         "Selection is already in a raster format "),
                                   QIcon(), 2000, KisFloatingMessage::Low);
         return;
     }
 
     KisProcessingApplicator *ap = beginAction(view, kundo2_i18n("Convert to Vector Selection"));
 
     struct RasterizeSelection : public KisTransactionBasedCommand {
         RasterizeSelection(KisSelectionSP sel)
             : m_sel(sel) {}
         KisSelectionSP m_sel;
 
         KUndo2Command* paint() override {
             // just create an empty transaction: it will rasterize the
             // selection and emit the necessary signals
 
             KisTransaction transaction(m_sel->pixelSelection());
             return transaction.endAndTake();
         }
     };
 
     ap->applyCommand(new RasterizeSelection(selection),
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::EXCLUSIVE);
 
     endAction(ap, KisOperationConfiguration(id()).toXML());
 }
 
 void KisShapesToVectorSelectionActionFactory::run(KisViewManager* view)
 {
     const QList<KoShape*> originalShapes = view->canvasBase()->shapeManager()->selection()->selectedShapes();
 
     bool hasSelectionShapes = false;
     QList<KoShape*> clonedShapes;
 
     Q_FOREACH (KoShape *shape, originalShapes) {
         if (dynamic_cast<KisShapeSelectionMarker*>(shape->userData())) {
             hasSelectionShapes = true;
             continue;
         }
         clonedShapes << shape->cloneShape();
     }
 
     if (clonedShapes.isEmpty()) {
         if (hasSelectionShapes) {
             view->showFloatingMessage(i18nc("floating message",
                                             "The shape already belongs to a selection"),
                                       QIcon(), 2000, KisFloatingMessage::Low);
         }
         return;
     }
 
     KisSelectionToolHelper helper(view->canvasBase(), kundo2_i18n("Convert shapes to vector selection"));
     helper.addSelectionShapes(clonedShapes);
 }
 
 void KisSelectionToShapeActionFactory::run(KisViewManager *view)
 {
     KisSelectionSP selection = view->selection();
     if (!selection->outlineCacheValid()) {
         return;
     }
 
     QPainterPath selectionOutline = selection->outlineCache();
     QTransform transform = view->canvasBase()->coordinatesConverter()->imageToDocumentTransform();
 
     KoShape *shape = KoPathShape::createShapeFromPainterPath(transform.map(selectionOutline));
     shape->setShapeId(KoPathShapeId);
 
-    KoColor fgColor = view->canvasBase()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
+    KoColor fgColor = view->canvasBase()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     KoShapeStrokeSP border(new KoShapeStroke(1.0, fgColor.toQColor()));
     shape->setStroke(border);
 
     view->document()->shapeController()->addShape(shape);
 }
 
 void KisStrokeSelectionActionFactory::run(KisViewManager *view, StrokeSelectionOptions params)
 {
     KisImageWSP image = view->image();
     if (!image) {
         return;
     }
 
     KisSelectionSP selection = view->selection();
     if (!selection) {
         return;
     }
 
     int size = params.lineSize;
 
     KisPixelSelectionSP pixelSelection = selection->projection();
     if (!pixelSelection->outlineCacheValid()) {
         pixelSelection->recalculateOutlineCache();
     }
 
     QPainterPath outline = pixelSelection->outlineCache();
     QColor color = params.color.toQColor();
 
     KisNodeSP currentNode = view->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     if (!currentNode->inherits("KisShapeLayer") && currentNode->paintDevice()) {
-        KoCanvasResourceManager * rManager = view->resourceProvider()->resourceManager();
+        KoCanvasResourceProvider * rManager = view->resourceProvider()->resourceManager();
         KisPainter::StrokeStyle strokeStyle =  KisPainter::StrokeStyleBrush;
         KisPainter::FillStyle fillStyle =  params.fillStyle();
 
         KisFigurePaintingToolHelper helper(kundo2_i18n("Draw Polyline"),
                                        image,
                                        currentNode,
                                        rManager ,
                                        strokeStyle,
                                        fillStyle);
         helper.setFGColorOverride(params.color);
         helper.setSelectionOverride(0);
         QPen pen(Qt::red, size);
         pen.setJoinStyle(Qt::RoundJoin);
 
         if (fillStyle != KisPainter::FillStyleNone) {
             helper.paintPainterPathQPenFill(outline, pen, params.fillColor);
         }
         else {
             helper.paintPainterPathQPen(outline, pen, params.fillColor);
         }
     }
     else if (currentNode->inherits("KisShapeLayer")) {
 
         QTransform transform = view->canvasBase()->coordinatesConverter()->imageToDocumentTransform();
 
         KoShape *shape = KoPathShape::createShapeFromPainterPath(transform.map(outline));
         shape->setShapeId(KoPathShapeId);
 
         KoShapeStrokeSP border(new KoShapeStroke(size, color));
         shape->setStroke(border);
 
         view->document()->shapeController()->addShape(shape);
     }
     image->setModified();
 
 }
 
 void KisStrokeBrushSelectionActionFactory::run(KisViewManager *view, StrokeSelectionOptions params)
 {
     KisImageWSP image = view->image();
     if (!image) {
         return;
     }
 
     KisSelectionSP selection = view->selection();
     if (!selection) {
         return;
     }
 
     KisPixelSelectionSP pixelSelection = selection->projection();
     if (!pixelSelection->outlineCacheValid()) {
         pixelSelection->recalculateOutlineCache();
     }
 
     KisNodeSP currentNode = view->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     if (!currentNode->inherits("KisShapeLayer") && currentNode->paintDevice())
     {
-        KoCanvasResourceManager * rManager = view->resourceProvider()->resourceManager();
+        KoCanvasResourceProvider * rManager = view->resourceProvider()->resourceManager();
         QPainterPath outline = pixelSelection->outlineCache();
         KisPainter::StrokeStyle strokeStyle =  KisPainter::StrokeStyleBrush;
         KisPainter::FillStyle fillStyle =  KisPainter::FillStyleNone;
         KoColor color = params.color;
 
         KisFigurePaintingToolHelper helper(kundo2_i18n("Draw Polyline"),
                                        image,
                                        currentNode,
                                        rManager ,
                                        strokeStyle,
                                        fillStyle);
         helper.setFGColorOverride(color);
         helper.setSelectionOverride(0);
         helper.paintPainterPath(outline);
         image->setModified();
     }
 }
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index 1d07dfe1ba..dd386b5424 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)
+    KisCanvas2Private(KoCanvasBase *parent, KisCoordinatesConverter* coordConverter, QPointer<KisView> view, KoCanvasResourceProvider* 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)
+KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceProvider *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()),
             selectedShapesProxy(), SIGNAL(selectionContentChanged()));
     connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             selectedShapesProxy(), 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(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_canvas2.h b/libs/ui/canvas/kis_canvas2.h
index 639ace1930..d7a1b731ed 100644
--- a/libs/ui/canvas/kis_canvas2.h
+++ b/libs/ui/canvas/kis_canvas2.h
@@ -1,354 +1,354 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2011       Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CANVAS_H
 #define KIS_CANVAS_H
 
 #include <QObject>
 #include <QWidget>
 #include <QSize>
 #include <QString>
 
 #include <KoConfig.h>
 #include <KoColorConversionTransformation.h>
 #include <KoCanvasBase.h>
 #include <kritaui_export.h>
 #include <kis_types.h>
 #include <KoPointerEvent.h>
 
 #include "opengl/kis_opengl.h"
 
 #include "kis_ui_types.h"
 #include "kis_coordinates_converter.h"
 #include "kis_canvas_decoration.h"
 #include "kis_painting_assistants_decoration.h"
 #include "input/KisInputActionGroup.h"
 #include "KisReferenceImagesDecoration.h"
 
 class KoToolProxy;
 class KoColorProfile;
 
 
 class KisViewManager;
 class KisFavoriteResourceManager;
 class KisDisplayFilter;
 class KisDisplayColorConverter;
 struct KisExposureGammaCorrectionInterface;
 class KisView;
 class KisInputManager;
 class KisAnimationPlayer;
 class KisShapeController;
 class KisCoordinatesConverter;
 class KoViewConverter;
 class KisAbstractCanvasWidget;
 
 /**
  * KisCanvas2 is not an actual widget class, but rather an adapter for
  * the widget it contains, which may be either a QPainter based
  * canvas, or an OpenGL based canvas: that are the real widgets.
  */
 class KRITAUI_EXPORT KisCanvas2 : public KoCanvasBase, public KisInputActionGroupsMaskInterface
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * Create a new canvas. The canvas manages a widget that will do
      * the actual painting: the canvas itself is not a widget.
      *
      * @param viewConverter the viewconverter for converting between
      *                       window and document coordinates.
      */
-    KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeControllerBase *sc);
+    KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceProvider *resourceManager, KisView *view, KoShapeControllerBase *sc);
 
     ~KisCanvas2() override;
 
     void notifyZoomChanged();
 
     void disconnectCanvasObserver(QObject *object) override;
 
 public: // KoCanvasBase implementation
 
     bool canvasIsOpenGL() const override;
 
     KisOpenGL::FilterMode openGLFilterMode() const;
 
     void gridSize(QPointF *offset, QSizeF *spacing) const override;
 
     bool snapToGrid() const override;
 
     // This method only exists to support flake-related operations
     void addCommand(KUndo2Command *command) override;
 
     QPoint documentOrigin() const override;
     QPoint documentOffset() const;
 
     /**
      * Return the right shape manager for the current layer. That is
      * to say, if the current layer is a vector layer, return the shape
      * layer's canvas' shapemanager, else the shapemanager associated
      * with the global krita canvas.
      */
     KoShapeManager * shapeManager() const override;
 
     /**
      * Since shapeManager() may change, we need a persistent object where we can
      * connect to and thack the selection. See more comments in KoCanvasBase.
      */
     KoSelectedShapesProxy *selectedShapesProxy() const override;
 
     /**
      * Return the shape manager associated with this canvas
      */
     KoShapeManager *globalShapeManager() const;
 
     /**
      * Return shape manager associated with the currently active node.
      * If current node has no internal shape manager, return null.
      */
     KoShapeManager *localShapeManager() const;
 
 
     void updateCanvas(const QRectF& rc) override;
 
     void updateInputMethodInfo() override;
 
     const KisCoordinatesConverter* coordinatesConverter() const;
     KoViewConverter *viewConverter() const override;
 
     QWidget* canvasWidget() override;
 
     const QWidget* canvasWidget() const override;
 
     KoUnit unit() const override;
 
     KoToolProxy* toolProxy() const override;
 
     const KoColorProfile* monitorProfile();
 
     // FIXME:
     // Temporary! Either get the current layer and image from the
     // resource provider, or use this, which gets them from the
     // current shape selection.
     KisImageWSP currentImage() const;
 
     /**
      * Filters events and sends them to canvas actions. Shared
      * among all the views/canvases
      *
      * NOTE: May be null while initialization!
      */
     KisInputManager* globalInputManager() const;
 
     /**
      * Return the mask of currently available input action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     KisInputActionGroupsMask inputActionGroupsMask() const override;
 
     /**
      * Set the mask of currently available action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     void setInputActionGroupsMask(KisInputActionGroupsMask mask) override;
 
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration() const;
     KisReferenceImagesDecorationSP referenceImagesDecoration() const;
 
 public: // KisCanvas2 methods
 
     KisImageWSP image() const;
     KisViewManager* viewManager() const;
     QPointer<KisView> imageView() const;
 
     /// @return true if the canvas image should be displayed in vertically mirrored mode
     void addDecoration(KisCanvasDecorationSP deco);
     KisCanvasDecorationSP decoration(const QString& id) const;
 
     void setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter);
     QSharedPointer<KisDisplayFilter> displayFilter() const;
 
     KisDisplayColorConverter *displayColorConverter() const;
     KisExposureGammaCorrectionInterface* exposureGammaCorrectionInterface() const;
 
     /**
      * @brief setProofingOptions
      * set the options for softproofing, without affecting the proofing options as stored inside the image.
      */
     void setProofingOptions(bool softProof, bool gamutCheck);
     KisProofingConfigurationSP proofingConfiguration() const;
 
     /**
      * @brief setProofingConfigUpdated This function is to set whether the proofing config is updated,
      * this is needed for determining whether or not to generate a new proofing transform.
      * @param updated whether it's updated. Just set it to false in normal usage.
      */
     void setProofingConfigUpdated(bool updated);
 
     /**
      * @brief proofingConfigUpdated ask the canvas whether or not it updated the proofing config.
      * @return whether or not the proofing config is updated, if so, a new proofing transform needs to be made
      * in KisOpenGL canvas.
      */
     bool proofingConfigUpdated();
 
     void setCursor(const QCursor &cursor) override;
     KisAnimationFrameCacheSP frameCache() const;
     KisAnimationPlayer *animationPlayer() const;
     void refetchDataFromImage();
 
     /**
      * @return area of the image (in image coordinates) that is visible on the canvas
      * with a small margin selected by the user
      */
     QRect regionOfInterest() const;
 
     /**
      * Set aftificial limit outside which the image will not be rendered
      * \p rc is measured in image pixels
      */
     void setRenderingLimit(const QRect &rc);
 
     /**
      * @return aftificial limit outside which the image will not be rendered
      */
     QRect renderingLimit() const;
 
 Q_SIGNALS:
     void sigCanvasEngineChanged();
 
     void sigCanvasCacheUpdated();
     void sigContinueResizeImage(qint32 w, qint32 h);
 
     void documentOffsetUpdateFinished();
 
     // emitted whenever the canvas widget thinks sketch should update
     void updateCanvasRequested(const QRect &rc);
 
     void sigRegionOfInterestChanged(const QRect &roi);
 
 public Q_SLOTS:
 
     /// Update the entire canvas area
     void updateCanvas();
 
     void startResizingImage();
     void finishResizingImage(qint32 w, qint32 h);
 
     /// canvas rotation in degrees
     qreal rotationAngle() const;
     /// Bools indicating canvasmirroring.
     bool xAxisMirrored() const;
     bool yAxisMirrored() const;
     void slotSoftProofing(bool softProofing);
     void slotGamutCheck(bool gamutCheck);
     void slotChangeProofingConfig();
     void slotPopupPaletteRequestedZoomChange(int zoom);
 
     void channelSelectionChanged();
 
     /**
      * Called whenever the display monitor profile resource changes
      */
     void slotSetDisplayProfile(const KoColorProfile *profile);
     void startUpdateInPatches(const QRect &imageRect);
 
     void slotTrySwitchShapeManager();
 
     /**
      * Called whenever the configuration settings change.
      */
     void slotConfigChanged();
 
 
 private Q_SLOTS:
 
     /// The image projection has changed, now start an update
     /// of the canvas representation.
     void startUpdateCanvasProjection(const QRect & rc);
     void updateCanvasProjection();
 
     void slotBeginUpdatesBatch();
     void slotEndUpdatesBatch();
     void slotSetLodUpdatesBlocked(bool value);
 
     /**
      * Called whenever the view widget needs to show a different part of
      * the document
      *
      * @param documentOffset the offset in widget pixels
      */
     void documentOffsetMoved(const QPoint &documentOffset);
 
     void slotSelectionChanged();
 
     void slotDoCanvasUpdate();
 
     void bootstrapFinished();
 
     void slotUpdateRegionOfInterest();
 
     void slotReferenceImagesChanged();
 
 public:
 
     bool isPopupPaletteVisible() const;
     void slotShowPopupPalette(const QPoint& = QPoint(0,0));
 
     // interface for KisCanvasController only
     void setWrapAroundViewingMode(bool value);
     bool wrapAroundViewingMode() const;
 
     void setLodAllowedInCanvas(bool value);
     bool lodAllowedInCanvas() const;
 
     void initializeImage();
 
     void setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager);
 
 private:
     Q_DISABLE_COPY(KisCanvas2)
 
     void connectCurrentCanvas();
     void createCanvas(bool useOpenGL);
     void createQPainterCanvas();
     void createOpenGLCanvas();
     void updateCanvasWidgetImpl(const QRect &rc = QRect());
     void setCanvasWidget(KisAbstractCanvasWidget *widget);
     void resetCanvas(bool useOpenGL);
 
     void notifyLevelOfDetailChange();
 
     // Completes construction of canvas.
     // To be called by KisView in its constructor, once it has been setup enough
     // (to be defined what that means) for things KisCanvas2 expects from KisView
     // TODO: see to avoid that
     void setup();
 
     void initializeFpsDecoration();
 
 private:
     friend class KisView; // calls setup()
     class KisCanvas2Private;
     KisCanvas2Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/canvas/kis_display_color_converter.cpp b/libs/ui/canvas/kis_display_color_converter.cpp
index 25d1f3b8b6..d5c2bd7297 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 <KoCanvasResourceProvider.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)
+    Private(KisDisplayColorConverter *_q, KoCanvasResourceProvider *_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;
+    KoCanvasResourceProvider *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)
+        DisplayRenderer(KisDisplayColorConverter *displayColorConverter, KoCanvasResourceProvider *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;
+        QPointer<KoCanvasResourceProvider> m_resourceManager;
     };
 
     QScopedPointer<KoColorDisplayRendererInterface> displayRenderer;
 };
 
-KisDisplayColorConverter::KisDisplayColorConverter(KoCanvasResourceManager *resourceManager, QObject *parent)
+KisDisplayColorConverter::KisDisplayColorConverter(KoCanvasResourceProvider *resourceManager, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, resourceManager))
 {
 
     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) {
+    } else if (useOcio() && key == KoCanvasResourceProvider::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_display_color_converter.h b/libs/ui/canvas/kis_display_color_converter.h
index 08416c9df3..8b2133e67e 100644
--- a/libs/ui/canvas/kis_display_color_converter.h
+++ b/libs/ui/canvas/kis_display_color_converter.h
@@ -1,111 +1,111 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_DISPLAY_COLOR_CONVERTER_H
 #define __KIS_DISPLAY_COLOR_CONVERTER_H
 
 #include <QScopedPointer>
 
 #include <KoColorDisplayRendererInterface.h>
 #include <KoColorConversionTransformation.h>
 
 #include "kis_types.h"
 #include "canvas/kis_display_filter.h"
 
 class KoColor;
 class KoColorProfile;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 
 /**
  * Special helper class that provides primitives for converting colors when
  * displaying. We have at least 3 color spaces:
  *
  * 1) Image color space (any: RGB, CMYK, Lab, etc)
  * 2) Display color space (a limited RGB color space)
  * 3) Color selectors color space (the one where color selectors generate
  *    their HSV-based colors. Right now it is sRGB.
  *
  * KoColor may be in any of these color spaces. QColor should always
  * be in the display color space only.
  */
 class KRITAUI_EXPORT KisDisplayColorConverter : public QObject
 {
     Q_OBJECT
 
 public:
     KisDisplayColorConverter();
-    KisDisplayColorConverter(KoCanvasResourceManager *resourceManager, QObject *parent);
+    KisDisplayColorConverter(KoCanvasResourceProvider *resourceManager, QObject *parent);
     ~KisDisplayColorConverter() override;
 
     static KisDisplayColorConverter* dumbConverterInstance();
 
     KoColorDisplayRendererInterface* displayRendererInterface() const;
 
     const KoColorSpace* paintingColorSpace() const;
     void setMonitorProfile(const KoColorProfile *monitorProfile);
     void setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter);
 
     QColor toQColor(const KoColor &c) const;
     KoColor approximateFromRenderedQColor(const QColor &c) const;
 
     /**
      * Converts the exactBounds() (!) of the \p srcDevice into QImage
      * properly rendered into display RGB space. Please note that the
      * offset of the image in QImage is always zero for efficiency
      * reasons.
      */
     QImage toQImage(KisPaintDeviceSP srcDevice) const;
 
     KoColor fromHsv(int h, int s, int v, int a = 255) const;
     KoColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
     KoColor fromHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
     KoColor fromHsiF(qreal h, qreal s, qreal i);
     KoColor fromHsyF(qreal h, qreal s, qreal y, qreal R=0.2126, qreal G=0.7152, qreal B=0.0722, qreal gamma=2.2);
 
     void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a = 0) const;
     void getHsvF(const KoColor &srcColor, qreal *h, qreal *s, qreal *v, qreal *a = 0);
     void getHslF(const KoColor &srcColor, qreal *h, qreal *s, qreal *l, qreal *a = 0);
     void getHsiF(const KoColor &srcColor, qreal *h, qreal *s, qreal *i);
     void getHsyF(const KoColor &srcColor, qreal *h, qreal *s, qreal *y, qreal R=0.2126, qreal G=0.7152, qreal B=0.0722, qreal gamma=2.2);
 
     static KoColorConversionTransformation::Intent renderingIntent();
     static KoColorConversionTransformation::ConversionFlags conversionFlags();
 
     QSharedPointer<KisDisplayFilter> displayFilter() const;
     const KoColorProfile* monitorProfile() const;
 
 Q_SIGNALS:
     void displayConfigurationChanged();
 
 private:
     // is not possible to implement!
     KoColor toKoColor(const QColor &c);
 
 
 private:
     Q_PRIVATE_SLOT(m_d, void slotCanvasResourceChanged(int key, const QVariant &v));
     Q_PRIVATE_SLOT(m_d, void selectPaintingColorSpace());
     Q_PRIVATE_SLOT(m_d, void slotUpdateCurrentNodeColorSpace());
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_DISPLAY_COLOR_CONVERTER_H */
diff --git a/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp b/libs/ui/dialogs/kis_dlg_stroke_selection_properties.cpp
index 643b1d837e..0776014aaa 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(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>();
+        color = m_resourceManager->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     }
     else  if (currentSource == "Background color") {
-              color = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
+              color = m_resourceManager->resource(KoCanvasResourceProvider::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>();
+        color = m_resourceManager->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     }
     else  if (currentSource == colorFillSource::BGColor) {
-              color = m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
+              color = m_resourceManager->resource(KoCanvasResourceProvider::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();
+    QColor BGColor = m_resourceManager->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>().toQColor();
+    QColor FGColor = m_resourceManager->resource(KoCanvasResourceProvider::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();
+    QColor BGcolor = m_resourceManager->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>().toQColor();
+    QColor FGColor = m_resourceManager->resource(KoCanvasResourceProvider::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/dialogs/kis_dlg_stroke_selection_properties.h b/libs/ui/dialogs/kis_dlg_stroke_selection_properties.h
index 6c0e0a3354..c093b80cec 100644
--- a/libs/ui/dialogs/kis_dlg_stroke_selection_properties.h
+++ b/libs/ui/dialogs/kis_dlg_stroke_selection_properties.h
@@ -1,113 +1,113 @@
 /*
  *  Copyright (c) 2016 Alexey Kapustin <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.
  */
 #ifndef KIS_DLG_STROKE_SELECTION_PROPERTIES_H_
 #define KIS_DLG_STROKE_SELECTION_PROPERTIES_H_
 
 #include <KoDialog.h>
 #include "KisProofingConfiguration.h"
 #include <kis_types.h>
 #include "KisViewManager.h"
 #include "KoStrokeConfigWidget.h"
 #include "ui_wdgstrokeselectionproperties.h"
 #include <kis_painter.h>
 #include <kis_canvas2.h>
 
 class KoColorSpace;
 class KoColorPopupAction;
 
 enum class linePosition
 {
     OUTSIDE, INSIDE, CENTER
 };
 
 enum class drawType{
     brushDraw, lineDraw
 };
 enum class colorFillSource {
     None, PaintColor, BGColor, CustomColor, FGColor
 };
 
 struct StrokeSelectionOptions {
     StrokeSelectionOptions ();
     int lineSize;
     bool brushSelected;
     int _colorFillSource;
     int lineColorSource;
     int lineDimension;
     KoColor color;
     KoColor fillColor;
     KoColor customColor;
     KisPainter::FillStyle fillStyle() const;
     void lock();
 };
 
 class WdgStrokeSelection : public QWidget, public Ui::WdgStrokeSelection
 {
     Q_OBJECT
 
 
 public:
     WdgStrokeSelection(QWidget *parent) ;
     StrokeSelectionOptions  m_options;
 
 Q_SIGNALS:
     void colorFillSelectorChanged();
     void colorSelectorChanged();
 
 private Q_SLOTS:
     void on_fillBox_currentIndexChanged(int index);
     void on_typeBox_currentIndexChanged(const QString &arg1);
     void on_lineColorBox_currentIndexChanged(const QString &arg1);
 
 };
 
 
 class KisDlgStrokeSelection : public KoDialog
 {
 
     Q_OBJECT
 
 
 public:
     KisDlgStrokeSelection(KisImageWSP image, KisViewManager *view, bool isVectorLayer);
     ~KisDlgStrokeSelection() override;
     int getLineSize() const;
     linePosition getLinePosition() const;
     KoColor getSelectedColor() const;
     bool isBrushSelected() const;
     KoColor getFillSelectedColor() const;
     StrokeSelectionOptions  getParams() const;
     void lockVectorLayerFunctions();
     void unlockVectorLayerFunctions();
 
 private:
     WdgStrokeSelection * m_page;
     KisImageWSP m_image;
-    KoCanvasResourceManager *m_resourceManager;
+    KoCanvasResourceProvider *m_resourceManager;
     KisDisplayColorConverter *converter;
 
 private Q_SLOTS:
     void setColorFillButton();
     void setColorButton();
     void colorChanged(const QColor &newColor);
     void colorFillChanged(const QColor &newColor);
 };
 
 
 
 #endif // KIS_DLG_STROKE_SEL_PROPERTIES_H_
diff --git a/libs/ui/kis_canvas_controls_manager.cpp b/libs/ui/kis_canvas_controls_manager.cpp
index 3c96050117..2e78116196 100644
--- a/libs/ui/kis_canvas_controls_manager.cpp
+++ b/libs/ui/kis_canvas_controls_manager.cpp
@@ -1,279 +1,279 @@
 /*
  *  Copyright (c) 2003-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2014 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_canvas_controls_manager.h"
 
 #include <kactioncollection.h>
 #include <QAction>
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 
 #include <brushengine/kis_locked_properties_proxy.h>
 #include <brushengine/kis_locked_properties_server.h>
 #include <brushengine/kis_locked_properties.h>
 
 #include <klocalizedstring.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <math.h>
 
 const int STEP = 25;
 
 KisCanvasControlsManager::KisCanvasControlsManager(KisViewManager * view) : m_view(view)
 {
 
 }
 
 KisCanvasControlsManager::~KisCanvasControlsManager()
 {
 
 }
 
 void KisCanvasControlsManager::setup(KisActionManager *actionManager)
 {
     KisAction *lighterColor = actionManager->createAction("make_brush_color_lighter");
     connect(lighterColor, SIGNAL(triggered()), SLOT(makeColorLighter()));
 
     KisAction *darkerColor = actionManager->createAction("make_brush_color_darker");
     connect(darkerColor, SIGNAL(triggered()), SLOT(makeColorDarker()));
     KisAction *saturatedColor = actionManager->createAction("make_brush_color_saturated");
     connect(saturatedColor, SIGNAL(triggered()), SLOT(makeColorSaturated()));
 
     KisAction *desaturatedColor = actionManager->createAction("make_brush_color_desaturated");
     connect(desaturatedColor, SIGNAL(triggered()), SLOT(makeColorDesaturated()));
 
     KisAction *hueClockwise = actionManager->createAction("shift_brush_color_clockwise");
     connect(hueClockwise, SIGNAL(triggered()), SLOT(shiftHueClockWise()));
 
     KisAction *hueCounterClockwise = actionManager->createAction("shift_brush_color_counter_clockwise");
     connect(hueCounterClockwise, SIGNAL(triggered()), SLOT(shiftHueCounterClockWise()));
 
     KisAction *moreRed = actionManager->createAction("make_brush_color_redder");
     connect(moreRed, SIGNAL(triggered()), SLOT(makeColorRed()));
 
     KisAction *moreGreen = actionManager->createAction("make_brush_color_greener");
     connect(moreGreen, SIGNAL(triggered()), SLOT(makeColorGreen()));
 
     KisAction *moreBlue = actionManager->createAction("make_brush_color_bluer");
     connect(moreBlue, SIGNAL(triggered()), SLOT(makeColorBlue()));
 
     KisAction *moreYellow = actionManager->createAction("make_brush_color_yellower");
     connect(moreYellow, SIGNAL(triggered()), SLOT(makeColorYellow()));
 
     KisAction *increaseOpacity = actionManager->createAction("increase_opacity");
     connect(increaseOpacity, SIGNAL(triggered()), SLOT(increaseOpacity()));
 
     KisAction *decreaseOpacity = actionManager->createAction("decrease_opacity");
     connect(decreaseOpacity, SIGNAL(triggered()), SLOT(decreaseOpacity()));
 }
 
 void KisCanvasControlsManager::setView(QPointer<KisView>imageView)
 {
     Q_UNUSED(imageView);
 }
 
 void KisCanvasControlsManager::transformColor(int step)
 {
     if (!m_view) return;
     if (!m_view->canvasBase()) return;
     if (!m_view->resourceProvider()->resourceManager()) return;
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
     int steps = hotkeycfg.readEntry("steps_lightness", 10);
 
 
-    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
+    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     if (color.colorSpace()->colorModelId().id()=="CMYKA" || color.colorSpace()->colorModelId().id()=="XYZA"){
         QColor rgb = color.toQColor();
         int h = 0, s = 0, v = 0;
         rgb.getHsv(&h,&s,&v);
         if ((v < 255) || ((s == 0) || (s == 255))) {
             v += step;
             v = qBound(0,v,255);
         } else {
             s += -step;
             s = qBound(0,s,255);
         }
         rgb.setHsv(h,s,v);
         color.fromQColor(rgb);
     } else if (step<0){
         color.colorSpace()->decreaseLuminosity(color.data(), 1.0/steps);
     } else {
         color.colorSpace()->increaseLuminosity(color.data(), 1.0/steps);
     }
-    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceManager::ForegroundColor, color);
+    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, color);
 }
 void KisCanvasControlsManager::transformSaturation(int step)
 {
     if (!m_view) return;
     if (!m_view->canvasBase()) return;
     if (!m_view->resourceProvider()->resourceManager()) return;
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
     int steps = hotkeycfg.readEntry("steps_saturation", 10);
 
-    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
+    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     if (color.colorSpace()->colorModelId().id()=="CMYKA" || color.colorSpace()->colorModelId().id()=="XYZA"){
         QColor rgb = color.toQColor();
         int h = 0, s = 0, v = 0;
         rgb.getHsl(&h,&s,&v);
         s += step;
         s = qBound(0,s,255);
         rgb.setHsl(h,s,v);
         color.fromQColor(rgb);
     } else if (step<0){
         color.colorSpace()->decreaseSaturation(color.data(), 1.0/steps);
     } else {
         color.colorSpace()->increaseSaturation(color.data(), 1.0/steps);
     }
-    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceManager::ForegroundColor, color);
+    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, color);
 }
 void KisCanvasControlsManager::transformHue(int step)
 {
     if (!m_view) return;
     if (!m_view->canvasBase()) return;
     if (!m_view->resourceProvider()->resourceManager()) return;
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
     int steps = hotkeycfg.readEntry("steps_hue", 36);
 
-    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
+    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     if (color.colorSpace()->colorModelId().id()=="CMYKA" || color.colorSpace()->colorModelId().id()=="XYZA"){
         QColor rgb = color.toQColor();
         int h = 0, s = 0, v = 0;
         rgb.getHsl(&h,&s,&v);
         h += step;
         if (h>360.0 || h<0.0){h=fmod(h, 360.0);}
         rgb.setHsl(h,s,v);
         color.fromQColor(rgb);
     } else if (step<0){
         color.colorSpace()->increaseHue(color.data(), 1.0/steps);
     } else {
         color.colorSpace()->decreaseHue(color.data(), 1.0/steps);
     }
-    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceManager::ForegroundColor, color);
+    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, color);
 }
 void KisCanvasControlsManager::transformRed(int step)
 {
     if (!m_view) return;
     if (!m_view->canvasBase()) return;
     if (!m_view->resourceProvider()->resourceManager()) return;
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
     int steps = hotkeycfg.readEntry("steps_redgreen", 10);
 
-    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
+    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     if (step<0){
         color.colorSpace()->increaseGreen(color.data(), 1.0/steps);
     } else {
         color.colorSpace()->increaseRed(color.data(), 1.0/steps);
     }
-    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceManager::ForegroundColor, color);
+    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, color);
 }
 void KisCanvasControlsManager::transformBlue(int step)
 {
     if (!m_view) return;
     if (!m_view->canvasBase()) return;
     if (!m_view->resourceProvider()->resourceManager()) return;
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
     int steps = hotkeycfg.readEntry("steps_blueyellow", 10);
 
-    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
+    KoColor color = m_view->resourceProvider()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     if (step<0){
         color.colorSpace()->increaseYellow(color.data(), 1.0/steps);
     } else {
         color.colorSpace()->increaseBlue(color.data(), 1.0/steps);
     }
-    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceManager::ForegroundColor, color);
+    m_view->resourceProvider()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, color);
 }
 
 
 void KisCanvasControlsManager::makeColorDarker()
 {
     transformColor(-STEP);
 }
 
 void KisCanvasControlsManager::makeColorLighter()
 {
     transformColor(STEP);
 }
 
 void KisCanvasControlsManager::makeColorDesaturated()
 {
     transformSaturation(-STEP);
 }
 
 void KisCanvasControlsManager::makeColorSaturated()
 {
     transformSaturation(STEP);
 }
 void KisCanvasControlsManager::shiftHueClockWise()
 {
     transformHue(STEP);
 }
 
 void KisCanvasControlsManager::shiftHueCounterClockWise()
 {
     transformHue(-STEP);
 }
 void KisCanvasControlsManager::makeColorRed()
 {
     transformRed(STEP);
 }
 void KisCanvasControlsManager::makeColorGreen()
 {
     transformRed(-STEP);
 }
 void KisCanvasControlsManager::makeColorBlue()
 {
     transformBlue(STEP);
 }
 void KisCanvasControlsManager::makeColorYellow()
 {
     transformBlue(-STEP);
 }
 
 void KisCanvasControlsManager::stepAlpha(float step)
 {
     if (!m_view) return;
     if (!m_view->canvasBase()) return;
     if (!m_view->resourceProvider()->resourceManager()) return;
 
     qreal alpha = m_view->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::Opacity).toDouble();
     alpha += step;
     alpha = qBound<qreal>(0.0, alpha, 1.0);
     m_view->canvasBase()->resourceManager ()->setResource(KisCanvasResourceProvider::Opacity, alpha);
 
     // FIXME: DK: should we uncomment it back?
     //KisLockedPropertiesProxySP p = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_view->resourceProvider()->currentPreset()->settings());
     //p->setProperty("OpacityValue", alpha);
 }
 
 void KisCanvasControlsManager::increaseOpacity()
 {
     stepAlpha(0.1f);
 }
 
 void KisCanvasControlsManager::decreaseOpacity()
 {
     stepAlpha(-0.1f);
 }
diff --git a/libs/ui/kis_canvas_resource_provider.cpp b/libs/ui/kis_canvas_resource_provider.cpp
index 47a9da45cc..23d0d34532 100644
--- a/libs/ui/kis_canvas_resource_provider.cpp
+++ b/libs/ui/kis_canvas_resource_provider.cpp
@@ -1,546 +1,546 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt  <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_canvas_resource_provider.h"
 
 #include <QImage>
 #include <QPainter>
 
 #include <KoCanvasBase.h>
 #include <KoID.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceServerProvider.h>
 #include <resources/KoStopGradient.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <resources/KoPattern.h>
 #include <kis_paint_device.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_favorite_resource_manager.h"
 
 #include "kis_config.h"
 #include "KisViewManager.h"
 #include "canvas/kis_canvas2.h"
 
 KisCanvasResourceProvider::KisCanvasResourceProvider(KisViewManager * view)
     : m_view(view)
 {
     m_fGChanged = true;
     m_enablefGChange = true;    // default to true, so that colour history is working without popup palette
 }
 
 KisCanvasResourceProvider::~KisCanvasResourceProvider()
 {
     disconnect(); // in case Qt gets confused
 }
 
-KoCanvasResourceManager* KisCanvasResourceProvider::resourceManager()
+KoCanvasResourceProvider* KisCanvasResourceProvider::resourceManager()
 {
     return m_resourceManager;
 }
 
-void KisCanvasResourceProvider::setResourceManager(KoCanvasResourceManager *resourceManager)
+void KisCanvasResourceProvider::setResourceManager(KoCanvasResourceProvider *resourceManager)
 {
     m_resourceManager = resourceManager;
 
     QVariant v;
     v.setValue(KoColor(Qt::black, KoColorSpaceRegistry::instance()->rgb8()));
-    m_resourceManager->setResource(KoCanvasResourceManager::ForegroundColor, v);
+    m_resourceManager->setResource(KoCanvasResourceProvider::ForegroundColor, v);
 
     v.setValue(KoColor(Qt::white, KoColorSpaceRegistry::instance()->rgb8()));
-    m_resourceManager->setResource(KoCanvasResourceManager::BackgroundColor, v);
+    m_resourceManager->setResource(KoCanvasResourceProvider::BackgroundColor, v);
 
     setCurrentCompositeOp(COMPOSITE_OVER);
 
     setMirrorHorizontal(false);
     setMirrorVertical(false);
 
     m_resourceManager->setResource(HdrExposure, 0.0);
     m_resourceManager->setResource(HdrGamma, 1.0);
     m_resourceManager->setResource(EffectiveZoom, 1.0);
 
     connect(m_resourceManager, SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
-    m_resourceManager->setResource(KoCanvasResourceManager::ApplicationSpeciality, KoCanvasResourceManager::NoAdvancedText);
+    m_resourceManager->setResource(KoCanvasResourceProvider::ApplicationSpeciality, KoCanvasResourceProvider::NoAdvancedText);
 }
 
 
 KoCanvasBase * KisCanvasResourceProvider::canvas() const
 {
     return m_view->canvasBase();
 }
 
 KoColor KisCanvasResourceProvider::bgColor() const
 {
-    return m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
+    return m_resourceManager->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>();
 }
 
 KoColor KisCanvasResourceProvider::fgColor() const
 {
-    return m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
+    return m_resourceManager->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
 }
 
 float KisCanvasResourceProvider::HDRExposure() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrExposure).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRExposure(float exposure)
 {
     m_resourceManager->setResource(HdrExposure, static_cast<double>(exposure));
 }
 
 float KisCanvasResourceProvider::HDRGamma() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrGamma).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRGamma(float gamma)
 {
     m_resourceManager->setResource(HdrGamma, static_cast<double>(gamma));
 }
 
 
 KoPattern * KisCanvasResourceProvider::currentPattern() const
 {
     if (m_resourceManager->hasResource(CurrentPattern)) {
         return m_resourceManager->resource(CurrentPattern).value<KoPattern*>();
     }
     else {
         return 0;
     }
 }
 
 KoAbstractGradient* KisCanvasResourceProvider::currentGradient() const
 {
     if (m_resourceManager->hasResource(CurrentGradient)) {
         return m_resourceManager->resource(CurrentGradient).value<KoAbstractGradient*>();
     }
     else {
         return 0;
     }
 }
 
 KisImageWSP KisCanvasResourceProvider::currentImage() const
 {
     return m_view->image();
 }
 
 KisNodeSP KisCanvasResourceProvider::currentNode() const
 {
     return m_view->activeNode();
 }
 
 KoGamutMask *KisCanvasResourceProvider::currentGamutMask() const
 {
     if (m_resourceManager->hasResource(CurrentGamutMask)) {
         return m_resourceManager->resource(CurrentGamutMask).value<KoGamutMask*>();
     }
     else {
         return nullptr;
     }
 }
 
 KisPaintOpPresetSP KisCanvasResourceProvider::currentPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(CurrentPaintOpPreset, v);
 }
 
 KisPaintOpPresetSP KisCanvasResourceProvider::previousPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(PreviousPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPreviousPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPreviousPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(PreviousPaintOpPreset, v);
 }
 
 void KisCanvasResourceProvider::slotPatternActivated(KoResource * res)
 {
     KoPattern *pattern = dynamic_cast<KoPattern*>(res);
     QVariant v;
     v.setValue<KoPattern*>(pattern);
     m_resourceManager->setResource(CurrentPattern, v);
     emit sigPatternChanged(pattern);
 }
 
 void KisCanvasResourceProvider::slotGradientActivated(KoResource *res)
 {
 
     KoAbstractGradient * gradient = dynamic_cast<KoAbstractGradient*>(res);
     QVariant v;
     v.setValue<KoAbstractGradient*>(gradient);
     m_resourceManager->setResource(CurrentGradient, v);
     emit sigGradientChanged(gradient);
 }
 
 
 void KisCanvasResourceProvider::setBGColor(const KoColor& c)
 {
     QVariant v;
     v.setValue(c);
-    m_resourceManager->setResource(KoCanvasResourceManager::BackgroundColor, v);
+    m_resourceManager->setResource(KoCanvasResourceProvider::BackgroundColor, v);
     emit sigBGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::setFGColor(const KoColor& c)
 {
     m_fGChanged = true;
 
     QVariant v;
     v.setValue(c);
-    m_resourceManager->setResource(KoCanvasResourceManager::ForegroundColor, v);
+    m_resourceManager->setResource(KoCanvasResourceProvider::ForegroundColor, v);
     emit sigFGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::slotSetFGColor(const KoColor& c)
 {
     setFGColor(c);
 }
 
 void KisCanvasResourceProvider::slotSetBGColor(const KoColor& c)
 {
     setBGColor(c);
 }
 
 void KisCanvasResourceProvider::slotNodeActivated(const KisNodeSP node)
 {
     QVariant v;
     v.setValue(KisNodeWSP(node));
     m_resourceManager->setResource(CurrentKritaNode, v);
     emit sigNodeChanged(currentNode());
 }
 
 
 void KisCanvasResourceProvider::slotImageSizeChanged()
 {
     if (KisImageWSP image = m_view->image()) {
         float fw = image->width() / image->xRes();
         float fh = image->height() / image->yRes();
 
         QSizeF postscriptSize(fw, fh);
-        m_resourceManager->setResource(KoCanvasResourceManager::PageSize, postscriptSize);
+        m_resourceManager->setResource(KoCanvasResourceProvider::PageSize, postscriptSize);
     }
 }
 
 void KisCanvasResourceProvider::slotOnScreenResolutionChanged()
 {
     KisImageWSP image = m_view->image();
     KisCanvas2 *canvas = m_view->canvasBase();
 
     if(!image || !canvas) return;
 
     qreal zoomX, zoomY;
     canvas->coordinatesConverter()->zoom(&zoomX, &zoomY);
 
     qreal scaleX = zoomX / image->xRes();
     qreal scaleY = zoomY / image->yRes();
 
     emit sigOnScreenResolutionChanged(scaleX, scaleY);
 }
 
 void KisCanvasResourceProvider::slotCanvasResourceChanged(int key, const QVariant & res)
 {
-    if(key == KoCanvasResourceManager::ForegroundColor || key == KoCanvasResourceManager::BackgroundColor) {
+    if(key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoAbstractGradient* resource = KoResourceServerProvider::instance()->gradientServer()->resources()[0];
         KoStopGradient* stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0,  KoColor(QColor(0, 0, 0, 0), fgColor().colorSpace()));
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
         resource = KoResourceServerProvider::instance()->gradientServer()->resources()[1];
         stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0, bgColor());
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
     }
     switch (key) {
-    case(KoCanvasResourceManager::ForegroundColor):
+    case(KoCanvasResourceProvider::ForegroundColor):
         m_fGChanged = true;
         emit sigFGColorChanged(res.value<KoColor>());
         break;
-    case(KoCanvasResourceManager::BackgroundColor):
+    case(KoCanvasResourceProvider::BackgroundColor):
         emit sigBGColorChanged(res.value<KoColor>());
         break;
     case(CurrentPattern):
         emit sigPatternChanged(static_cast<KoPattern *>(res.value<void *>()));
         break;
     case(CurrentGradient):
         emit sigGradientChanged(static_cast<KoAbstractGradient *>(res.value<void *>()));
         break;
     case(CurrentKritaNode) :
         emit sigNodeChanged(currentNode());
         break;
     case (Opacity):
     {
         emit sigOpacityChanged(res.toDouble());
     }
     default:
         ;
         // Do nothing
     };
 }
 
 void KisCanvasResourceProvider::setCurrentCompositeOp(const QString& compositeOp)
 {
     m_resourceManager->setResource(CurrentCompositeOp,
                                    QVariant::fromValue(compositeOp));
 }
 
 QString KisCanvasResourceProvider::currentCompositeOp() const
 {
     return m_resourceManager->resource(CurrentCompositeOp).value<QString>();
 }
 
 bool KisCanvasResourceProvider::eraserMode() const
 {
     return m_resourceManager->resource(EraserMode).toBool();
 }
 
 void KisCanvasResourceProvider::setEraserMode(bool value)
 {
     m_resourceManager->setResource(EraserMode,
                                    QVariant::fromValue(value));
 }
 
 void KisCanvasResourceProvider::slotPainting()
 {
     if (m_fGChanged && m_enablefGChange) {
         emit sigFGColorUsed(fgColor());
         m_fGChanged = false;
     }
 }
 
 void KisCanvasResourceProvider::slotGamutMaskActivated(KoGamutMask *mask)
 {
     QVariant v;
     v.setValue<KoGamutMask*>(mask);
     m_resourceManager->setResource(CurrentGamutMask, v);
     emit sigGamutMaskChanged(mask);
 }
 
 void KisCanvasResourceProvider::slotGamutMaskUnset()
 {
     m_resourceManager->clearResource(CurrentGamutMask);
     emit sigGamutMaskUnset();
 }
 
 void KisCanvasResourceProvider::slotGamutMaskPreviewUpdate()
 {
     emit sigGamutMaskPreviewUpdate();
 }
 
 void KisCanvasResourceProvider::slotResetEnableFGChange(bool b)
 {
     m_enablefGChange = b;
 }
 
 QList<QPointer<KisAbstractPerspectiveGrid> > KisCanvasResourceProvider::perspectiveGrids() const
 {
     return m_perspectiveGrids;
 }
 
 void KisCanvasResourceProvider::addPerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.append(grid);
 }
 
 void KisCanvasResourceProvider::removePerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.removeOne(grid);
 }
 
 void KisCanvasResourceProvider::clearPerspectiveGrids()
 {
     m_perspectiveGrids.clear();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontal(bool mirrorHorizontal)
 {
     m_resourceManager->setResource(MirrorHorizontal, mirrorHorizontal);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontal() const
 {
     return m_resourceManager->resource(MirrorHorizontal).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVertical(bool mirrorVertical)
 {
     m_resourceManager->setResource(MirrorVertical, mirrorVertical);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorVertical() const
 {
     return m_resourceManager->resource(MirrorVertical).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorHorizontalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontalLock() {
      return m_resourceManager->resource(MirrorHorizontalLock).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorVerticalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 
 
 bool KisCanvasResourceProvider::mirrorVerticalHideDecorations() {
      return m_resourceManager->resource(MirrorVerticalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorVerticalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorHorizontalHideDecorations() {
      return m_resourceManager->resource(MirrorHorizontalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorHorizontalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorVerticalLock() {
      return m_resourceManager->resource(MirrorVerticalLock).toBool();
 }
 
 void KisCanvasResourceProvider::mirrorVerticalMoveCanvasToCenter() {
      emit moveMirrorVerticalCenter();
 }
 
 void KisCanvasResourceProvider::mirrorHorizontalMoveCanvasToCenter() {
      emit moveMirrorHorizontalCenter();
 }
 
 
 
 void KisCanvasResourceProvider::setOpacity(qreal opacity)
 {
     m_resourceManager->setResource(Opacity, opacity);
 }
 
 qreal KisCanvasResourceProvider::opacity() const
 {
     return m_resourceManager->resource(Opacity).toReal();
 }
 
 void KisCanvasResourceProvider::setFlow(qreal flow)
 {
     m_resourceManager->setResource(Flow, flow);
 }
 
 qreal KisCanvasResourceProvider::flow() const
 {
     return m_resourceManager->resource(Flow).toReal();
 }
 
 void KisCanvasResourceProvider::setSize(qreal size)
 {
     m_resourceManager->setResource(Size, size);
 }
 
 qreal KisCanvasResourceProvider::size() const
 {
     return m_resourceManager->resource(Size).toReal();
 }
 
 void KisCanvasResourceProvider::setGlobalAlphaLock(bool lock)
 {
     m_resourceManager->setResource(GlobalAlphaLock, lock);
 }
 
 bool KisCanvasResourceProvider::globalAlphaLock() const
 {
     return m_resourceManager->resource(GlobalAlphaLock).toBool();
 }
 
 void KisCanvasResourceProvider::setDisablePressure(bool value)
 {
     m_resourceManager->setResource(DisablePressure, value);
 }
 
 bool KisCanvasResourceProvider::disablePressure() const
 {
     return m_resourceManager->resource(DisablePressure).toBool();
 }
 
 void KisCanvasResourceProvider::notifyLoadingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigLoadingWorkspace(workspace);
 }
 
 void KisCanvasResourceProvider::notifySavingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigSavingWorkspace(workspace);
 }
 
diff --git a/libs/ui/kis_canvas_resource_provider.h b/libs/ui/kis_canvas_resource_provider.h
index f1ab81723f..5cfb97dace 100644
--- a/libs/ui/kis_canvas_resource_provider.h
+++ b/libs/ui/kis_canvas_resource_provider.h
@@ -1,246 +1,246 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt  <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CANVAS_RESOURCE_PROVIDER_H_
 #define KIS_CANVAS_RESOURCE_PROVIDER_H_
 
 #include <QObject>
 
 #include <KoColor.h>
 #include <KoID.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 
 class KisWorkspaceResource;
 class KoColorProfile;
 class KoAbstractGradient;
 class KoResource;
 
 class KoCanvasBase;
 class KisViewManager;
 class KoPattern;
 class KoGamutMask;
 class KisFilterConfiguration;
 
 #include <kis_abstract_perspective_grid.h>
 
 /**
  * KisCanvasResourceProvider contains the per-window current settings that
  * influence painting, like paintop, color, gradients and so on.
  */
 class KRITAUI_EXPORT KisCanvasResourceProvider : public QObject
 {
     Q_OBJECT
 
 public:
 
     enum Resources {
-        HdrExposure = KoCanvasResourceManager::KritaStart + 1,
+        HdrExposure = KoCanvasResourceProvider::KritaStart + 1,
         CurrentPattern,
         CurrentGamutMask,
         CurrentGradient,
         CurrentDisplayProfile,
         CurrentKritaNode,
         CurrentPaintOpPreset,
         CurrentGeneratorConfiguration,
         CurrentCompositeOp,
         CurrentEffectiveCompositeOp,
         LodAvailability, ///<-user choice
         LodSizeThreshold, ///<-user choice
         LodSizeThresholdSupported, ///<-paintop property
         EffectiveLodAvailablility, ///<- a superposition of user choice, threshold and paintop traits
         EraserMode,
         MirrorHorizontal,
         MirrorVertical,
         MirrorHorizontalLock,
         MirrorVerticalLock,
         MirrorVerticalHideDecorations,
         MirrorHorizontalHideDecorations,
         Opacity,
         Flow,
         Size,
         HdrGamma,
         GlobalAlphaLock,
         DisablePressure,
         PreviousPaintOpPreset,
         EffectiveZoom ///<-Used only by painting tools for non-displaying purposes
     };
 
 
     KisCanvasResourceProvider(KisViewManager * view);
     ~KisCanvasResourceProvider() override;
 
-    void setResourceManager(KoCanvasResourceManager *resourceManager);
-    KoCanvasResourceManager* resourceManager();
+    void setResourceManager(KoCanvasResourceProvider *resourceManager);
+    KoCanvasResourceProvider* resourceManager();
 
     KoCanvasBase * canvas() const;
 
     KoColor bgColor() const;
     void setBGColor(const KoColor& c);
 
     KoColor fgColor() const;
     void setFGColor(const KoColor& c);
 
     float HDRExposure() const;
     void setHDRExposure(float exposure);
 
     float HDRGamma() const;
     void setHDRGamma(float gamma);
 
     bool eraserMode() const;
     void setEraserMode(bool value);
 
     KoPattern *currentPattern() const;
 
     KoAbstractGradient *currentGradient() const;
 
     KisImageWSP currentImage() const;
 
     KisNodeSP currentNode() const;
 
     KoGamutMask* currentGamutMask() const;
 
     KisPaintOpPresetSP currentPreset() const;
     void setPaintOpPreset(const KisPaintOpPresetSP preset);
 
     KisPaintOpPresetSP previousPreset() const;
     void setPreviousPaintOpPreset(const KisPaintOpPresetSP preset);
 
     void setCurrentCompositeOp(const QString& compositeOp);
     QString currentCompositeOp() const;
 
     QList<QPointer<KisAbstractPerspectiveGrid> > perspectiveGrids() const;
     void addPerspectiveGrid(KisAbstractPerspectiveGrid*);
     void removePerspectiveGrid(KisAbstractPerspectiveGrid*);
     void clearPerspectiveGrids();
 
     void setMirrorHorizontal(bool mirrorHorizontal);
     bool mirrorHorizontal() const;
 
     void setMirrorVertical(bool mirrorVertical);
     bool mirrorVertical() const;
 
     // options for horizontal and vertical mirror toolbar
     void setMirrorHorizontalLock(bool isLocked);
     bool mirrorHorizontalLock();
     void setMirrorVerticalLock(bool isLocked);
     bool mirrorVerticalLock();
 
     void setMirrorVerticalHideDecorations(bool hide);
     bool mirrorVerticalHideDecorations();
 
     void setMirrorHorizontalHideDecorations(bool hide);
     bool mirrorHorizontalHideDecorations();
 
     void mirrorVerticalMoveCanvasToCenter();
     void mirrorHorizontalMoveCanvasToCenter();
 
     void setOpacity(qreal opacity);
     qreal opacity() const;
 
     void setFlow(qreal opacity);
     qreal flow() const;
 
     void setSize(qreal size);
     qreal size() const;
 
     void setGlobalAlphaLock(bool lock);
     bool globalAlphaLock() const;
 
     void setDisablePressure(bool value);
     bool disablePressure() const;
 
     ///Notify that the workspace is saved and settings should be saved to it
     void notifySavingWorkspace(KisWorkspaceResource* workspace);
 
     ///Notify that the workspace is loaded and settings can be read
     void notifyLoadingWorkspace(KisWorkspaceResource* workspace);
 
 public Q_SLOTS:
 
     void slotSetFGColor(const KoColor& c);
     void slotSetBGColor(const KoColor& c);
     void slotPatternActivated(KoResource *pattern);
     void slotGradientActivated(KoResource *gradient);
     void slotNodeActivated(const KisNodeSP node);
     void slotPainting();
 
     void slotGamutMaskActivated(KoGamutMask* mask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
 
     /**
      * Set the image size in pixels. The resource provider will store
      * the image size in postscript points.
      */
     // FIXME: this slot doesn't catch the case when image resolution is changed
     void slotImageSizeChanged();
     void slotOnScreenResolutionChanged();
 
     // This is a flag 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
     void slotResetEnableFGChange(bool);
 
 private Q_SLOTS:
 
     void slotCanvasResourceChanged(int key, const QVariant & res);
 
 Q_SIGNALS:
 
     void sigFGColorChanged(const KoColor &);
     void sigBGColorChanged(const KoColor &);
     void sigGradientChanged(KoAbstractGradient *);
     void sigPatternChanged(KoPattern *);
     void sigNodeChanged(const KisNodeSP);
     void sigDisplayProfileChanged(const KoColorProfile *);
     void sigFGColorUsed(const KoColor&);
     void sigOnScreenResolutionChanged(qreal scaleX, qreal scaleY);
     void sigOpacityChanged(qreal);
     void sigSavingWorkspace(KisWorkspaceResource* workspace);
     void sigLoadingWorkspace(KisWorkspaceResource* workspace);
 
     void mirrorModeChanged();
     void moveMirrorVerticalCenter();
     void moveMirrorHorizontalCenter();
 
     void sigGamutMaskChanged(KoGamutMask* mask);
     void sigGamutMaskUnset();
     void sigGamutMaskPreviewUpdate();
 
 private:
 
     KisViewManager * m_view;
-    KoCanvasResourceManager *m_resourceManager;
+    KoCanvasResourceProvider *m_resourceManager;
     bool m_fGChanged;
     QList<QPointer<KisAbstractPerspectiveGrid> > m_perspectiveGrids;
 
     // This is a flag 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
     bool m_enablefGChange;
 
 };
 
 #endif
diff --git a/libs/ui/kis_filter_manager.cc b/libs/ui/kis_filter_manager.cc
index ba28f4c296..b0f2389d96 100644
--- a/libs/ui/kis_filter_manager.cc
+++ b/libs/ui/kis_filter_manager.cc
@@ -1,351 +1,351 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_filter_manager.h"
 
 
 #include <QHash>
 #include <QSignalMapper>
 
 #include <QMessageBox>
 #include <kactionmenu.h>
 #include <kactioncollection.h>
 
 #include <KoID.h>
 #include <KisMainWindow.h>
 
 // krita/image
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_paint_device.h>
 
 // krita/ui
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include <kis_bookmarked_configuration_manager.h>
 
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_canvas_resource_provider.h"
 #include "dialogs/kis_dlg_filter.h"
 #include "strokes/kis_filter_stroke_strategy.h"
 #include "krita_utils.h"
 
 
 struct KisFilterManager::Private {
     Private()
         : reapplyAction(0)
         , actionCollection(0)
         , actionManager(0)
         , view(0)
     {
     }
     KisAction* reapplyAction;
     QHash<QString, KActionMenu*> filterActionMenus;
     QHash<KisFilter*, QAction *> filters2Action;
     KActionCollection *actionCollection;
     KisActionManager *actionManager;
     KisViewManager *view;
 
     KisFilterConfigurationSP lastConfiguration;
     KisFilterConfigurationSP currentlyAppliedConfiguration;
     KisStrokeId currentStrokeId;
     QRect initialApplyRect;
 
     QSignalMapper actionsMapper;
 
     QPointer<KisDlgFilter> filterDialog;
 };
 
 KisFilterManager::KisFilterManager(KisViewManager * view)
     : d(new Private)
 {
     d->view = view;
 }
 
 KisFilterManager::~KisFilterManager()
 {
     delete d;
 }
 
 void KisFilterManager::setView(QPointer<KisView>imageView)
 {
     Q_UNUSED(imageView);
 }
 
 
 void KisFilterManager::setup(KActionCollection * ac, KisActionManager *actionManager)
 {
     d->actionCollection = ac;
     d->actionManager = actionManager;
 
     // Setup reapply action
     d->reapplyAction = d->actionManager->createAction("filter_apply_again");
     d->reapplyAction->setActivationFlags(KisAction::ACTIVE_DEVICE);
     d->reapplyAction->setEnabled(false);
     connect(d->reapplyAction, SIGNAL(triggered()), SLOT(reapplyLastFilter()));
 
     connect(&d->actionsMapper, SIGNAL(mapped(const QString&)), SLOT(showFilterDialog(const QString&)));
 
     // Setup list of filters
     QStringList keys = KisFilterRegistry::instance()->keys();
     keys.sort();
     Q_FOREACH (const QString &filterName, keys) {
         insertFilter(filterName);
     }
 
     connect(KisFilterRegistry::instance(), SIGNAL(filterAdded(QString)), SLOT(insertFilter(const QString &)));
 }
 
 void KisFilterManager::insertFilter(const QString & filterName)
 {
     Q_ASSERT(d->actionCollection);
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(filterName);
     Q_ASSERT(filter);
 
     if (d->filters2Action.contains(filter.data())) {
         warnKrita << "Filter" << filterName << " has already been inserted";
         return;
     }
 
     KoID category = filter->menuCategory();
     KActionMenu* actionMenu = d->filterActionMenus[ category.id()];
     if (!actionMenu) {
         actionMenu = new KActionMenu(category.name(), this);
         d->actionCollection->addAction(category.id(), actionMenu);
         d->filterActionMenus[category.id()] = actionMenu;
     }
 
     KisAction *action = new KisAction(filter->menuEntry(), this);
     action->setDefaultShortcut(filter->shortcut());
     action->setActivationFlags(KisAction::ACTIVE_DEVICE);
 
     d->actionManager->addAction(QString("krita_filter_%1").arg(filterName), action);
     d->filters2Action[filter.data()] = action;
 
     actionMenu->addAction(action);
 
     d->actionsMapper.setMapping(action, filterName);
     connect(action, SIGNAL(triggered()), &d->actionsMapper, SLOT(map()));
 }
 
 void KisFilterManager::updateGUI()
 {
     if (!d->view) return;
 
     bool enable = false;
 
     KisNodeSP activeNode = d->view->activeNode();
     enable = activeNode && activeNode->hasEditablePaintDevice();
 
     d->reapplyAction->setEnabled(enable);
 
     for (QHash<KisFilter*, QAction *>::iterator it = d->filters2Action.begin();
             it != d->filters2Action.end(); ++it) {
 
         bool localEnable = enable;
 
         it.value()->setEnabled(localEnable);
     }
 }
 
 void KisFilterManager::reapplyLastFilter()
 {
     if (!d->lastConfiguration) return;
 
     apply(d->lastConfiguration);
     finish();
 }
 
 void KisFilterManager::showFilterDialog(const QString &filterId)
 {
     if (d->filterDialog && d->filterDialog->isVisible()) {
         KisFilterSP filter = KisFilterRegistry::instance()->value(filterId);
         d->filterDialog->setFilter(filter);
         return;
     }
 
     connect(d->view->image(),
             SIGNAL(sigStrokeCancellationRequested()),
             SLOT(slotStrokeCancelRequested()),
             Qt::UniqueConnection);
 
     connect(d->view->image(),
             SIGNAL(sigStrokeEndRequested()),
             SLOT(slotStrokeEndRequested()),
             Qt::UniqueConnection);
 
     /**
      * The UI should show only after every running stroke is finished,
      * so a virtual barrier is added here.
      */
     if (!d->view->blockUntilOperationsFinished(d->view->image())) {
         return;
     }
 
     Q_ASSERT(d->view);
     Q_ASSERT(d->view->activeNode());
 
     KisPaintDeviceSP dev = d->view->activeNode()->paintDevice();
     if (!dev) {
         warnKrita << "KisFilterManager::showFilterDialog(): Filtering was requested for illegal active layer!" << d->view->activeNode();
         return;
     }
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(filterId);
 
     if (dev->colorSpace()->willDegrade(filter->colorSpaceIndependence())) {
         // Warning bells!
         if (filter->colorSpaceIndependence() == TO_LAB16) {
             if (QMessageBox::warning(d->view->mainWindow(),
                                      i18nc("@title:window", "Krita"),
                                      i18n("The %1 filter will convert your %2 data to 16-bit L*a*b* and vice versa. ",
                                           filter->name(),
                                           dev->colorSpace()->name()),
                                      QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok)
                     != QMessageBox::Ok) return;
 
         } else if (filter->colorSpaceIndependence() == TO_RGBA16) {
             if (QMessageBox::warning(d->view->mainWindow(),
                                      i18nc("@title:window", "Krita"),
                                      i18n("The %1 filter will convert your %2 data to 16-bit RGBA and vice versa. ",
                                           filter->name() , dev->colorSpace()->name()),
                                      QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok)
                     != QMessageBox::Ok) return;
         }
     }
 
     if (filter->showConfigurationWidget()) {
         if (!d->filterDialog) {
             d->filterDialog = new KisDlgFilter(d->view , d->view->activeNode(), this, d->view->mainWindow());
             d->filterDialog->setAttribute(Qt::WA_DeleteOnClose);
         }
         d->filterDialog->setFilter(filter);
         d->filterDialog->setVisible(true);
     } else {
         apply(KisFilterConfigurationSP(filter->defaultConfiguration()));
         finish();
     }
 }
 
 void KisFilterManager::apply(KisFilterConfigurationSP filterConfig)
 {
     KisFilterSP filter = KisFilterRegistry::instance()->value(filterConfig->name());
     KisImageWSP image = d->view->image();
 
     if (d->currentStrokeId) {
         image->addJob(d->currentStrokeId, new KisFilterStrokeStrategy::CancelSilentlyMarker);
         image->cancelStroke(d->currentStrokeId);
         d->currentStrokeId.clear();
     } else {
         image->waitForDone();
         d->initialApplyRect = d->view->activeNode()->exactBounds();
     }
 
     QRect applyRect = d->initialApplyRect;
 
     KisPaintDeviceSP paintDevice = d->view->activeNode()->paintDevice();
     if (paintDevice &&
         filter->needsTransparentPixels(filterConfig.data(), paintDevice->colorSpace())) {
 
         applyRect |= image->bounds();
     }
 
-    KoCanvasResourceManager *resourceManager =
+    KoCanvasResourceProvider *resourceManager =
         d->view->resourceProvider()->resourceManager();
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image,
                                  d->view->activeNode(),
                                  resourceManager);
 
     d->currentStrokeId =
         image->startStroke(new KisFilterStrokeStrategy(filter,
                                                        KisFilterConfigurationSP(filterConfig),
                                                        resources));
 
     QRect processRect = filter->changedRect(applyRect, filterConfig.data(), 0);
     processRect &= image->bounds();
 
     if (filter->supportsThreading()) {
         QSize size = KritaUtils::optimalPatchSize();
         QVector<QRect> rects = KritaUtils::splitRectIntoPatches(processRect, size);
 
         Q_FOREACH (const QRect &rc, rects) {
             image->addJob(d->currentStrokeId,
                           new KisFilterStrokeStrategy::Data(rc, true));
         }
     } else {
         image->addJob(d->currentStrokeId,
                       new KisFilterStrokeStrategy::Data(processRect, false));
     }
 
     d->currentlyAppliedConfiguration = filterConfig;
 }
 
 void KisFilterManager::finish()
 {
     Q_ASSERT(d->currentStrokeId);
 
     d->view->image()->endStroke(d->currentStrokeId);
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->currentlyAppliedConfiguration->name());
     if (filter->bookmarkManager()) {
         filter->bookmarkManager()->save(KisBookmarkedConfigurationManager::ConfigLastUsed,
                                        d->currentlyAppliedConfiguration.data());
     }
 
     d->lastConfiguration = d->currentlyAppliedConfiguration;
     d->reapplyAction->setEnabled(true);
     d->reapplyAction->setText(i18n("Apply Filter Again: %1", filter->name()));
 
     d->currentStrokeId.clear();
     d->currentlyAppliedConfiguration.clear();
 }
 
 void KisFilterManager::cancel()
 {
     Q_ASSERT(d->currentStrokeId);
 
     d->view->image()->cancelStroke(d->currentStrokeId);
 
     d->currentStrokeId.clear();
     d->currentlyAppliedConfiguration.clear();
 }
 
 bool KisFilterManager::isStrokeRunning() const
 {
     return d->currentStrokeId;
 }
 
 void KisFilterManager::slotStrokeEndRequested()
 {
     if (d->currentStrokeId && d->filterDialog) {
         d->filterDialog->accept();
     }
 }
 
 void KisFilterManager::slotStrokeCancelRequested()
 {
     if (d->currentStrokeId && d->filterDialog) {
         d->filterDialog->reject();
     }
 }
diff --git a/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp b/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
index 74c28da94c..6813164c0e 100644
--- a/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
+++ b/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
@@ -1,134 +1,134 @@
 #include "KisPaintOnTransparencyMaskTest.h"
 
 #include <QTest>
 #include <KoCompositeOpRegistry.h>
 #include <KoColor.h>
 #include "stroke_testing_utils.h"
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
 #include "kis_resources_snapshot.h"
 #include "kis_image.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_transparency_mask.h"
 
 #include "kis_paint_device_debug_utils.h"
 #include "kis_tool_utils.h"
 
 #include "kis_sequential_iterator.h"
 
 class PaintOnTransparencyMaskTester : public utils::StrokeTester
 {
 public:
     PaintOnTransparencyMaskTester(const QString &presetFilename)
         : StrokeTester("freehand_benchmark", QSize(5000, 5000), presetFilename)
     {
         setBaseFuzziness(3);
     }
 
 protected:
     using utils::StrokeTester::initImage;
     void initImage(KisImageWSP image, KisNodeSP activeNode) override {
 
         activeNode->paintDevice()->fill(QRect(0,0,1024,1024), KoColor(Qt::red, image->colorSpace()));
         m_mask = new KisTransparencyMask();
         m_mask->setSelection(new KisSelection());
         m_mask->paintDevice()->clear();
         image->addNode(m_mask, activeNode);
         image->setWorkingThreadsLimit(8);
     }
 
     using utils::StrokeTester::modifyResourceManager;
-    void modifyResourceManager(KoCanvasResourceManager *manager,
+    void modifyResourceManager(KoCanvasResourceProvider *manager,
                                KisImageWSP image) override {
 
         KoColor color(Qt::red, image->colorSpace());
         color.setOpacity(0.5);
 
         QVariant i;
         i.setValue(color);
-        manager->setResource(KoCanvasResourceManager::ForegroundColor, i);
+        manager->setResource(KoCanvasResourceProvider::ForegroundColor, i);
     }
 
     KisStrokeStrategy* createStroke(KisResourcesSnapshotSP resources,
                                     KisImageWSP image) override {
         Q_UNUSED(image);
 
         resources->setCurrentNode(m_mask);
 
         KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
         QScopedPointer<FreehandStrokeStrategy> stroke(
             new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("Freehand Stroke")));
 
         return stroke.take();
     }
 
     void addPaintingJobs(KisImageWSP image,
                                  KisResourcesSnapshotSP resources) override
     {
         addPaintingJobs(image, resources, 0);
     }
 
     void addPaintingJobs(KisImageWSP image, KisResourcesSnapshotSP resources, int iteration) override {
         Q_UNUSED(iteration);
         Q_UNUSED(resources);
 
 
         KisPaintInformation pi1;
         KisPaintInformation pi2;
 
         pi1 = KisPaintInformation(QPointF(100, 100), 1.0);
         pi2 = KisPaintInformation(QPointF(800, 800), 1.0);
 
         QScopedPointer<KisStrokeJobData> data(
                     new FreehandStrokeStrategy::Data(0, pi1, pi2));
 
         image->addJob(strokeId(), data.take());
 
         image->addJob(strokeId(), new FreehandStrokeStrategy::UpdateData(true));
     }
 
 
     void checkDeviceIsEmpty(KisPaintDeviceSP dev, const QString &name)
     {
         const KoColorSpace *cs = dev->colorSpace();
         KisSequentialConstIterator it(dev, QRect(0,0,1024,1024));
         while (it.nextPixel()) {
             if (cs->opacityU8(it.rawDataConst()) > 0) {
                 KIS_DUMP_DEVICE_2(dev, QRect(0,0,1024,1024), "image", "dd");
                 qFatal("%s", QString("failed: %1").arg(name).toLatin1().data());
             }
         }
     }
 
     void beforeCheckingResult(KisImageWSP image, KisNodeSP activeNode) override {
         ENTER_FUNCTION() << ppVar(image) << ppVar(activeNode);
 
         KisToolUtils::clearImage(image, activeNode, 0);
         image->waitForDone();
 
         checkDeviceIsEmpty(m_mask->paintDevice(), "mask");
         checkDeviceIsEmpty(m_mask->parent()->projection(), "projection");
         checkDeviceIsEmpty(image->projection(), "image");
     }
 
 private:
     KisMaskSP m_mask;
 };
 
 #include <KoResourcePaths.h>
 
 void KisPaintOnTransparencyMaskTest::initTestCase()
 {
     KoResourcePaths::addResourceType("kis_brushes", "data", FILES_DATA_DIR);
 }
 
 void KisPaintOnTransparencyMaskTest::test()
 {
     for (int i = 0; i < 1000; i++) {
         PaintOnTransparencyMaskTester tester("testing_wet_circle.kpp");
         tester.testSimpleStrokeNoVerification();
     }
 }
 
 QTEST_MAIN(KisPaintOnTransparencyMaskTest)
diff --git a/libs/ui/tests/fill_processing_visitor_test.cpp b/libs/ui/tests/fill_processing_visitor_test.cpp
index e3ec02fefc..222e8a8dca 100644
--- a/libs/ui/tests/fill_processing_visitor_test.cpp
+++ b/libs/ui/tests/fill_processing_visitor_test.cpp
@@ -1,145 +1,145 @@
 /*
  *  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 "fill_processing_visitor_test.h"
 
 #include <QTest>
 
 #include "kis_undo_stores.h"
 #include "kis_processing_applicator.h"
 
 #include "testutil.h"
 #include "qimage_based_test.h"
 #include "stroke_testing_utils.h"
 #include <resources/KoPattern.h>
 #include "kis_canvas_resource_provider.h"
 
 #include <processing/fill_processing_visitor.h>
 
 class FillProcessingVisitorTester : public TestUtil::QImageBasedTest
 {
 public:
     FillProcessingVisitorTester()
         : QImageBasedTest("fill_processing")
     {
     }
 
     void test(const QString &testname, bool haveSelection, bool usePattern, bool selectionOnly) {
         KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
         KisImageSP image = createImage(undoStore);
 
         if (haveSelection) {
             addGlobalSelection(image);
         }
 
         image->initialRefreshGraph();
 
         QVERIFY(checkLayersInitial(image));
 
         KisNodeSP fillNode = findNode(image->root(), "paint1");
 
-        KoCanvasResourceManager *manager = utils::createResourceManager(image, fillNode);
+        KoCanvasResourceProvider *manager = utils::createResourceManager(image, fillNode);
 
         KoPattern *newPattern = new KoPattern(TestUtil::fetchDataFileLazy("HR_SketchPaper_01.pat"));
         newPattern->load();
         Q_ASSERT(newPattern->valid());
 
         QVariant v;
         v.setValue(static_cast<void*>(newPattern));
         manager->setResource(KisCanvasResourceProvider::CurrentPattern, v);
 
         KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(image,
                                      fillNode,
                                      manager);
 
         KisProcessingVisitorSP visitor =
             new FillProcessingVisitor(QPoint(100,100),
                                       image->globalSelection(),
                                       resources,
                                       false, // useFastMode
                                       usePattern,
                                       selectionOnly,
                                       10, 10, 10, true, false);
 
 
         KisProcessingApplicator applicator(image, fillNode,
                                            KisProcessingApplicator::NONE);
 
         applicator.applyVisitor(visitor);
         applicator.end();
         image->waitForDone();
 
         QVERIFY(checkOneLayer(image, fillNode, testname, 500));
 
         undoStore->undo();
         image->waitForDone();
 
         QVERIFY(checkLayersInitial(image));
     }
 };
 
 void FillProcessingVisitorTest::testFillColorNoSelection()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_color_no_selection", false, false, false);
 }
 
 void FillProcessingVisitorTest::testFillPatternNoSelection()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_pattern_no_selection", false, true, false);
 }
 
 void FillProcessingVisitorTest::testFillColorHaveSelection()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_color_have_selection", true, false, false);
 }
 
 void FillProcessingVisitorTest::testFillPatternHaveSelection()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_pattern_have_selection", true, true, false);
 }
 
 void FillProcessingVisitorTest::testFillColorNoSelectionSelectionOnly()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_color_no_selection_selection_only", false, false, true);
 }
 
 void FillProcessingVisitorTest::testFillPatternNoSelectionSelectionOnly()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_pattern_no_selection_selection_only", false, true, true);
 }
 
 void FillProcessingVisitorTest::testFillColorHaveSelectionSelectionOnly()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_color_have_selection_selection_only", true, false, true);
 }
 
 void FillProcessingVisitorTest::testFillPatternHaveSelectionSelectionOnly()
 {
     FillProcessingVisitorTester tester;
     tester.test("fill_pattern_have_selection_selection_only", true, true, true);
 }
 
 QTEST_MAIN(FillProcessingVisitorTest)
diff --git a/libs/ui/tests/freehand_stroke_test.cpp b/libs/ui/tests/freehand_stroke_test.cpp
index 2dd206e088..1ae19b8c5b 100644
--- a/libs/ui/tests/freehand_stroke_test.cpp
+++ b/libs/ui/tests/freehand_stroke_test.cpp
@@ -1,189 +1,189 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "freehand_stroke_test.h"
 
 #include <QTest>
 #include <KoCompositeOpRegistry.h>
 #include <KoColor.h>
 #include "stroke_testing_utils.h"
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
 #include "kis_resources_snapshot.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <brushengine/kis_paint_information.h>
 
 #include "kistest.h"
 
 class FreehandStrokeTester : public utils::StrokeTester
 {
 public:
     FreehandStrokeTester(const QString &presetFilename, bool useLod = false)
         : StrokeTester(useLod ? "freehand-lod" : "freehand", QSize(500, 500), presetFilename),
           m_useLod(useLod),
           m_flipLineDirection(false)
     {
         setBaseFuzziness(3);
     }
 
     void setFlipLineDirection(bool value) {
         m_flipLineDirection = value;
         setNumIterations(2);
     }
 
     void setPaintColor(const QColor &color) {
         m_paintColor.reset(new QColor(color));
     }
 
 protected:
     using utils::StrokeTester::initImage;
     void initImage(KisImageWSP image, KisNodeSP activeNode) override {
         Q_UNUSED(activeNode);
 
         if (m_useLod) {
             image->setDesiredLevelOfDetail(1);
         }
     }
 
     void beforeCheckingResult(KisImageWSP image, KisNodeSP activeNode) override {
         Q_UNUSED(image)
         Q_UNUSED(activeNode);
 
         if (m_useLod) {
             //image->testingSetLevelOfDetailsEnabled(true);
         }
     }
 
-    void modifyResourceManager(KoCanvasResourceManager *manager,
+    void modifyResourceManager(KoCanvasResourceProvider *manager,
                                KisImageWSP image) override
     {
         modifyResourceManager(manager, image, 0);
     }
 
 
-    void modifyResourceManager(KoCanvasResourceManager *manager,
+    void modifyResourceManager(KoCanvasResourceProvider *manager,
                                KisImageWSP image,
                                int iteration) override {
 
         if (m_paintColor && iteration > 0) {
             QVariant i;
             i.setValue(KoColor(*m_paintColor, image->colorSpace()));
-            manager->setResource(KoCanvasResourceManager::ForegroundColor, i);
+            manager->setResource(KoCanvasResourceProvider::ForegroundColor, i);
         }
     }
 
     KisStrokeStrategy* createStroke(KisResourcesSnapshotSP resources,
                                     KisImageWSP image) override {
         Q_UNUSED(image);
 
         KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
         QScopedPointer<FreehandStrokeStrategy> stroke(
             new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("Freehand Stroke")));
 
         return stroke.take();
     }
 
     void addPaintingJobs(KisImageWSP image,
                                  KisResourcesSnapshotSP resources) override
     {
         addPaintingJobs(image, resources, 0);
     }
 
     void addPaintingJobs(KisImageWSP image, KisResourcesSnapshotSP resources, int iteration) override {
         Q_UNUSED(resources);
 
         KisPaintInformation pi1;
         KisPaintInformation pi2;
 
         if (!iteration) {
             pi1 = KisPaintInformation(QPointF(200, 200));
             pi2 = KisPaintInformation(QPointF(300, 300));
         } else {
             pi1 = KisPaintInformation(QPointF(200, 300));
             pi2 = KisPaintInformation(QPointF(300, 200));
         }
 
         QScopedPointer<KisStrokeJobData> data(
             new FreehandStrokeStrategy::Data(0, pi1, pi2));
 
         image->addJob(strokeId(), data.take());
         image->addJob(strokeId(), new FreehandStrokeStrategy::UpdateData(true));
     }
 
 private:
     bool m_useLod;
     bool m_flipLineDirection;
     QScopedPointer<QColor> m_paintColor;
 };
 
 void FreehandStrokeTest::testAutoBrushStroke()
 {
     FreehandStrokeTester tester("autobrush_300px.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testHatchingStroke()
 {
     FreehandStrokeTester tester("hatching_30px.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testColorSmudgeStroke()
 {
     FreehandStrokeTester tester("colorsmudge_predefined.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testAutoTextured17()
 {
     FreehandStrokeTester tester("auto_textured_17.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testAutoTextured38()
 {
     FreehandStrokeTester tester("auto_textured_38.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testMixDullCompositioning()
 {
     FreehandStrokeTester tester("Mix_dull.kpp");
     tester.setFlipLineDirection(true);
     tester.setPaintColor(Qt::red);
     tester.test();
 }
 
 void FreehandStrokeTest::testAutoBrushStrokeLod()
 {
     FreehandStrokeTester tester("Basic_tip_default.kpp", true);
     tester.testSimpleStroke();
 }
 
 void FreehandStrokeTest::testPredefinedBrushStrokeLod()
 {
     qsrand(QTime::currentTime().msec());
 
     FreehandStrokeTester tester("testing_predefined_lod_spc13.kpp", true);
     //FreehandStrokeTester tester("testing_predefined_lod.kpp", true);
     tester.testSimpleStroke();
 }
 
 KISTEST_MAIN(FreehandStrokeTest)
diff --git a/libs/ui/tests/kis_derived_resources_test.cpp b/libs/ui/tests/kis_derived_resources_test.cpp
index edbd9f4e36..c9451508c0 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 <KoCanvasResourceProvider.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();
+    KoCanvasResourceProvider *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,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_figure_painting_tool_helper.cpp b/libs/ui/tool/kis_figure_painting_tool_helper.cpp
index 19733d04b1..54a42a6121 100644
--- a/libs/ui/tool/kis_figure_painting_tool_helper.cpp
+++ b/libs/ui/tool/kis_figure_painting_tool_helper.cpp
@@ -1,144 +1,144 @@
 /*
  *  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_figure_painting_tool_helper.h"
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 
 #include "kis_resources_snapshot.h"
 #include <kis_distance_information.h>
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <strokes/KisFreehandStrokeInfo.h>
 
 
 KisFigurePaintingToolHelper::KisFigurePaintingToolHelper(const KUndo2MagicString &name,
                                                          KisImageWSP image,
                                                          KisNodeSP currentNode,
-                                                         KoCanvasResourceManager *resourceManager,
+                                                         KoCanvasResourceProvider *resourceManager,
                                                          KisPainter::StrokeStyle strokeStyle,
                                                          KisPainter::FillStyle fillStyle)
 {
     m_strokesFacade = image.data();
 
     m_resources =
         new KisResourcesSnapshot(image,
                                  currentNode,
                                  resourceManager);
 
     m_resources->setStrokeStyle(strokeStyle);
     m_resources->setFillStyle(fillStyle);
 
     KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
     KisStrokeStrategy *stroke =
         new FreehandStrokeStrategy(m_resources, strokeInfo, name);
 
     m_strokeId = m_strokesFacade->startStroke(stroke);
 }
 
 KisFigurePaintingToolHelper::~KisFigurePaintingToolHelper()
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::UpdateData(true));
     m_strokesFacade->endStroke(m_strokeId);
 }
 
 void KisFigurePaintingToolHelper::paintLine(const KisPaintInformation &pi0,
                                             const KisPaintInformation &pi1)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          pi0, pi1));
 }
 
 void KisFigurePaintingToolHelper::paintPolyline(const vQPointF &points)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::POLYLINE,
                                          points));
 }
 
 void KisFigurePaintingToolHelper::paintPolygon(const vQPointF &points)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::POLYGON,
                                          points));
 }
 
 void KisFigurePaintingToolHelper::paintRect(const QRectF &rect)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::RECT,
                                          rect));
 }
 
 void KisFigurePaintingToolHelper::paintEllipse(const QRectF &rect)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::ELLIPSE,
                                          rect));
 }
 
 void KisFigurePaintingToolHelper::paintPainterPath(const QPainterPath &path)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::PAINTER_PATH,
                                          path));
 }
 
 void KisFigurePaintingToolHelper::setFGColorOverride(const KoColor &color)
 {
     m_resources->setFGColorOverride(color);
 }
 
 void KisFigurePaintingToolHelper::setBGColorOverride(const KoColor &color)
 {
     m_resources->setBGColorOverride(color);
 }
 
 void KisFigurePaintingToolHelper::setSelectionOverride(KisSelectionSP m_selection)
 {
     m_resources->setSelectionOverride(m_selection);
 }
 
 void KisFigurePaintingToolHelper::setBrush(const KisPaintOpPresetSP &brush)
 {
     m_resources->setBrush(brush);
 }
 
 void KisFigurePaintingToolHelper::paintPainterPathQPen(const QPainterPath path, const QPen &pen, const KoColor &color)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::QPAINTER_PATH,
                                          path, pen, color));
 }
 
 void KisFigurePaintingToolHelper::paintPainterPathQPenFill(const QPainterPath path, const QPen &pen, const KoColor &color)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::QPAINTER_PATH_FILL,
                                          path, pen, color));
 }
diff --git a/libs/ui/tool/kis_figure_painting_tool_helper.h b/libs/ui/tool/kis_figure_painting_tool_helper.h
index f037e5eab6..3dcc334774 100644
--- a/libs/ui/tool/kis_figure_painting_tool_helper.h
+++ b/libs/ui/tool/kis_figure_painting_tool_helper.h
@@ -1,61 +1,61 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_FIGURE_PAINTING_TOOL_HELPER_H
 #define __KIS_FIGURE_PAINTING_TOOL_HELPER_H
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include <brushengine/kis_paint_information.h>
 #include "strokes/freehand_stroke.h"
 
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 class KisStrokesFacade;
 
 class KRITAUI_EXPORT KisFigurePaintingToolHelper
 {
 public:
     KisFigurePaintingToolHelper(const KUndo2MagicString &name,
                                 KisImageWSP image,
                                 KisNodeSP currentNode,
-                                KoCanvasResourceManager *resourceManager,
+                                KoCanvasResourceProvider *resourceManager,
                                 KisPainter::StrokeStyle strokeStyle,
                                 KisPainter::FillStyle fillStyle);
     ~KisFigurePaintingToolHelper();
 
     void paintLine(const KisPaintInformation &pi0,
                    const KisPaintInformation &pi1);
     void paintPolyline(const vQPointF &points);
     void paintPolygon(const vQPointF &points);
     void paintRect(const QRectF &rect);
     void paintEllipse(const QRectF &rect);
     void paintPainterPath(const QPainterPath &path);
     void setFGColorOverride(const KoColor &color);
     void setBGColorOverride(const KoColor &color);
     void setSelectionOverride(KisSelectionSP m_selection);
     void setBrush(const KisPaintOpPresetSP &brush);
     void paintPainterPathQPen(const QPainterPath, const QPen &pen, const KoColor &color);
     void paintPainterPathQPenFill(const QPainterPath, const QPen &pen, const KoColor &color);
 
 private:
     KisStrokeId m_strokeId;
     KisResourcesSnapshotSP m_resources;
     KisStrokesFacade *m_strokesFacade;
 };
 
 #endif /* __KIS_FIGURE_PAINTING_TOOL_HELPER_H */
diff --git a/libs/ui/tool/kis_painting_information_builder.cpp b/libs/ui/tool/kis_painting_information_builder.cpp
index 19f3d25fe2..e52259105f 100644
--- a/libs/ui/tool/kis_painting_information_builder.cpp
+++ b/libs/ui/tool/kis_painting_information_builder.cpp
@@ -1,198 +1,198 @@
 /*
  *  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_painting_information_builder.h"
 
 #include <KoPointerEvent.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 
 #include "kis_cubic_curve.h"
 #include "kis_speed_smoother.h"
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include "kis_canvas_resource_provider.h"
 
 
 /***********************************************************************/
 /*           KisPaintingInformationBuilder                             */
 /***********************************************************************/
 
 
 const int KisPaintingInformationBuilder::LEVEL_OF_PRESSURE_RESOLUTION = 1024;
 
 
 KisPaintingInformationBuilder::KisPaintingInformationBuilder()
     : m_speedSmoother(new KisSpeedSmoother()),
       m_pressureDisabled(false)
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(updateSettings()));
 
     updateSettings();
 }
 
 KisPaintingInformationBuilder::~KisPaintingInformationBuilder()
 {
 
 }
 
 void KisPaintingInformationBuilder::updateSettings()
 {
     KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString(cfg.pressureTabletCurve());
     m_pressureSamples = curve.floatTransfer(LEVEL_OF_PRESSURE_RESOLUTION + 1);
 }
 
 KisPaintInformation KisPaintingInformationBuilder::startStroke(KoPointerEvent *event,
                                                                int timeElapsed,
-                                                               const KoCanvasResourceManager *manager)
+                                                               const KoCanvasResourceProvider *manager)
 {
     if (manager) {
         m_pressureDisabled = manager->resource(KisCanvasResourceProvider::DisablePressure).toBool();
     }
 
     m_startPoint = event->point;
     return createPaintingInformation(event, timeElapsed);
 
 }
 
 KisPaintInformation KisPaintingInformationBuilder::continueStroke(KoPointerEvent *event,
                                                                   int timeElapsed)
 {
     return createPaintingInformation(event, timeElapsed);
 }
 
 QPointF KisPaintingInformationBuilder::adjustDocumentPoint(const QPointF &point, const QPointF &/*startPoint*/)
 {
     return point;
 }
 
 QPointF KisPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return point;
 }
 
 QPointF KisPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return point;
 }
 
 qreal KisPaintingInformationBuilder::calculatePerspective(const QPointF &documentPoint)
 {
     Q_UNUSED(documentPoint);
     return 1.0;
 }
 
 
 KisPaintInformation KisPaintingInformationBuilder::createPaintingInformation(KoPointerEvent *event,
                                                                              int timeElapsed)
 {
 
     QPointF adjusted = adjustDocumentPoint(event->point, m_startPoint);
     QPointF imagePoint = documentToImage(adjusted);
     qreal perspective = calculatePerspective(adjusted);
     qreal speed = m_speedSmoother->getNextSpeed(imageToView(imagePoint));
 
     return KisPaintInformation(imagePoint,
                                !m_pressureDisabled ? 1.0 : pressureToCurve(event->pressure()),
                                event->xTilt(), event->yTilt(),
                                event->rotation(),
                                event->tangentialPressure(),
                                perspective,
                                timeElapsed,
                                speed);
 }
 
 KisPaintInformation KisPaintingInformationBuilder::hover(const QPointF &imagePoint,
                                                          const KoPointerEvent *event)
 {
     qreal perspective = calculatePerspective(imagePoint);
     qreal speed = m_speedSmoother->getNextSpeed(imageToView(imagePoint));
 
     if (event) {
         return KisPaintInformation::createHoveringModeInfo(imagePoint,
                                                            PRESSURE_DEFAULT,
                                                            event->xTilt(), event->yTilt(),
                                                            event->rotation(),
                                                            event->tangentialPressure(),
                                                            perspective,
                                                            speed);
     } else {
         return KisPaintInformation::createHoveringModeInfo(imagePoint);
     }
 }
 
 qreal KisPaintingInformationBuilder::pressureToCurve(qreal pressure)
 {
     return KisCubicCurve::interpolateLinear(pressure, m_pressureSamples);
 }
 
 /***********************************************************************/
 /*           KisConverterPaintingInformationBuilder                        */
 /***********************************************************************/
 
 #include "kis_coordinates_converter.h"
 
 KisConverterPaintingInformationBuilder::KisConverterPaintingInformationBuilder(const KisCoordinatesConverter *converter)
     : m_converter(converter)
 {
 }
 
 QPointF KisConverterPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return m_converter->documentToImage(point);
 }
 
 QPointF KisConverterPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return m_converter->documentToWidget(point);
 }
 
 /***********************************************************************/
 /*           KisToolFreehandPaintingInformationBuilder                        */
 /***********************************************************************/
 
 #include "kis_tool_freehand.h"
 
 KisToolFreehandPaintingInformationBuilder::KisToolFreehandPaintingInformationBuilder(KisToolFreehand *tool)
     : m_tool(tool)
 {
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return m_tool->convertToPixelCoord(point);
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return m_tool->pixelToView(point);
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::adjustDocumentPoint(const QPointF &point, const QPointF &startPoint)
 {
     return m_tool->adjustPosition(point, startPoint);
 }
 
 qreal KisToolFreehandPaintingInformationBuilder::calculatePerspective(const QPointF &documentPoint)
 {
     return m_tool->calculatePerspective(documentPoint);
 }
diff --git a/libs/ui/tool/kis_painting_information_builder.h b/libs/ui/tool/kis_painting_information_builder.h
index 56b2181d42..42e9820a9d 100644
--- a/libs/ui/tool/kis_painting_information_builder.h
+++ b/libs/ui/tool/kis_painting_information_builder.h
@@ -1,112 +1,112 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_PAINTING_INFORMATION_BUILDER_H
 #define __KIS_PAINTING_INFORMATION_BUILDER_H
 
 #include <QObject>
 #include <QVector>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include <brushengine/kis_paint_information.h>
 
 class KoPointerEvent;
 class KisToolFreehand;
 class KisCoordinatesConverter;
 class KisSpeedSmoother;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 class KRITAUI_EXPORT KisPaintingInformationBuilder : public QObject
 {
     Q_OBJECT
 
 public:
     KisPaintingInformationBuilder();
     ~KisPaintingInformationBuilder() override;
 
-    KisPaintInformation startStroke(KoPointerEvent *event, int timeElapsed, const KoCanvasResourceManager *manager);
+    KisPaintInformation startStroke(KoPointerEvent *event, int timeElapsed, const KoCanvasResourceProvider *manager);
 
     KisPaintInformation continueStroke(KoPointerEvent *event,
                                        int timeElapsed);
 
     KisPaintInformation hover(const QPointF &imagePoint,
                               const KoPointerEvent *event);
 
     qreal pressureToCurve(qreal pressure);
 
 protected Q_SLOTS:
     void updateSettings();
 
 protected:
     virtual QPointF adjustDocumentPoint(const QPointF &point, const QPointF &startPoint);
     virtual QPointF documentToImage(const QPointF &point);
     virtual QPointF imageToView(const QPointF &point);
     virtual qreal calculatePerspective(const QPointF &documentPoint);
 
 private:
 
     KisPaintInformation createPaintingInformation(KoPointerEvent *event,
                                                   int timeElapsed);
 
     /**
      * Defines how many discrete samples are stored in a precomputed array
      * of different pressures.
      */
     static const int LEVEL_OF_PRESSURE_RESOLUTION;
 
 private:
     QVector<qreal> m_pressureSamples;
     QPointF m_startPoint;
     QScopedPointer<KisSpeedSmoother> m_speedSmoother;
     bool m_pressureDisabled;
 };
 
 class KRITAUI_EXPORT KisConverterPaintingInformationBuilder : public KisPaintingInformationBuilder
 {
     Q_OBJECT
 
 public:
     KisConverterPaintingInformationBuilder(const KisCoordinatesConverter *converter);
 
 protected:
     QPointF documentToImage(const QPointF &point) override;
     QPointF imageToView(const QPointF &point) override;
 
 private:
     const KisCoordinatesConverter *m_converter;
 };
 
 class KRITAUI_EXPORT KisToolFreehandPaintingInformationBuilder : public KisPaintingInformationBuilder
 {
     Q_OBJECT
 
 public:
     KisToolFreehandPaintingInformationBuilder(KisToolFreehand *tool);
 
 protected:
     QPointF documentToImage(const QPointF &point) override;
     QPointF imageToView(const QPointF &point) override;
     QPointF adjustDocumentPoint(const QPointF &point, const QPointF &startPoint) override;
     qreal calculatePerspective(const QPointF &documentPoint) override;
 
 private:
     KisToolFreehand *m_tool;
 };
 
 #endif /* __KIS_PAINTING_INFORMATION_BUILDER_H */
diff --git a/libs/ui/tool/kis_resources_snapshot.cpp b/libs/ui/tool/kis_resources_snapshot.cpp
index 5cff079402..c6837c2f03 100644
--- a/libs/ui/tool/kis_resources_snapshot.cpp
+++ b/libs/ui/tool/kis_resources_snapshot.cpp
@@ -1,415 +1,415 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_resources_snapshot.h"
 
 #include <KoColor.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoCompositeOpRegistry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <kis_threaded_text_rendering_workaround.h>
 #include <resources/KoPattern.h>
 #include "kis_canvas_resource_provider.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_algebra_2d.h"
 
 
 struct KisResourcesSnapshot::Private {
     Private()
         : currentPattern(0)
         , currentGradient(0)
         , currentGenerator(0)
         , compositeOp(0)
     {
     }
 
     KisImageSP image;
     KisDefaultBoundsBaseSP bounds;
     KoColor currentFgColor;
     KoColor currentBgColor;
     KoPattern *currentPattern = 0;
     KoAbstractGradient *currentGradient;
     KisPaintOpPresetSP currentPaintOpPreset;
     KisNodeSP currentNode;
     qreal currentExposure;
     KisFilterConfigurationSP currentGenerator;
 
     QPointF axesCenter;
     bool mirrorMaskHorizontal = false;
     bool mirrorMaskVertical = false;
 
     quint8 opacity = OPACITY_OPAQUE_U8;
     QString compositeOpId = COMPOSITE_OVER;
     const KoCompositeOp *compositeOp;
 
     KisPainter::StrokeStyle strokeStyle = KisPainter::StrokeStyleBrush;
     KisPainter::FillStyle fillStyle = KisPainter::FillStyleForegroundColor;
 
     bool globalAlphaLock = false;
     qreal effectiveZoom = 1.0;
     bool presetAllowsLod = false;
     KisSelectionSP selectionOverride;
 };
 
-KisResourcesSnapshot::KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KoCanvasResourceManager *resourceManager, KisDefaultBoundsBaseSP bounds)
+KisResourcesSnapshot::KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KoCanvasResourceProvider *resourceManager, KisDefaultBoundsBaseSP bounds)
     : m_d(new Private())
 {
     m_d->image = image;
     if (!bounds) {
         bounds = new KisDefaultBounds(m_d->image);
     }
     m_d->bounds = bounds;
-    m_d->currentFgColor = resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
-    m_d->currentBgColor = resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
+    m_d->currentFgColor = resourceManager->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
+    m_d->currentBgColor = resourceManager->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>();
     m_d->currentPattern = resourceManager->resource(KisCanvasResourceProvider::CurrentPattern).value<KoPattern*>();
     m_d->currentGradient = resourceManager->resource(KisCanvasResourceProvider::CurrentGradient).value<KoAbstractGradient*>();
 
     /**
      * We should deep-copy the preset, so that long-runnign actions
      * will have correct brush parameters. Theoretically this cloniong
      * can be expensive, but according to measurements, it takes
      * something like 0.1 ms for an average preset.
      */
     KisPaintOpPresetSP p = resourceManager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     if (p) {
         m_d->currentPaintOpPreset = resourceManager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>()->clone();
     }
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     KisPaintOpRegistry::instance()->preinitializePaintOpIfNeeded(m_d->currentPaintOpPreset);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     m_d->currentExposure = resourceManager->resource(KisCanvasResourceProvider::HdrExposure).toDouble();
     m_d->currentGenerator = resourceManager->resource(KisCanvasResourceProvider::CurrentGeneratorConfiguration).value<KisFilterConfiguration*>();
 
 
     QPointF relativeAxesCenter(0.5, 0.5);
     if (m_d->image) {
         relativeAxesCenter = m_d->image->mirrorAxesCenter();
     }
     m_d->axesCenter = KisAlgebra2D::relativeToAbsolute(relativeAxesCenter, m_d->bounds->bounds());
 
     m_d->mirrorMaskHorizontal = resourceManager->resource(KisCanvasResourceProvider::MirrorHorizontal).toBool();
     m_d->mirrorMaskVertical = resourceManager->resource(KisCanvasResourceProvider::MirrorVertical).toBool();
 
 
     qreal normOpacity = resourceManager->resource(KisCanvasResourceProvider::Opacity).toDouble();
     m_d->opacity = quint8(normOpacity * OPACITY_OPAQUE_U8);
 
     m_d->compositeOpId = resourceManager->resource(KisCanvasResourceProvider::CurrentEffectiveCompositeOp).toString();
     setCurrentNode(currentNode);
 
     /**
      * Fill and Stroke styles are not a part of the resource manager
      * so the tools should set them manually
      * TODO: port stroke and fill styles to be a part
      *       of the resource manager
      */
     m_d->strokeStyle = KisPainter::StrokeStyleBrush;
     m_d->fillStyle = KisPainter::FillStyleNone;
 
     m_d->globalAlphaLock = resourceManager->resource(KisCanvasResourceProvider::GlobalAlphaLock).toBool();
     m_d->effectiveZoom = resourceManager->resource(KisCanvasResourceProvider::EffectiveZoom).toDouble();
 
     m_d->presetAllowsLod = resourceManager->resource(KisCanvasResourceProvider::EffectiveLodAvailablility).toBool();
 }
 
 KisResourcesSnapshot::KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KisDefaultBoundsBaseSP bounds)
     : m_d(new Private())
 {
     m_d->image = image;
     if (!bounds) {
         bounds = new KisDefaultBounds(m_d->image);
     }
     m_d->bounds = bounds;
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     KisPaintOpRegistry::instance()->preinitializePaintOpIfNeeded(m_d->currentPaintOpPreset);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     QPointF relativeAxesCenter(0.5, 0.5);
     if (m_d->image) {
         relativeAxesCenter = m_d->image->mirrorAxesCenter();
     }
     m_d->axesCenter = KisAlgebra2D::relativeToAbsolute(relativeAxesCenter, m_d->bounds->bounds());
     m_d->opacity = OPACITY_OPAQUE_U8;
 
     setCurrentNode(currentNode);
 
     /**
      * Fill and Stroke styles are not a part of the resource manager
      * so the tools should set them manually
      * TODO: port stroke and fill styles to be a part
      *       of the resource manager
      */
     m_d->strokeStyle = KisPainter::StrokeStyleBrush;
     m_d->fillStyle = KisPainter::FillStyleNone;
 }
 
 
 KisResourcesSnapshot::~KisResourcesSnapshot()
 {
     delete m_d;
 }
 
 void KisResourcesSnapshot::setupPainter(KisPainter* painter)
 {
     painter->setPaintColor(m_d->currentFgColor);
     painter->setBackgroundColor(m_d->currentBgColor);
     painter->setGenerator(m_d->currentGenerator);
     painter->setPattern(m_d->currentPattern);
     painter->setGradient(m_d->currentGradient);
 
     QBitArray lockflags = channelLockFlags();
     if (lockflags.size() > 0) {
         painter->setChannelFlags(lockflags);
     }
 
     painter->setOpacity(m_d->opacity);
     painter->setCompositeOp(m_d->compositeOp);
     painter->setMirrorInformation(m_d->axesCenter, m_d->mirrorMaskHorizontal, m_d->mirrorMaskVertical);
 
     painter->setStrokeStyle(m_d->strokeStyle);
     painter->setFillStyle(m_d->fillStyle);
 
     /**
      * The paintOp should be initialized the last, because it may
      * ask the painter for some options while initialization
      */
     painter->setPaintOpPreset(m_d->currentPaintOpPreset, m_d->currentNode, m_d->image);
 }
 
 void KisResourcesSnapshot::setupMaskingBrushPainter(KisPainter *painter)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(painter->device());
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->currentPaintOpPreset->hasMaskingPreset());
 
     painter->setPaintColor(KoColor(Qt::white, painter->device()->colorSpace()));
     painter->setBackgroundColor(KoColor(Qt::black, painter->device()->colorSpace()));
 
     painter->setOpacity(OPACITY_OPAQUE_U8);
     painter->setChannelFlags(QBitArray());
 
     // masked brush always paints in indirect mode
     painter->setCompositeOp(COMPOSITE_ALPHA_DARKEN);
 
     painter->setMirrorInformation(m_d->axesCenter, m_d->mirrorMaskHorizontal, m_d->mirrorMaskVertical);
 
     /**
      * The paintOp should be initialized the last, because it may
      * ask the painter for some options while initialization
      */
     painter->setPaintOpPreset(m_d->currentPaintOpPreset->createMaskingPreset(),
                               m_d->currentNode, m_d->image);
 }
 
 KisPostExecutionUndoAdapter* KisResourcesSnapshot::postExecutionUndoAdapter() const
 {
     return m_d->image ? m_d->image->postExecutionUndoAdapter() : 0;
 }
 
 void KisResourcesSnapshot::setCurrentNode(KisNodeSP node)
 {
     m_d->currentNode = node;
 
     KisPaintDeviceSP device;
     if(m_d->currentNode && (device = m_d->currentNode->paintDevice())) {
         m_d->compositeOp = device->colorSpace()->compositeOp(m_d->compositeOpId);
         if(!m_d->compositeOp) {
             m_d->compositeOp = device->colorSpace()->compositeOp(COMPOSITE_OVER);
         }
     }
 }
 
 void KisResourcesSnapshot::setStrokeStyle(KisPainter::StrokeStyle strokeStyle)
 {
     m_d->strokeStyle = strokeStyle;
 }
 
 void KisResourcesSnapshot::setFillStyle(KisPainter::FillStyle fillStyle)
 {
     m_d->fillStyle = fillStyle;
 }
 
 KisNodeSP KisResourcesSnapshot::currentNode() const
 {
     return m_d->currentNode;
 }
 
 KisImageSP KisResourcesSnapshot::image() const
 {
     return m_d->image;
 }
 
 bool KisResourcesSnapshot::needsIndirectPainting() const
 {
     return !m_d->currentPaintOpPreset->settings()->paintIncremental();
 }
 
 QString KisResourcesSnapshot::indirectPaintingCompositeOp() const
 {
     return m_d->currentPaintOpPreset ?
             m_d->currentPaintOpPreset->settings()->indirectPaintingCompositeOp()
               : COMPOSITE_ALPHA_DARKEN;
 }
 
 bool KisResourcesSnapshot::needsMaskingBrushRendering() const
 {
     return m_d->currentPaintOpPreset && m_d->currentPaintOpPreset->hasMaskingPreset();
 }
 
 KisSelectionSP KisResourcesSnapshot::activeSelection() const
 {
     /**
      * It is possible to have/use the snapshot without the image. Such
      * usecase is present for example in the scratchpad.
      */
     if (m_d->selectionOverride) {
         return m_d->selectionOverride;
     }
 
     KisSelectionSP selection = m_d->image ? m_d->image->globalSelection() : 0;
 
     KisLayerSP layer = qobject_cast<KisLayer*>(m_d->currentNode.data());
     KisSelectionMaskSP mask;
     if((layer = qobject_cast<KisLayer*>(m_d->currentNode.data()))) {
          selection = layer->selection();
     } else if ((mask = dynamic_cast<KisSelectionMask*>(m_d->currentNode.data())) &&
                mask->selection() == selection) {
 
          selection = 0;
     }
 
     return selection;
 }
 
 bool KisResourcesSnapshot::needsAirbrushing() const
 {
     return m_d->currentPaintOpPreset->settings()->isAirbrushing();
 }
 
 qreal KisResourcesSnapshot::airbrushingInterval() const
 {
     return m_d->currentPaintOpPreset->settings()->airbrushInterval();
 }
 
 bool KisResourcesSnapshot::needsSpacingUpdates() const
 {
     return m_d->currentPaintOpPreset->settings()->useSpacingUpdates();
 }
 
 void KisResourcesSnapshot::setOpacity(qreal opacity)
 {
     m_d->opacity = opacity * OPACITY_OPAQUE_U8;
 }
 
 quint8 KisResourcesSnapshot::opacity() const
 {
     return m_d->opacity;
 }
 
 const KoCompositeOp* KisResourcesSnapshot::compositeOp() const
 {
     return m_d->compositeOp;
 }
 
 QString KisResourcesSnapshot::compositeOpId() const
 {
     return m_d->compositeOpId;
 }
 
 KoPattern* KisResourcesSnapshot::currentPattern() const
 {
     return m_d->currentPattern;
 }
 
 KoColor KisResourcesSnapshot::currentFgColor() const
 {
     return m_d->currentFgColor;
 }
 
 KoColor KisResourcesSnapshot::currentBgColor() const
 {
     return m_d->currentBgColor;
 }
 
 KisPaintOpPresetSP KisResourcesSnapshot::currentPaintOpPreset() const
 {
     return m_d->currentPaintOpPreset;
 }
 
 
 QBitArray KisResourcesSnapshot::channelLockFlags() const
 {
     QBitArray channelFlags;
     KisPaintLayer *paintLayer;
     if ((paintLayer = dynamic_cast<KisPaintLayer*>(m_d->currentNode.data()))) {
 
         channelFlags = paintLayer->channelLockFlags();
         if (m_d->globalAlphaLock) {
             if (channelFlags.isEmpty()) {
                 channelFlags = paintLayer->colorSpace()->channelFlags(true, true);
             }
 
             channelFlags &= paintLayer->colorSpace()->channelFlags(true, false);
         }
     }
     return channelFlags;
 }
 
 qreal KisResourcesSnapshot::effectiveZoom() const
 {
     return m_d->effectiveZoom;
 }
 
 bool KisResourcesSnapshot::presetAllowsLod() const
 {
     return m_d->presetAllowsLod;
 }
 
 bool KisResourcesSnapshot::presetNeedsAsynchronousUpdates() const
 {
     return m_d->currentPaintOpPreset && m_d->currentPaintOpPreset->settings()->needsAsynchronousUpdates();
 }
 
 void KisResourcesSnapshot::setFGColorOverride(const KoColor &color)
 {
     m_d->currentFgColor = color;
 }
 
 void KisResourcesSnapshot::setBGColorOverride(const KoColor &color)
 {
     m_d->currentBgColor = color;
 }
 
 void KisResourcesSnapshot::setSelectionOverride(KisSelectionSP selection)
 {
     m_d->selectionOverride = selection;
 }
 
 void KisResourcesSnapshot::setBrush(const KisPaintOpPresetSP &brush)
 {
     m_d->currentPaintOpPreset = brush;
 }
diff --git a/libs/ui/tool/kis_resources_snapshot.h b/libs/ui/tool/kis_resources_snapshot.h
index 658936ba89..b2361657b6 100644
--- a/libs/ui/tool/kis_resources_snapshot.h
+++ b/libs/ui/tool/kis_resources_snapshot.h
@@ -1,106 +1,106 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_RESOURCES_SNAPSHOT_H
 #define __KIS_RESOURCES_SNAPSHOT_H
 
 #include "kis_shared.h"
 #include "kis_shared_ptr.h"
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include "kis_painter.h"
 #include "kis_default_bounds.h"
 
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 class KoCompositeOp;
 class KisPainter;
 class KisPostExecutionUndoAdapter;
 class KoPattern;
 
 /**
  * @brief The KisResourcesSnapshot class takes a snapshot of the various resources
  * like colors and settings used at the begin of a stroke so subsequent
  * changes don't impact the running stroke. The main reason for the snapshot is that the
  * user can *change* the options while the stroke is being executed in the background.
  */
 class KRITAUI_EXPORT KisResourcesSnapshot : public KisShared
 {
 public:
-    KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KoCanvasResourceManager *resourceManager, KisDefaultBoundsBaseSP bounds = 0);
+    KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KoCanvasResourceProvider *resourceManager, KisDefaultBoundsBaseSP bounds = 0);
     KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KisDefaultBoundsBaseSP bounds = 0);
     ~KisResourcesSnapshot();
 
     void setupPainter(KisPainter *painter);
     void setupMaskingBrushPainter(KisPainter *painter);
 
     KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const;
     void setCurrentNode(KisNodeSP node);
     void setStrokeStyle(KisPainter::StrokeStyle strokeStyle);
     void setFillStyle(KisPainter::FillStyle fillStyle);
 
     KisNodeSP currentNode() const;
     KisImageSP image() const;
     bool needsIndirectPainting() const;
     QString indirectPaintingCompositeOp() const;
 
     bool needsMaskingBrushRendering() const;
 
     /**
      * \return currently active selection. Note that it will return
      *         null if current node *is* the current selection. This
      *         is done to avoid recursive selection application when
      *         painting on selectgion masks.
      */
     KisSelectionSP activeSelection() const;
 
     bool needsAirbrushing() const;
     qreal airbrushingInterval() const;
 
     bool needsSpacingUpdates() const;
 
     void setOpacity(qreal opacity);
     quint8 opacity() const;
     const KoCompositeOp* compositeOp() const;
     QString compositeOpId() const;
 
     KoPattern* currentPattern() const;
     KoColor currentFgColor() const;
     KoColor currentBgColor() const;
     KisPaintOpPresetSP currentPaintOpPreset() const;
 
     /// @return the channel lock flags of the current node with the global override applied
     QBitArray channelLockFlags() const;
 
     qreal effectiveZoom() const;
     bool presetAllowsLod() const;
     bool presetNeedsAsynchronousUpdates() const;
 
     void setFGColorOverride(const KoColor &color);
     void setBGColorOverride(const KoColor &color);
     void setSelectionOverride(KisSelectionSP selection);
     void setBrush(const KisPaintOpPresetSP &brush);
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 typedef KisSharedPtr<KisResourcesSnapshot> KisResourcesSnapshotSP;
 
 
 #endif /* __KIS_RESOURCES_SNAPSHOT_H */
diff --git a/libs/ui/tool/kis_selection_tool_config_widget_helper.h b/libs/ui/tool/kis_selection_tool_config_widget_helper.h
index aff792b269..acb631c905 100644
--- a/libs/ui/tool/kis_selection_tool_config_widget_helper.h
+++ b/libs/ui/tool/kis_selection_tool_config_widget_helper.h
@@ -1,73 +1,73 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_SELECTION_TOOL_CONFIG_WIDGET_HELPER_H
 #define __KIS_SELECTION_TOOL_CONFIG_WIDGET_HELPER_H
 
 #include <QObject>
 
 #include "kritaui_export.h"
 #include "kis_selection.h"
 #include "kis_canvas_resource_provider.h"
 
 class QKeyEvent;
 class KisCanvas2;
 class KisSelectionOptions;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 
 class KRITAUI_EXPORT KisSelectionToolConfigWidgetHelper : public QObject
 {
     Q_OBJECT
 public:
     KisSelectionToolConfigWidgetHelper(const QString &windowTitle);
 
     void createOptionWidget(KisCanvas2 *canvas, const QString &toolId);
     KisSelectionOptions* optionWidget() const;
 
     SelectionMode selectionMode() const;
     SelectionAction selectionAction() const;
     bool antiAliasSelection() const;
     int action() const { return selectionAction(); }
 
 Q_SIGNALS:
     void selectionActionChanged(int newAction);
 
 public Q_SLOTS:
     void slotToolActivatedChanged(bool isActivated);
 
     void slotWidgetActionChanged(int action);
     void slotWidgetModeChanged(int mode);
     void slotWidgetAntiAliasChanged(bool value);
 
     void slotReplaceModeRequested();
     void slotAddModeRequested();
     void slotSubtractModeRequested();
     void slotIntersectModeRequested();
 
 private:
     KisSelectionOptions* m_optionsWidget;
 
     QString m_windowTitle;
 
     SelectionMode m_selectionMode;
     SelectionAction m_selectionAction;
     bool m_antiAliasSelection = true;
 };
 
 #endif /* __KIS_SELECTION_TOOL_CONFIG_WIDGET_HELPER_H */
diff --git a/libs/ui/tool/kis_tool.cc b/libs/ui/tool/kis_tool.cc
index 6c4bb13734..4c3bc11e86 100644
--- a/libs/ui/tool/kis_tool.cc
+++ b/libs/ui/tool/kis_tool.cc
@@ -1,709 +1,709 @@
 /*
  *  Copyright (c) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_tool.h"
 #include <QCursor>
 #include <QLabel>
 #include <QWidget>
 #include <QPolygonF>
 #include <QTransform>
 
 #include <klocalizedstring.h>
 #include <QAction>
 #include <kactioncollection.h>
 
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoToolBase.h>
 #include <KoID.h>
 #include <KoPointerEvent.h>
 #include <KoViewConverter.h>
 #include <KoSelection.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoSnapGuide.h>
 
 #include <KisViewManager.h>
 #include "kis_node_manager.h"
 #include <kis_selection.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <resources/KoPattern.h>
 #include <kis_floating_message.h>
 
 #include "opengl/kis_opengl_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_coordinates_converter.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include <kis_selection_mask.h>
 #include "kis_resources_snapshot.h"
 #include <KisView.h>
 #include "kis_action_registry.h"
 #include "kis_tool_utils.h"
 
 
 struct Q_DECL_HIDDEN KisTool::Private {
     QCursor cursor; // the cursor that should be shown on tool activation.
 
     // From the canvas resources
     KoPattern* currentPattern{0};
     KoAbstractGradient* currentGradient{0};
     KoColor currentFgColor;
     KoColor currentBgColor;
     float currentExposure{1.0};
     KisFilterConfigurationSP currentGenerator;
     QWidget* optionWidget{0};
     ToolMode m_mode{HOVER_MODE};
     bool m_isActive{false};
 };
 
 KisTool::KisTool(KoCanvasBase * canvas, const QCursor & cursor)
     : KoToolBase(canvas)
     , d(new Private)
 {
     d->cursor = cursor;
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()));
     connect(this, SIGNAL(isActiveChanged(bool)), SLOT(resetCursorStyle()));
 
     KActionCollection *collection = this->canvas()->canvasController()->actionCollection();
 
     if (!collection->action("toggle_fg_bg")) {
         QAction *toggleFgBg = KisActionRegistry::instance()->makeQAction("toggle_fg_bg", collection);
         collection->addAction("toggle_fg_bg", toggleFgBg);
     }
 
     if (!collection->action("reset_fg_bg")) {
         QAction *toggleFgBg = KisActionRegistry::instance()->makeQAction("reset_fg_bg", collection);
         collection->addAction("reset_fg_bg", toggleFgBg);
     }
 
     addAction("toggle_fg_bg", dynamic_cast<QAction *>(collection->action("toggle_fg_bg")));
     addAction("reset_fg_bg", dynamic_cast<QAction *>(collection->action("reset_fg_bg")));
 
 }
 
 KisTool::~KisTool()
 {
     delete d;
 }
 
 void KisTool::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KoToolBase::activate(activation, shapes);
 
     resetCursorStyle();
 
     if (!canvas()) return;
     if (!canvas()->resourceManager()) return;
 
 
-    d->currentFgColor = canvas()->resourceManager()->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
-    d->currentBgColor = canvas()->resourceManager()->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
+    d->currentFgColor = canvas()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
+    d->currentBgColor = canvas()->resourceManager()->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>();
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentPattern)) {
         d->currentPattern = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPattern).value<KoPattern*>();
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentGradient)) {
         d->currentGradient = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentGradient).value<KoAbstractGradient*>();
     }
 
     KisPaintOpPresetSP preset = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     if (preset && preset->settings()) {
         preset->settings()->activate();
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::HdrExposure)) {
         d->currentExposure = static_cast<float>(canvas()->resourceManager()->resource(KisCanvasResourceProvider::HdrExposure).toDouble());
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentGeneratorConfiguration)) {
         d->currentGenerator = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentGeneratorConfiguration).value<KisFilterConfiguration*>();
     }
 
     connect(action("toggle_fg_bg"), SIGNAL(triggered()), SLOT(slotToggleFgBg()), Qt::UniqueConnection);
     connect(action("reset_fg_bg"), SIGNAL(triggered()), SLOT(slotResetFgBg()), Qt::UniqueConnection);
 
     d->m_isActive = true;
     emit isActiveChanged(true);
 }
 
 void KisTool::deactivate()
 {
     bool result = true;
 
     result &= disconnect(action("toggle_fg_bg"), 0, this, 0);
     result &= disconnect(action("reset_fg_bg"), 0, this, 0);
 
     if (!result) {
         warnKrita << "WARNING: KisTool::deactivate() failed to disconnect"
                    << "some signal connections. Your actions might be executed twice!";
     }
 
     d->m_isActive = false;
     emit isActiveChanged(false);
 
     KoToolBase::deactivate();
 }
 
 void KisTool::canvasResourceChanged(int key, const QVariant & v)
 {
     QString formattedBrushName;
     if (key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
          formattedBrushName = v.value<KisPaintOpPresetSP>()->name().replace("_", " ");
     }
 
     switch (key) {
-    case(KoCanvasResourceManager::ForegroundColor):
+    case(KoCanvasResourceProvider::ForegroundColor):
         d->currentFgColor = v.value<KoColor>();
         break;
-    case(KoCanvasResourceManager::BackgroundColor):
+    case(KoCanvasResourceProvider::BackgroundColor):
         d->currentBgColor = v.value<KoColor>();
         break;
     case(KisCanvasResourceProvider::CurrentPattern):
         d->currentPattern = static_cast<KoPattern *>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::CurrentGradient):
         d->currentGradient = static_cast<KoAbstractGradient *>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::HdrExposure):
         d->currentExposure = static_cast<float>(v.toDouble());
         break;
     case(KisCanvasResourceProvider::CurrentGeneratorConfiguration):
         d->currentGenerator = static_cast<KisFilterConfiguration*>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::CurrentPaintOpPreset):
         emit statusTextChanged(formattedBrushName);
         break;
     case(KisCanvasResourceProvider::CurrentKritaNode):
         resetCursorStyle();
         break;
     default:
         break; // Do nothing
     };
 }
 
 void KisTool::updateSettingsViews()
 {
 }
 
 QPointF KisTool::widgetCenterInWidgetPixels()
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     const KisCoordinatesConverter *converter = kritaCanvas->coordinatesConverter();
     return converter->flakeToWidget(converter->flakeCenterPoint());
 }
 
 QPointF KisTool::convertDocumentToWidget(const QPointF& pt)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->coordinatesConverter()->documentToWidget(pt);
 }
 
 QPointF KisTool::convertToPixelCoord(KoPointerEvent *e)
 {
     if (!image())
         return e->point;
 
     return image()->documentToPixel(e->point);
 }
 
 QPointF KisTool::convertToPixelCoord(const QPointF& pt)
 {
     if (!image())
         return pt;
 
     return image()->documentToPixel(pt);
 }
 
 QPointF KisTool::convertToPixelCoordAndSnap(KoPointerEvent *e, const QPointF &offset, bool useModifiers)
 {
     if (!image())
         return e->point;
 
     KoSnapGuide *snapGuide = canvas()->snapGuide();
     QPointF pos = snapGuide->snap(e->point, offset, useModifiers ? e->modifiers() : Qt::NoModifier);
 
     return image()->documentToPixel(pos);
 }
 
 QPointF KisTool::convertToPixelCoordAndSnap(const QPointF& pt, const QPointF &offset)
 {
     if (!image())
         return pt;
 
     KoSnapGuide *snapGuide = canvas()->snapGuide();
     QPointF pos = snapGuide->snap(pt, offset, Qt::NoModifier);
 
     return image()->documentToPixel(pos);
 }
 
 QPoint KisTool::convertToImagePixelCoordFloored(KoPointerEvent *e)
 {
     if (!image())
         return e->point.toPoint();
 
     return image()->documentToImagePixelFloored(e->point);
 }
 
 QPointF KisTool::viewToPixel(const QPointF &viewCoord) const
 {
     if (!image())
         return viewCoord;
 
     return image()->documentToPixel(canvas()->viewConverter()->viewToDocument(viewCoord));
 }
 
 QRectF KisTool::convertToPt(const QRectF &rect)
 {
     if (!image())
         return rect;
     QRectF r;
     //We add 1 in the following to the extreme coords because a pixel always has size
     r.setCoords(int(rect.left()) / image()->xRes(), int(rect.top()) / image()->yRes(),
                 int(rect.right()) / image()->xRes(), int( rect.bottom()) / image()->yRes());
     return r;
 }
 
 qreal KisTool::convertToPt(qreal value)
 {
     const qreal avgResolution = 0.5 * (image()->xRes() + image()->yRes());
     return value / avgResolution;
 }
 
 QPointF KisTool::pixelToView(const QPoint &pixelCoord) const
 {
     if (!image())
         return pixelCoord;
     QPointF documentCoord = image()->pixelToDocument(pixelCoord);
     return canvas()->viewConverter()->documentToView(documentCoord);
 }
 
 QPointF KisTool::pixelToView(const QPointF &pixelCoord) const
 {
     if (!image())
         return pixelCoord;
     QPointF documentCoord = image()->pixelToDocument(pixelCoord);
     return canvas()->viewConverter()->documentToView(documentCoord);
 }
 
 QRectF KisTool::pixelToView(const QRectF &pixelRect) const
 {
     if (!image())
         return pixelRect;
     QPointF topLeft = pixelToView(pixelRect.topLeft());
     QPointF bottomRight = pixelToView(pixelRect.bottomRight());
     return QRectF(topLeft, bottomRight);
 }
 
 QPainterPath KisTool::pixelToView(const QPainterPath &pixelPolygon) const
 {
     QTransform matrix;
     qreal zoomX, zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     matrix.scale(zoomX/image()->xRes(), zoomY/ image()->yRes());
     return matrix.map(pixelPolygon);
 }
 
 QPolygonF KisTool::pixelToView(const QPolygonF &pixelPath) const
 {
     QTransform matrix;
     qreal zoomX, zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     matrix.scale(zoomX/image()->xRes(), zoomY/ image()->yRes());
     return matrix.map(pixelPath);
 }
 
 void KisTool::updateCanvasPixelRect(const QRectF &pixelRect)
 {
     canvas()->updateCanvas(convertToPt(pixelRect));
 }
 
 void KisTool::updateCanvasViewRect(const QRectF &viewRect)
 {
     canvas()->updateCanvas(canvas()->viewConverter()->viewToDocument(viewRect));
 }
 
 KisImageWSP KisTool::image() const
 {
     // For now, krita tools only work in krita, not for a krita shape. Krita shapes are for 2.1
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     if (kisCanvas) {
         return kisCanvas->currentImage();
     }
 
     return 0;
 
 }
 
 QCursor KisTool::cursor() const
 {
     return d->cursor;
 }
 
 void KisTool::notifyModified() const
 {
     if (image()) {
         image()->setModified();
     }
 }
 
 KoPattern * KisTool::currentPattern()
 {
     return d->currentPattern;
 }
 
 KoAbstractGradient * KisTool::currentGradient()
 {
     return d->currentGradient;
 }
 
 KisPaintOpPresetSP KisTool::currentPaintOpPreset()
 {
     return canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 }
 
 KisNodeSP KisTool::currentNode() const
 {
     KisNodeSP node = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     return node;
 }
 
 KisNodeList KisTool::selectedNodes() const
 {
     KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager* viewManager = kiscanvas->viewManager();
     return viewManager->nodeManager()->selectedNodes();
 }
 
 KoColor KisTool::currentFgColor()
 {
     return d->currentFgColor;
 }
 
 KoColor KisTool::currentBgColor()
 {
     return d->currentBgColor;
 }
 
 KisImageWSP KisTool::currentImage()
 {
     return image();
 }
 
 KisFilterConfigurationSP  KisTool::currentGenerator()
 {
     return d->currentGenerator;
 }
 
 void KisTool::setMode(ToolMode mode) {
     d->m_mode = mode;
 }
 
 KisTool::ToolMode KisTool::mode() const {
     return d->m_mode;
 }
 
 void KisTool::setCursor(const QCursor &cursor)
 {
     d->cursor = cursor;
 }
 
 KisTool::AlternateAction KisTool::actionToAlternateAction(ToolAction action) {
     KIS_ASSERT_RECOVER_RETURN_VALUE(action != Primary, Secondary);
     return (AlternateAction)action;
 }
 
 void KisTool::activatePrimaryAction()
 {
     resetCursorStyle();
 }
 
 void KisTool::deactivatePrimaryAction()
 {
     resetCursorStyle();
 }
 
 void KisTool::beginPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::beginPrimaryDoubleClickAction(KoPointerEvent *event)
 {
     beginPrimaryAction(event);
 }
 
 void KisTool::continuePrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 bool KisTool::primaryActionSupportsHiResEvents() const
 {
     return false;
 }
 
 void KisTool::activateAlternateAction(AlternateAction action)
 {
     Q_UNUSED(action);
 }
 
 void KisTool::deactivateAlternateAction(AlternateAction action)
 {
     Q_UNUSED(action);
 }
 
 void KisTool::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::beginAlternateDoubleClickAction(KoPointerEvent *event, AlternateAction action)
 {
     beginAlternateAction(event, action);
 }
 
 void KisTool::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseTripleClickEvent(KoPointerEvent *event)
 {
     mouseDoubleClickEvent(event);
 }
 
 void KisTool::mousePressEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseMoveEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::deleteSelection()
 {
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
 
     if (!blockUntilOperationsFinished()) {
         return;
     }
 
     if (!KisToolUtils::clearImage(image(), resources->currentNode(), resources->activeSelection())) {
         KoToolBase::deleteSelection();
     }
 }
 
 QWidget* KisTool::createOptionWidget()
 {
     d->optionWidget = new QLabel(i18n("No options"));
     d->optionWidget->setObjectName("SpecialSpacer");
     return d->optionWidget;
 }
 
 #define NEAR_VAL -1000.0
 #define FAR_VAL 1000.0
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 
 void KisTool::paintToolOutline(QPainter* painter, const QPainterPath &path)
 {
     KisOpenGLCanvas2 *canvasWidget = dynamic_cast<KisOpenGLCanvas2 *>(canvas()->canvasWidget());
     if (canvasWidget)  {
         painter->beginNativePainting();
         canvasWidget->paintToolOutline(path);
         painter->endNativePainting();
     }
     else {
         painter->save();
         painter->setCompositionMode(QPainter::RasterOp_SourceXorDestination);
         painter->setPen(QColor(128, 255, 128));
         painter->drawPath(path);
         painter->restore();
     }
 }
 
 void KisTool::resetCursorStyle()
 {
     useCursor(d->cursor);
 }
 
 bool KisTool::overrideCursorIfNotEditable()
 {
     // override cursor for canvas iff this tool is active
     // and we can't paint on the active layer
     if (isActive()) {
         KisNodeSP node = currentNode();
         if (node && !node->isEditable()) {
             canvas()->setCursor(Qt::ForbiddenCursor);
             return true;
         }
     }
     return false;
 }
 
 bool KisTool::blockUntilOperationsFinished()
 {
     KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager* viewManager = kiscanvas->viewManager();
     return viewManager->blockUntilOperationsFinished(image());
 }
 
 void KisTool::blockUntilOperationsFinishedForced()
 {
     KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager* viewManager = kiscanvas->viewManager();
     viewManager->blockUntilOperationsFinishedForced(image());
 }
 
 bool KisTool::isActive() const
 {
     return d->m_isActive;
 }
 
 void KisTool::slotToggleFgBg()
 {
-    KoCanvasResourceManager* resourceManager = canvas()->resourceManager();
+    KoCanvasResourceProvider* resourceManager = canvas()->resourceManager();
     KoColor newFg = resourceManager->backgroundColor();
     KoColor newBg = resourceManager->foregroundColor();
 
     /**
      * NOTE: Some of color selectors do not differentiate foreground
      *       and background colors, so if one wants them to end up
      *       being set up to foreground color, it should be set the
      *       last.
      */
     resourceManager->setBackgroundColor(newBg);
     resourceManager->setForegroundColor(newFg);
 }
 
 void KisTool::slotResetFgBg()
 {
-    KoCanvasResourceManager* resourceManager = canvas()->resourceManager();
+    KoCanvasResourceProvider* resourceManager = canvas()->resourceManager();
 
     // see a comment in slotToggleFgBg()
     resourceManager->setBackgroundColor(KoColor(Qt::white, KoColorSpaceRegistry::instance()->rgb8()));
     resourceManager->setForegroundColor(KoColor(Qt::black, KoColorSpaceRegistry::instance()->rgb8()));
 }
 
 bool KisTool::nodeEditable()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return false;
     }
 
     bool blockedNoIndirectPainting = false;
 
     const bool presetUsesIndirectPainting =
         !currentPaintOpPreset()->settings()->paintIncremental();
 
     if (!presetUsesIndirectPainting) {
         const KisIndirectPaintingSupport *indirectPaintingLayer =
                 dynamic_cast<const KisIndirectPaintingSupport*>(node.data());
         if (indirectPaintingLayer) {
             blockedNoIndirectPainting = !indirectPaintingLayer->supportsNonIndirectPainting();
         }
     }
 
     bool nodeEditable = node->isEditable() && !blockedNoIndirectPainting;
 
     if (!nodeEditable) {
         KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
         QString message;
         if (!node->visible() && node->userLocked()) {
             message = i18n("Layer is locked and invisible.");
         } else if (node->userLocked()) {
             message = i18n("Layer is locked.");
         } else if(!node->visible()) {
             message = i18n("Layer is invisible.");
         } else if (blockedNoIndirectPainting) {
             message = i18n("Layer can be painted in Wash Mode only.");
         } else {
             message = i18n("Group not editable.");
         }
         kiscanvas->viewManager()->showFloatingMessage(message, KisIconUtils::loadIcon("object-locked"));
     }
     return nodeEditable;
 }
 
 bool KisTool::selectionEditable()
 {
     KisCanvas2 * kisCanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager * view = kisCanvas->viewManager();
 
     bool editable = view->selectionEditable();
     if (!editable) {
         KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
         kiscanvas->viewManager()->showFloatingMessage(i18n("Local selection is locked."), KisIconUtils::loadIcon("object-locked"));
     }
     return editable;
 }
 
 void KisTool::listenToModifiers(bool listen)
 {
     Q_UNUSED(listen);
 }
 
 bool KisTool::listeningToModifiers()
 {
     return false;
 }
diff --git a/libs/ui/tool/kis_tool.h b/libs/ui/tool/kis_tool.h
index 7e38b65507..83eb6ede95 100644
--- a/libs/ui/tool/kis_tool.h
+++ b/libs/ui/tool/kis_tool.h
@@ -1,322 +1,322 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_H_
 #define KIS_TOOL_H_
 
 #include <QCursor>
 
 #include <KoColor.h>
 #include <KoToolBase.h>
 #include <KoID.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <kritaui_export.h>
 #include <kis_types.h>
 
 #ifdef __GNUC__
 #define WARN_WRONG_MODE(_mode) warnKrita << "Unexpected tool event has come to" << __func__ << "while being mode" << _mode << "!"
 #else
 #define WARN_WRONG_MODE(_mode) warnKrita << "Unexpected tool event has come while being mode" << _mode << "!"
 #endif
 
 #define CHECK_MODE_SANITY_OR_RETURN(_mode) if (mode() != _mode) { WARN_WRONG_MODE(mode()); return; }
 
 class KoCanvasBase;
 class KoPattern;
 class KoAbstractGradient;
 class KisFilterConfiguration;
 class QPainter;
 class QPainterPath;
 class QPolygonF;
 
 /// Definitions of the toolgroups of Krita
 static const QString TOOL_TYPE_SHAPE = "0 Krita/Shape";         // Geometric shapes like ellipses and lines
 static const QString TOOL_TYPE_TRANSFORM = "2 Krita/Transform"; // Tools that transform the layer;
 static const QString TOOL_TYPE_FILL = "3 Krita/Fill";                // Tools that fill parts of the canvas
 static const QString TOOL_TYPE_VIEW = "4 Krita/View";                // Tools that affect the canvas: pan, zoom, etc.
 static const QString TOOL_TYPE_SELECTION = "5 Krita/Select";          // Tools that select pixels
 
 //activation id for Krita tools, Krita tools are always active and handle locked and invisible layers by themself
 static const QString KRITA_TOOL_ACTIVATION_ID = "flake/always";
 
 class  KRITAUI_EXPORT KisTool
         : public KoToolBase
 {
     Q_OBJECT
 
     Q_PROPERTY(bool isActive READ isActive NOTIFY isActiveChanged)
 
 public:
     enum { FLAG_USES_CUSTOM_PRESET=0x01, FLAG_USES_CUSTOM_COMPOSITEOP=0x02, FLAG_USES_CUSTOM_SIZE=0x04 };
 
     KisTool(KoCanvasBase * canvas, const QCursor & cursor);
     ~KisTool() override;
 
     virtual int flags() const { return 0; }
 
     void deleteSelection() override;
 // KoToolBase Implementation.
 
 public:
 
     /**
      * Called by KisToolProxy when the primary action of the tool is
      * going to be started now, that is when all the modifiers are
      * pressed and the only thing left is just to press the mouse
      * button.  On coming of this callback the tool is supposed to
      * prepare the cursor and/or the outline to show the user shat is
      * going to happen next
      */
     virtual void activatePrimaryAction();
 
     /**
      * Called by KisToolProxy when the primary is no longer possible
      * to be started now, e.g. when its modifiers and released. The
      * tool is supposed revert all the preparetions it has doen in
      * activatePrimaryAction().
      */
     virtual void deactivatePrimaryAction();
 
     /**
      * Called by KisToolProxy when a primary action for the tool is
      * started. The \p event stores the original event that
      * started the stroke. The \p event is _accepted_ by default. If
      * the tool decides to ignore this particular action (e.g. when
      * the node is not editable), it should call event->ignore(). Then
      * no further continuePrimaryAction() or endPrimaryAction() will
      * be called until the next user action.
      */
     virtual void beginPrimaryAction(KoPointerEvent *event);
 
     /**
      * Called by KisToolProxy when the primary action is in progress
      * of pointer movement.  If the tool has ignored the event in
      * beginPrimaryAction(), this method will not be called.
      */
     virtual void continuePrimaryAction(KoPointerEvent *event);
 
     /**
      * Called by KisToolProxy when the primary action is being
      * finished, that is while mouseRelease or tabletRelease event.
      * If the tool has ignored the event in beginPrimaryAction(), this
      * method will not be called.
      */
     virtual void endPrimaryAction(KoPointerEvent *event);
 
     /**
      * The same as beginPrimaryAction(), but called when the stroke is
      * started by a double-click
      *
      * \see beginPrimaryAction()
      */
     virtual void beginPrimaryDoubleClickAction(KoPointerEvent *event);
 
     /**
      * Returns true if the tool can handle (and wants to handle) a
      * very tight flow of input events from the tablet
      */
     virtual bool primaryActionSupportsHiResEvents() const;
 
     enum ToolAction {
         Primary,
         AlternateChangeSize,
         AlternatePickFgNode,
         AlternatePickBgNode,
         AlternatePickFgImage,
         AlternatePickBgImage,
         AlternateSecondary,
         AlternateThird,
         AlternateFourth,
         AlternateFifth,
         Alternate_NONE = 10000
     };
 
     // Technically users are allowed to configure this, but nobody ever would do that.
     // So these can basically be thought of as aliases to ctrl+click, etc.
     enum AlternateAction {
         ChangeSize = AlternateChangeSize, // Default: Shift+Left click
         PickFgNode = AlternatePickFgNode, // Default: Ctrl+Alt+Left click
         PickBgNode = AlternatePickBgNode, // Default: Ctrl+Alt+Right click
         PickFgImage = AlternatePickFgImage, // Default: Ctrl+Left click
         PickBgImage = AlternatePickBgImage, // Default: Ctrl+Right click
         Secondary = AlternateSecondary,
         Third = AlternateThird,
         Fourth = AlternateFourth,
         Fifth = AlternateFifth,
         NONE = 10000
     };
 
     static AlternateAction actionToAlternateAction(ToolAction action);
 
     virtual void activateAlternateAction(AlternateAction action);
     virtual void deactivateAlternateAction(AlternateAction action);
 
     virtual void beginAlternateAction(KoPointerEvent *event, AlternateAction action);
     virtual void continueAlternateAction(KoPointerEvent *event, AlternateAction action);
     virtual void endAlternateAction(KoPointerEvent *event, AlternateAction action);
     virtual void beginAlternateDoubleClickAction(KoPointerEvent *event, AlternateAction action);
 
 
     void mousePressEvent(KoPointerEvent *event) override;
     void mouseDoubleClickEvent(KoPointerEvent *event) override;
     void mouseTripleClickEvent(KoPointerEvent *event) override;
     void mouseReleaseEvent(KoPointerEvent *event) override;
     void mouseMoveEvent(KoPointerEvent *event) override;
 
     bool isActive() const;
 
 public Q_SLOTS:
     void activate(ToolActivation activation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
     void canvasResourceChanged(int key, const QVariant & res) override;
     // Implement this slot in case there are any widgets or properties which need
     // to be updated after certain operations, to reflect the inner state correctly.
     // At the moment this is used for smoothing options in the freehand brush, but
     // this will likely be expanded.
     virtual void updateSettingsViews();
 
 Q_SIGNALS:
     void isActiveChanged(bool isActivated);
 
 protected:
     // conversion methods are also needed by the paint information builder
     friend class KisToolPaintingInformationBuilder;
 
     /// Convert from native (postscript points) to image pixel
     /// coordinates.
     QPointF convertToPixelCoord(KoPointerEvent *e);
     QPointF convertToPixelCoord(const QPointF& pt);
 
     QPointF convertToPixelCoordAndSnap(KoPointerEvent *e, const QPointF &offset = QPointF(), bool useModifiers = true);
     QPointF convertToPixelCoordAndSnap(const QPointF& pt, const QPointF &offset = QPointF());
 
 protected:
     QPointF widgetCenterInWidgetPixels();
     QPointF convertDocumentToWidget(const QPointF& pt);
 
     /// Convert from native (postscript points) to integer image pixel
     /// coordinates. This rounds down (not truncate) the pixel coordinates and
     /// should be used in preference to QPointF::toPoint(), which rounds,
     /// to ensure the cursor acts on the pixel it is visually over.
     QPoint convertToImagePixelCoordFloored(KoPointerEvent *e);
 
     QRectF convertToPt(const QRectF &rect);
     qreal convertToPt(qreal value);
 
     QPointF viewToPixel(const QPointF &viewCoord) const;
     /// Convert an integer pixel coordinate into a view coordinate.
     /// The view coordinate is at the centre of the pixel.
     QPointF pixelToView(const QPoint &pixelCoord) const;
 
     /// Convert a floating point pixel coordinate into a view coordinate.
     QPointF pixelToView(const QPointF &pixelCoord) const;
 
     /// Convert a pixel rectangle into a view rectangle.
     QRectF pixelToView(const QRectF &pixelRect) const;
 
     /// Convert a pixel path into a view path
     QPainterPath pixelToView(const QPainterPath &pixelPath) const;
 
     /// Convert a pixel polygon into a view path
     QPolygonF pixelToView(const QPolygonF &pixelPolygon) const;
 
     /// Update the canvas for the given rectangle in image pixel coordinates.
     void updateCanvasPixelRect(const QRectF &pixelRect);
 
     /// Update the canvas for the given rectangle in view coordinates.
     void updateCanvasViewRect(const QRectF &viewRect);
 
     QWidget* createOptionWidget() override;
 
     /**
      * To determine whether this tool will change its behavior when
      * modifier keys are pressed
      */
     virtual bool listeningToModifiers();
     /**
      * Request that this tool no longer listen to modifier keys
      * (Responding to the request is optional)
      */
     virtual void listenToModifiers(bool listen);
 
 protected:
     KisImageWSP image() const;
     QCursor cursor() const;
 
     /// Call this to set the document modified
     void notifyModified() const;
 
     KisImageWSP currentImage();
     KoPattern* currentPattern();
     KoAbstractGradient *currentGradient();
     KisNodeSP currentNode() const;
     KisNodeList selectedNodes() const;
     KoColor currentFgColor();
     KoColor currentBgColor();
     KisPaintOpPresetSP currentPaintOpPreset();
     KisFilterConfigurationSP currentGenerator();
 
     /// paint the path which is in view coordinates, default paint mode is XOR_MODE, BW_MODE is also possible
     /// never apply transformations to the painter, they would be useless, if drawing in OpenGL mode. The coordinates in the path should be in view coordinates.
     void paintToolOutline(QPainter * painter, const QPainterPath &path);
 
     /// Checks checks if the current node is editable
     bool nodeEditable();
 
     /// Checks checks if the selection is editable, only applies to local selection as global selection is always editable
     bool selectionEditable();
 
     /// Override the cursor appropriately if current node is not editable
     bool overrideCursorIfNotEditable();
 
     bool blockUntilOperationsFinished();
     void blockUntilOperationsFinishedForced();
 
 protected:
     enum ToolMode {
         HOVER_MODE,
         PAINT_MODE,
         SECONDARY_PAINT_MODE,
         MIRROR_AXIS_SETUP_MODE,
         GESTURE_MODE,
         PAN_MODE,
         OTHER // not used now
     };
 
     virtual void setMode(ToolMode mode);
     virtual ToolMode mode() const;
     void setCursor(const QCursor &cursor);
 
 protected Q_SLOTS:
     /**
      * Called whenever the configuration settings change.
      */
     virtual void resetCursorStyle();
 
 private Q_SLOTS:
     void slotToggleFgBg();
     void slotResetFgBg();
 
 private:
     struct Private;
     Private* const d;
 };
 
 
 
 #endif // KIS_TOOL_H_
diff --git a/libs/ui/tool/kis_tool_freehand_helper.cpp b/libs/ui/tool/kis_tool_freehand_helper.cpp
index 1281b41dea..5edfed1a69 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.cpp
+++ b/libs/ui/tool/kis_tool_freehand_helper.cpp
@@ -1,1003 +1,1003 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_freehand_helper.h"
 
 #include <QTimer>
 #include <QQueue>
 
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 
 #include "kis_algebra_2d.h"
 #include "kis_distance_information.h"
 #include "kis_painting_information_builder.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_utils.h>
 
 #include "kis_update_time_monitor.h"
 #include "kis_stabilized_events_sampler.h"
 #include "KisStabilizerDelayedPaintHelper.h"
 #include "kis_config.h"
 
 #include "kis_random_source.h"
 #include "KisPerStrokeRandomSource.h"
 
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
 
 #include <math.h>
 
 //#define DEBUG_BEZIER_CURVES
 
 // Factor by which to scale the airbrush timer's interval, relative to the actual airbrushing rate.
 // Setting this less than 1 makes the timer-generated pseudo-events happen faster than the desired
 // airbrush rate, which can improve responsiveness.
 const qreal AIRBRUSH_INTERVAL_FACTOR = 0.5;
 
 // The amount of time, in milliseconds, to allow between updates of the spacing information. Only
 // used when spacing updates between dabs are enabled.
 const qreal SPACING_UPDATE_INTERVAL = 50.0;
 
 // The amount of time, in milliseconds, to allow between updates of the timing information. Only
 // used when airbrushing.
 const qreal TIMING_UPDATE_INTERVAL = 50.0;
 
 struct KisToolFreehandHelper::Private
 {
     KisPaintingInformationBuilder *infoBuilder;
     KisStrokesFacade *strokesFacade;
 
     KUndo2MagicString transactionText;
 
     bool haveTangent;
     QPointF previousTangent;
 
     bool hasPaintAtLeastOnce;
 
     QTime strokeTime;
     QTimer strokeTimeoutTimer;
 
     QVector<KisFreehandStrokeInfo*> strokeInfos;
     KisResourcesSnapshotSP resources;
     KisStrokeId strokeId;
 
     KisPaintInformation previousPaintInformation;
     KisPaintInformation olderPaintInformation;
 
     KisSmoothingOptionsSP smoothingOptions;
 
     // fake random sources for hovering outline *only*
     KisRandomSourceSP fakeDabRandomSource;
     KisPerStrokeRandomSourceSP fakeStrokeRandomSource;
 
     // Timer used to generate paint updates periodically even without input events. This is only
     // used for paintops that depend on timely updates even when the cursor is not moving, e.g. for
     // airbrushing effects.
     QTimer airbrushingTimer;
 
     QList<KisPaintInformation> history;
     QList<qreal> distanceHistory;
 
     // Keeps track of past cursor positions. This is used to determine the drawing angle when
     // drawing the brush outline or starting a stroke.
     KisPaintOpUtils::PositionHistory lastCursorPos;
 
     // Stabilizer data
     bool usingStabilizer;
     QQueue<KisPaintInformation> stabilizerDeque;
     QTimer stabilizerPollTimer;
     KisStabilizedEventsSampler stabilizedSampler;
     KisStabilizerDelayedPaintHelper stabilizerDelayedPaintHelper;
 
     QTimer asynchronousUpdatesThresholdTimer;
 
     int canvasRotation;
     bool canvasMirroredH;
 
     qreal effectiveSmoothnessDistance() const;
 };
 
 
 KisToolFreehandHelper::KisToolFreehandHelper(KisPaintingInformationBuilder *infoBuilder,
                                              const KUndo2MagicString &transactionText,
                                              KisSmoothingOptions *smoothingOptions)
     : m_d(new Private())
 {
     m_d->infoBuilder = infoBuilder;
     m_d->transactionText = transactionText;
     m_d->smoothingOptions = KisSmoothingOptionsSP(
                 smoothingOptions ? smoothingOptions : new KisSmoothingOptions());
     m_d->canvasRotation = 0;
 
     m_d->fakeDabRandomSource = new KisRandomSource();
     m_d->fakeStrokeRandomSource = new KisPerStrokeRandomSource();
 
     m_d->strokeTimeoutTimer.setSingleShot(true);
     connect(&m_d->strokeTimeoutTimer, SIGNAL(timeout()), SLOT(finishStroke()));
     connect(&m_d->airbrushingTimer, SIGNAL(timeout()), SLOT(doAirbrushing()));
     connect(&m_d->asynchronousUpdatesThresholdTimer, SIGNAL(timeout()), SLOT(doAsynchronousUpdate()));
     connect(&m_d->stabilizerPollTimer, SIGNAL(timeout()), SLOT(stabilizerPollAndPaint()));
     connect(m_d->smoothingOptions.data(), SIGNAL(sigSmoothingTypeChanged()), SLOT(slotSmoothingTypeChanged()));
 
     m_d->stabilizerDelayedPaintHelper.setPaintLineCallback(
                 [this](const KisPaintInformation &pi1, const KisPaintInformation &pi2) {
                     paintLine(pi1, pi2);
                 });
     m_d->stabilizerDelayedPaintHelper.setUpdateOutlineCallback(
                 [this]() {
                     emit requestExplicitUpdateOutline();
                 });
 }
 
 KisToolFreehandHelper::~KisToolFreehandHelper()
 {
     delete m_d;
 }
 
 void KisToolFreehandHelper::setSmoothness(KisSmoothingOptionsSP smoothingOptions)
 {
     m_d->smoothingOptions = smoothingOptions;
 }
 
 KisSmoothingOptionsSP KisToolFreehandHelper::smoothingOptions() const
 {
     return m_d->smoothingOptions;
 }
 
 QPainterPath KisToolFreehandHelper::paintOpOutline(const QPointF &savedCursorPos,
                                                    const KoPointerEvent *event,
                                                    const KisPaintOpSettingsSP globalSettings,
                                                    KisPaintOpSettings::OutlineMode mode) const
 {
     KisPaintOpSettingsSP settings = globalSettings;
     KisPaintInformation info = m_d->infoBuilder->hover(savedCursorPos, event);
     QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(savedCursorPos);
     qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, savedCursorPos, 0);
     info.setCanvasRotation(m_d->canvasRotation);
     info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
     KisDistanceInformation distanceInfo(prevPoint, startAngle);
 
     if (!m_d->strokeInfos.isEmpty()) {
         settings = m_d->resources->currentPaintOpPreset()->settings();
         if (m_d->stabilizerDelayedPaintHelper.running() &&
                 m_d->stabilizerDelayedPaintHelper.hasLastPaintInformation()) {
             info = m_d->stabilizerDelayedPaintHelper.lastPaintInformation();
         } else {
             info = m_d->previousPaintInformation;
         }
 
         /**
          * When LoD mode is active it may happen that the helper has
          * already started a stroke, but it painted noting, because
          * all the work is being calculated by the scaled-down LodN
          * stroke. So at first we try to fetch the data from the lodN
          * stroke ("buddy") and then check if there is at least
          * something has been painted with this distance information
          * object.
          */
         KisDistanceInformation *buddyDistance =
             m_d->strokeInfos.first()->buddyDragDistance();
 
         if (buddyDistance) {
             /**
              * Tiny hack alert: here we fetch the distance information
              * directly from the LodN stroke. Ideally, we should
              * upscale its data, but here we just override it with our
              * local copy of the coordinates.
              */
             distanceInfo = *buddyDistance;
             distanceInfo.overrideLastValues(prevPoint, startAngle);
 
         } else if (m_d->strokeInfos.first()->dragDistance->isStarted()) {
             distanceInfo = *m_d->strokeInfos.first()->dragDistance;
         }
     }
 
     KisPaintInformation::DistanceInformationRegistrar registrar =
         info.registerDistanceInformation(&distanceInfo);
 
     info.setRandomSource(m_d->fakeDabRandomSource);
     info.setPerStrokeRandomSource(m_d->fakeStrokeRandomSource);
 
     QPainterPath outline = settings->brushOutline(info, mode);
 
     if (m_d->resources &&
         m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER &&
         m_d->smoothingOptions->useDelayDistance()) {
 
         const qreal R = m_d->smoothingOptions->delayDistance() /
             m_d->resources->effectiveZoom();
 
         outline.addEllipse(info.pos(), R, R);
     }
 
     return outline;
 }
 
 void KisToolFreehandHelper::cursorMoved(const QPointF &cursorPos)
 {
     m_d->lastCursorPos.pushThroughHistory(cursorPos);
 }
 
 void KisToolFreehandHelper::initPaint(KoPointerEvent *event,
                                       const QPointF &pixelCoords,
-                                      KoCanvasResourceManager *resourceManager,
+                                      KoCanvasResourceProvider *resourceManager,
                                       KisImageWSP image, KisNodeSP currentNode,
                                       KisStrokesFacade *strokesFacade,
                                       KisNodeSP overrideNode,
                                       KisDefaultBoundsBaseSP bounds)
 {
     QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(pixelCoords);
     m_d->strokeTime.start();
     KisPaintInformation pi =
         m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), resourceManager);
     qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, pixelCoords, 0.0);
 
     initPaintImpl(startAngle,
                   pi,
                   resourceManager,
                   image,
                   currentNode,
                   strokesFacade,
                   overrideNode,
                   bounds);
 }
 
 bool KisToolFreehandHelper::isRunning() const
 {
     return m_d->strokeId;
 }
 
 void KisToolFreehandHelper::initPaintImpl(qreal startAngle,
                                           const KisPaintInformation &pi,
-                                          KoCanvasResourceManager *resourceManager,
+                                          KoCanvasResourceProvider *resourceManager,
                                           KisImageWSP image,
                                           KisNodeSP currentNode,
                                           KisStrokesFacade *strokesFacade,
                                           KisNodeSP overrideNode,
                                           KisDefaultBoundsBaseSP bounds)
 {
     m_d->strokesFacade = strokesFacade;
 
     m_d->haveTangent = false;
     m_d->previousTangent = QPointF();
 
     m_d->hasPaintAtLeastOnce = false;
 
     m_d->previousPaintInformation = pi;
 
     m_d->resources = new KisResourcesSnapshot(image,
                                               currentNode,
                                               resourceManager,
                                               bounds);
     if(overrideNode) {
         m_d->resources->setCurrentNode(overrideNode);
     }
 
     const bool airbrushing = m_d->resources->needsAirbrushing();
     const bool useSpacingUpdates = m_d->resources->needsSpacingUpdates();
 
     KisDistanceInitInfo startDistInfo(m_d->previousPaintInformation.pos(),
                                       startAngle,
                                       useSpacingUpdates ? SPACING_UPDATE_INTERVAL : LONG_TIME,
                                       airbrushing ? TIMING_UPDATE_INTERVAL : LONG_TIME,
                                       0);
     KisDistanceInformation startDist = startDistInfo.makeDistInfo();
 
     createPainters(m_d->strokeInfos,
                    startDist);
 
     KisStrokeStrategy *stroke =
         new FreehandStrokeStrategy(m_d->resources, m_d->strokeInfos, m_d->transactionText);
 
     m_d->strokeId = m_d->strokesFacade->startStroke(stroke);
 
     m_d->history.clear();
     m_d->distanceHistory.clear();
 
     if (airbrushing) {
         m_d->airbrushingTimer.setInterval(computeAirbrushTimerInterval());
         m_d->airbrushingTimer.start();
     } else if (m_d->resources->presetNeedsAsynchronousUpdates()) {
         m_d->asynchronousUpdatesThresholdTimer.setInterval(80 /* msec */);
         m_d->asynchronousUpdatesThresholdTimer.start();
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerStart(m_d->previousPaintInformation);
     }
 
     // If airbrushing, paint an initial dab immediately. This is a workaround for an issue where
     // some paintops (Dyna, Particle, Sketch) might never initialize their spacing/timing
     // information until paintAt is called.
     if (airbrushing) {
         paintAt(pi);
     }
 }
 
 void KisToolFreehandHelper::paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2,
                                                QPointF tangent1, QPointF tangent2)
 {
     if (tangent1.isNull() || tangent2.isNull()) return;
 
     const qreal maxSanePoint = 1e6;
 
     QPointF controlTarget1;
     QPointF controlTarget2;
 
     // Shows the direction in which control points go
     QPointF controlDirection1 = pi1.pos() + tangent1;
     QPointF controlDirection2 = pi2.pos() - tangent2;
 
     // Lines in the direction of the control points
     QLineF line1(pi1.pos(), controlDirection1);
     QLineF line2(pi2.pos(), controlDirection2);
 
     // Lines to check whether the control points lay on the opposite
     // side of the line
     QLineF line3(controlDirection1, controlDirection2);
     QLineF line4(pi1.pos(), pi2.pos());
 
     QPointF intersection;
     if (line3.intersect(line4, &intersection) == QLineF::BoundedIntersection) {
         qreal controlLength = line4.length() / 2;
 
         line1.setLength(controlLength);
         line2.setLength(controlLength);
 
         controlTarget1 = line1.p2();
         controlTarget2 = line2.p2();
     } else {
         QLineF::IntersectType type = line1.intersect(line2, &intersection);
 
         if (type == QLineF::NoIntersection ||
             intersection.manhattanLength() > maxSanePoint) {
 
             intersection = 0.5 * (pi1.pos() + pi2.pos());
 //            dbgKrita << "WARINING: there is no intersection point "
 //                     << "in the basic smoothing algoriths";
         }
 
         controlTarget1 = intersection;
         controlTarget2 = intersection;
     }
 
     // shows how near to the controlTarget the value raises
     qreal coeff = 0.8;
 
     qreal velocity1 = QLineF(QPointF(), tangent1).length();
     qreal velocity2 = QLineF(QPointF(), tangent2).length();
 
     if (velocity1 == 0.0 || velocity2 == 0.0) {
         velocity1 = 1e-6;
         velocity2 = 1e-6;
         warnKrita << "WARNING: Basic Smoothing: Velocity is Zero! Please report a bug:" << ppVar(velocity1) << ppVar(velocity2);
     }
 
     qreal similarity = qMin(velocity1/velocity2, velocity2/velocity1);
 
     // the controls should not differ more than 50%
     similarity = qMax(similarity, qreal(0.5));
 
     // when the controls are symmetric, their size should be smaller
     // to avoid corner-like curves
     coeff *= 1 - qMax(qreal(0.0), similarity - qreal(0.8));
 
     Q_ASSERT(coeff > 0);
 
 
     QPointF control1;
     QPointF control2;
 
     if (velocity1 > velocity2) {
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
         coeff *= similarity;
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
     } else {
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
         coeff *= similarity;
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
     }
 
     paintBezierCurve(pi1,
                      control1,
                      control2,
                      pi2);
 }
 
 qreal KisToolFreehandHelper::Private::effectiveSmoothnessDistance() const
 {
     const qreal effectiveSmoothnessDistance =
         !smoothingOptions->useScalableDistance() ?
         smoothingOptions->smoothnessDistance() :
         smoothingOptions->smoothnessDistance() / resources->effectiveZoom();
 
     return effectiveSmoothnessDistance;
 }
 
 void KisToolFreehandHelper::paintEvent(KoPointerEvent *event)
 {
     KisPaintInformation info =
             m_d->infoBuilder->continueStroke(event,
                                              elapsedStrokeTime());
     info.setCanvasRotation( m_d->canvasRotation );
     info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
 
     KisUpdateTimeMonitor::instance()->reportMouseMove(info.pos());
 
     paint(info);
 }
 
 void KisToolFreehandHelper::paint(KisPaintInformation &info)
 {
     /**
      * Smooth the coordinates out using the history and the
      * distance. This is a heavily modified version of an algo used in
      * Gimp and described in https://bugs.kde.org/show_bug.cgi?id=281267 and
      * http://www24.atwiki.jp/sigetch_2007/pages/17.html.  The main
      * differences are:
      *
      * 1) It uses 'distance' instead of 'velocity', since time
      *    measurements are too unstable in realworld environment
      *
      * 2) There is no 'Quality' parameter, since the number of samples
      *    is calculated automatically
      *
      * 3) 'Tail Aggressiveness' is used for controlling the end of the
      *    stroke
      *
      * 4) The formila is a little bit different: 'Distance' parameter
      *    stands for $3 \Sigma$
      */
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING
         && m_d->smoothingOptions->smoothnessDistance() > 0.0) {
 
         { // initialize current distance
             QPointF prevPos;
 
             if (!m_d->history.isEmpty()) {
                 const KisPaintInformation &prevPi = m_d->history.last();
                 prevPos = prevPi.pos();
             } else {
                 prevPos = m_d->previousPaintInformation.pos();
             }
 
             qreal currentDistance = QVector2D(info.pos() - prevPos).length();
             m_d->distanceHistory.append(currentDistance);
         }
 
         m_d->history.append(info);
 
         qreal x = 0.0;
         qreal y = 0.0;
 
         if (m_d->history.size() > 3) {
             const qreal sigma = m_d->effectiveSmoothnessDistance() / 3.0; // '3.0' for (3 * sigma) range
 
             qreal gaussianWeight = 1 / (sqrt(2 * M_PI) * sigma);
             qreal gaussianWeight2 = sigma * sigma;
             qreal distanceSum = 0.0;
             qreal scaleSum = 0.0;
             qreal pressure = 0.0;
             qreal baseRate = 0.0;
 
             Q_ASSERT(m_d->history.size() == m_d->distanceHistory.size());
 
             for (int i = m_d->history.size() - 1; i >= 0; i--) {
                 qreal rate = 0.0;
 
                 const KisPaintInformation nextInfo = m_d->history.at(i);
                 double distance = m_d->distanceHistory.at(i);
                 Q_ASSERT(distance >= 0.0);
 
                 qreal pressureGrad = 0.0;
                 if (i < m_d->history.size() - 1) {
                     pressureGrad = nextInfo.pressure() - m_d->history.at(i + 1).pressure();
 
                     const qreal tailAgressiveness = 40.0 * m_d->smoothingOptions->tailAggressiveness();
 
                     if (pressureGrad > 0.0 ) {
                         pressureGrad *= tailAgressiveness * (1.0 - nextInfo.pressure());
                         distance += pressureGrad * 3.0 * sigma; // (3 * sigma) --- holds > 90% of the region
                     }
                 }
 
                 if (gaussianWeight2 != 0.0) {
                     distanceSum += distance;
                     rate = gaussianWeight * exp(-distanceSum * distanceSum / (2 * gaussianWeight2));
                 }
 
                 if (m_d->history.size() - i == 1) {
                     baseRate = rate;
                 } else if (baseRate / rate > 100) {
                     break;
                 }
 
                 scaleSum += rate;
                 x += rate * nextInfo.pos().x();
                 y += rate * nextInfo.pos().y();
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure += rate * nextInfo.pressure();
                 }
             }
 
             if (scaleSum != 0.0) {
                 x /= scaleSum;
                 y /= scaleSum;
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure /= scaleSum;
                 }
             }
 
             if ((x != 0.0 && y != 0.0) || (x == info.pos().x() && y == info.pos().y())) {
                 info.setPos(QPointF(x, y));
                 if (m_d->smoothingOptions->smoothPressure()) {
                     info.setPressure(pressure);
                 }
                 m_d->history.last() = info;
             }
         }
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::SIMPLE_SMOOTHING
         || m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING)
     {
         // Now paint between the coordinates, using the bezier curve interpolation
         if (!m_d->haveTangent) {
             m_d->haveTangent = true;
             m_d->previousTangent =
                 (info.pos() - m_d->previousPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->previousPaintInformation.currentTime());
         } else {
             QPointF newTangent = (info.pos() - m_d->olderPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->olderPaintInformation.currentTime());
 
             if (newTangent.isNull() || m_d->previousTangent.isNull())
             {
                 paintLine(m_d->previousPaintInformation, info);
             } else {
                 paintBezierSegment(m_d->olderPaintInformation, m_d->previousPaintInformation,
                                    m_d->previousTangent, newTangent);
             }
 
             m_d->previousTangent = newTangent;
         }
         m_d->olderPaintInformation = m_d->previousPaintInformation;
 
         // Enable stroke timeout only when not airbrushing.
         if (!m_d->airbrushingTimer.isActive()) {
             m_d->strokeTimeoutTimer.start(100);
         }
     }
     else if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::NO_SMOOTHING){
         paintLine(m_d->previousPaintInformation, info);
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         m_d->stabilizedSampler.addEvent(info);
         if (m_d->stabilizerDelayedPaintHelper.running()) {
             // Paint here so we don't have to rely on the timer
             // This is just a tricky source for a relatively stable 7ms "timer"
             m_d->stabilizerDelayedPaintHelper.paintSome();
         }
     } else {
         m_d->previousPaintInformation = info;
     }
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.start();
     }
 }
 
 void KisToolFreehandHelper::endPaint()
 {
     if (!m_d->hasPaintAtLeastOnce) {
         paintAt(m_d->previousPaintInformation);
     } else if (m_d->smoothingOptions->smoothingType() != KisSmoothingOptions::NO_SMOOTHING) {
         finishStroke();
     }
     m_d->strokeTimeoutTimer.stop();
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
     if (m_d->asynchronousUpdatesThresholdTimer.isActive()) {
         m_d->asynchronousUpdatesThresholdTimer.stop();
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerEnd();
     }
 
     /**
      * There might be some timer events still pending, so
      * we should cancel them. Use this flag for the purpose.
      * Please note that we are not in MT here, so no mutex
      * is needed
      */
     m_d->strokeInfos.clear();
 
     // last update to complete rendering if there is still something pending
     doAsynchronousUpdate(true);
 
     m_d->strokesFacade->endStroke(m_d->strokeId);
     m_d->strokeId.clear();
 }
 
 void KisToolFreehandHelper::cancelPaint()
 {
     if (!m_d->strokeId) return;
 
     m_d->strokeTimeoutTimer.stop();
 
     if (m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
     if (m_d->asynchronousUpdatesThresholdTimer.isActive()) {
         m_d->asynchronousUpdatesThresholdTimer.stop();
     }
 
     if (m_d->stabilizerPollTimer.isActive()) {
         m_d->stabilizerPollTimer.stop();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.cancel();
     }
 
     // see a comment in endPaint()
     m_d->strokeInfos.clear();
 
     m_d->strokesFacade->cancelStroke(m_d->strokeId);
     m_d->strokeId.clear();
 
 }
 
 int KisToolFreehandHelper::elapsedStrokeTime() const
 {
     return m_d->strokeTime.elapsed();
 }
 
 void KisToolFreehandHelper::stabilizerStart(KisPaintInformation firstPaintInfo)
 {
     m_d->usingStabilizer = true;
     // FIXME: Ugly hack, this is no a "distance" in any way
     int sampleSize = qRound(m_d->effectiveSmoothnessDistance());
     sampleSize = qMax(3, sampleSize);
 
     // Fill the deque with the current value repeated until filling the sample
     m_d->stabilizerDeque.clear();
     for (int i = sampleSize; i > 0; i--) {
         m_d->stabilizerDeque.enqueue(firstPaintInfo);
     }
 
     // Poll and draw regularly
     KisConfig cfg(true);
     int stabilizerSampleSize = cfg.stabilizerSampleSize();
     m_d->stabilizerPollTimer.setInterval(stabilizerSampleSize);
     m_d->stabilizerPollTimer.start();
 
     bool delayedPaintEnabled = cfg.stabilizerDelayedPaint();
     if (delayedPaintEnabled) {
         m_d->stabilizerDelayedPaintHelper.start(firstPaintInfo);
     }
 
     m_d->stabilizedSampler.clear();
     m_d->stabilizedSampler.addEvent(firstPaintInfo);
 }
 
 KisPaintInformation
 KisToolFreehandHelper::getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
                                               const KisPaintInformation &lastPaintInfo)
 {
     KisPaintInformation result(lastPaintInfo.pos(),
                                lastPaintInfo.pressure(),
                                lastPaintInfo.xTilt(),
                                lastPaintInfo.yTilt(),
                                lastPaintInfo.rotation(),
                                lastPaintInfo.tangentialPressure(),
                                lastPaintInfo.perspective(),
                                elapsedStrokeTime(),
                                lastPaintInfo.drawingSpeed());
 
     if (queue.size() > 1) {
         QQueue<KisPaintInformation>::const_iterator it = queue.constBegin();
         QQueue<KisPaintInformation>::const_iterator end = queue.constEnd();
 
         /**
          * The first point is going to be overridden by lastPaintInfo, skip it.
          */
         it++;
         int i = 2;
 
         if (m_d->smoothingOptions->stabilizeSensors()) {
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result.KisPaintInformation::mixOtherWithoutTime(k, *it);
                 it++;
                 i++;
             }
         } else{
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result.KisPaintInformation::mixOtherOnlyPosition(k, *it);
                 it++;
                 i++;
             }
         }
     }
 
     return result;
 }
 
 void KisToolFreehandHelper::stabilizerPollAndPaint()
 {
     KisStabilizedEventsSampler::iterator it;
     KisStabilizedEventsSampler::iterator end;
     std::tie(it, end) = m_d->stabilizedSampler.range();
     QVector<KisPaintInformation> delayedPaintTodoItems;
 
     for (; it != end; ++it) {
         KisPaintInformation sampledInfo = *it;
 
         bool canPaint = true;
 
         if (m_d->smoothingOptions->useDelayDistance()) {
             const qreal R = m_d->smoothingOptions->delayDistance() /
                     m_d->resources->effectiveZoom();
 
             QPointF diff = sampledInfo.pos() - m_d->previousPaintInformation.pos();
             qreal dx = sqrt(pow2(diff.x()) + pow2(diff.y()));
 
             if (!(dx > R)) {
                 if (m_d->resources->needsAirbrushing()) {
                     sampledInfo.setPos(m_d->previousPaintInformation.pos());
                 }
                 else {
                     canPaint = false;
                 }
             }
         }
 
         if (canPaint) {
             KisPaintInformation newInfo = getStabilizedPaintInfo(m_d->stabilizerDeque, sampledInfo);
 
             if (m_d->stabilizerDelayedPaintHelper.running()) {
                 delayedPaintTodoItems.append(newInfo);
             } else {
                 paintLine(m_d->previousPaintInformation, newInfo);
             }
             m_d->previousPaintInformation = newInfo;
 
             // Push the new entry through the queue
             m_d->stabilizerDeque.dequeue();
             m_d->stabilizerDeque.enqueue(sampledInfo);
         } else if (m_d->stabilizerDeque.head().pos() != m_d->previousPaintInformation.pos()) {
 
             QQueue<KisPaintInformation>::iterator it = m_d->stabilizerDeque.begin();
             QQueue<KisPaintInformation>::iterator end = m_d->stabilizerDeque.end();
 
             while (it != end) {
                 *it = m_d->previousPaintInformation;
                 ++it;
             }
         }
     }
 
     m_d->stabilizedSampler.clear();
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.update(delayedPaintTodoItems);
     } else {
         emit requestExplicitUpdateOutline();
     }
 }
 
 void KisToolFreehandHelper::stabilizerEnd()
 {
     // Stop the timer
     m_d->stabilizerPollTimer.stop();
 
     // Finish the line
     if (m_d->smoothingOptions->finishStabilizedCurve()) {
         // Process all the existing events first
         stabilizerPollAndPaint();
 
         // Draw the finish line with pending events and a time override
         m_d->stabilizedSampler.addFinishingEvent(m_d->stabilizerDeque.size());
         stabilizerPollAndPaint();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.end();
     }
     m_d->usingStabilizer = false;
 }
 
 void KisToolFreehandHelper::slotSmoothingTypeChanged()
 {
     if (!isRunning()) {
         return;
     }
     KisSmoothingOptions::SmoothingType currentSmoothingType =
             m_d->smoothingOptions->smoothingType();
     if (m_d->usingStabilizer
             && (currentSmoothingType != KisSmoothingOptions::STABILIZER)) {
         stabilizerEnd();
     } else if (!m_d->usingStabilizer
             && (currentSmoothingType == KisSmoothingOptions::STABILIZER)) {
         stabilizerStart(m_d->previousPaintInformation);
     }
 }
 
 void KisToolFreehandHelper::finishStroke()
 {
     if (m_d->haveTangent) {
         m_d->haveTangent = false;
 
         QPointF newTangent = (m_d->previousPaintInformation.pos() - m_d->olderPaintInformation.pos()) /
             (m_d->previousPaintInformation.currentTime() - m_d->olderPaintInformation.currentTime());
 
         paintBezierSegment(m_d->olderPaintInformation,
                            m_d->previousPaintInformation,
                            m_d->previousTangent,
                            newTangent);
     }
 }
 
 void KisToolFreehandHelper::doAirbrushing()
 {
     // Check that the stroke hasn't ended.
     if (!m_d->strokeInfos.isEmpty()) {
 
         // Add a new painting update at a point identical to the previous one, except for the time
         // and speed information.
         const KisPaintInformation &prevPaint = m_d->previousPaintInformation;
         KisPaintInformation nextPaint(prevPaint.pos(),
                                       prevPaint.pressure(),
                                       prevPaint.xTilt(),
                                       prevPaint.yTilt(),
                                       prevPaint.rotation(),
                                       prevPaint.tangentialPressure(),
                                       prevPaint.perspective(),
                                       elapsedStrokeTime(),
                                       0.0);
         paint(nextPaint);
     }
 }
 
 void KisToolFreehandHelper::doAsynchronousUpdate(bool forceUpdate)
 {
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::UpdateData(forceUpdate));
 }
 
 int KisToolFreehandHelper::computeAirbrushTimerInterval() const
 {
     qreal realInterval = m_d->resources->airbrushingInterval() * AIRBRUSH_INTERVAL_FACTOR;
     return qMax(1, qFloor(realInterval));
 }
 
 void KisToolFreehandHelper::paintAt(int strokeInfoId,
                                     const KisPaintInformation &pi)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId, pi));
 
 }
 
 void KisToolFreehandHelper::paintLine(int strokeInfoId,
                                       const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId, pi1, pi2));
 
 }
 
 void KisToolFreehandHelper::paintBezierCurve(int strokeInfoId,
                                              const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
 #ifdef DEBUG_BEZIER_CURVES
     KisPaintInformation tpi1;
     KisPaintInformation tpi2;
 
     tpi1 = pi1;
     tpi2 = pi2;
 
     tpi1.setPressure(0.3);
     tpi2.setPressure(0.3);
 
     paintLine(tpi1, tpi2);
 
     tpi1.setPressure(0.6);
     tpi2.setPressure(0.3);
 
     tpi1.setPos(pi1.pos());
     tpi2.setPos(control1);
     paintLine(tpi1, tpi2);
 
     tpi1.setPos(pi2.pos());
     tpi2.setPos(control2);
     paintLine(tpi1, tpi2);
 #endif
 
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId,
                                                                 pi1, control1, control2, pi2));
 
 }
 
 void KisToolFreehandHelper::createPainters(QVector<KisFreehandStrokeInfo*> &strokeInfos,
                                            const KisDistanceInformation &startDist)
 {
     strokeInfos << new KisFreehandStrokeInfo(startDist);
 }
 
 void KisToolFreehandHelper::paintAt(const KisPaintInformation &pi)
 {
     paintAt(0, pi);
 }
 
 void KisToolFreehandHelper::paintLine(const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     paintLine(0, pi1, pi2);
 }
 
 void KisToolFreehandHelper::paintBezierCurve(const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
     paintBezierCurve(0, pi1, control1, control2, pi2);
 }
 
 int KisToolFreehandHelper::canvasRotation()
 {
     return m_d->canvasRotation;
 }
 
 void KisToolFreehandHelper::setCanvasRotation(int rotation)
 {
    m_d->canvasRotation = rotation;
 }
 bool KisToolFreehandHelper::canvasMirroredH()
 {
     return m_d->canvasMirroredH;
 }
 
 void KisToolFreehandHelper::setCanvasHorizontalMirrorState(bool mirrored)
 {
    m_d->canvasMirroredH = mirrored;
 }
diff --git a/libs/ui/tool/kis_tool_freehand_helper.h b/libs/ui/tool/kis_tool_freehand_helper.h
index d313eca245..da4f912f37 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.h
+++ b/libs/ui/tool/kis_tool_freehand_helper.h
@@ -1,159 +1,159 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_TOOL_FREEHAND_HELPER_H
 #define __KIS_TOOL_FREEHAND_HELPER_H
 
 #include <QObject>
 #include <QVector>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_default_bounds.h"
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_smoothing_options.h"
 #include "kundo2magicstring.h"
 
 
 class KoPointerEvent;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 class KisPaintingInformationBuilder;
 class KisStrokesFacade;
 class KisPostExecutionUndoAdapter;
 class KisPaintOp;
 class KisFreehandStrokeInfo;
 
 
 class KRITAUI_EXPORT KisToolFreehandHelper : public QObject
 {
     Q_OBJECT
 
 public:
 
     KisToolFreehandHelper(KisPaintingInformationBuilder *infoBuilder,
                           const KUndo2MagicString &transactionText = KUndo2MagicString(),
                           KisSmoothingOptions *smoothingOptions = 0);
     ~KisToolFreehandHelper() override;
 
     void setSmoothness(KisSmoothingOptionsSP smoothingOptions);
     KisSmoothingOptionsSP smoothingOptions() const;
 
     bool isRunning() const;
 
     void cursorMoved(const QPointF &cursorPos);
 
     /**
      * @param pixelCoords - The position of the KoPointerEvent, in pixel coordinates.
      */
     void initPaint(KoPointerEvent *event,
                    const QPointF &pixelCoords,
-                   KoCanvasResourceManager *resourceManager,
+                   KoCanvasResourceProvider *resourceManager,
                    KisImageWSP image,
                    KisNodeSP currentNode,
                    KisStrokesFacade *strokesFacade,
                    KisNodeSP overrideNode = 0,
                    KisDefaultBoundsBaseSP bounds = 0);
     void paintEvent(KoPointerEvent *event);
     void endPaint();
 
     QPainterPath paintOpOutline(const QPointF &savedCursorPos,
                                 const KoPointerEvent *event,
                                 const KisPaintOpSettingsSP globalSettings,
                                 KisPaintOpSettings::OutlineMode mode) const;
     int canvasRotation();
     void setCanvasRotation(int rotation = 0);
     bool canvasMirroredH();
     void setCanvasHorizontalMirrorState (bool mirrored = false);
 Q_SIGNALS:
     /**
      * The signal is emitted when the outline should be updated
      * explicitly by the tool. Used by Stabilizer option, because it
      * paints on internal timer events instead of the on every paint()
      * event
      */
     void requestExplicitUpdateOutline();
 
 protected:
     void cancelPaint();
     int elapsedStrokeTime() const;
 
     void initPaintImpl(qreal startAngle,
                        const KisPaintInformation &pi,
-                       KoCanvasResourceManager *resourceManager,
+                       KoCanvasResourceProvider *resourceManager,
                        KisImageWSP image,
                        KisNodeSP node,
                        KisStrokesFacade *strokesFacade,
                        KisNodeSP overrideNode = 0,
                        KisDefaultBoundsBaseSP bounds = 0);
 
 protected:
 
     virtual void createPainters(QVector<KisFreehandStrokeInfo*> &strokeInfos,
                                 const KisDistanceInformation &startDist);
 
     // lo-level methods for painting primitives
 
     void paintAt(int strokeInfoId, const KisPaintInformation &pi);
 
     void paintLine(int strokeInfoId,
                    const KisPaintInformation &pi1,
                    const KisPaintInformation &pi2);
 
     void paintBezierCurve(int strokeInfoId,
                           const KisPaintInformation &pi1,
                           const QPointF &control1,
                           const QPointF &control2,
                           const KisPaintInformation &pi2);
 
     // hi-level methods for painting primitives
 
     virtual void paintAt(const KisPaintInformation &pi);
 
     virtual void paintLine(const KisPaintInformation &pi1,
                            const KisPaintInformation &pi2);
 
     virtual void paintBezierCurve(const KisPaintInformation &pi1,
                                   const QPointF &control1,
                                   const QPointF &control2,
                                   const KisPaintInformation &pi2);
 
 private:
     void paint(KisPaintInformation &info);
     void paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2,
                                                    QPointF tangent1, QPointF tangent2);
 
     void stabilizerStart(KisPaintInformation firstPaintInfo);
     void stabilizerEnd();
     KisPaintInformation getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
                                                const KisPaintInformation &lastPaintInfo);
     int computeAirbrushTimerInterval() const;
 
 private Q_SLOTS:
     void finishStroke();
     void doAirbrushing();
     void doAsynchronousUpdate(bool forceUpdate = false);
     void stabilizerPollAndPaint();
     void slotSmoothingTypeChanged();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* __KIS_TOOL_FREEHAND_HELPER_H */
diff --git a/libs/ui/tool/kis_tool_paint.cc b/libs/ui/tool/kis_tool_paint.cc
index 1bc56466b2..b6c4ae5079 100644
--- a/libs/ui/tool/kis_tool_paint.cc
+++ b/libs/ui/tool/kis_tool_paint.cc
@@ -1,801 +1,801 @@
 /*
  *  Copyright (c) 2003-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_paint.h"
 
 #include <algorithm>
 
 #include <QWidget>
 #include <QRect>
 #include <QLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QWhatsThis>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QVariant>
 #include <QAction>
 #include <kis_debug.h>
 #include <QPoint>
 
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 
 #include <kis_icon.h>
 #include <KoShape.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoColorSpace.h>
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_types.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_cubic_curve.h>
 #include "kis_display_color_converter.h"
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_tool_utils.h"
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_action_manager.h>
 #include <kis_action.h>
 #include "strokes/kis_color_picker_stroke_strategy.h"
 
 
 KisToolPaint::KisToolPaint(KoCanvasBase *canvas, const QCursor &cursor)
     : KisTool(canvas, cursor),
       m_showColorPreview(false),
       m_colorPreviewShowComparePlate(false),
       m_colorPickerDelayTimer(),
       m_isOutlineEnabled(true)
 {
     m_specialHoverModifier = false;
     m_optionsWidgetLayout = 0;
 
     m_opacity = OPACITY_OPAQUE_U8;
 
     m_supportOutline = false;
 
     {
         int maxSize = KisConfig(true).readEntry("maximumBrushSize", 1000);
 
         int brushSize = 1;
         do {
             m_standardBrushSizes.push_back(brushSize);
             int increment = qMax(1, int(std::ceil(qreal(brushSize) / 15)));
             brushSize += increment;
         } while (brushSize < maxSize);
 
         m_standardBrushSizes.push_back(maxSize);
     }
 
     KisCanvas2 *kiscanvas = dynamic_cast<KisCanvas2*>(canvas);
     KisActionManager *actionManager = kiscanvas->viewManager()->actionManager();
 
     // XXX: Perhaps a better place for these?
     if (!actionManager->actionByName("increase_brush_size")) {
         KisAction *increaseBrushSize = new KisAction(i18n("Increase Brush Size"));
         increaseBrushSize->setShortcut(Qt::Key_BracketRight);
         actionManager->addAction("increase_brush_size", increaseBrushSize);
     }
 
     if (!actionManager->actionByName("decrease_brush_size")) {
         KisAction *decreaseBrushSize = new KisAction(i18n("Decrease Brush Size"));
         decreaseBrushSize->setShortcut(Qt::Key_BracketLeft);
         actionManager->addAction("decrease_brush_size", decreaseBrushSize);
     }
 
     addAction("increase_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("increase_brush_size")));
     addAction("decrease_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("decrease_brush_size")));
 
     connect(this, SIGNAL(sigPaintingFinished()), kiscanvas->viewManager()->resourceProvider(), SLOT(slotPainting()));
 
     m_colorPickerDelayTimer.setSingleShot(true);
     connect(&m_colorPickerDelayTimer, SIGNAL(timeout()), this, SLOT(activatePickColorDelayed()));
 
     using namespace std::placeholders; // For _1 placeholder
     std::function<void(PickingJob)> callback =
         std::bind(&KisToolPaint::addPickerJob, this, _1);
     m_colorPickingCompressor.reset(
         new PickingCompressor(100, callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 
 KisToolPaint::~KisToolPaint()
 {
 }
 
 int KisToolPaint::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP;
 }
 
 void KisToolPaint::canvasResourceChanged(int key, const QVariant& v)
 {
     KisTool::canvasResourceChanged(key, v);
 
     switch(key) {
     case(KisCanvasResourceProvider::Opacity):
         setOpacity(v.toDouble());
         break;
     default: //nothing
         break;
     }
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()), Qt::UniqueConnection);
 
 }
 
 
 void KisToolPaint::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     if (currentPaintOpPreset()) {
         QString formattedBrushName = currentPaintOpPreset()->name().replace("_", " ");
         emit statusTextChanged(formattedBrushName);
     }
 
     KisTool::activate(toolActivation, shapes);
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         connect(action("increase_brush_size"), SIGNAL(triggered()), SLOT(increaseBrushSize()), Qt::UniqueConnection);
         connect(action("decrease_brush_size"), SIGNAL(triggered()), SLOT(decreaseBrushSize()), Qt::UniqueConnection);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_oldOpacity = provider->opacity();
     provider->setOpacity(m_localOpacity);
 }
 
 void KisToolPaint::deactivate()
 {
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         disconnect(action("increase_brush_size"), 0, this, 0);
         disconnect(action("decrease_brush_size"), 0, this, 0);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_localOpacity = provider->opacity();
     provider->setOpacity(m_oldOpacity);
 
     KisTool::deactivate();
 }
 
 QPainterPath KisToolPaint::tryFixBrushOutline(const QPainterPath &originalOutline)
 {
     KisConfig cfg(true);
     if (cfg.newOutlineStyle() == OUTLINE_NONE) return originalOutline;
 
     const qreal minThresholdSize = cfg.outlineSizeMinimum();
 
     /**
      * If the brush outline is bigger than the canvas itself (which
      * would make it invisible for a user in most of the cases) just
      * add a cross in the center of it
      */
 
     QSize widgetSize = canvas()->canvasWidget()->size();
     const int maxThresholdSum = widgetSize.width() + widgetSize.height();
 
     QPainterPath outline = originalOutline;
     QRectF boundingRect = outline.boundingRect();
     const qreal sum = boundingRect.width() + boundingRect.height();
 
     QPointF center = boundingRect.center();
 
     if (sum > maxThresholdSum) {
         const int hairOffset = 7;
 
         outline.moveTo(center.x(), center.y() - hairOffset);
         outline.lineTo(center.x(), center.y() + hairOffset);
 
         outline.moveTo(center.x() - hairOffset, center.y());
         outline.lineTo(center.x() + hairOffset, center.y());
     } else if (sum < minThresholdSize && !outline.isEmpty()) {
         outline = QPainterPath();
         outline.addEllipse(center, 0.5 * minThresholdSize, 0.5 * minThresholdSize);
     }
 
     return outline;
 }
 
 void KisToolPaint::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     QPainterPath path = tryFixBrushOutline(pixelToView(m_currentOutline));
     paintToolOutline(&gc, path);
 
     if (m_showColorPreview) {
         QRectF viewRect = converter.documentToView(m_oldColorPreviewRect);
         gc.fillRect(viewRect, m_colorPreviewCurrentColor);
 
         if (m_colorPreviewShowComparePlate) {
             QRectF baseColorRect = viewRect.translated(viewRect.width(), 0);
             gc.fillRect(baseColorRect, m_colorPreviewBaseColor);
         }
     }
 }
 
 void KisToolPaint::setMode(ToolMode mode)
 {
     if(this->mode() == KisTool::PAINT_MODE &&
             mode != KisTool::PAINT_MODE) {
 
         // Let's add history information about recently used colors
         emit sigPaintingFinished();
     }
 
     KisTool::setMode(mode);
 }
 
 void KisToolPaint::activatePickColor(AlternateAction action)
 {
     m_showColorPreview = true;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 
     int resource = colorPreviewResourceId(action);
     KoColor color = canvas()->resourceManager()->koColorResource(resource);
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
     m_colorPreviewCurrentColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     if (!m_colorPreviewBaseColor.isValid()) {
         m_colorPreviewBaseColor = m_colorPreviewCurrentColor;
     }
 }
 
 void KisToolPaint::deactivatePickColor(AlternateAction action)
 {
     Q_UNUSED(action);
 
     m_showColorPreview = false;
     m_oldColorPreviewRect = QRect();
     m_oldColorPreviewUpdateRect = QRect();
     m_colorPreviewCurrentColor = QColor();
 }
 
 void KisToolPaint::pickColorWasOverridden()
 {
     m_colorPreviewShowComparePlate = false;
     m_colorPreviewBaseColor = QColor();
 }
 
 void KisToolPaint::activateAlternateAction(AlternateAction action)
 {
     switch (action) {
     case PickFgNode:
         /* Falls through */
     case PickBgNode:
         /* Falls through */
     case PickFgImage:
         /* Falls through */
     case PickBgImage:
         delayedAction = action;
         m_colorPickerDelayTimer.start(100);
         /* Falls through */
     default:
         pickColorWasOverridden();
         KisTool::activateAlternateAction(action);
     };
 }
 
 void KisToolPaint::activatePickColorDelayed()
 {
     switch (delayedAction) {
         case PickFgNode:
         useCursor(KisCursor::pickerLayerForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgNode:
         useCursor(KisCursor::pickerLayerBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickFgImage:
         useCursor(KisCursor::pickerImageForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgImage:
         useCursor(KisCursor::pickerImageBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     default:
         break;
     };
 
     repaintDecorations();
 }
 
 bool KisToolPaint::isPickingAction(AlternateAction action) {
     return action == PickFgNode ||
         action == PickBgNode ||
         action == PickFgImage ||
         action == PickBgImage;
 }
 
 void KisToolPaint::deactivateAlternateAction(AlternateAction action)
 {
     if (!isPickingAction(action)) {
         KisTool::deactivateAlternateAction(action);
         return;
     }
 
     delayedAction = KisTool::NONE;
     m_colorPickerDelayTimer.stop();
 
     resetCursorStyle();
     deactivatePickColor(action);
 }
 
 void KisToolPaint::addPickerJob(const PickingJob &pickingJob)
 {
     /**
      * The actual picking is delayed by a compressor, so we can get this
      * event when the stroke is already closed
      */
     if (!m_pickerStrokeId) return;
 
     KIS_ASSERT_RECOVER_RETURN(isPickingAction(pickingJob.action));
 
     const QPoint imagePoint = image()->documentToImagePixelFloored(pickingJob.documentPixel);
     const bool fromCurrentNode = pickingJob.action == PickFgNode || pickingJob.action == PickBgNode;
     m_pickingResource = colorPreviewResourceId(pickingJob.action);
 
     if (!fromCurrentNode) {
         auto *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
         KisSharedPtr<KisReferenceImagesLayer> referencesLayer = kisCanvas->imageView()->document()->referenceImagesLayer();
         if (referencesLayer && kisCanvas->referenceImagesDecoration()->visible()) {
             QColor color = referencesLayer->getPixel(imagePoint);
             if (color.isValid() && color.alpha() != 0) {
                 slotColorPickingFinished(KoColor(color, image()->colorSpace()));
                 return;
             }
         }
     }
 
     KisPaintDeviceSP device = fromCurrentNode ?
         currentNode()->colorPickSourceDevice() : image()->projection();
 
     // Used for color picker blending.
     KoColor currentColor = canvas()->resourceManager()->foregroundColor();
     if( pickingJob.action == PickBgNode || pickingJob.action == PickBgImage ){
         currentColor = canvas()->resourceManager()->backgroundColor();
     }
 
     image()->addJob(m_pickerStrokeId,
                     new KisColorPickerStrokeStrategy::Data(device, imagePoint, currentColor));
 }
 
 void KisToolPaint::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(!m_pickerStrokeId);
         setMode(SECONDARY_PAINT_MODE);
 
         KisColorPickerStrokeStrategy *strategy = new KisColorPickerStrokeStrategy();
         connect(strategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
                 this, &KisToolPaint::slotColorPickingFinished);
 
         m_pickerStrokeId = image()->startStroke(strategy);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::beginAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::continueAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         image()->endStroke(m_pickerStrokeId);
         m_pickerStrokeId.clear();
         requestUpdateOutline(event->point, event);
         setMode(HOVER_MODE);
     } else {
         KisTool::endAlternateAction(event, action);
     }
 }
 
 int KisToolPaint::colorPreviewResourceId(AlternateAction action)
 {
     bool toForegroundColor = action == PickFgNode || action == PickFgImage;
     int resource = toForegroundColor ?
-        KoCanvasResourceManager::ForegroundColor : KoCanvasResourceManager::BackgroundColor;
+        KoCanvasResourceProvider::ForegroundColor : KoCanvasResourceProvider::BackgroundColor;
 
     return resource;
 }
 
 void KisToolPaint::slotColorPickingFinished(const KoColor &color)
 {
     canvas()->resourceManager()->setResource(m_pickingResource, color);
 
     if (!m_showColorPreview) return;
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     QColor previewColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     m_colorPreviewShowComparePlate = true;
     m_colorPreviewCurrentColor = previewColor;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseMoveEvent(KoPointerEvent *event)
 {
     KisTool::mouseMoveEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 QWidget * KisToolPaint::createOptionWidget()
 {
     QWidget *optionWidget = new QWidget();
     optionWidget->setObjectName(toolId());
 
     QVBoxLayout *verticalLayout = new QVBoxLayout(optionWidget);
     verticalLayout->setObjectName("KisToolPaint::OptionWidget::VerticalLayout");
     verticalLayout->setContentsMargins(0,0,0,0);
     verticalLayout->setSpacing(5);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     verticalLayout->addWidget(specialSpacer);
     verticalLayout->addWidget(specialSpacer);
 
     m_optionsWidgetLayout = new QGridLayout();
     m_optionsWidgetLayout->setColumnStretch(1, 1);
 
     verticalLayout->addLayout(m_optionsWidgetLayout);
     m_optionsWidgetLayout->setContentsMargins(0,0,0,0);
     m_optionsWidgetLayout->setSpacing(5);
 
     if (!quickHelp().isEmpty()) {
         QPushButton *push = new QPushButton(KisIconUtils::loadIcon("help-contents"), QString(), optionWidget);
         connect(push, SIGNAL(clicked()), this, SLOT(slotPopupQuickHelp()));
 
         QHBoxLayout *hLayout = new QHBoxLayout(optionWidget);
         hLayout->addWidget(push);
         hLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
         verticalLayout->addLayout(hLayout);
     }
 
     return optionWidget;
 }
 
 QWidget* findLabelWidget(QGridLayout *layout, QWidget *control)
 {
     QWidget *result = 0;
 
     int index = layout->indexOf(control);
 
     int row, col, rowSpan, colSpan;
     layout->getItemPosition(index, &row, &col, &rowSpan, &colSpan);
 
     if (col > 0) {
         QLayoutItem *item = layout->itemAtPosition(row, col - 1);
 
         if (item) {
             result = item->widget();
         }
     } else {
         QLayoutItem *item = layout->itemAtPosition(row, col + 1);
         if (item) {
             result = item->widget();
         }
     }
 
     return result;
 }
 
 void KisToolPaint::showControl(QWidget *control, bool value)
 {
     control->setVisible(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setVisible(value);
     }
 }
 
 void KisToolPaint::enableControl(QWidget *control, bool value)
 {
     control->setEnabled(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setEnabled(value);
     }
 }
 
 void KisToolPaint::addOptionWidgetLayout(QLayout *layout)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     int rowCount = m_optionsWidgetLayout->rowCount();
     m_optionsWidgetLayout->addLayout(layout, rowCount, 0, 1, 2);
 }
 
 
 void KisToolPaint::addOptionWidgetOption(QWidget *control, QWidget *label)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     if (label) {
         m_optionsWidgetLayout->addWidget(label, m_optionsWidgetLayout->rowCount(), 0);
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount() - 1, 1);
     }
     else {
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount(), 0, 1, 2);
     }
 }
 
 
 void KisToolPaint::setOpacity(qreal opacity)
 {
     m_opacity = quint8(opacity * OPACITY_OPAQUE_U8);
 }
 
 const KoCompositeOp* KisToolPaint::compositeOp()
 {
     if (currentNode()) {
         KisPaintDeviceSP device = currentNode()->paintDevice();
         if (device) {
             QString op = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentCompositeOp).toString();
             return device->colorSpace()->compositeOp(op);
         }
     }
     return 0;
 }
 
 void KisToolPaint::slotPopupQuickHelp()
 {
     QWhatsThis::showText(QCursor::pos(), quickHelp());
 }
 
 KisToolPaint::NodePaintAbility KisToolPaint::nodePaintAbility()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return NONE;
     }
     if (node->inherits("KisShapeLayer")) {
         return VECTOR;
     }
     if (node->inherits("KisCloneLayer")) {
         return CLONE;
     }
     if (node->paintDevice()) {
         return PAINT;
     }
     return NONE;
 }
 
 void KisToolPaint::activatePrimaryAction()
 {
     pickColorWasOverridden();
     setOutlineEnabled(true);
     KisTool::activatePrimaryAction();
 }
 
 void KisToolPaint::deactivatePrimaryAction()
 {
     setOutlineEnabled(false);
     KisTool::deactivatePrimaryAction();
 }
 
 bool KisToolPaint::isOutlineEnabled() const
 {
     return m_isOutlineEnabled;
 }
 
 void KisToolPaint::setOutlineEnabled(bool value)
 {
     m_isOutlineEnabled = value;
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::increaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::iterator result =
         std::upper_bound(m_standardBrushSizes.begin(),
                          m_standardBrushSizes.end(),
                          qRound(paintopSize));
 
     int newValue = result != m_standardBrushSizes.end() ? *result : m_standardBrushSizes.back();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::decreaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::reverse_iterator result =
         std::upper_bound(m_standardBrushSizes.rbegin(),
                          m_standardBrushSizes.rend(),
                          (int)paintopSize,
                          std::greater<int>());
 
     int newValue = result != m_standardBrushSizes.rend() ? *result : m_standardBrushSizes.front();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QRectF KisToolPaint::colorPreviewDocRect(const QPointF &outlineDocPoint)
 {
     if (!m_showColorPreview) return QRect();
 
     KisConfig cfg(true);
 
     const QRectF colorPreviewViewRect = cfg.colorPreviewRect();
     const QRectF colorPreviewDocumentRect = canvas()->viewConverter()->viewToDocument(colorPreviewViewRect);
 
     return colorPreviewDocumentRect.translated(outlineDocPoint);
 }
 
 void KisToolPaint::requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event)
 {
     if (!m_supportOutline) return;
 
     KisConfig cfg(true);
     KisPaintOpSettings::OutlineMode outlineMode;
 
     if (isOutlineEnabled() &&
         (mode() == KisTool::GESTURE_MODE ||
          ((cfg.newOutlineStyle() == OUTLINE_FULL ||
            cfg.newOutlineStyle() == OUTLINE_CIRCLE ||
            cfg.newOutlineStyle() == OUTLINE_TILT) &&
           ((mode() == HOVER_MODE) ||
            (mode() == PAINT_MODE && cfg.showOutlineWhilePainting()))))) { // lisp forever!
 
         outlineMode.isVisible = true;
 
         if (cfg.newOutlineStyle() == OUTLINE_CIRCLE) {
             outlineMode.forceCircle = true;
         } else if(cfg.newOutlineStyle() == OUTLINE_TILT) {
             outlineMode.forceCircle = true;
             outlineMode.showTiltDecoration = true;
         } else {
             // noop
         }
     }
 
     outlineMode.forceFullSize = cfg.forceAlwaysFullSizedOutline();
 
     m_outlineDocPoint = outlineDocPoint;
     m_currentOutline = getOutlinePath(m_outlineDocPoint, event, outlineMode);
 
     QRectF outlinePixelRect = m_currentOutline.boundingRect();
     QRectF outlineDocRect = currentImage()->pixelToDocument(outlinePixelRect);
 
     // This adjusted call is needed as we paint with a 3 pixel wide brush and the pen is outside the bounds of the path
     // Pen uses view coordinates so we have to zoom the document value to match 2 pixel in view coordinates
     // See BUG 275829
     qreal zoomX;
     qreal zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     qreal xoffset = 2.0/zoomX;
     qreal yoffset = 2.0/zoomY;
 
     if (!outlineDocRect.isEmpty()) {
         outlineDocRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     QRectF colorPreviewDocRect = this->colorPreviewDocRect(m_outlineDocPoint);
     QRectF colorPreviewDocUpdateRect;
     if (!colorPreviewDocRect.isEmpty()) {
         colorPreviewDocUpdateRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     // DIRTY HACK ALERT: we should fetch the assistant's dirty rect when requesting
     //                   the update, instead of just dumbly update the entire canvas!
 
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas());
     KisPaintingAssistantsDecorationSP decoration = kiscanvas->paintingAssistantsDecoration();
     if (decoration && decoration->visible()) {
         kiscanvas->updateCanvas();
     } else {
         // TODO: only this branch should be present!
         if (!m_oldColorPreviewUpdateRect.isEmpty()) {
             canvas()->updateCanvas(m_oldColorPreviewUpdateRect);
         }
 
         if (!m_oldOutlineRect.isEmpty()) {
             canvas()->updateCanvas(m_oldOutlineRect);
         }
 
         if (!outlineDocRect.isEmpty()) {
             canvas()->updateCanvas(outlineDocRect);
         }
 
         if (!colorPreviewDocUpdateRect.isEmpty()) {
             canvas()->updateCanvas(colorPreviewDocUpdateRect);
         }
     }
 
     m_oldOutlineRect = outlineDocRect;
     m_oldColorPreviewRect = colorPreviewDocRect;
     m_oldColorPreviewUpdateRect = colorPreviewDocUpdateRect;
 }
 
 QPainterPath KisToolPaint::getOutlinePath(const QPointF &documentPos,
                                           const KoPointerEvent *event,
                                           KisPaintOpSettings::OutlineMode outlineMode)
 {
     Q_UNUSED(event);
 
     QPointF imagePos = currentImage()->documentToPixel(documentPos);
     QPainterPath path = currentPaintOpPreset()->settings()->
         brushOutline(KisPaintInformation(imagePos), outlineMode);
 
     return path;
 }
 
diff --git a/libs/ui/tool/kis_tool_paint.h b/libs/ui/tool/kis_tool_paint.h
index 129d766655..e071fd77b6 100644
--- a/libs/ui/tool/kis_tool_paint.h
+++ b/libs/ui/tool/kis_tool_paint.h
@@ -1,210 +1,210 @@
 /*
  *  Copyright (c) 2003 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_PAINT_H_
 #define KIS_TOOL_PAINT_H_
 
 #include "kis_tool.h"
 
 #include <QGridLayout>
 #include <QTimer>
 #include <QCheckBox>
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoToolBase.h>
 #include <resources/KoAbstractGradient.h>
 
 #include <kritaui_export.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include "kis_signal_compressor_with_param.h"
 #include <brushengine/kis_paintop_settings.h>
 #include <resources/KoPattern.h>
 
 class QGridLayout;
 class KoCompositeOp;
 class KoCanvasBase;
 
 class KRITAUI_EXPORT KisToolPaint : public KisTool
 {
 
     Q_OBJECT
 
 public:
     KisToolPaint(KoCanvasBase *canvas, const QCursor &cursor);
     ~KisToolPaint() override;
     int flags() const override;
 
     void mousePressEvent(KoPointerEvent *event) override;
     void mouseReleaseEvent(KoPointerEvent *event) override;
     void mouseMoveEvent(KoPointerEvent *event) override;
 
 protected:
 
     void setMode(ToolMode mode) override;
 
     void canvasResourceChanged(int key, const QVariant &v) override;
 
     void paint(QPainter &gc, const KoViewConverter &converter) override;
 
     void activatePrimaryAction() override;
     void deactivatePrimaryAction() override;
 
     void activateAlternateAction(AlternateAction action) override;
     void deactivateAlternateAction(AlternateAction action) override;
 
     void beginAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void continueAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void endAlternateAction(KoPointerEvent *event, AlternateAction action) override;
 
     virtual void requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event);
 
     /** If the paint tool support outline like brushes, set to true.
     *   If not (e.g. gradient tool), set to false. Default is false.
     */
     void setSupportOutline(bool supportOutline) {
         m_supportOutline = supportOutline;
     }
 
     virtual QPainterPath getOutlinePath(const QPointF &documentPos,
                                         const KoPointerEvent *event,
                                         KisPaintOpSettings::OutlineMode outlineMode);
 
 protected:
     bool isOutlineEnabled() const;
     void setOutlineEnabled(bool enabled);
 
     bool pickColor(const QPointF &documentPixel, AlternateAction action);
 
     /// Add the tool-specific layout to the default option widget layout.
     void addOptionWidgetLayout(QLayout *layout);
 
     /// Add a widget and a label to the current option widget layout.
     virtual void addOptionWidgetOption(QWidget *control, QWidget *label = 0);
 
     void showControl(QWidget *control, bool value);
     void enableControl(QWidget *control, bool value);
 
     QWidget * createOptionWidget() override;
 
     /**
      * Quick help is a short help text about the way the tool functions.
      */
     virtual QString quickHelp() const {
         return QString();
     }
 
     enum NodePaintAbility {
         NONE,
         PAINT,
         VECTOR,
         CLONE
     };
 
     /// Checks if and how the tool can paint on the current node
     NodePaintAbility nodePaintAbility();
 
     const KoCompositeOp* compositeOp();
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
 
 private Q_SLOTS:
 
     void slotPopupQuickHelp();
 
     void increaseBrushSize();
     void decreaseBrushSize();
 
     void activatePickColorDelayed();
 
     void slotColorPickingFinished(const KoColor &color);
 
 protected:
     quint8 m_opacity;
     bool m_paintOutline;
     QPointF m_outlineDocPoint;
     QPainterPath m_currentOutline;
     QRectF m_oldOutlineRect;
 
     bool m_showColorPreview;
     QRectF m_oldColorPreviewRect;
     QRectF m_oldColorPreviewUpdateRect;
     QColor m_colorPreviewCurrentColor;
     bool m_colorPreviewShowComparePlate;
     QColor m_colorPreviewBaseColor;
 
 private:
     QPainterPath tryFixBrushOutline(const QPainterPath &originalOutline);
     void setOpacity(qreal opacity);
 
     void activatePickColor(AlternateAction action);
     void deactivatePickColor(AlternateAction action);
     void pickColorWasOverridden();
 
     int colorPreviewResourceId(AlternateAction action);
     QRectF colorPreviewDocRect(const QPointF &outlineDocPoint);
 
     bool isPickingAction(AlternateAction action);
 
     struct PickingJob {
         PickingJob() {}
         PickingJob(QPointF _documentPixel,
                    AlternateAction _action)
             : documentPixel(_documentPixel),
               action(_action) {}
 
         QPointF documentPixel;
         AlternateAction action;
     };
     void addPickerJob(const PickingJob &pickingJob);
 
 private:
 
     bool m_specialHoverModifier;
     QGridLayout *m_optionsWidgetLayout;
 
     bool m_supportOutline;
 
     /**
      * Used as a switch for pickColor
      */
 
     // used to skip some of the tablet events and don't update the colour that often
     QTimer m_colorPickerDelayTimer;
     AlternateAction delayedAction;
 
     bool m_isOutlineEnabled;
     std::vector<int> m_standardBrushSizes;
 
     KisStrokeId m_pickerStrokeId;
     int m_pickingResource;
     typedef KisSignalCompressorWithParam<PickingJob> PickingCompressor;
     QScopedPointer<PickingCompressor> m_colorPickingCompressor;
 
     qreal m_localOpacity {1.0};
     qreal m_oldOpacity {1.0};
 
 Q_SIGNALS:
     void sigPaintingFinished();
 };
 
 #endif // KIS_TOOL_PAINT_H_
 
diff --git a/libs/ui/widgets/KoFillConfigWidget.cpp b/libs/ui/widgets/KoFillConfigWidget.cpp
index ec391ec0de..8d82ccf76d 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 <KoCanvasResourceProvider.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(KoColor)), &d->colorChangedCompressor, SLOT(start()));
     connect(&d->colorChangedCompressor, SIGNAL(timeout()), SLOT(colorChanged()));
 
     connect(d->ui->btnChooseSolidColor, SIGNAL(iconSizeChanged()), d->colorAction, SLOT(updateIcon()));
 
     connect(d->group, SIGNAL(buttonClicked(int)), SLOT(styleButtonPressed(int)));
 
     connect(d->group, SIGNAL(buttonClicked(int)), SLOT(slotUpdateFillTitle()));
 
     slotUpdateFillTitle();
     styleButtonPressed(d->group->checkedId());
 
 
     // Gradient selector
     d->ui->wdgGradientEditor->setCompactMode(true);
     connect(d->ui->wdgGradientEditor, SIGNAL(sigGradientChanged()), &d->gradientChangedCompressor, SLOT(start()));
     connect(&d->gradientChangedCompressor, SIGNAL(timeout()), SLOT(activeGradientChanged()));
 
     KoResourceServerProvider *serverProvider = KoResourceServerProvider::instance();
     QSharedPointer<KoAbstractResourceServerAdapter> gradientResourceAdapter(
                 new KoResourceServerAdapter<KoAbstractGradient>(serverProvider->gradientServer()));
 
     d->gradientAction = new KoResourcePopupAction(gradientResourceAdapter,
                                                   d->ui->btnChoosePredefinedGradient);
 
     d->gradientAction->setToolTip(i18n("Change filling gradient"));
     d->ui->btnChoosePredefinedGradient->setDefaultAction(d->gradientAction);
     d->ui->btnChoosePredefinedGradient->setPopupMode(QToolButton::InstantPopup);
 
     connect(d->gradientAction, SIGNAL(resourceSelected(QSharedPointer<KoShapeBackground>)),
             SLOT(gradientResourceChanged()));
     connect(d->ui->btnChoosePredefinedGradient, SIGNAL(iconSizeChanged()), d->gradientAction, SLOT(updateIcon()));
 
     d->ui->btnSaveGradient->setIcon(KisIconUtils::loadIcon("document-save"));
     connect(d->ui->btnSaveGradient, SIGNAL(clicked()), SLOT(slotSavePredefinedGradientClicked()));
 
     connect(d->ui->cmbGradientRepeat, SIGNAL(currentIndexChanged(int)), SLOT(slotGradientRepeatChanged()));
     connect(d->ui->cmbGradientType, SIGNAL(currentIndexChanged(int)), SLOT(slotGradientTypeChanged()));
 
     deactivate();
 
 #if 0
 
     // Pattern selector
     QSharedPointer<KoAbstractResourceServerAdapter>patternResourceAdapter(new KoResourceServerAdapter<KoPattern>(serverProvider->patternServer()));
     d->patternAction = new KoResourcePopupAction(patternResourceAdapter, d->colorButton);
     d->patternAction->setToolTip(i18n("Change the filling pattern"));
     connect(d->patternAction, SIGNAL(resourceSelected(QSharedPointer<KoShapeBackground>)), this, SLOT(patternChanged(QSharedPointer<KoShapeBackground>)));
     connect(d->colorButton, SIGNAL(iconSizeChanged()), d->patternAction, SLOT(updateIcon()));
 
 #endif
 
 }
 
 KoFillConfigWidget::~KoFillConfigWidget()
 {
     delete d;
 }
 
 void KoFillConfigWidget::activate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->deactivationLocks.empty());
     d->deactivationLocks.clear();
 
     if (!d->noSelectionTrackingMode) {
         shapeChanged();
     } else {
         loadCurrentFillFromResourceServer();
     }
 
     updateWidgetComponentVisbility();
 }
 
 void KoFillConfigWidget::deactivate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->deactivationLocks.empty());
     d->deactivationLocks.push_back(KisAcyclicSignalConnector::Blocker(d->shapeChangedAcyclicConnector));
     d->deactivationLocks.push_back(KisAcyclicSignalConnector::Blocker(d->resourceManagerAcyclicConnector));
 }
 
 void KoFillConfigWidget::forceUpdateOnSelectionChanged()
 {
     shapeChanged();
 }
 
 void KoFillConfigWidget::setNoSelectionTrackingMode(bool value)
 {
     d->noSelectionTrackingMode = value;
     if (!d->noSelectionTrackingMode) {
         shapeChanged();
     }
 }
 
 void KoFillConfigWidget::slotUpdateFillTitle()
 {
     QString text = d->group->checkedButton() ? d->group->checkedButton()->text() : QString();
     text.replace('&', QString());
     d->ui->lblFillTitle->setText(text);
 }
 
 void KoFillConfigWidget::slotCanvasResourceChanged(int key, const QVariant &value)
 {
-    if ((key == KoCanvasResourceManager::ForegroundColor && d->fillVariant == KoFlake::Fill) ||
-        (key == KoCanvasResourceManager::BackgroundColor &&
+    if ((key == KoCanvasResourceProvider::ForegroundColor && d->fillVariant == KoFlake::Fill) ||
+        (key == KoCanvasResourceProvider::BackgroundColor &&
          d->fillVariant == KoFlake::StrokeFill && !d->noSelectionTrackingMode) ||
-        (key == KoCanvasResourceManager::ForegroundColor && d->noSelectionTrackingMode)) {
+        (key == KoCanvasResourceProvider::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) {
+        } else if (checkedId == Gradient && key == KoCanvasResourceProvider::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;
+    KoCanvasResourceProvider::CanvasResource colorSlot = KoCanvasResourceProvider::ForegroundColor;
 
 
     if (checkedId == Solid) {
         if (d->fillVariant == KoFlake::StrokeFill) {
-            colorSlot = KoCanvasResourceManager::BackgroundColor;
+            colorSlot = KoCanvasResourceProvider::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));
+        slotCanvasResourceChanged(KoCanvasResourceProvider::BackgroundColor, QVariant::fromValue(color));
     }
 
     {
         KoColor color = d->canvas->resourceManager()->foregroundColor();
-        slotCanvasResourceChanged(KoCanvasResourceManager::ForegroundColor, QVariant::fromValue(color));
+        slotCanvasResourceChanged(KoCanvasResourceProvider::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 1a301a7ad6..a957aed8f3 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 <KoCanvasResourceProvider.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,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:
+    case KoCanvasResourceProvider::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_lod_availability_widget.cpp b/libs/ui/widgets/kis_lod_availability_widget.cpp
index 56f15019a6..dee55f699b 100644
--- a/libs/ui/widgets/kis_lod_availability_widget.cpp
+++ b/libs/ui/widgets/kis_lod_availability_widget.cpp
@@ -1,253 +1,253 @@
 /*
  *  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_lod_availability_widget.h"
 
 #include <QPushButton>
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <QToolTip>
 
 
 #include <kis_canvas_resource_provider.h>
 #include <kis_slider_spin_box.h>
 #include "kis_config.h"
 #include <QWidgetAction>
 #include <QMenu>
 
 #include "kis_signals_blocker.h"
 
 namespace {
 /**
  * These strings are added intentionally so we could relayout the threshold slider after
  * the string freeze for 4.0. Please translate them :)
  */
 static const KLocalizedString stringForInstantPreviewThreshold1 = ki18nc("@label:slider", "Threshold:");
 static const KLocalizedString stringForInstantPreviewThreshold2 = ki18nc("@label:slider", "Instant preview threshold:");
 }
 
 
 struct KisLodAvailabilityWidget::Private
 {
     Private() : chkLod(0), resourceManager(0) {}
 
     QCheckBox *chkLod;
     QPushButton *btnLod;
     QScopedPointer<QMenu> thresholdMenu;
     KisDoubleSliderSpinBox *thresholdSlider = 0;
-    KoCanvasResourceManager *resourceManager;
+    KoCanvasResourceProvider *resourceManager;
 
     KisPaintopLodLimitations limitations;
     bool thresholdSupported = true;
 
     bool sizeThresholdPassed();
 };
 
 KisLodAvailabilityWidget::KisLodAvailabilityWidget(QWidget *parent)
     : QWidget(parent),
       m_d(new Private)
 {
     m_d->chkLod = new QCheckBox(this);
 
     m_d->btnLod = new QPushButton(this);
     m_d->btnLod->setFlat(true);
 
     connect(m_d->btnLod, SIGNAL(clicked()), SLOT(showLodToolTip()));
 
     {
         m_d->thresholdMenu.reset(new QMenu());
         m_d->thresholdMenu->addSection(i18n("Enable after:"));
 
         m_d->btnLod->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(m_d->btnLod, SIGNAL(customContextMenuRequested(QPoint)),
                 this, SLOT(showLodThresholdWidget(QPoint)));
 
         KisConfig cfg(true);
         m_d->thresholdSlider = new KisDoubleSliderSpinBox(m_d->thresholdMenu.data());
 
         m_d->thresholdSlider->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         m_d->thresholdSlider->setValue(100);
         m_d->thresholdSlider->setSingleStep(1);
         m_d->thresholdSlider->setExponentRatio(3.0);
         m_d->thresholdSlider->setSuffix(i18n(" px"));
         m_d->thresholdSlider->setBlockUpdateSignalOnDrag(true);
 
         QWidgetAction *sliderAction = new QWidgetAction(this);
         sliderAction->setDefaultWidget(m_d->thresholdSlider);
 
         m_d->thresholdMenu->addAction(sliderAction);
     }
 
     QHBoxLayout *layout = new QHBoxLayout;
     layout->addWidget(m_d->chkLod);
     layout->addWidget(m_d->btnLod);
 
     layout->setSpacing(0);
 
     setLayout(layout);
 
     // set no limitations
     setLimitations(m_d->limitations);
 
     connect(m_d->chkLod, SIGNAL(toggled(bool)), SIGNAL(sigUserChangedLodAvailability(bool)));
     connect(m_d->thresholdSlider, SIGNAL(valueChanged(qreal)), SIGNAL(sigUserChangedLodThreshold(qreal)));
 }
 
 KisLodAvailabilityWidget::~KisLodAvailabilityWidget()
 {
 }
 
 void KisLodAvailabilityWidget::showLodToolTip()
 {
     QToolTip::showText(QCursor::pos(), m_d->btnLod->toolTip(), m_d->btnLod);
 }
 
 void KisLodAvailabilityWidget::showLodThresholdWidget(const QPoint &pos)
 {
     Q_UNUSED(pos);
 
     if (m_d->thresholdSupported) {
         m_d->thresholdMenu->popup(QCursor::pos());
     }
 }
 
 void KisLodAvailabilityWidget::setLimitations(const KisPaintopLodLimitations &l)
 {
     QString limitationsText;
     Q_FOREACH (const KoID &id, l.limitations) {
         limitationsText.append("<li>");
         limitationsText.append(id.name());
         limitationsText.append("</li>");
     }
 
     QString blockersText;
     Q_FOREACH (const KoID &id, l.blockers) {
         blockersText.append("<li>");
         blockersText.append(id.name());
         blockersText.append("</li>");
     }
 
     bool isBlocked = !l.blockers.isEmpty();
     bool isLimited = !l.limitations.isEmpty();
 
     m_d->thresholdSupported =
         m_d->resourceManager ?
         m_d->resourceManager->resource(KisCanvasResourceProvider::LodSizeThresholdSupported).toBool() :
         true;
     bool isBlockedByThreshold = !m_d->sizeThresholdPassed() && m_d->thresholdSupported;
 
     const QString text = !isBlocked && !isBlockedByThreshold && isLimited ?
         i18n("(Instant Preview)*") : i18n("Instant Preview");
 
     QString toolTip;
 
     if (isBlocked) {
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview Mode is "
                         "disabled by the following options:"
                         "<ul>%1</ul></p>", blockersText);
     } else if (isBlockedByThreshold) {
         const qreal lodThreshold = m_d->resourceManager->resource(KisCanvasResourceProvider::LodSizeThreshold).toDouble();
         const qreal size = m_d->resourceManager->resource(KisCanvasResourceProvider::Size).toDouble();
 
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview Mode is "
                         "disabled by instant preview threshold. "
                         "Please right-click here to change the threshold"
                         "<ul><li>Brush size %1</li>"
                         "<li>Threshold: %2</li></ul></p>",
                         size, lodThreshold);
 
     } else if (isLimited) {
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview may look different "
                         "from the final result. In case of troubles "
                         "try disabling the following options:"
                         "<ul>%1</ul></p>", limitationsText);
     } else {
         toolTip = i18nc("@info:tooltip", "<p>Instant Preview Mode is available</p>");
     }
 
     {
         QFont font;
         font.setStrikeOut(isBlocked || isBlockedByThreshold);
         m_d->chkLod->setEnabled(!isBlocked);
         m_d->btnLod->setEnabled(!isBlocked);
         m_d->btnLod->setFont(font);
         m_d->btnLod->setText(text);
         m_d->btnLod->setToolTip(toolTip);
 
         if (isBlocked) {
             /**
              * If LoD is really blocked by some limitation we sneakly reset
              * the checkbox to let the user know it is fully disabled.
              */
 
             KisSignalsBlocker b(m_d->chkLod);
             m_d->chkLod->setChecked(false);
         }
     }
 
     m_d->limitations = l;
 
     if (m_d->resourceManager) {
         const bool lodAvailableForUse =
             !isBlocked && !isBlockedByThreshold &&
             m_d->resourceManager->resource(KisCanvasResourceProvider::LodAvailability).toBool();
 
         m_d->resourceManager->setResource(KisCanvasResourceProvider::EffectiveLodAvailablility, lodAvailableForUse);
     }
 
 }
 
 void KisLodAvailabilityWidget::slotUserChangedLodAvailability(bool value)
 {
     KisSignalsBlocker b(m_d->chkLod);
 
     m_d->chkLod->setChecked(value);
     setLimitations(m_d->limitations);
 }
 
 void KisLodAvailabilityWidget::slotUserChangedLodThreshold(qreal value)
 {
     KisSignalsBlocker b(m_d->thresholdSlider);
 
     m_d->thresholdSlider->setValue(value);
     setLimitations(m_d->limitations);
 }
 
 void KisLodAvailabilityWidget::slotUserChangedSize(qreal value)
 {
     Q_UNUSED(value);
     setLimitations(m_d->limitations);
 }
 
-void KisLodAvailabilityWidget::setCanvasResourceManager(KoCanvasResourceManager *resourceManager)
+void KisLodAvailabilityWidget::setCanvasResourceManager(KoCanvasResourceProvider *resourceManager)
 {
     m_d->resourceManager = resourceManager;
 }
 
 bool KisLodAvailabilityWidget::Private::sizeThresholdPassed()
 {
     if (!resourceManager) return true;
 
     const qreal lodThreshold = resourceManager->resource(KisCanvasResourceProvider::LodSizeThreshold).toDouble();
     const qreal size = resourceManager->resource(KisCanvasResourceProvider::Size).toDouble();
 
     return size >= lodThreshold;
 }
diff --git a/libs/ui/widgets/kis_lod_availability_widget.h b/libs/ui/widgets/kis_lod_availability_widget.h
index 023fa08de9..ca6f319cef 100644
--- a/libs/ui/widgets/kis_lod_availability_widget.h
+++ b/libs/ui/widgets/kis_lod_availability_widget.h
@@ -1,60 +1,60 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_LOD_AVAILABILITY_WIDGET_H
 #define __KIS_LOD_AVAILABILITY_WIDGET_H
 
 #include <QWidget>
 #include <QScopedPointer>
 
 #include <brushengine/kis_paintop_lod_limitations.h>
 
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 
 class KisLodAvailabilityWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     KisLodAvailabilityWidget(QWidget *parent);
     ~KisLodAvailabilityWidget() override;
 
-    void setCanvasResourceManager(KoCanvasResourceManager *resourceManager);
+    void setCanvasResourceManager(KoCanvasResourceProvider *resourceManager);
 
     void setLimitations(const KisPaintopLodLimitations &l);
 
 public Q_SLOTS:
     void slotUserChangedLodAvailability(bool value);
     void slotUserChangedLodThreshold(qreal value);
     void slotUserChangedSize(qreal value);
 
 Q_SIGNALS:
     void sigUserChangedLodAvailability(bool value);
     void sigUserChangedLodThreshold(qreal value);
 
 private Q_SLOTS:
     void showLodToolTip();
     void showLodThresholdWidget(const QPoint &pos);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_LOD_AVAILABILITY_WIDGET_H */
diff --git a/libs/ui/widgets/kis_scratch_pad.cpp b/libs/ui/widgets/kis_scratch_pad.cpp
index 3f3e90b26b..4ba935a749 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();
+    KoCanvasResourceProvider *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(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/widgets/KoShadowConfigWidget.cpp b/libs/widgets/KoShadowConfigWidget.cpp
index 86bf872891..a43a55893c 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 <KoCanvasResourceProvider.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(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,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 ) {
+    if( key == KoCanvasResourceProvider::Unit ) {
         setUnit(res.value<KoUnit>());
     }
 }
diff --git a/libs/widgets/KoStrokeConfigWidget.cpp b/libs/widgets/KoStrokeConfigWidget.cpp
index ad88bb25d6..fe0775bf34 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 <KoCanvasResourceProvider.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(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,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:
+    case KoCanvasResourceProvider::Unit:
         setUnit(value.value<KoUnit>());
         break;
     }
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_patches.cpp b/plugins/dockers/advancedcolorselector/kis_color_patches.cpp
index 2042e7dbb6..4c5261e7f4 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_patches.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_patches.cpp
@@ -1,350 +1,350 @@
 /*
  *  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_patches.h"
 
 #include <QApplication>
 #include <QPainter>
 #include <QWheelEvent>
 #include <QMouseEvent>
 #include <QDrag>
 #include <QMimeData>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "kis_canvas2.h"
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 #include "kis_display_color_converter.h"
 
 
 KisColorPatches::KisColorPatches(QString configPrefix, QWidget *parent) :
     KisColorSelectorBase(parent), m_allowColorListChangeGuard(true), m_scrollValue(0), m_configPrefix(configPrefix)
 {
     resize(1, 1);
     updateSettings();
 }
 
 void KisColorPatches::setColors(QList<KoColor>colors)
 {
     if (m_allowColorListChangeGuard) {
         m_colors = colors;
 
         m_allowColorListChangeGuard=false;
 
         KisColorPatches* parent = dynamic_cast<KisColorPatches*>(m_parent);
         if (parent) parent->setColors(colors);
 
         KisColorPatches* popup = dynamic_cast<KisColorPatches*>(m_popup);
         if (popup) popup->setColors(colors);
 
         m_allowColorListChangeGuard=true;
 
         update();
     }
 }
 
 void KisColorPatches::paintEvent(QPaintEvent* e)
 {
     QPainter painter(this);
     if(m_allowScrolling) {
         if(m_direction == Vertical)
             painter.translate(0, m_scrollValue);
         else
             painter.translate(m_scrollValue, 0);
     }
 
 
     int widgetWidth = width();
     int numPatchesInARow = qMax(widgetWidth/m_patchWidth, 1);
 
     int widgetHeight = height();
     int numPatchesInACol = qMax(widgetHeight/m_patchHeight, 1);
 
     for(int i = m_buttonList.size(); i < qMin(fieldCount(), m_colors.size() + m_buttonList.size()); i++) {
         int row;
         int col;
         if(m_direction == Vertical) {
             row =  i /numPatchesInARow;
             col = i % numPatchesInARow;
         }
         else {
             row= i % numPatchesInACol;
             col = i / numPatchesInACol;
         }
 
         QColor qcolor = converter()->toQColor(m_colors.at(i - m_buttonList.size()));
 
         painter.fillRect(col*m_patchWidth,
                          row*m_patchHeight,
                          m_patchWidth,
                          m_patchHeight,
                          qcolor);
     }
 
     QWidget::paintEvent(e);
 }
 
 void KisColorPatches::wheelEvent(QWheelEvent* event)
 {
     m_scrollValue+=event->delta()/2;
     if(m_direction == Vertical) {
         if(m_scrollValue < -1*(heightOfAllPatches()-height()))
             m_scrollValue = -1*(heightOfAllPatches()-height());
     }
     else {
         if(m_scrollValue < -1*(widthOfAllPatches()-width()))
             m_scrollValue = -1*(widthOfAllPatches()-width());
     }
     if(m_scrollValue>0) m_scrollValue=0;
 
 
     update();
 }
 
 void KisColorPatches::resizeEvent(QResizeEvent* event)
 {
     if(size()==QSize(1, 1))
         return;
 
     QWheelEvent dummyWheelEvent(QPoint(), 0, Qt::NoButton, Qt::NoModifier);
     wheelEvent(&dummyWheelEvent);
 
     if(parentWidget()==0) {
         // this instance is a popup
         setMinimumWidth(m_patchWidth*(m_patchCount/4));
         setMaximumWidth(minimumWidth());
     }
 
     if(m_allowScrolling == false && event->oldSize() != event->size()) {
         if(m_direction == Horizontal) {
             setMaximumHeight(heightForWidth(width()));
             setMinimumHeight(heightForWidth(width()));
         }
         else {
             setMaximumWidth(widthForHeight(height()));
             setMinimumWidth(widthForHeight(height()));
         }
     }
 }
 
 void KisColorPatches::mouseReleaseEvent(QMouseEvent* event)
 {
     KisColorSelectorBase::mouseReleaseEvent(event);
     event->setAccepted(false);
     KisColorSelectorBase::mouseReleaseEvent(event);
     if (event->isAccepted() || !rect().contains(event->pos()))
         return;
 
     if (!m_canvas) return;
 
     KoColor color;
     if(colorAt(event->pos(), &color)) {
         if (event->button()==Qt::LeftButton)
             m_canvas->resourceManager()->setForegroundColor(color);
         else if (event->button()==Qt::RightButton)
             m_canvas->resourceManager()->setBackgroundColor(color);
     }
 }
 
 
 void KisColorPatches::mousePressEvent(QMouseEvent *event)
 {
     KoColor koColor;
     if(!colorAt(event->pos(), &koColor))
         return;
 
     KisColorSelectorBase::mousePressEvent(event);
     if(event->isAccepted())
         return;
 
     updateColorPreview(koColor);
 
     if (event->button() == Qt::LeftButton)
         m_dragStartPos = event->pos();
 }
 
 void KisColorPatches::mouseMoveEvent(QMouseEvent *event)
 {
     event->ignore();
     KisColorSelectorBase::mouseMoveEvent(event);
     if(event->isAccepted())
         return;
 
     if (!(event->buttons() & Qt::LeftButton))
         return;
     if ((event->pos() - m_dragStartPos).manhattanLength()
          < QApplication::startDragDistance())
         return;
 
     KoColor koColor;
     if(!colorAt(m_dragStartPos, &koColor))
         return;
 
     QDrag *drag = new QDrag(this);
     QMimeData *mimeData = new QMimeData;
 
     QColor color = converter()->toQColor(koColor);
     mimeData->setColorData(color);
     mimeData->setText(color.name());
     drag->setMimeData(mimeData);
 
     drag->exec(Qt::CopyAction);
 
     event->accept();
 }
 
 int KisColorPatches::patchCount() const
 {
     return m_patchCount;
 }
 
 bool KisColorPatches::colorAt(const QPoint &pos, KoColor *result) const
 {
     if(!rect().contains(pos))
         return false;
 
     int scrollX = m_direction==Horizontal?m_scrollValue:0;
     int scrollY = m_direction==Vertical?m_scrollValue:0;
     int column = (pos.x()-scrollX)/m_patchWidth;
     int row = (pos.y()-scrollY)/m_patchHeight;
 
     int patchNr;
     if(m_direction == Vertical) {
         int patchesInARow = width()/m_patchWidth;
         patchNr=row*patchesInARow+column;
     }
     else {
         // Vertical
         int patchesInAColumn = height()/m_patchHeight;
         patchNr=column*patchesInAColumn+row;
     }
 
     patchNr-=m_buttonList.size();
 
     if(patchNr>=0 && patchNr<m_colors.size()) {
         (*result)=m_colors.at(patchNr);
         return true;
     }
     else return false;
 }
 
 void KisColorPatches::setAdditionalButtons(QList<QWidget*> buttonList)
 {
     for(int i=0; i<buttonList.size(); i++) {
         buttonList.at(i)->setParent(this);
     }
     m_buttonList = buttonList;
 }
 
 void KisColorPatches::updateSettings()
 {
     KisColorSelectorBase::updateSettings();
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     if(cfg.readEntry(m_configPrefix+"Alignment", false))
         m_direction=Vertical;
     else
         m_direction=Horizontal;
 
     m_allowScrolling=cfg.readEntry(m_configPrefix+"Scrolling", true);
     m_numCols=cfg.readEntry(m_configPrefix+"NumCols", 1);
     m_numRows=cfg.readEntry(m_configPrefix+"NumRows", 1);
     m_patchCount=cfg.readEntry(m_configPrefix+"Count", 15);
     m_patchWidth=cfg.readEntry(m_configPrefix+"Width", 20);
     m_patchHeight=cfg.readEntry(m_configPrefix+"Height", 20);
     if(m_patchHeight == 0) {
         m_patchHeight = 1;
     }
 
     if(parentWidget()==0) {
         // this instance is a popup
         m_allowScrolling = false;
         m_direction = Horizontal;
         m_patchWidth*=2;
         m_patchHeight*=2;
     }
 
     for(int i=0; i<m_buttonList.size(); i++) {
         m_buttonList.at(i)->setGeometry(0, i*m_patchHeight, m_patchWidth, m_patchHeight);
     }
 
     setMaximumWidth(QWIDGETSIZE_MAX);
     setMinimumWidth(1);
     setMaximumHeight(QWIDGETSIZE_MAX);
     setMinimumHeight(1);
 
     if(m_allowScrolling && m_direction == Horizontal) {
         setMaximumHeight(m_numRows*m_patchHeight);
         setMinimumHeight(m_numRows*m_patchHeight);
     }
 
     if(m_allowScrolling && m_direction == Vertical) {
         setMaximumWidth(m_numCols*m_patchWidth);
         setMinimumWidth(m_numCols*m_patchWidth);
     }
 
     if(m_allowScrolling == false) {
         m_scrollValue = 0;
     }
 
     QResizeEvent dummy(size(), QSize(-1,-1));
     resizeEvent(&dummy);
 
     setPopupBehaviour(false, false);
     update();
 }
 
 int KisColorPatches::widthOfAllPatches()
 {
     return (fieldCount()/m_numRows)*m_patchWidth;
 }
 
 int KisColorPatches::heightOfAllPatches()
 {
     return (fieldCount()/m_numCols)*m_patchHeight;
 }
 
 int KisColorPatches::heightForWidth(int width) const
 {
     int numPatchesInARow = width / m_patchWidth;
     int numRows = qMax((fieldCount() - 1), 1) / qMax(numPatchesInARow + 1, 1);
     return numRows * m_patchHeight;
 }
 
 int KisColorPatches::widthForHeight(int height) const
 {
     if (height == 0) {
         return 0;
     }
 
     if (m_patchHeight == 0) {
         return 0;
     }
     int numPatchesInACol = height / m_patchHeight;
 
     int numCols = (fieldCount() - 1) / (numPatchesInACol + 1);
 
     return numCols*m_patchWidth;
 }
 
 int KisColorPatches::fieldCount() const
 {
     return m_patchCount+m_buttonList.size();
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
index 0a01117fb7..9a19449f0a 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -1,395 +1,395 @@
 /*
  *  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 <KoCanvasResourceProvider.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);
 
     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::slotGamutMaskSet(KoGamutMask *gamutMask)
 {
     m_mainComponent->setGamutMask(gamutMask);
     m_subComponent->setGamutMask(gamutMask);
 
     slotGamutMaskToggle(true);
 }
 
 void KisColorSelector::slotGamutMaskUnset()
 {
     m_mainComponent->unsetGamutMask();
     m_subComponent->unsetGamutMask();
 
     slotGamutMaskToggle(false);
 }
 
 void KisColorSelector::slotGamutMaskPreviewUpdate()
 {
     m_mainComponent->updateGamutMaskPreview();
     m_subComponent->updateGamutMaskPreview();
 }
 
 void KisColorSelector::slotGamutMaskToggle(bool state)
 {
     m_mainComponent->toggleGamutMask(state);
     m_subComponent->toggleGamutMask(state);
 }
 
 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 55bb587097..1199d7a707 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
@@ -1,537 +1,537 @@
 /*
  *  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"
 
 #include <resources/KoGamutMask.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,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) {
+    if (key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoColor realColor(v.value<KoColor>());
         updateColorPreview(realColor);
         if (m_colorUpdateAllowed && !m_colorUpdateSelf) {
             setColor(realColor);
         }
     }
 }
 
 const KoColorSpace* KisColorSelectorBase::colorSpace() const
 {
     return converter()->paintingColorSpace();
 }
 
 void KisColorSelectorBase::updateSettings()
 {
     if(m_popup) {
         m_popup->updateSettings();
     }
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
 
    int zoomSelectorOptions =  (int) cfg.readEntry("zoomSelectorOptions", 0) ;
    if (zoomSelectorOptions == 0)   {
        setPopupBehaviour(false, true);   // middle mouse button click will open zoom selector
    } else if (zoomSelectorOptions == 1)   {
        setPopupBehaviour(true, false);   // move over will open the zoom selector
    }
    else
    {
         setPopupBehaviour(false, false); // do not show zoom selector
    }
 
 
     if(m_isPopup) {
         m_hideOnMouseClick = cfg.readEntry("hidePopupOnClickCheck", false);
         const int zoomSize = cfg.readEntry("zoomSize", 280);
         resize(zoomSize, zoomSize);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::reset()
 {
     update();
 }
 
 void KisColorSelectorBase::updateBaseColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setBaseColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::updatePreviousColorPreview()
 {
     m_colorPreviewPopup->setPreviousColor();
 }
 
 void KisColorSelectorBase::updateLastUsedColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setLastUsedColor(converter()->toQColor(color));
 }
 
 KisDisplayColorConverter* KisColorSelectorBase::converter() const
 {
     return m_canvas ?
         m_canvas->displayColorConverter() :
         KisDisplayColorConverter::dumbConverterInstance();
 }
 
 
 void KisColorSelectorBase::mouseMoveEvent(QMouseEvent *event)
 {
     event->accept();
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp b/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp
index 7044bbd719..f3fc6b6d30 100644
--- a/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp
@@ -1,182 +1,182 @@
 /*
  *  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_minimal_shade_selector.h"
 
 #include <QColor>
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QMouseEvent>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 
 #include "kis_shade_selector_line.h"
 
 #include "kis_color_selector_base_proxy.h"
 
 
 KisMinimalShadeSelector::KisMinimalShadeSelector(QWidget *parent)
     : KisColorSelectorBase(parent)
     , m_canvas(0)
     , m_proxy(new KisColorSelectorBaseProxyObject(this))
 {
     setAcceptDrops(true);
 
     QVBoxLayout* l = new QVBoxLayout(this);
     l->setSpacing(0);
     l->setMargin(0);
 
     updateSettings();
 
     setMouseTracking(true);
 }
 
 KisMinimalShadeSelector::~KisMinimalShadeSelector()
 {
 }
 
 void KisMinimalShadeSelector::unsetCanvas()
 {
     KisColorSelectorBase::unsetCanvas();
     m_canvas = 0;
 }
 
 void KisMinimalShadeSelector::setCanvas(KisCanvas2 *canvas)
 {
     KisColorSelectorBase::setCanvas(canvas);
     m_canvas = canvas;
 }
 
 void KisMinimalShadeSelector::setColor(const KoColor& color)
 {
     m_lastRealColor = color;
 
     for(int i=0; i<m_shadingLines.size(); i++) {
         m_shadingLines.at(i)->setColor(color);
     }
 }
 
 void KisMinimalShadeSelector::updateSettings()
 {
     KisColorSelectorBase::updateSettings();
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     QString stri = cfg.readEntry("minimalShadeSelectorLineConfig", "0|0.2|0|0");
     QStringList strili = stri.split(';', QString::SkipEmptyParts);
 
     int lineCount = strili.size();
     while(lineCount-m_shadingLines.size() > 0) {
         KisShadeSelectorLine *line = new KisShadeSelectorLine(m_proxy.data(), this);
         m_shadingLines.append(line);
         m_shadingLines.last()->setLineNumber(m_shadingLines.size()-1);
         layout()->addWidget(m_shadingLines.last());
     }
     while(lineCount-m_shadingLines.size() < 0) {
         layout()->removeWidget(m_shadingLines.last());
         delete m_shadingLines.takeLast();
     }
 
     for(int i=0; i<strili.size(); i++) {
         m_shadingLines.at(i)->fromString(strili.at(i));
     }
 
     int lineHeight = cfg.readEntry("minimalShadeSelectorLineHeight", 20);
     setMinimumHeight(lineCount*lineHeight+2*lineCount);
     setMaximumHeight(lineCount*lineHeight+2*lineCount);
 
     for(int i=0; i<m_shadingLines.size(); i++)
         m_shadingLines.at(i)->updateSettings();
 
     setPopupBehaviour(false, false);
 }
 
 void KisMinimalShadeSelector::mousePressEvent(QMouseEvent * e)
 {
     Q_FOREACH (KisShadeSelectorLine* line, m_shadingLines) {
         QMouseEvent newEvent(e->type(),
                                           line->mapFromGlobal(e->globalPos()),
                                           e->button(),
                                           e->buttons(),
                                           e->modifiers());
         if(line->rect().contains(newEvent.pos()))
             line->mousePressEvent(&newEvent);
     }
     KisColorSelectorBase::mousePressEvent(e);
 }
 
 void KisMinimalShadeSelector::mouseMoveEvent(QMouseEvent * e)
 {
     Q_FOREACH (KisShadeSelectorLine* line, m_shadingLines) {
         QMouseEvent newEvent(e->type(),
                                           line->mapFromGlobal(e->globalPos()),
                                           e->button(),
                                           e->buttons(),
                                           e->modifiers());
         if(line->rect().contains(newEvent.pos()))
             line->mouseMoveEvent(&newEvent);
     }
     KisColorSelectorBase::mouseMoveEvent(e);
 }
 
 void KisMinimalShadeSelector::mouseReleaseEvent(QMouseEvent * e)
 {
     Q_FOREACH (KisShadeSelectorLine* line, m_shadingLines) {
         QMouseEvent newEvent(e->type(),
                                           line->mapFromGlobal(e->globalPos()),
                                           e->button(),
                                           e->buttons(),
                                           e->modifiers());
 
         if(line->rect().contains(newEvent.pos()))
             line->mouseReleaseEvent(&newEvent);
     }
     KisColorSelectorBase::mouseReleaseEvent(e);
 }
 
 void KisMinimalShadeSelector::canvasResourceChanged(int key, const QVariant &v)
 {
     if(m_colorUpdateAllowed==false)
         return;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     bool onForeground = cfg.readEntry("shadeSelectorUpdateOnForeground", false);
     bool onBackground = cfg.readEntry("shadeSelectorUpdateOnBackground", true);
 
-    if ((key == KoCanvasResourceManager::ForegroundColor && onForeground)
-        || (key == KoCanvasResourceManager::BackgroundColor && onBackground)) {
+    if ((key == KoCanvasResourceProvider::ForegroundColor && onForeground)
+        || (key == KoCanvasResourceProvider::BackgroundColor && onBackground)) {
 
         setColor(v.value<KoColor>());
     }
 }
 
 void KisMinimalShadeSelector::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
     painter.fillRect(0,0,width(), height(), QColor(128,128,128));
 }
 
 KisColorSelectorBase* KisMinimalShadeSelector::createPopup() const
 {
     KisMinimalShadeSelector* popup = new KisMinimalShadeSelector(0);
     popup->setColor(m_lastRealColor);
     return popup;
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp b/plugins/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp
index f67953aa9a..b7083534a3 100644
--- a/plugins/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_my_paint_shade_selector.cpp
@@ -1,303 +1,303 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *  Copyright (c) 2008 Martin Renold <martinxyz@gmx.ch>
  *  Copyright (c) 2009 Ilya Portnov <nomail>
  *
  *  This class is based on "lib/colorchanger.hpp" from MyPaint (mypaint.intilinux.com)
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_my_paint_shade_selector.h"
 
 #include <cmath>
 #include <cstdlib>
 
 #include <QImage>
 #include <QColor>
 #include <QPainter>
 #include <QMouseEvent>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QtGlobal>
 #include <QTimer>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 #include "kis_display_color_converter.h"
 
 inline int sqr(int x);
 inline qreal sqr2(qreal x);
 inline int signedSqr(int x);
 
 
 KisMyPaintShadeSelector::KisMyPaintShadeSelector(QWidget *parent) :
         KisColorSelectorBase(parent),
         m_updateTimer(new QTimer(this))
 {
     setAcceptDrops(true);
 
     updateSettings();
 
     setMinimumSize(80, 80);
     setColor(KoColor(Qt::red, colorSpace()));
 
     m_updateTimer->setInterval(1);
     m_updateTimer->setSingleShot(true);
     connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(update()));
 }
 
 void KisMyPaintShadeSelector::paintEvent(QPaintEvent *) {
     // Hint to the casual reader: some of the calculation here do not
     // what Martin Renold originally intended. Not everything here will make sense.
     // It does not matter in the end, as long as the result looks good.
 
     // This selector was ported from MyPaint in 2010
     if (m_cachedColorSpace != colorSpace()) {
         m_realPixelCache = new KisPaintDevice(colorSpace());
         m_realCircleBorder = new KisPaintDevice(colorSpace());
         m_cachedColorSpace = colorSpace();
     }
     else {
         m_realPixelCache->clear();
         m_realCircleBorder->clear();
     }
 	KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 	QString shadeMyPaintType=cfg.readEntry("shadeMyPaintType", "HSV");
 
     int size = qMin(width(), height());
     int s_radius = size/2.6;
 
     for (int x=0; x<width(); x++) {
         for (int y=0; y<height(); y++) {
 
             float v_factor = 0.6f;
             float s_factor = 0.6f;
             float v_factor2 = 0.013f;
             float s_factor2 = 0.013f;
 
             int stripe_width = 15*size/255.;
 
             float h = 0;
             float s = 0;
             float v = 0;
 
             int dx = x-width()/2;
             int dy = y-height()/2;
             int diag = sqrt(2.0)*size/2;
 
             int dxs, dys;
             if (dx > 0)
                 dxs = dx - stripe_width;
             else
                 dxs = dx + stripe_width;
             if (dy > 0)
                 dys = dy - stripe_width;
             else
                 dys = dy + stripe_width;
 
             qreal r = std::sqrt(qreal(sqr(dxs)+sqr(dys)));
 
             if (qMin(abs(dx), abs(dy)) < stripe_width) {
                 // horizontal and vertical lines
                 dx = (dx/qreal(width()))*255;
                 dy = (dy/qreal(height()))*255;
                 h = 0;
                 // x-axis = value, y-axis = saturation
                 v =    dx*v_factor + signedSqr(dx)*v_factor2;
                 s = - (dy*s_factor + signedSqr(dy)*s_factor2);
                 // but not both at once
                 if (std::abs(dx) > std::abs(dy)) {
                     // horizontal stripe
                     s = 0.0;
                 } else {
                     // vertical stripe
                     v = 0.0;
                 }
             }
             else if (r < s_radius+1) {
                 // hue
                 if (dx > 0)
                     h = 90*sqr2(r/s_radius);
                 else
                     h = 360 - 90*sqr2(r/s_radius);
                 s = 256*(atan2f(std::abs(dxs),dys)/M_PI) - 128;
 
                 if (r > s_radius) {
                     // antialiasing boarder
                     qreal aaFactor = r-floor(r); // part after the decimal point
                     aaFactor = 1-aaFactor;
 
                     qreal fh = m_colorH + h/360.0;
                     qreal fs = m_colorS + s/255.0;
                     qreal fv = m_colorV + v/255.0;
 
                     fh -= floor(fh);
                     fs = qBound(qreal(0.0), fs, qreal(1.0));
                     fv = qBound(qreal(0.01), fv, qreal(1.0));
 					KoColor color;
                     //KoColor color = converter()->fromHsvF(fh, fs, fv);
 					if(shadeMyPaintType=="HSV"){color = converter()->fromHsvF(fh, fs, fv);}
 					else if(shadeMyPaintType=="HSL"){color = converter()->fromHslF(fh, fs, fv);}	
 					else if(shadeMyPaintType=="HSI"){color = converter()->fromHsiF(fh, fs, fv);}	
 					else if(shadeMyPaintType=="HSY"){color = converter()->fromHsyF(fh, fs, fv, R, G, B);}
 					else{dbgKrita<<"MyPaint Color selector don't work right.";
 					color = converter()->fromHsvF(fh, fs, fv);}
 //dbgKrita<<color->toQcolor();
                     color.setOpacity(aaFactor);
                     Acs::setColor(m_realCircleBorder, QPoint(x, y), color);
 
                     h = 180 + 180*atan2f(dys,-dxs)/M_PI;
                     v = 255*(r-s_radius)/(diag-s_radius) - 128;
                 }
             }
             else {
                 // background (hue+darkness gradient)
                 h = 180 + 180*atan2f(dys,-dxs)/M_PI;
                 v = 255*(r-s_radius)/(diag-s_radius) - 128;
             }
 
             qreal fh = m_colorH + h/360.0;
             qreal fs = m_colorS + s/255.0;
             qreal fv = m_colorV + v/255.0;
 
             fh -= floor(fh);
             fs = qBound(qreal(0.0), fs, qreal(1.0));
             fv = qBound(qreal(0.01), fv, qreal(1.0));
 			KoColor color;
             //KoColor color = converter()->fromHsvF(fh, fs, fv);
 			if(shadeMyPaintType=="HSV"){color = converter()->fromHsvF(fh, fs, fv);}
 			else if(shadeMyPaintType=="HSL"){color = converter()->fromHslF(fh, fs, fv);}	
 			else if(shadeMyPaintType=="HSI"){color = converter()->fromHsiF(fh, fs, fv);}	
 			else if(shadeMyPaintType=="HSY"){color = converter()->fromHsyF(fh, fs, fv);}
 			else{dbgKrita<<"MyPaint Color selector don't work right.";
 			color = converter()->fromHsvF(fh, fs, fv);}
 
             Acs::setColor(m_realPixelCache, QPoint(x, y), color);
         }
     }
 
     KisPainter gc(m_realPixelCache);
     gc.bitBlt(QPoint(0,0), m_realCircleBorder, rect());
 
     QPainter painter(this);
     QImage renderedImage = converter()->toQImage(m_realPixelCache);
 
     painter.drawImage(0, 0, renderedImage);
 }
 
 
 void KisMyPaintShadeSelector::mousePressEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mousePressEvent(e);
 }
 
 void KisMyPaintShadeSelector::mouseMoveEvent(QMouseEvent *e)
 {
     if(rect().contains(e->pos())) {
         KoColor color(Acs::pickColor(m_realPixelCache, e->pos()));
         this->updateColorPreview(color);
     }
     KisColorSelectorBase::mouseMoveEvent(e);
 }
 
 void KisMyPaintShadeSelector::mouseReleaseEvent(QMouseEvent *e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mouseReleaseEvent(e);
 
     if(!e->isAccepted()) {
         KoColor color(Acs::pickColor(m_realPixelCache, e->pos()));
 
         Acs::ColorRole role = Acs::buttonToRole(e->button());
 
         KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
         bool onRightClick = cfg.readEntry("shadeSelectorUpdateOnRightClick", false);
         bool onLeftClick = cfg.readEntry("shadeSelectorUpdateOnLeftClick", false);
 
         bool explicitColorReset =
             (e->button() == Qt::LeftButton && onLeftClick) ||
             (e->button() == Qt::RightButton && onRightClick);
 
         this->updateColor(color, role, explicitColorReset);
         e->accept();
     }
 }
 
 KisColorSelectorBase* KisMyPaintShadeSelector::createPopup() const
 {
     KisColorSelectorBase* popup = new KisMyPaintShadeSelector(0);
     popup->setColor(m_lastRealColor);
     return popup;
 }
 
 void KisMyPaintShadeSelector::setColor(const KoColor &color) {
 
 	KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 	QString shadeMyPaintType=cfg.readEntry("shadeMyPaintType", "HSV");
 
     R = cfg.readEntry("lumaR", 0.2126);
     G = cfg.readEntry("lumaG", 0.7152);
     B = cfg.readEntry("lumaB", 0.0722);
 
 	if(shadeMyPaintType=="HSV"){this->converter()->getHsvF(color, &m_colorH, &m_colorS, &m_colorV);}
 	if(shadeMyPaintType=="HSL"){this->converter()->getHslF(color, &m_colorH, &m_colorS, &m_colorV);}	
 	if(shadeMyPaintType=="HSI"){this->converter()->getHsiF(color, &m_colorH, &m_colorS, &m_colorV);}	
 	if(shadeMyPaintType=="HSY"){this->converter()->getHsyF(color, &m_colorH, &m_colorS, &m_colorV, R, G, B);}
     m_lastRealColor = color;
     this->updateColorPreview(color);
 
     m_updateTimer->start();
 }
 
 void KisMyPaintShadeSelector::canvasResourceChanged(int key, const QVariant &v)
 {
     if(m_colorUpdateAllowed==false)
         return;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     bool onForeground = cfg.readEntry("shadeSelectorUpdateOnForeground", false);
     bool onBackground = cfg.readEntry("shadeSelectorUpdateOnBackground", true);
 
-    if ((key == KoCanvasResourceManager::ForegroundColor && onForeground) ||
-        (key == KoCanvasResourceManager::BackgroundColor && onBackground)) {
+    if ((key == KoCanvasResourceProvider::ForegroundColor && onForeground) ||
+        (key == KoCanvasResourceProvider::BackgroundColor && onBackground)) {
 
         setColor(v.value<KoColor>());
     }
 }
 
 inline int sqr(int x) {
     return x*x;
 }
 
 inline qreal sqr2(qreal x) {
     return (x*x)/2+x/2;
 }
 
 inline int signedSqr(int x) {
     int sign = x>0?1:-1;
     return x*x*sign;
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
index 981795c164..27f3e26163 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -1,459 +1,459 @@
 /*
  *  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 <KoCanvasResourceProvider.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 <kis_arcs_constants.h>
 #include <KisGamutMaskToolbar.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_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"));
 
     //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->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->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->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->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(KisColor))     , SLOT(slotFgColorChanged(KisColor)));
     connect(m_selectorUI->colorSelector         , SIGNAL(sigBgColorChanged(KisColor))     , SLOT(slotBgColorChanged(KisColor)));
 
     // gamut mask connections
     connect(m_selectorUI->gamutMaskToolbar, SIGNAL(sigGamutMaskToggle(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()));
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
             this, SLOT(slotGamutMaskPreviewUpdate()));
 
     m_selectorUI->gamutMaskToolbar->connectMaskSignals(m_resourceProvider);
 }
 
 void ArtisticColorSelectorDock::slotCanvasResourceChanged(int key, const QVariant& value)
 {
-    if(key == KoCanvasResourceManager::ForegroundColor)
+    if(key == KoCanvasResourceProvider::ForegroundColor)
         m_selectorUI->colorSelector->setFgColor(value.value<KoColor>());
 
-    if(key == KoCanvasResourceManager::BackgroundColor)
+    if(key == KoCanvasResourceProvider::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->setShowBgColor(m_preferencesUI->showBgColor->isChecked());
     m_selectorUI->colorSelector->setShowValueScaleNumbers(m_preferencesUI->showValueScaleNumbers->isChecked());
     m_selectorUI->colorSelector->setEnforceGamutMask(m_preferencesUI->enforceGamutMask->isChecked());
 
     m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
 }
 
 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::slotGamutMaskToggle(bool checked)
 {
     bool b = (!m_selectedMask) ? false : checked;
 
     if (b == true) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
     }
 
     m_selectorUI->colorSelector->setGamutMaskOn(b);
 }
 
 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,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);
         slotGamutMaskToggle(true);
     } else {
         slotGamutMaskToggle(false);
     }
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskUnset()
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask = nullptr;
 
     slotGamutMaskToggle(false);
     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/digitalmixer/digitalmixer_dock.cc b/plugins/dockers/digitalmixer/digitalmixer_dock.cc
index 987f84aa57..d6be4dd068 100644
--- a/plugins/dockers/digitalmixer/digitalmixer_dock.cc
+++ b/plugins/dockers/digitalmixer/digitalmixer_dock.cc
@@ -1,167 +1,167 @@
 /*
  *  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 "digitalmixer_dock.h"
 
 #include <QGridLayout>
 #include <QToolButton>
 #include <QSignalMapper>
 
 #include <klocalizedstring.h>
 
 #include <KoColorPatch.h>
 #include <KoColorSlider.h>
 #include <KoColorPopupAction.h>
 #include <KoColorSpaceRegistry.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoCanvasBase.h>
 
 #include <kis_color_button.h>
 
 class DigitalMixerPatch : public KoColorPatch {
     public:
         DigitalMixerPatch(QWidget* parent) : KoColorPatch(parent) {}
         QSize sizeHint() const override
         {
             return QSize(24,24);
         }
 };
 
 DigitalMixerDock::DigitalMixerDock( )
     : QDockWidget(i18n("Digital Colors Mixer")), m_canvas(0)
     , m_tellCanvas(true)
 {
     const KoColorSpace *sRGB = KoColorSpaceRegistry::instance()->rgb8();
     KoColor initColors[6] = { KoColor(Qt::black, sRGB),
                               KoColor(Qt::white, sRGB),
                               KoColor(Qt::red, sRGB),
                               KoColor(Qt::green, sRGB),
                               KoColor(Qt::blue, sRGB),
                               KoColor(Qt::yellow, sRGB) };
 
     QWidget* widget = new QWidget(this);
     QGridLayout* layout = new QGridLayout( widget );
 
     // Current Color
     m_currentColorPatch = new KoColorPatch(this);
     m_currentColorPatch->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     m_currentColorPatch->setMinimumWidth(48);
     layout->addWidget(m_currentColorPatch, 0, 0,3,1);
 
     // Create the sliders
 
     QSignalMapper* signalMapperSelectColor = new QSignalMapper(this);
     connect(signalMapperSelectColor, SIGNAL(mapped(int)), SLOT(popupColorChanged(int)));
 
     QSignalMapper* signalMapperColorSlider = new QSignalMapper(this);
     connect(signalMapperColorSlider, SIGNAL(mapped(int)), SLOT(colorSliderChanged(int)));
 
     QSignalMapper* signalMapperTargetColor = new QSignalMapper(this);
     connect(signalMapperTargetColor, SIGNAL(mapped(int)), SLOT(targetColorChanged(int)));
 
     for(int i = 0; i < 6; ++i)
     {
         Mixer mixer;
         mixer.targetColor = new DigitalMixerPatch(this);
         mixer.targetColor->setFixedSize(32, 22);
         layout->addWidget(mixer.targetColor, 0, i + 1);
         mixer.targetSlider = new KoColorSlider(Qt::Vertical, this);
         mixer.targetSlider->setFixedWidth(22);
         mixer.targetSlider->setMinimumHeight(66);
         layout->addWidget(mixer.targetSlider, 1, i + 1);
         mixer.actionColor = new KisColorButton( this );
         mixer.actionColor->setColor(initColors[i]);
         mixer.actionColor->setFixedWidth(22);
         layout->addWidget(mixer.actionColor, 2, i + 1);
 
         m_mixers.push_back(mixer);
 
         connect(mixer.actionColor, SIGNAL(changed(KoColor)), signalMapperSelectColor, SLOT(map()));
         signalMapperSelectColor->setMapping(mixer.actionColor, i);
 
         connect(mixer.targetSlider, SIGNAL(valueChanged(int)), signalMapperColorSlider, SLOT(map()));
         signalMapperColorSlider->setMapping(mixer.targetSlider, i);
         mixer.targetSlider->setValue(125);
 
         connect(mixer.targetColor, SIGNAL(triggered(KoColorPatch*)), signalMapperTargetColor, SLOT(map()));
         signalMapperTargetColor->setMapping(mixer.targetColor, i);
     }
     setCurrentColor(KoColor(Qt::black, KoColorSpaceRegistry::instance()->rgb8()));
     setWidget( widget );
 }
 
 void DigitalMixerDock::setCanvas(KoCanvasBase * canvas)
 {
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
 
     m_canvas = canvas;
 
     if (m_canvas) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
                 this, SLOT(canvasResourceChanged(int, const QVariant&)));
 
         m_tellCanvas=false;
         setCurrentColor(m_canvas->resourceManager()->foregroundColor());
         m_tellCanvas=true;
     }
 }
 
 void DigitalMixerDock::popupColorChanged(int i)
 {
     KoColor color = m_mixers[i].actionColor->color();
     color.convertTo(m_currentColor.colorSpace());
     m_mixers[i].targetSlider->setColors( color, m_currentColor);
     colorSliderChanged(i);
 }
 
 void DigitalMixerDock::colorSliderChanged(int i)
 {
     m_mixers[i].targetColor->setColor(m_mixers[i].targetSlider->currentColor());
 }
 
 void DigitalMixerDock::targetColorChanged(int i)
 {
     setCurrentColor(m_mixers[i].targetColor->color());
 }
 
 void DigitalMixerDock::setCurrentColor(const KoColor& color)
 {
     m_currentColor = color;
     m_currentColorPatch->setColor(color);
     for(int i = 0; i < m_mixers.size(); ++i)
     {
         popupColorChanged(i);
         colorSliderChanged(i);
     }
     if (m_canvas && m_tellCanvas)
     {
         m_canvas->resourceManager()->setForegroundColor(m_currentColor);
     }
 }
 
 void DigitalMixerDock::canvasResourceChanged(int key, const QVariant& v)
 {
     m_tellCanvas = false;
-    if (key == KoCanvasResourceManager::ForegroundColor)
+    if (key == KoCanvasResourceProvider::ForegroundColor)
         setCurrentColor(v.value<KoColor>());
     m_tellCanvas = true;
 }
 
diff --git a/plugins/dockers/gamutmask/gamutmask_dock.cpp b/plugins/dockers/gamutmask/gamutmask_dock.cpp
index 5343eefe7a..63ef163d12 100644
--- a/plugins/dockers/gamutmask/gamutmask_dock.cpp
+++ b/plugins/dockers/gamutmask/gamutmask_dock.cpp
@@ -1,629 +1,629 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <kis_debug.h>
 
 #include <klocalizedstring.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerObserver.h>
 #include <KoResourceServerAdapter.h>
 #include <KoCanvasBase.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 <QWidget>
 #include <QMenu>
 #include <QButtonGroup>
 #include <QRegularExpressionValidator>
 #include <QRegularExpression>
 #include <QFileInfo>
 #include <QMessageBox>
 
 #include "gamutmask_dock.h"
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <KoColorBackground.h>
 #include <KoShapeStroke.h>
 
 #include <ctime>
 
 #include "ui_wdgGamutMaskChooser.h"
 
 class KisMainWindow;
 
 struct GamutMaskChooserUI: public QWidget, public Ui_wdgGamutMaskChooser
 {
     GamutMaskChooserUI() {
         setupUi(this);
     }
 };
 
 
 GamutMaskDock::GamutMaskDock()
     : QDockWidget(i18n("Gamut Masks"))
     , m_resourceProvider(0)
     , m_selfClosingTemplate(false)
     , m_externalTemplateClose(false)
     , m_creatingNewMask(false)
     , m_templatePrevSaved(false)
     , m_selfSelectingMask(false)
     , m_selectedMask(nullptr)
     , m_maskDocument(nullptr)
     , m_view(nullptr)
 {
     m_dockerUI    = new GamutMaskChooserUI();
 
     m_dockerUI->bnMaskEditor->setIcon(KisIconUtils::loadIcon("dirty-preset"));
     m_dockerUI->bnMaskDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_dockerUI->bnMaskNew->setIcon(KisIconUtils::loadIcon("list-add"));
     m_dockerUI->bnMaskDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     m_dockerUI->maskPropertiesBox->setVisible(false);
     m_dockerUI->bnSaveMask->setIcon(KisIconUtils::loadIcon("document-save"));
     m_dockerUI->bnCancelMaskEdit->setIcon(KisIconUtils::loadIcon("dialog-cancel"));
     m_dockerUI->bnPreviewMask->setIcon(KisIconUtils::loadIcon("visible"));
 
     QRegularExpression maskTitleRegex("^[-_\\(\\)\\sA-Za-z0-9]+$");
     QRegularExpressionValidator* m_maskTitleValidator = new QRegularExpressionValidator(maskTitleRegex, this);
     m_dockerUI->maskTitleEdit->setValidator(m_maskTitleValidator);
 
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->addObserver(this);
 
     // gamut mask connections
     connect(m_dockerUI->bnSaveMask        , SIGNAL(clicked())                        , SLOT(slotGamutMaskSave()));
     connect(m_dockerUI->bnCancelMaskEdit        , SIGNAL(clicked())                        , SLOT(slotGamutMaskCancelEdit()));
     connect(m_dockerUI->bnPreviewMask        , SIGNAL(clicked())                        , SLOT(slotGamutMaskPreview()));
 
     connect(m_dockerUI->bnMaskEditor          , SIGNAL(clicked())               , SLOT(slotGamutMaskEdit()));
     connect(m_dockerUI->maskChooser, SIGNAL(sigGamutMaskSelected(KoGamutMask*)), SLOT(slotGamutMaskSelected(KoGamutMask*)));
     connect(m_dockerUI->bnMaskNew          , SIGNAL(clicked())               , SLOT(slotGamutMaskCreateNew()));
     connect(m_dockerUI->bnMaskDelete          , SIGNAL(clicked())               , SLOT(slotGamutMaskDelete()));
     connect(m_dockerUI->bnMaskDuplicate       , SIGNAL(clicked())               , SLOT(slotGamutMaskDuplicate()));
 
     setWidget(m_dockerUI);
 }
 
 GamutMaskDock::~GamutMaskDock()
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeObserver(this);
 }
 
 void GamutMaskDock::setViewManager(KisViewManager* kisview)
 {
     m_resourceProvider = kisview->resourceProvider();
 
     selectMask(m_resourceProvider->currentGamutMask());
 
     connect(this, SIGNAL(sigGamutMaskSet(KoGamutMask*)), m_resourceProvider, SLOT(slotGamutMaskActivated(KoGamutMask*)));
     connect(this, SIGNAL(sigGamutMaskChanged(KoGamutMask*)), m_resourceProvider, SLOT(slotGamutMaskActivated(KoGamutMask*)));
     connect(this, SIGNAL(sigGamutMaskUnset()), m_resourceProvider, SLOT(slotGamutMaskUnset()));
     connect(this, SIGNAL(sigGamutMaskPreviewUpdate()), m_resourceProvider, SLOT(slotGamutMaskPreviewUpdate()));
     connect(KisPart::instance(), SIGNAL(sigDocumentRemoved(QString)), this, SLOT(slotDocumentRemoved(QString)));
 }
 
 void GamutMaskDock::slotGamutMaskEdit()
 {
     if (!m_selectedMask) {
         return;
     }
     openMaskEditor();
 }
 
 bool GamutMaskDock::openMaskEditor()
 {
     if (!m_selectedMask) {
         return false;
     }
 
     // find the template resource first, so we can abort the action early on
     QString maskTemplateFile = KoResourcePaths::findResource("ko_gamutmasks", "GamutMaskTemplate.kra");
     if (maskTemplateFile.isEmpty() || maskTemplateFile.isNull() || !QFile::exists(maskTemplateFile)) {
         dbgPlugins << "GamutMaskDock::openMaskEditor(): maskTemplateFile (" << maskTemplateFile << ") was not found on the system";
         getUserFeedback(i18n("Could not open gamut mask for editing."),
                         i18n("The editor template was not found."),
                         QMessageBox::Ok, QMessageBox::Ok, QMessageBox::Critical);
         return false;
     }
 
     m_dockerUI->maskPropertiesBox->setVisible(true);
     m_dockerUI->maskPropertiesBox->setEnabled(true);
     m_dockerUI->editControlsBox->setEnabled(false);
     m_dockerUI->editControlsBox->setVisible(false);
 
     m_dockerUI->maskTitleEdit->setText(m_selectedMask->title());
     m_dockerUI->maskDescriptionEdit->setPlainText(m_selectedMask->description());
 
     m_maskDocument = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(m_maskDocument);
     m_maskDocument->openUrl(QUrl::fromLocalFile(maskTemplateFile), KisDocument::DontAddToRecent);
 
     // template document needs a proper autogenerated filename,
     // to avoid collision with other documents,
     // otherwise bugs happen when slotDocumentRemoved is called
     // (e.g. user closes another view, the template stays open, but the edit operation is canceled)
     m_maskDocument->setInfiniteAutoSaveInterval();
     QString maskPath = QString("%1%2%3_%4.kra")
             .arg(QDir::tempPath())
             .arg(QDir::separator())
             .arg("GamutMaskTemplate")
             .arg(std::time(nullptr));
     m_maskDocument->setUrl(QUrl::fromLocalFile(maskPath));
     m_maskDocument->setLocalFilePath(maskPath);
 
     KisShapeLayerSP shapeLayer = getShapeLayer();
 
     // pass only copies of shapes to the layer,
     // so the originals don't disappear from the mask later
     for (KoShape *shape: m_selectedMask->koShapes()) {
         KoShape* newShape = shape->cloneShape();
         newShape->setStroke(KoShapeStrokeModelSP());
         newShape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(QColor(255,255,255))));
         shapeLayer->addShape(newShape);
     }
 
     m_maskDocument->setPreActivatedNode(shapeLayer);
 
     // set document as active
     KisMainWindow* mainWindow = KisPart::instance()->currentMainwindow();
     KIS_ASSERT(mainWindow);
 
     m_view = mainWindow->addViewAndNotifyLoadingCompleted(m_maskDocument);
     KIS_ASSERT(m_view);
 
     for(KisView *view: KisPart::instance()->views()) {
         if (view->document() == m_maskDocument) {
             view->activateWindow();
             break;
         }
     }
 
     connect(m_view->viewManager(), SIGNAL(viewChanged()), this, SLOT(slotViewChanged()));
     connect(m_maskDocument, SIGNAL(completed()), this, SLOT(slotDocumentSaved()));
 
     return true;
 }
 
 void GamutMaskDock::cancelMaskEdit()
 {
     if (m_creatingNewMask) {
         deleteMask();
     }
 
     if (m_selectedMask) {
         m_selectedMask->clearPreview();
 
         if (m_resourceProvider->currentGamutMask() == m_selectedMask) {
             emit sigGamutMaskChanged(m_selectedMask);
         }
     }
 
     closeMaskDocument();
 }
 
 void GamutMaskDock::selectMask(KoGamutMask *mask, bool notifyItemChooser)
 {
     if (!mask) {
         return;
     }
 
     m_selectedMask = mask;
 
     if (notifyItemChooser) {
         m_selfSelectingMask = true;
         m_dockerUI->maskChooser->setCurrentResource(m_selectedMask);
         m_selfSelectingMask = false;
     }
 
     emit sigGamutMaskSet(m_selectedMask);
 }
 
 bool GamutMaskDock::saveSelectedMaskResource()
 {
     if (!m_selectedMask || !m_maskDocument) {
         return false;
     }
 
     bool maskSaved = false;
 
     if (m_selectedMask) {
         QList<KoShape*> shapes = getShapesFromLayer();
 
         if (shapes.count() > 0) {
             m_selectedMask->setMaskShapes(shapes);
 
             m_selectedMask->setImage(
                         m_maskDocument->image()->convertToQImage(m_maskDocument->image()->bounds()
                                                                  , m_maskDocument->image()->profile()
                                                                  )
                         );
 
             m_selectedMask->setDescription(m_dockerUI->maskDescriptionEdit->toPlainText());
 
             m_selectedMask->clearPreview();
             m_selectedMask->save();
             maskSaved = true;
         } else {
             getUserFeedback(i18n("Saving of gamut mask '%1' was aborted.", m_selectedMask->title()),
                             i18n("<p>The mask template is invalid.</p>"
                                  "<p>Please check that:"
                                  "<ul>"
                                  "<li>your template contains a vector layer named 'maskShapesLayer'</li>"
                                  "<li>there are one or more vector shapes on the 'maskShapesLayer'</li>"
                                  "</ul></p>"
                                  ),
                             QMessageBox::Ok, QMessageBox::Ok);
         }
     }
 
     return maskSaved;
 }
 
 void GamutMaskDock::deleteMask()
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeResourceAndBlacklist(m_selectedMask);
     m_selectedMask = nullptr;
 }
 
 int GamutMaskDock::getUserFeedback(QString text, QString informativeText,
                                    QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton,
                                    QMessageBox::Icon severity)
 {
     QMessageBox msgBox;
     msgBox.setWindowTitle(i18nc("@title:window", "Krita"));
     msgBox.setText(QString("<p><b>%1</b></p>").arg(text));
     msgBox.setInformativeText(informativeText);
     msgBox.setStandardButtons(buttons);
     msgBox.setDefaultButton(defaultButton);
     msgBox.setIcon(severity);
     int res = msgBox.exec();
 
     return res;
 }
 
 int GamutMaskDock::saveOrCancel(QMessageBox::StandardButton defaultAction)
 {
     int response = 0;
 
     if (m_maskDocument->isModified()) {
         response = getUserFeedback(i18n("Gamut mask <b>'%1'</b> has been modified.", m_selectedMask->title()),
                                    i18n("Do you want to save it?"),
                                    QMessageBox::Cancel | QMessageBox::Close | QMessageBox::Save, defaultAction);
 
     } else if (m_templatePrevSaved && defaultAction != QMessageBox::Close) {
         response = QMessageBox::Save;
 
     } else if (!m_templatePrevSaved) {
         response = QMessageBox::Close;
 
     } else {
         response = defaultAction;
     }
 
     switch (response) {
         case QMessageBox::Save : {
             slotGamutMaskSave();
             break;
     }
         case QMessageBox::Close : {
             cancelMaskEdit();
             break;
         }
     }
 
     return response;
 }
 
 KoGamutMask *GamutMaskDock::createMaskResource(KoGamutMask* sourceMask, QString newTitle)
 {
     m_creatingNewMask = true;
 
     KoGamutMask* newMask = nullptr;
     if (sourceMask) {
         newMask = new KoGamutMask(sourceMask);
         newMask->setImage(sourceMask->image());
     } else {
         newMask = new KoGamutMask();
 
         QString defaultPreviewPath = KoResourcePaths::findResource("ko_gamutmasks", "empty_mask_preview.png");
         KIS_SAFE_ASSERT_RECOVER_NOOP(!(defaultPreviewPath.isEmpty() || defaultPreviewPath.isNull() || !QFile::exists(defaultPreviewPath)));
 
         newMask->setImage(QImage(defaultPreviewPath, "PNG"));
     }
 
     QPair<QString,QFileInfo> maskFile = resolveMaskTitle(newTitle);
     QString maskTitle = maskFile.first;
     QFileInfo fileInfo = maskFile.second;
 
     newMask->setTitle(maskTitle);
     newMask->setFilename(fileInfo.filePath());
 
     newMask->setValid(true);
 
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeFromBlacklist(newMask);
     rServer->addResource(newMask, false);
 
     return newMask;
 }
 
 QPair<QString, QFileInfo> GamutMaskDock::resolveMaskTitle(QString suggestedTitle)
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     QString saveLocation = rServer->saveLocation();
     QString processedTitle = suggestedTitle.trimmed();
 
     QString resourceName = processedTitle;
     while (rServer->resourceByName(resourceName)) {
         resourceName = resourceName + QString(" (Copy)");
     }
 
     QString maskTitle = resourceName;
     QString maskFile = maskTitle + ".kgm";
     QString path = saveLocation + maskFile.replace(QRegularExpression("\\s+"), "_");
     QFileInfo fileInfo(path);
 
     return QPair<QString, QFileInfo>(maskTitle, fileInfo);
 }
 
 void GamutMaskDock::closeMaskDocument()
 {
     if (!m_externalTemplateClose) {
         if (m_maskDocument) {
             // set the document to not modified to bypass confirmation dialog
             // the close is already confirmed
             m_maskDocument->setModified(false);
 
             m_maskDocument->closeUrl();
             m_view->closeView();
             m_view->deleteLater();
 
             // set a flag that we are doing it ourselves, so the docker does not react to
             // removing signal from KisPart
             m_selfClosingTemplate = true;
             KisPart::instance()->removeView(m_view);
             KisPart::instance()->removeDocument(m_maskDocument);
             m_selfClosingTemplate = false;
         }
     }
 
     m_dockerUI->maskPropertiesBox->setVisible(false);
     m_dockerUI->editControlsBox->setVisible(true);
     m_dockerUI->editControlsBox->setEnabled(true);
 
     disconnect(m_view->viewManager(), SIGNAL(viewChanged()), this, SLOT(slotViewChanged()));
     disconnect(m_maskDocument, SIGNAL(completed()), this, SLOT(slotDocumentSaved()));
 
     // the template file is meant as temporary, if the user saved it, delete now
     if (QFile::exists(m_maskDocument->localFilePath())) {
         QFile::remove(m_maskDocument->localFilePath());
     }
 
     m_maskDocument = nullptr;
     m_view = nullptr;
     m_creatingNewMask = false;
     m_templatePrevSaved = false;
 }
 
 QList<KoShape*> GamutMaskDock::getShapesFromLayer()
 {
     KisShapeLayerSP shapeLayer = getShapeLayer();
 
     // create a deep copy of the shapes to save in the mask,
     // otherwise they vanish when the template closes
     QList<KoShape*> newShapes;
 
     if (shapeLayer) {
         for (KoShape* sh: shapeLayer->shapes()) {
             KoShape* newShape = sh->cloneShape();
             KoShapeStrokeSP border(new KoShapeStroke(0.5f, Qt::white));
             newShape->setStroke(border);
             newShape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(QColor(255,255,255,0))));
             newShapes.append(newShape);
         }
     }
 
     return newShapes;
 }
 
 KisShapeLayerSP GamutMaskDock::getShapeLayer()
 {
     KisNodeSP node = m_maskDocument->image()->rootLayer()->findChildByName("maskShapesLayer");
     return KisShapeLayerSP(dynamic_cast<KisShapeLayer*>(node.data()));
 }
 
 void GamutMaskDock::slotGamutMaskSave()
 {
     if (!m_selectedMask || !m_maskDocument) {
         return;
     }
 
     QString newTitle = m_dockerUI->maskTitleEdit->text();
 
     if (m_selectedMask->title() != newTitle) {
         // title has changed, rename
         KoGamutMask* newMask = createMaskResource(m_selectedMask, newTitle);
 
         // delete old mask and select new
         deleteMask();
         selectMask(newMask);
     }
 
     bool maskSaved = saveSelectedMaskResource();
     if (maskSaved) {
         emit sigGamutMaskSet(m_selectedMask);
         closeMaskDocument();
     }
 }
 
 void GamutMaskDock::slotGamutMaskCancelEdit()
 {
     if (!m_selectedMask) {
         return;
     }
 
     saveOrCancel(QMessageBox::Close);
 }
 
 void GamutMaskDock::slotGamutMaskPreview()
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask->setPreviewMaskShapes(getShapesFromLayer());
     emit sigGamutMaskPreviewUpdate();
 }
 
 void GamutMaskDock::slotGamutMaskSelected(KoGamutMask *mask)
 {
     if (!m_selfSelectingMask) {
         if (m_maskDocument) {
             int res = saveOrCancel();
             if (res == QMessageBox::Cancel) {
                 return;
             }
         }
 
         selectMask(mask, false);
     }
 }
 
 void GamutMaskDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
 }
 
 void GamutMaskDock::unsetCanvas()
 {
     setEnabled(false);
 }
 
 
 void GamutMaskDock::unsetResourceServer()
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeObserver(this);
 }
 
 void GamutMaskDock::removingResource(KoGamutMask *resource)
 {
     // if deleting previously set mask, notify selectors to unset their mask
     if (resource == m_resourceProvider->currentGamutMask()) {
         emit sigGamutMaskUnset();
         m_selectedMask = nullptr;
     }
 }
 
 void GamutMaskDock::resourceChanged(KoGamutMask *resource)
 {
     // if currently set mask has been changed, notify selectors
     if (resource == m_resourceProvider->currentGamutMask()) {
         selectMask(resource);
     }
 }
 
 void GamutMaskDock::slotGamutMaskCreateNew()
 {
     KoGamutMask* newMask = createMaskResource(nullptr, "new mask");
     selectMask(newMask);
 
     bool editorOpened = openMaskEditor();
     if (!editorOpened) {
         deleteMask();
     }
 }
 
 void GamutMaskDock::slotGamutMaskDuplicate()
 {
     if (!m_selectedMask) {
         return;
     }
 
     KoGamutMask* newMask = createMaskResource(m_selectedMask, m_selectedMask->title());
     selectMask(newMask);
 
     bool editorOpened = openMaskEditor();
     if (!editorOpened) {
         deleteMask();
     }
 }
 
 void GamutMaskDock::slotGamutMaskDelete()
 {   
     if (!m_selectedMask) {
         return;
     }
 
     int res = getUserFeedback(i18n("Are you sure you want to delete mask <b>'%1'</b>?"
                                    , m_selectedMask->title()));
 
     if (res == QMessageBox::Yes) {
         deleteMask();
     }
 }
 
 void GamutMaskDock::slotDocumentRemoved(QString filename)
 {
     if (!m_maskDocument) {
         return;
     }
 
     m_externalTemplateClose = true;
 
     // we do not want to run this if it is we who close the file
     if (!m_selfClosingTemplate) {
         // KisPart called, that a document will be removed
         // if it's ours, cancel the mask edit operation
         if (m_maskDocument->url().toLocalFile() == filename) {
             m_maskDocument->waitForSavingToComplete();
             saveOrCancel();
         }
     }
 
     m_externalTemplateClose = false;
 }
 
 void GamutMaskDock::slotViewChanged()
 {
     if (!m_maskDocument || !m_view) {
         return;
     }
 
     if (m_view->viewManager()->document() == m_maskDocument) {
         m_dockerUI->maskPropertiesBox->setEnabled(true);
     } else {
         m_dockerUI->maskPropertiesBox->setEnabled(false);
     }
 }
 
 void GamutMaskDock::slotDocumentSaved()
 {
     m_templatePrevSaved = true;
 }
diff --git a/plugins/dockers/lut/tests/kis_ocio_display_filter_test.cpp b/plugins/dockers/lut/tests/kis_ocio_display_filter_test.cpp
index 80785978e2..388ab53353 100644
--- a/plugins/dockers/lut/tests/kis_ocio_display_filter_test.cpp
+++ b/plugins/dockers/lut/tests/kis_ocio_display_filter_test.cpp
@@ -1,119 +1,119 @@
 /*
  *  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_ocio_display_filter_test.h"
 
 #include <QTest>
 
 #include <QFile>
 
 #include "KoColorModelStandardIds.h"
 
 #include <stroke_testing_utils.h>
 #include <testutil.h>
 
 #include "kis_exposure_gamma_correction_interface.h"
 #include <ocio_display_filter.h>
 #include "kis_display_color_converter.h"
 #include "kis_canvas_resource_provider.h"
 
 #include <KoChannelInfo.h>
 
 
 void KisOcioDisplayFilterTest::test()
 {
     KisExposureGammaCorrectionInterface *egInterface =
             new KisDumbExposureGammaCorrectionInterface();
 
     QSharedPointer<OcioDisplayFilter> filter(new OcioDisplayFilter(egInterface));
 
     QString configFile = TestUtil::fetchDataFileLazy("./psyfiTestingConfig-master/config.ocio");
     dbgKrita << ppVar(configFile);
 
     Q_ASSERT(QFile::exists(configFile));
 
     OCIO::ConstConfigRcPtr ocioConfig =
             OCIO::Config::CreateFromFile(configFile.toUtf8());
 
     filter->config = ocioConfig;
     filter->inputColorSpaceName = ocioConfig->getColorSpaceNameByIndex(0);
     filter->displayDevice = ocioConfig->getDisplay(1);
     filter->view = ocioConfig->getView(filter->displayDevice, 0);
     filter->gamma = 1.0;
     filter->exposure = 0.0;
     filter->swizzle = RGBA;
 
     filter->blackPoint = 0.0;
     filter->whitePoint = 1.0;
 
     filter->forceInternalColorManagement = false;
     filter->setLockCurrentColorVisualRepresentation(false);
 
     filter->updateProcessor();
 
     dbgKrita << ppVar(filter->inputColorSpaceName);
     dbgKrita << ppVar(filter->displayDevice);
     dbgKrita << ppVar(filter->view);
     dbgKrita << ppVar(filter->gamma);
     dbgKrita << ppVar(filter->exposure);
 
     const KoColorSpace *paintingCS =
             KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), 0);
 
     KisImageSP image = utils::createImage(0, QSize(100, 100));
     image->convertImageColorSpace(paintingCS, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     image->waitForDone();
 
     dbgKrita << ppVar(paintingCS) << ppVar(image->root()->firstChild()->colorSpace());
 
-    KoCanvasResourceManager *resourceManager =
+    KoCanvasResourceProvider *resourceManager =
             utils::createResourceManager(image,
                                          image->root(), "");
 
     KisDisplayColorConverter converter(resourceManager, 0);
 
     dbgKrita << ppVar(image->root()->firstChild());
 
     QVariant v;
     v.setValue(KisNodeWSP(image->root()->firstChild()));
     resourceManager->setResource(KisCanvasResourceProvider::CurrentKritaNode, v);
 
     converter.setDisplayFilter(filter);
     dbgKrita << ppVar(converter.paintingColorSpace());
 
     {
         QColor refColor(255, 128, 0);
         KoColor realColor = converter.approximateFromRenderedQColor(refColor);
         QColor roundTripColor = converter.toQColor(realColor);
 
         dbgKrita << ppVar(refColor);
         dbgKrita << ppVar(realColor.colorSpace()) << ppVar(KoColor::toQString(realColor));
         dbgKrita << ppVar(roundTripColor);
     }
 
     {
         KoColor realColor(Qt::red, paintingCS);
         QColor roundTripColor = converter.toQColor(realColor);
 
         dbgKrita << ppVar(realColor.colorSpace()) << ppVar(KoColor::toQString(realColor));
         dbgKrita << ppVar(roundTripColor);
     }
 
 }
 
 QTEST_MAIN(KisOcioDisplayFilterTest)
diff --git a/plugins/dockers/presetdocker/presetdocker_dock.cpp b/plugins/dockers/presetdocker/presetdocker_dock.cpp
index 22a5772459..c24b0e28b4 100644
--- a/plugins/dockers/presetdocker/presetdocker_dock.cpp
+++ b/plugins/dockers/presetdocker/presetdocker_dock.cpp
@@ -1,84 +1,84 @@
 /*
  *  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 "presetdocker_dock.h"
 
 #include <QHBoxLayout>
 #include <QPushButton>
 
 #include <klocalizedstring.h>
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoCanvasBase.h>
 
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_paintop_box.h"
 #include "kis_paintop_presets_chooser_popup.h"
 #include "kis_canvas_resource_provider.h"
 #include <brushengine/kis_paintop_preset.h>
 
 
 PresetDockerDock::PresetDockerDock( )
     : QDockWidget(i18n("Brush Presets"))
     , m_canvas(0)
 {
     m_presetChooser = new KisPaintOpPresetsChooserPopup(this);
     m_presetChooser->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     m_presetChooser->showButtons(false);
     setWidget(m_presetChooser);
 }
 
 void PresetDockerDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_presetChooser->disconnect(m_canvas->viewManager()->paintOpBox());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (!m_canvas || !m_canvas->viewManager() || !m_canvas->resourceManager()) return;
 
     connect(m_presetChooser, SIGNAL(resourceSelected(KoResource*)),
             m_canvas->viewManager()->paintOpBox(), SLOT(resourceSelected(KoResource*)));
     connect(m_presetChooser, SIGNAL(resourceClicked(KoResource*)),
             m_canvas->viewManager()->paintOpBox(), SLOT(resourceSelected(KoResource*)));
     connect(canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(canvasResourceChanged(int,QVariant)));
 
 
     connect(m_canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), m_presetChooser, SLOT(slotThemeChanged()));
 
 }
 
 void PresetDockerDock::canvasResourceChanged(int /*key*/, const QVariant& /*v*/)
 {
     if (m_canvas && m_canvas->resourceManager()) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_canvas->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if(preset)
             m_presetChooser->canvasResourceChanged(preset);
         sender()->blockSignals(false);
         m_presetChooser->updateViewSettings();
     }
 }
 
 
 
diff --git a/plugins/dockers/presethistory/presethistory_dock.cpp b/plugins/dockers/presethistory/presethistory_dock.cpp
index e40ab636c7..6841708ac7 100644
--- a/plugins/dockers/presethistory/presethistory_dock.cpp
+++ b/plugins/dockers/presethistory/presethistory_dock.cpp
@@ -1,144 +1,144 @@
 /*
  *  Copyright (c) 2015 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU 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 "presethistory_dock.h"
 
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QListWidget>
 #include <QImage>
 
 #include <klocalizedstring.h>
 
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoCanvasBase.h>
 
 #include "kis_config.h"
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_paintop_box.h"
 #include "kis_paintop_presets_chooser_popup.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_types.h>
 
 #define ICON_SIZE 48
 
 PresetHistoryDock::PresetHistoryDock( )
     : QDockWidget(i18n("Brush Preset History"))
     , m_canvas(0)
     , m_block(false)
     , m_initialized(false)
 {
     m_presetHistory = new QListWidget(this);
     m_presetHistory->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_presetHistory->setDragEnabled(false);
     m_presetHistory->setSelectionBehavior(QAbstractItemView::SelectRows);
     m_presetHistory->setSelectionMode(QAbstractItemView::SingleSelection);
     m_presetHistory->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     setWidget(m_presetHistory);
 
     connect(m_presetHistory, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(presetSelected(QListWidgetItem*)));
 }
 
 void PresetHistoryDock::setCanvas(KoCanvasBase * canvas)
 {
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         disconnect(m_canvas->resourceManager());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (!m_canvas || !m_canvas->viewManager() || !m_canvas->resourceManager()) return;
 
     connect(canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)), SLOT(canvasResourceChanged(int,QVariant)));
 
     if (!m_initialized) {
         KisConfig cfg(true);
         QStringList presetHistory = cfg.readEntry<QString>("presethistory", "").split(",", QString::SkipEmptyParts);
         KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         Q_FOREACH (const QString &p, presetHistory) {
             KisPaintOpPresetSP preset = rserver->resourceByName(p);
             addPreset(preset);
         }
         m_initialized = true;
     }
 }
 
 void PresetHistoryDock::unsetCanvas()
 {
     m_canvas = 0;
     setEnabled(false);
     QStringList presetHistory;
     for(int i = m_presetHistory->count() -1; i >=0; --i) {
         QListWidgetItem *item = m_presetHistory->item(i);
         QVariant v = item->data(Qt::UserRole);
         KisPaintOpPresetSP preset = v.value<KisPaintOpPresetSP>();
         presetHistory << preset->name();
     }
     KisConfig cfg(false);
     cfg.writeEntry("presethistory", presetHistory.join(","));
 }
 
 void PresetHistoryDock::presetSelected(QListWidgetItem *item)
 {
     if (item) {
         QVariant v = item->data(Qt::UserRole);
         KisPaintOpPresetSP preset = v.value<KisPaintOpPresetSP>();
         m_block = true;
         m_canvas->viewManager()->paintOpBox()->resourceSelected(preset.data());
         m_block = false;
     }
 }
 
 void PresetHistoryDock::canvasResourceChanged(int key, const QVariant& /*v*/)
 {
     if (m_block) return;
 
     if (m_canvas && key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
         KisPaintOpPresetSP preset = m_canvas->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset) {
             for (int i = 0; i < m_presetHistory->count(); ++i) {
                 if (preset->name() == m_presetHistory->item(i)->text()) {
                     m_presetHistory->setCurrentRow(i);
                     return;
                 }
             }
             addPreset(preset);
         }
     }
 }
 
 void PresetHistoryDock::addPreset(KisPaintOpPresetSP preset)
 {
     if (preset) {
         QListWidgetItem *item = new QListWidgetItem(QPixmap::fromImage(preset->image()), preset->name());
         QVariant v = QVariant::fromValue<KisPaintOpPresetSP>(preset);
         item->setData(Qt::UserRole, v);
         m_presetHistory->insertItem(0, item);
         m_presetHistory->setCurrentRow(0);
         if (m_presetHistory->count() > 10) {
             m_presetHistory->takeItem(10);
         }
     }
 
 }
 
diff --git a/plugins/dockers/smallcolorselector/smallcolorselector_dock.cc b/plugins/dockers/smallcolorselector/smallcolorselector_dock.cc
index 5adffa908c..1c83260dd9 100644
--- a/plugins/dockers/smallcolorselector/smallcolorselector_dock.cc
+++ b/plugins/dockers/smallcolorselector/smallcolorselector_dock.cc
@@ -1,75 +1,75 @@
 /*
  *  Copyright (c) 2008 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 "smallcolorselector_dock.h"
 
 #include <klocalizedstring.h>
 #include <KoCanvasBase.h>
 
 #include "kis_small_color_widget.h"
 #include "kis_canvas_resource_provider.h"
 
 #include <KoColorSpaceRegistry.h>
 
 #include <QVBoxLayout>
 
 SmallColorSelectorDock::SmallColorSelectorDock()
         : QDockWidget()
         , m_canvas(0)
 {
     QWidget *page = new QWidget(this);
     QVBoxLayout *layout = new QVBoxLayout(page);
     m_smallColorWidget = new KisSmallColorWidget(this);
     layout->addWidget(m_smallColorWidget);
     layout->addStretch(1);
     setWidget(page);
     m_smallColorWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
     connect(m_smallColorWidget, SIGNAL(colorChanged(const QColor&)),
             this, SLOT(colorChangedProxy(const QColor&)));
 
     setWindowTitle(i18n("Small Color Selector"));
 }
 
 void SmallColorSelectorDock::setCanvas(KoCanvasBase * canvas)
 {
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_smallColorWidget->setQColor(Qt::black);
     }
     m_canvas = canvas;
     if (m_canvas && m_canvas->resourceManager()) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int, const QVariant&)),
                 this, SLOT(canvasResourceChanged(int, const QVariant&)));
         m_smallColorWidget->setQColor(m_canvas->resourceManager()->foregroundColor().toQColor());
     }
 }
 
 void SmallColorSelectorDock::colorChangedProxy(const QColor& c)
 {
     if (m_canvas)
         m_canvas->resourceManager()->setForegroundColor(KoColor(c , KoColorSpaceRegistry::instance()->rgb8()));
 }
 
 void SmallColorSelectorDock::canvasResourceChanged(int key, const QVariant& v)
 {
-    if (key == KoCanvasResourceManager::ForegroundColor) {
+    if (key == KoCanvasResourceProvider::ForegroundColor) {
         m_smallColorWidget->setQColor(v.value<KoColor>().toQColor());
     }
 }
 
diff --git a/plugins/flake/textshape/TextShape.cpp b/plugins/flake/textshape/TextShape.cpp
index 80d27b8848..ce67ed79a3 100644
--- a/plugins/flake/textshape/TextShape.cpp
+++ b/plugins/flake/textshape/TextShape.cpp
@@ -1,466 +1,466 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
  * Copyright (C) 2008-2010 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2008 Pierre Stirnweiss \pierre.stirnweiss_calligra@gadz.org>
  * Copyright (C) 2010 KO GmbH <cbo@kogmbh.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 "TextShape.h"
 #include "ShrinkToFitShapeContainer.h"
 #include <KoTextSharedLoadingData.h>
 #include "SimpleRootAreaProvider.h"
 
 #include <KoTextLayoutRootArea.h>
 #include <KoTextEditor.h>
 
 #include <KoCanvasBase.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoChangeTracker.h>
 #include <KoInlineTextObjectManager.h>
 #include <KoTextRangeManager.h>
 #include <KoOdfLoadingContext.h>
 #include <KoOdfWorkaround.h>
 #include <KoParagraphStyle.h>
 #include <KoPostscriptPaintDevice.h>
 #include <KoSelection.h>
 #include <KoShapeLoadingContext.h>
 #include <KoShapeBackground.h>
 #include <KoShapePaintingContext.h>
 #include <KoShapeSavingContext.h>
 #include <KoText.h>
 #include <KoTextDocument.h>
 #include <KoTextDocumentLayout.h>
 #include <KoTextPage.h>
 #include <KoTextShapeContainerModel.h>
 #include <KoPageProvider.h>
 #include <KoViewConverter.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoXmlNS.h>
 #include <KoStyleStack.h>
 
 #include <QAbstractTextDocumentLayout>
 #include <QApplication>
 #include <QFont>
 #include <QPainter>
 #include <QPen>
 #include <QTextLayout>
 
 #include <QDebug>
 
 #include <KoShapeContainer_p.h>
 #include "kis_painting_tweaks.h"
 
 TextShape::TextShape(KoInlineTextObjectManager *inlineTextObjectManager, KoTextRangeManager *textRangeManager)
     : KoShapeContainer(new KoTextShapeContainerModel())
     , KoFrameShape(KoXmlNS::draw, "text-box")
     , m_pageProvider(0)
     , m_imageCollection(0)
     , m_clip(true)
 {
     setShapeId(TextShape_SHAPEID);
     m_textShapeData = new KoTextShapeData();
     setUserData(m_textShapeData);
     SimpleRootAreaProvider *provider = new SimpleRootAreaProvider(m_textShapeData, this);
 
     KoTextDocument(m_textShapeData->document()).setInlineTextObjectManager(inlineTextObjectManager);
     KoTextDocument(m_textShapeData->document()).setTextRangeManager(textRangeManager);
 
     m_layout = new KoTextDocumentLayout(m_textShapeData->document(), provider);
     m_textShapeData->document()->setDocumentLayout(m_layout);
 
     setCollisionDetection(true);
 
     QObject::connect(m_layout, SIGNAL(layoutIsDirty()), m_layout, SLOT(scheduleLayout()));
 }
 
 TextShape::TextShape(const TextShape &rhs)
     : KoShapeContainer(new KoShapeContainerPrivate(*reinterpret_cast<KoShapeContainerPrivate*>(rhs.d_ptr), this)),
       KoFrameShape(rhs),
       m_textShapeData(dynamic_cast<KoTextShapeData*>(rhs.m_textShapeData->clone())),
       m_pageProvider(0),
       m_imageCollection(0),
       m_clip(rhs.m_clip)
 {
     reinterpret_cast<KoShapeContainerPrivate*>(rhs.d_ptr)->model = new KoTextShapeContainerModel();
 
     setShapeId(TextShape_SHAPEID);
     setUserData(m_textShapeData);
 
     SimpleRootAreaProvider *provider = new SimpleRootAreaProvider(m_textShapeData, this);
     m_layout = new KoTextDocumentLayout(m_textShapeData->document(), provider);
     m_textShapeData->document()->setDocumentLayout(m_layout);
 
     setCollisionDetection(true);
     QObject::connect(m_layout, SIGNAL(layoutIsDirty()), m_layout, SLOT(scheduleLayout()));
 
     updateDocumentData();
     m_layout->scheduleLayout();
 }
 
 
 TextShape::~TextShape()
 {
 }
 
 KoShape *TextShape::cloneShape() const
 {
     return new TextShape(*this);
 }
 
 void TextShape::paintComponent(QPainter &painter, const KoViewConverter &converter,
                                KoShapePaintingContext &paintContext)
 {
     painter.save();
     applyConversion(painter, converter);
     KoBorder *border = this->border();
 
     if (border) {
         paintBorder(painter, converter);
     } else if (paintContext.showTextShapeOutlines) {
         // No need to paint the outlines if there is a real border.
         if (qAbs(rotation()) > 1) {
             painter.setRenderHint(QPainter::Antialiasing);
         }
 
         QPen pen(QColor(210, 210, 210)); // use cosmetic pen
         QPointF onePixel = converter.viewToDocument(QPointF(1.0, 1.0));
         QRectF rect(QPointF(0.0, 0.0), size() - QSizeF(onePixel.x(), onePixel.y()));
         painter.setPen(pen);
         painter.drawRect(rect);
     }
     painter.restore();
 
     if (m_textShapeData->isDirty()) { // not layouted yet.
         return;
     }
 
     QTextDocument *doc = m_textShapeData->document();
     Q_ASSERT(doc);
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(doc->documentLayout());
     Q_ASSERT(lay);
     lay->showInlineObjectVisualization(paintContext.showInlineObjectVisualization);
 
     applyConversion(painter, converter);
 
     if (background()) {
         QPainterPath p;
         p.addRect(QRectF(QPointF(), size()));
         background()->paint(painter, converter, paintContext, p);
     }
 
     // this enables to use the same shapes on different pages showing different page numbers
     if (m_pageProvider) {
         KoTextPage *page = m_pageProvider->page(this);
         if (page) {
             // this is used to not trigger repaints if layout during the painting is done
             m_paintRegion = KisPaintingTweaks::safeClipRegion(painter);
             if (!m_textShapeData->rootArea()->page() || page->pageNumber() != m_textShapeData->rootArea()->page()->pageNumber()) {
                 m_textShapeData->rootArea()->setPage(page); // takes over ownership of the page
             } else {
                 delete page;
             }
         }
     }
 
     KoTextDocumentLayout::PaintContext pc;
 
     QAbstractTextDocumentLayout::Selection selection;
     KoTextEditor *textEditor = KoTextDocument(m_textShapeData->document()).textEditor();
     selection.cursor = *(textEditor->cursor());
     QPalette palette = pc.textContext.palette;
     selection.format.setBackground(palette.brush(QPalette::Highlight));
     selection.format.setForeground(palette.brush(QPalette::HighlightedText));
     pc.textContext.selections.append(selection);
 
     pc.textContext.selections += KoTextDocument(doc).selections();
     pc.viewConverter = &converter;
     pc.imageCollection = m_imageCollection;
     pc.showFormattingCharacters = paintContext.showFormattingCharacters;
     pc.showTableBorders = paintContext.showTableBorders;
     pc.showSectionBounds = paintContext.showSectionBounds;
     pc.showSpellChecking = paintContext.showSpellChecking;
     pc.showSelections = paintContext.showSelections;
 
     // When clipping the painter we need to make sure not to cutoff cosmetic pens which
     // may used to draw e.g. table-borders for user convenience when on screen (but not
     // on e.g. printing). Such cosmetic pens are special cause they will always have the
     // same pen-width (1 pixel) independent of zoom-factor or painter transformations and
     // are not taken into account in any border-calculations.
     QRectF clipRect = outlineRect();
     qreal cosmeticPenX = 1 * 72. / painter.device()->logicalDpiX();
     qreal cosmeticPenY = 1 * 72. / painter.device()->logicalDpiY();
     painter.setClipRect(clipRect.adjusted(-cosmeticPenX, -cosmeticPenY, cosmeticPenX, cosmeticPenY), Qt::IntersectClip);
 
     painter.save();
     painter.translate(0, -m_textShapeData->documentOffset());
     m_textShapeData->rootArea()->paint(&painter, pc); // only need to draw ourselves
     painter.restore();
 
     m_paintRegion = QRegion();
 }
 
 QPointF TextShape::convertScreenPos(const QPointF &point) const
 {
     QPointF p = absoluteTransformation(0).inverted().map(point);
     return p + QPointF(0.0, m_textShapeData->documentOffset());
 }
 
 QPainterPath TextShape::outline() const
 {
     QPainterPath path;
     path.addRect(QRectF(QPointF(0, 0), size()));
     return path;
 }
 
 QRectF TextShape::outlineRect() const
 {
     if (m_textShapeData->rootArea()) {
         QRectF rect = m_textShapeData->rootArea()->boundingRect();
         rect.moveTop(rect.top() - m_textShapeData->rootArea()->top());
         if (m_clip) {
             rect.setHeight(size().height());
         }
         return rect | QRectF(QPointF(0, 0), size());
     }
     return QRectF(QPointF(0, 0), size());
 }
 
 void TextShape::shapeChanged(ChangeType type, KoShape *shape)
 {
     Q_UNUSED(shape);
     KoShapeContainer::shapeChanged(type, shape);
     if (type == PositionChanged || type == SizeChanged || type == CollisionDetected) {
         m_textShapeData->setDirty();
     }
 }
 
 void TextShape::saveOdf(KoShapeSavingContext &context) const
 {
     KoXmlWriter &writer = context.xmlWriter();
 
     QString textHeight = additionalAttribute("fo:min-height");
     const_cast<TextShape *>(this)->removeAdditionalAttribute("fo:min-height");
     writer.startElement("draw:frame");
     // if the TextShape is wrapped in a shrink to fit container we need to save the geometry of the container as
     // the geomerty of the shape might have been changed.
     if (ShrinkToFitShapeContainer *stf = dynamic_cast<ShrinkToFitShapeContainer *>(this->parent())) {
         stf->saveOdfAttributes(context, OdfSize | OdfPosition | OdfTransformation);
         saveOdfAttributes(context, OdfAdditionalAttributes | OdfMandatories | OdfCommonChildElements);
     } else {
         saveOdfAttributes(context, OdfAllAttributes);
     }
 
     writer.startElement("draw:text-box");
     if (!textHeight.isEmpty()) {
         writer.addAttribute("fo:min-height", textHeight);
     }
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(m_textShapeData->document()->documentLayout());
     int index = -1;
     if (lay) {
         int i = 0;
         foreach (KoShape *shape, lay->shapes()) {
             if (shape == this) {
                 index = i;
             } else if (index >= 0) {
                 writer.addAttribute("draw:chain-next-name", shape->name());
                 break;
             }
             ++i;
         }
     }
     const bool saveMyText = index == 0; // only save the text once.
 
     m_textShapeData->saveOdf(context, 0, 0, saveMyText ? -1 : 0);
     writer.endElement(); // draw:text-box
     saveOdfCommonChildElements(context);
     writer.endElement(); // draw:frame
 }
 
 QString TextShape::saveStyle(KoGenStyle &style, KoShapeSavingContext &context) const
 {
     Qt::Alignment vAlign(m_textShapeData->verticalAlignment());
     QString verticalAlign = "top";
     if (vAlign == Qt::AlignBottom) {
         verticalAlign = "bottom";
     } else if (vAlign == Qt::AlignVCenter) {
         verticalAlign = "middle";
     }
     style.addProperty("draw:textarea-vertical-align", verticalAlign);
 
     KoTextShapeData::ResizeMethod resize = m_textShapeData->resizeMethod();
     if (resize == KoTextShapeData::AutoGrowWidth || resize == KoTextShapeData::AutoGrowWidthAndHeight) {
         style.addProperty("draw:auto-grow-width", "true");
     }
     if (resize != KoTextShapeData::AutoGrowHeight && resize != KoTextShapeData::AutoGrowWidthAndHeight) {
         style.addProperty("draw:auto-grow-height", "false");
     }
     if (resize == KoTextShapeData::ShrinkToFitResize) {
         style.addProperty("draw:fit-to-size", "true");
     }
 
     m_textShapeData->saveStyle(style, context);
 
     return KoShape::saveStyle(style, context);
 }
 
 void TextShape::loadStyle(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     KoShape::loadStyle(element, context);
     KoStyleStack &styleStack = context.odfLoadingContext().styleStack();
     styleStack.setTypeProperties("graphic");
 
     QString verticalAlign(styleStack.property(KoXmlNS::draw, "textarea-vertical-align"));
     Qt::Alignment alignment(Qt::AlignTop);
     if (verticalAlign == "bottom") {
         alignment = Qt::AlignBottom;
     } else if (verticalAlign == "justify") {
         // not yet supported
         alignment = Qt::AlignVCenter;
     } else if (verticalAlign == "middle") {
         alignment = Qt::AlignVCenter;
     }
 
     m_textShapeData->setVerticalAlignment(alignment);
 
     const QString fitToSize = styleStack.property(KoXmlNS::draw, "fit-to-size");
     KoTextShapeData::ResizeMethod resize = KoTextShapeData::NoResize;
     if (fitToSize == "true" || fitToSize == "shrink-to-fit") { // second is buggy value from impress
         resize = KoTextShapeData::ShrinkToFitResize;
     } else {
         // An explicit svg:width or svg:height defined do change the default value (means those value
         // used if not explicit defined otherwise) for auto-grow-height and auto-grow-height. So
         // they are mutable exclusive.
         // It is not clear (means we did not test and took care of it) what happens if both are
         // defined and are in conflict with each other or how the fit-to-size is related to this.
 
         QString autoGrowWidth = styleStack.property(KoXmlNS::draw, "auto-grow-width");
         if (autoGrowWidth.isEmpty()) {
             autoGrowWidth = element.hasAttributeNS(KoXmlNS::svg, "width") ? "false" : "true";
         }
 
         QString autoGrowHeight = styleStack.property(KoXmlNS::draw, "auto-grow-height");
         if (autoGrowHeight.isEmpty()) {
             autoGrowHeight = element.hasAttributeNS(KoXmlNS::svg, "height") ? "false" : "true";
         }
 
         if (autoGrowWidth == "true") {
             resize = autoGrowHeight == "true" ? KoTextShapeData::AutoGrowWidthAndHeight : KoTextShapeData::AutoGrowWidth;
         } else if (autoGrowHeight == "true") {
             resize = KoTextShapeData::AutoGrowHeight;
         }
     }
 
     m_textShapeData->setResizeMethod(resize);
 }
 
 bool TextShape::loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     m_textShapeData->document()->setUndoRedoEnabled(false);
     loadOdfAttributes(element, context, OdfAllAttributes);
 
     // this cannot be done in loadStyle as that fills the style stack incorrectly and therefore
     // it results in wrong data being loaded.
     m_textShapeData->loadStyle(element, context);
 
 #ifndef NWORKAROUND_ODF_BUGS
     KoTextShapeData::ResizeMethod method = m_textShapeData->resizeMethod();
     if (KoOdfWorkaround::fixAutoGrow(method, context)) {
         KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(m_textShapeData->document()->documentLayout());
         Q_ASSERT(lay);
         if (lay) {
             SimpleRootAreaProvider *provider = dynamic_cast<SimpleRootAreaProvider *>(lay->provider());
             if (provider) {
                 provider->m_fixAutogrow = true;
             }
         }
     }
 #endif
 
     bool answer = loadOdfFrame(element, context);
     m_textShapeData->document()->setUndoRedoEnabled(true);
     return answer;
 }
 
 bool TextShape::loadOdfFrame(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     // If the loadOdfFrame from the base class for draw:text-box fails, check
     // for table:table, because that is a legal child of draw:frame in ODF 1.2.
     if (!KoFrameShape::loadOdfFrame(element, context)) {
         const KoXmlElement &possibleTableElement(KoXml::namedItemNS(element, KoXmlNS::table, "table"));
         if (possibleTableElement.isNull()) {
             return false;
         } else {
             return loadOdfFrameElement(possibleTableElement, context);
         }
     }
 
     return true;
 }
 
 bool TextShape::loadOdfFrameElement(const KoXmlElement &element, KoShapeLoadingContext &context)
 {
     bool ok = m_textShapeData->loadOdf(element, context, 0, this);
     if (ok) {
         ShrinkToFitShapeContainer::tryWrapShape(this, element, context);
     }
     return ok;
 }
 
 void TextShape::update() const
 {
     KoShapeContainer::update();
 }
 
 void TextShape::updateAbsolute(const QRectF &shape) const
 {
     // this is done to avoid updates which are called during the paint event and not needed.
     //if (!m_paintRegion.contains(shape.toRect())) {
         //KoShape::update(shape);
     //}
 
     // FIXME: just a hack to remove outdated call from the deprecated shape
     KoShape::updateAbsolute(shape);
 }
 
 void TextShape::waitUntilReady(const KoViewConverter &, bool asynchronous) const
 {
     Q_UNUSED(asynchronous);
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(m_textShapeData->document()->documentLayout());
     Q_ASSERT(lay);
     if (m_textShapeData->isDirty()) {
         // Do a simple layout-call which will make sure to relayout till things are done. If more
         // layouts are scheduled then we don't need to wait for them here but can just continue.
         lay->layout();
     }
 }
 
 KoImageCollection *TextShape::imageCollection()
 {
     return m_imageCollection;
 }
 
 void TextShape::updateDocumentData()
 {
     if (m_layout) {
         KoTextDocument document(m_textShapeData->document());
         m_layout->setStyleManager(document.styleManager());
         m_layout->setInlineTextObjectManager(document.inlineTextObjectManager());
         m_layout->setTextRangeManager(document.textRangeManager());
         m_layout->setChangeTracker(document.changeTracker());
     }
 }
diff --git a/plugins/flake/textshape/TextTool.cpp b/plugins/flake/textshape/TextTool.cpp
index aa056b7304..811f846380 100644
--- a/plugins/flake/textshape/TextTool.cpp
+++ b/plugins/flake/textshape/TextTool.cpp
@@ -1,3140 +1,3140 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
  * Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2008 Girish Ramakrishnan <girish@forwardbias.in>
  * Copyright (C) 2008, 2012 Pierre Stirnweiss <pstirnweiss@googlemail.org>
  * Copyright (C) 2009 KO GmbH <cbo@kogmbh.com>
  * Copyright (C) 2011 Mojtaba Shahi Senobari <mojtaba.shahi3000@gmail.com>
  * Copyright (C) 2014 Denis Kuplyakov <dener.kup@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 "TextTool.h"
 
 #include "TextEditingPluginContainer.h"
 #include "dialogs/SimpleCharacterWidget.h"
 #include "dialogs/SimpleParagraphWidget.h"
 #include "dialogs/SimpleTableWidget.h"
 #include "dialogs/SimpleInsertWidget.h"
 #include "dialogs/ParagraphSettingsDialog.h"
 #include "dialogs/StyleManagerDialog.h"
 #include "dialogs/InsertCharacter.h"
 #include "dialogs/FontDia.h"
 #include "dialogs/TableDialog.h"
 #include "dialogs/SectionFormatDialog.h"
 #include "dialogs/SectionsSplitDialog.h"
 #include "commands/AutoResizeCommand.h"
 #include "commands/ChangeListLevelCommand.h"
 #include "FontSizeAction.h"
 #include "FontFamilyAction.h"
 
 #include <KoOdf.h>
 #include <KoCanvasBase.h>
 #include <KoShapeController.h>
 #include <KoCanvasController.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoColorBackground.h>
 #include <KoColorPopupAction.h>
 #include <KoTextDocumentLayout.h>
 #include <KoParagraphStyle.h>
 #include <KoToolSelection.h>
 #include <KoTextEditingPlugin.h>
 #include <KoTextEditingRegistry.h>
 #include <KoInlineTextObjectManager.h>
 #include <KoTextRangeManager.h>
 #include <KoStyleManager.h>
 #include <KoTextOdfSaveHelper.h>
 #include <KoTextDrag.h>
 #include <KoTextDocument.h>
 #include <KoTextEditor.h>
 #include <KoChangeTracker.h>
 #include <KoChangeTrackerElement.h>
 #include <KoInlineNote.h>
 #include <KoBookmark.h>
 #include <KoBookmarkManager.h>
 #include <KoListLevelProperties.h>
 #include <KoTextLayoutRootArea.h>
 //#include <ResizeTableCommand.h>
 #include <KoIcon.h>
 #include <KoViewConverter.h>
 #include <KoShapeFactoryBase.h>
 #include "kis_action_registry.h"
 
 #include <QDebug>
 #include <kstandardshortcut.h>
 #include <kactionmenu.h>
 #include <kstandardaction.h>
 #include <ksharedconfig.h>
 
 #include <QDesktopServices>
 #include <QMenu>
 #include <QMenuBar>
 #include <QAction>
 #include <QTextTable>
 #include <QTextList>
 #include <QTabWidget>
 #include <QTextDocumentFragment>
 #include <QToolTip>
 #include <QSignalMapper>
 #include <QLinearGradient>
 #include <QBitmap>
 #include <QDrag>
 #include <QDragLeaveEvent>
 #include <QDragMoveEvent>
 #include <QDropEvent>
 #include <QMimeData>
 
 #include "KoShapeControllerBase.h"
 #include <KoAnnotation.h>
 #include <KoShapeRegistry.h>
 #include <kuser.h>
 
 #include <KoDocumentRdfBase.h>
 
 class TextToolSelection : public KoToolSelection
 {
 public:
 
     TextToolSelection(QWeakPointer<KoTextEditor> editor)
         : KoToolSelection(0)
         , m_editor(editor)
     {
     }
 
     bool hasSelection() override
     {
         if (!m_editor.isNull()) {
             return m_editor.data()->hasSelection();
         }
         return false;
     }
 
     QWeakPointer<KoTextEditor> m_editor;
 };
 
 static bool hit(const QKeySequence &input, KStandardShortcut::StandardShortcut shortcut)
 {
     foreach (const QKeySequence &ks, KStandardShortcut::shortcut(shortcut)) {
         if (input == ks) {
             return true;
         }
     }
     return false;
 }
 
 TextTool::TextTool(KoCanvasBase *canvas)
     : KoToolBase(canvas)
     , m_textShape(0)
     , m_textShapeData(0)
     , m_changeTracker(0)
     , m_allowActions(true)
     , m_allowAddUndoCommand(true)
     , m_allowResourceManagerUpdates(true)
     , m_prevCursorPosition(-1)
     , m_caretTimer(this)
     , m_caretTimerState(true)
     , m_currentCommand(0)
     , m_currentCommandHasChildren(false)
     , m_specialCharacterDocker(0)
     , m_textTyping(false)
     , m_textDeleting(false)
     , m_editTipTimer(this)
     , m_delayedEnsureVisible(false)
     , m_toolSelection(0)
     , m_tableDraggedOnce(false)
     , m_tablePenMode(false)
     , m_lastImMicroFocus(QRectF(0, 0, 0, 0))
     , m_drag(0)
 {
     setTextMode(true);
 
     createActions();
 
-    m_unit = canvas->resourceManager()->unitResource(KoCanvasResourceManager::Unit);
+    m_unit = canvas->resourceManager()->unitResource(KoCanvasResourceProvider::Unit);
 
     foreach (KoTextEditingPlugin *plugin, textEditingPluginContainer()->values()) {
         connect(plugin, SIGNAL(startMacro(QString)),
                 this, SLOT(startMacro(QString)));
         connect(plugin, SIGNAL(stopMacro()), this, SLOT(stopMacro()));
         QHash<QString, QAction *> actions = plugin->actions();
         QHash<QString, QAction *>::iterator i = actions.begin();
         while (i != actions.end()) {
             addAction(i.key(), i.value());
             ++i;
         }
     }
 
     m_contextMenu.reset(new QMenu());
 
     // setup the context list.
     QSignalMapper *signalMapper = new QSignalMapper(this);
     connect(signalMapper, SIGNAL(mapped(QString)), this, SLOT(startTextEditingPlugin(QString)));
     m_contextMenu->addAction(this->action("format_font"));
     foreach (const QString &key, KoTextEditingRegistry::instance()->keys()) {
         KoTextEditingFactory *factory =  KoTextEditingRegistry::instance()->value(key);
         if (factory->showInMenu()) {
             QAction *a = new QAction(factory->title(), this);
             connect(a, SIGNAL(triggered()), signalMapper, SLOT(map()));
             signalMapper->setMapping(a, factory->id());
             m_contextMenu->addAction(a);
             addAction(QString("apply_%1").arg(factory->id()), a);
         }
     }
 
     connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(shapeAddedToCanvas()));
 
     m_caretTimer.setInterval(500);
     connect(&m_caretTimer, SIGNAL(timeout()), this, SLOT(blinkCaret()));
 
     m_editTipTimer.setInterval(500);
     m_editTipTimer.setSingleShot(true);
     connect(&m_editTipTimer, SIGNAL(timeout()), this, SLOT(showEditTip()));
 }
 
 void TextTool::createActions()
 {
-    bool useAdvancedText = !(canvas()->resourceManager()->intResource(KoCanvasResourceManager::ApplicationSpeciality)
-                             & KoCanvasResourceManager::NoAdvancedText);
+    bool useAdvancedText = !(canvas()->resourceManager()->intResource(KoCanvasResourceProvider::ApplicationSpeciality)
+                             & KoCanvasResourceProvider::NoAdvancedText);
 
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
     // FIXME: find new icons for these
     m_actionConfigureSection = actionRegistry->makeQAction("configure_section", this);
     addAction("configure_section", m_actionConfigureSection);
     connect(m_actionConfigureSection, SIGNAL(triggered(bool)), this, SLOT(configureSection()));
 
     m_actionInsertSection = actionRegistry->makeQAction("insert_section", this);
     addAction("insert_section", m_actionInsertSection);
     connect(m_actionInsertSection, SIGNAL(triggered(bool)), this, SLOT(insertNewSection()));
 
     m_actionSplitSections = actionRegistry->makeQAction("split_sections", this);
     addAction("split_sections", m_actionSplitSections);
     connect(m_actionSplitSections, SIGNAL(triggered(bool)), this, SLOT(splitSections()));
 
     m_actionPasteAsText  = actionRegistry->makeQAction("edit_paste_text", this);
     addAction("edit_paste_text", m_actionPasteAsText);
     connect(m_actionPasteAsText, SIGNAL(triggered(bool)), this, SLOT(pasteAsText()));
 
     m_actionFormatBold  = actionRegistry->makeQAction("format_bold", this);
     addAction("format_bold", m_actionFormatBold);
     m_actionFormatBold->setCheckable(true);
     connect(m_actionFormatBold, SIGNAL(triggered(bool)), this, SLOT(bold(bool)));
 
     m_actionFormatItalic  = actionRegistry->makeQAction("format_italic", this);
     m_actionFormatItalic->setCheckable(true);
     addAction("format_italic", m_actionFormatItalic);
     connect(m_actionFormatItalic, SIGNAL(triggered(bool)), this, SLOT(italic(bool)));
 
     m_actionFormatUnderline  = actionRegistry->makeQAction("format_underline", this);
     m_actionFormatUnderline->setCheckable(true);
     addAction("format_underline", m_actionFormatUnderline);
     connect(m_actionFormatUnderline, SIGNAL(triggered(bool)), this, SLOT(underline(bool)));
 
     m_actionFormatStrikeOut  = actionRegistry->makeQAction("format_strike", this);
     m_actionFormatStrikeOut->setCheckable(true);
     addAction("format_strike", m_actionFormatStrikeOut);
     connect(m_actionFormatStrikeOut, SIGNAL(triggered(bool)), this, SLOT(strikeOut(bool)));
 
     QActionGroup *alignmentGroup = new QActionGroup(this);
     m_actionAlignLeft  = actionRegistry->makeQAction("format_alignleft", this);
     m_actionAlignLeft->setCheckable(true);
     alignmentGroup->addAction(m_actionAlignLeft);
     addAction("format_alignleft", m_actionAlignLeft);
     connect(m_actionAlignLeft, SIGNAL(triggered(bool)), this, SLOT(alignLeft()));
 
     m_actionAlignRight  = actionRegistry->makeQAction("format_alignright", this);
     m_actionAlignRight->setCheckable(true);
     alignmentGroup->addAction(m_actionAlignRight);
     addAction("format_alignright", m_actionAlignRight);
     connect(m_actionAlignRight, SIGNAL(triggered(bool)), this, SLOT(alignRight()));
 
     m_actionAlignCenter  = actionRegistry->makeQAction("format_aligncenter", this);
     m_actionAlignCenter->setCheckable(true);
     addAction("format_aligncenter", m_actionAlignCenter);
 
     alignmentGroup->addAction(m_actionAlignCenter);
     connect(m_actionAlignCenter, SIGNAL(triggered(bool)), this, SLOT(alignCenter()));
 
     m_actionAlignBlock  = actionRegistry->makeQAction("format_alignblock", this);
     m_actionAlignBlock->setCheckable(true);
     alignmentGroup->addAction(m_actionAlignBlock);
     addAction("format_alignblock", m_actionAlignBlock);
     connect(m_actionAlignBlock, SIGNAL(triggered(bool)), this, SLOT(alignBlock()));
 
     m_actionChangeDirection = actionRegistry->makeQAction("change_text_direction", this);
     m_actionChangeDirection->setCheckable(true);
     addAction("change_text_direction", m_actionChangeDirection);
     connect(m_actionChangeDirection, SIGNAL(triggered()), this, SLOT(textDirectionChanged()));
 
     m_actionFormatSuper = actionRegistry->makeQAction("format_super", this);
     m_actionFormatSuper->setCheckable(true);
     addAction("format_super", m_actionFormatSuper);
     connect(m_actionFormatSuper, SIGNAL(triggered(bool)), this, SLOT(superScript(bool)));
 
     m_actionFormatSub = actionRegistry->makeQAction("format_sub", this);
     m_actionFormatSub->setCheckable(true);
     addAction("format_sub", m_actionFormatSub);
     connect(m_actionFormatSub, SIGNAL(triggered(bool)), this, SLOT(subScript(bool)));
 
     // TODO: check these rtl-things work properly
     m_actionFormatIncreaseIndent = actionRegistry->makeQAction("format_increaseindent", this);
     addAction("format_increaseindent", m_actionFormatIncreaseIndent);
     connect(m_actionFormatIncreaseIndent, SIGNAL(triggered()), this, SLOT(increaseIndent()));
 
     m_actionFormatDecreaseIndent = actionRegistry->makeQAction("format_decreaseindent", this);
     addAction("format_decreaseindent", m_actionFormatDecreaseIndent);
     connect(m_actionFormatDecreaseIndent, SIGNAL(triggered()), this, SLOT(decreaseIndent()));
 
     const char *const increaseIndentActionIconName =
         QApplication::isRightToLeft() ? koIconNameCStr("format-indent-less") : koIconNameCStr("format-indent-more");
     m_actionFormatIncreaseIndent->setIcon(koIcon(increaseIndentActionIconName));
 
     const char *const decreaseIndentActionIconName =
         QApplication::isRightToLeft() ? koIconNameCStr("format_decreaseindent") : koIconNameCStr("format-indent-less");
     m_actionFormatIncreaseIndent->setIcon(koIcon(decreaseIndentActionIconName));
 
     QAction *action = actionRegistry->makeQAction("format_bulletlist", this);
     addAction("format_bulletlist", action);
 
     action = actionRegistry->makeQAction("format_numberlist", this);
     addAction("format_numberlist", action);
 
     action = actionRegistry->makeQAction("fontsizeup", this);
     addAction("fontsizeup", action);
     connect(action, SIGNAL(triggered()), this, SLOT(increaseFontSize()));
 
     action = actionRegistry->makeQAction("fontsizedown", this);
     addAction("fontsizedown", action);
     connect(action, SIGNAL(triggered()), this, SLOT(decreaseFontSize()));
 
     m_actionFormatFontFamily = new KoFontFamilyAction(this);
     m_actionFormatFontFamily->setText(i18n("Font Family"));
     addAction("format_fontfamily", m_actionFormatFontFamily);
     connect(m_actionFormatFontFamily, SIGNAL(triggered(QString)),
             this, SLOT(setFontFamily(QString)));
 
     m_variableMenu = new KActionMenu(i18n("Variable"), this);
     addAction("insert_variable", m_variableMenu);
 
     // ------------------- Actions with a key binding and no GUI item
     action = actionRegistry->makeQAction("nonbreaking_space", this);
     addAction("nonbreaking_space", action);
     connect(action, SIGNAL(triggered()), this, SLOT(nonbreakingSpace()));
 
     action = actionRegistry->makeQAction("nonbreaking_hyphen", this);
     addAction("nonbreaking_hyphen", action);
     connect(action, SIGNAL(triggered()), this, SLOT(nonbreakingHyphen()));
 
     action = actionRegistry->makeQAction("insert_index", this);
     addAction("insert_index", action);
     connect(action, SIGNAL(triggered()), this, SLOT(insertIndexMarker()));
 
     action = actionRegistry->makeQAction("soft_hyphen", this);
     // TODO: double check this one works, conflicts with "zoom out"
     addAction("soft_hyphen", action);
     connect(action, SIGNAL(triggered()), this, SLOT(softHyphen()));
 
     if (useAdvancedText) {
         action  = actionRegistry->makeQAction("line_break", this);
         addAction("line_break", action);
         connect(action, SIGNAL(triggered()), this, SLOT(lineBreak()));
 
         action  = actionRegistry->makeQAction("insert_framebreak", this);
         addAction("insert_framebreak", action);
         connect(action, SIGNAL(triggered()), this, SLOT(insertFrameBreak()));
     }
 
     action = actionRegistry->makeQAction("format_font", this);
     addAction("format_font", action);
     connect(action, SIGNAL(triggered()), this, SLOT(selectFont()));
 
     m_actionFormatFontSize = new FontSizeAction(i18n("Font Size"), this);
     addAction("format_fontsize", m_actionFormatFontSize);
     connect(m_actionFormatFontSize, SIGNAL(fontSizeChanged(qreal)), this, SLOT(setFontSize(qreal)));
 
     m_actionFormatTextColor = new KoColorPopupAction(this);
     addAction("format_textcolor", m_actionFormatTextColor);
     connect(m_actionFormatTextColor, SIGNAL(colorChanged(KoColor)), this, SLOT(setTextColor(KoColor)));
 
     m_actionFormatBackgroundColor = new KoColorPopupAction(this);
     addAction("format_backgroundcolor", m_actionFormatBackgroundColor);
     connect(m_actionFormatBackgroundColor, SIGNAL(colorChanged(KoColor)), this, SLOT(setBackgroundColor(KoColor)));
 
     m_growWidthAction = actionRegistry->makeQAction("grow_to_fit_width", this);
     addAction("grow_to_fit_width", m_growWidthAction);
     connect(m_growWidthAction, SIGNAL(triggered(bool)), this, SLOT(setGrowWidthToFit(bool)));
 
     m_growHeightAction = actionRegistry->makeQAction("grow_to_fit_height", this);
     addAction("grow_to_fit_height", m_growHeightAction);
     connect(m_growHeightAction, SIGNAL(triggered(bool)), this, SLOT(setGrowHeightToFit(bool)));
 
     m_shrinkToFitAction = actionRegistry->makeQAction("shrink_to_fit", this);
     addAction("shrink_to_fit", m_shrinkToFitAction);
     connect(m_shrinkToFitAction, SIGNAL(triggered(bool)), this, SLOT(setShrinkToFit(bool)));
 
     if (useAdvancedText) {
         action = actionRegistry->makeQAction("insert_table", this);
         addAction("insert_table", action);
         connect(action, SIGNAL(triggered()), this, SLOT(insertTable()));
 
         action  = actionRegistry->makeQAction("insert_tablerow_above", this);
         addAction("insert_tablerow_above", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(insertTableRowAbove()));
 
         action  = actionRegistry->makeQAction("insert_tablerow_below", this);
         addAction("insert_tablerow_below", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(insertTableRowBelow()));
 
         action  = actionRegistry->makeQAction("insert_tablecolumn_left", this);
         addAction("insert_tablecolumn_left", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(insertTableColumnLeft()));
 
         action  = actionRegistry->makeQAction("insert_tablecolumn_right", this);
         addAction("insert_tablecolumn_right", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(insertTableColumnRight()));
 
         action  = actionRegistry->makeQAction("delete_tablecolumn", this);
         addAction("delete_tablecolumn", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(deleteTableColumn()));
 
         action  = actionRegistry->makeQAction("delete_tablerow", this);
         addAction("delete_tablerow", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(deleteTableRow()));
 
         action  = actionRegistry->makeQAction("merge_tablecells", this);
         addAction("merge_tablecells", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(mergeTableCells()));
 
         action  = actionRegistry->makeQAction("split_tablecells", this);
         addAction("split_tablecells", action);
         connect(action, SIGNAL(triggered(bool)), this, SLOT(splitTableCells()));
 
         action = actionRegistry->makeQAction("activate_borderpainter", this);
         addAction("activate_borderpainter", action);
     }
 
     action = actionRegistry->makeQAction("format_paragraph", this);
     addAction("format_paragraph", action);
     connect(action, SIGNAL(triggered()), this, SLOT(formatParagraph()));
 
     action = actionRegistry->makeQAction("format_stylist", this);
     addAction("format_stylist", action);
     connect(action, SIGNAL(triggered()), this, SLOT(showStyleManager()));
 
     action = KStandardAction::selectAll(this, SLOT(selectAll()), this);
     addAction("edit_select_all", action);
 
     action = actionRegistry->makeQAction("insert_specialchar", this);
     addAction("insert_specialchar", action);
     connect(action, SIGNAL(triggered()), this, SLOT(insertSpecialCharacter()));
 
     action = actionRegistry->makeQAction("repaint", this);
     addAction("repaint", action);
     connect(action, SIGNAL(triggered()), this, SLOT(relayoutContent()));
 
     action = actionRegistry->makeQAction("insert_annotation", this);
     addAction("insert_annotation", action);
     connect(action, SIGNAL(triggered()), this, SLOT(insertAnnotation()));
 
 #ifndef NDEBUG
     action = actionRegistry->makeQAction("detailed_debug_paragraphs", this);
     addAction("detailed_debug_paragraphs", action);
     connect(action, SIGNAL(triggered()), this, SLOT(debugTextDocument()));
     action = actionRegistry->makeQAction("detailed_debug_styles", this);
     addAction("detailed_debug_styles", action);
     connect(action, SIGNAL(triggered()), this, SLOT(debugTextStyles()));
 #endif
 }
 
 #ifndef NDEBUG
 #include "tests/MockShapes.h"
 #include <kundo2stack.h>
 #include <KisMimeDatabase.h>
 
 TextTool::TextTool(MockCanvas *canvas)  // constructor for our unit tests;
     : KoToolBase(canvas),
       m_textShape(0),
       m_textShapeData(0),
       m_changeTracker(0),
       m_allowActions(true),
       m_allowAddUndoCommand(true),
       m_allowResourceManagerUpdates(true),
       m_prevCursorPosition(-1),
       m_caretTimer(this),
       m_caretTimerState(true),
       m_currentCommand(0),
       m_currentCommandHasChildren(false),
       m_specialCharacterDocker(0),
       m_textEditingPlugins(0)
     , m_editTipTimer(this)
     , m_delayedEnsureVisible(false)
     , m_tableDraggedOnce(false)
     , m_tablePenMode(false)
 {
     // we could init some vars here, but we probably don't have to
     QLocale::setDefault(QLocale("en"));
     QTextDocument *document = new QTextDocument(); // this document is leaked
 
     KoInlineTextObjectManager *inlineManager = new KoInlineTextObjectManager();
     KoTextDocument(document).setInlineTextObjectManager(inlineManager);
 
     KoTextRangeManager *locationManager = new KoTextRangeManager();
     KoTextDocument(document).setTextRangeManager(locationManager);
 
     m_textEditor = new KoTextEditor(document);
     KoTextDocument(document).setTextEditor(m_textEditor.data());
     m_toolSelection = new TextToolSelection(m_textEditor);
 
     m_changeTracker = new KoChangeTracker();
     KoTextDocument(document).setChangeTracker(m_changeTracker);
 
     KoTextDocument(document).setUndoStack(new KUndo2Stack());
 }
 #endif
 
 TextTool::~TextTool()
 {
     delete m_toolSelection;
 
     KIS_SAFE_ASSERT_RECOVER (!m_currentCommand) {
         delete m_currentCommand;
     }
 }
 
 void TextTool::showEditTip()
 {
     if (!m_textShapeData || m_editTipPointedAt.position == -1) {
         return;
     }
 
     QTextCursor c(m_textShapeData->document());
     c.setPosition(m_editTipPointedAt.position);
     QString text = "<p align=center style=\'white-space:pre\' >";
     int toolTipWidth = 0;
 
     if (m_changeTracker && m_changeTracker->containsInlineChanges(c.charFormat())
             && m_changeTracker->displayChanges()) {
         KoChangeTrackerElement *element = m_changeTracker->elementById(c.charFormat().property(KoCharacterStyle::ChangeTrackerId).toInt());
         if (element->isEnabled()) {
             QString changeType;
             if (element->getChangeType() == KoGenChange::InsertChange) {
                 changeType = i18n("Insertion");
             } else if (element->getChangeType() == KoGenChange::DeleteChange) {
                 changeType = i18n("Deletion");
             } else {
                 changeType = i18n("Formatting");
             }
 
             text += "<b>" + changeType + "</b><br/>";
 
             QString date = element->getDate();
             //Remove the T which separates the Data and Time.
             date[10] = QLatin1Char(' ');
             date = element->getCreator() + QLatin1Char(' ') + date;
             text += date + "</p>";
 
             toolTipWidth = QFontMetrics(QToolTip::font()).boundingRect(date).width();
         }
     }
 
     if (m_editTipPointedAt.bookmark || !m_editTipPointedAt.externalHRef.isEmpty()) {
         QString help = i18n("Ctrl+click to go to link ");
         help += m_editTipPointedAt.externalHRef;
         text += help + "</p>";
         toolTipWidth = QFontMetrics(QToolTip::font()).boundingRect(help).width();
     }
 
     if (m_editTipPointedAt.note) {
         QString help = i18n("Ctrl+click to go to the note ");
         text += help + "</p>";
         toolTipWidth = QFontMetrics(QToolTip::font()).boundingRect(help).width();
     }
 
     if (m_editTipPointedAt.noteReference > 0) {
         QString help = i18n("Ctrl+click to go to the note reference");
         text += help + "</p>";
         toolTipWidth = QFontMetrics(QToolTip::font()).boundingRect(help).width();
     }
 
     QToolTip::hideText();
 
     if (toolTipWidth) {
         QRect keepRect(m_editTipPos - QPoint(3, 3), QSize(6, 6));
         QToolTip::showText(m_editTipPos - QPoint(toolTipWidth / 2, 0), text, canvas()->canvasWidget(), keepRect);
     }
 
 }
 
 void TextTool::blinkCaret()
 {
     if (!(canvas()->canvasWidget() && canvas()->canvasWidget()->hasFocus())) {
         m_caretTimer.stop();
         m_caretTimerState = false; // not visible.
     } else {
         m_caretTimerState = !m_caretTimerState;
     }
     repaintCaret();
 }
 
 void TextTool::relayoutContent()
 {
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(m_textShapeData->document()->documentLayout());
     Q_ASSERT(lay);
     foreach (KoTextLayoutRootArea *rootArea, lay->rootAreas()) {
         rootArea->setDirty();
     }
     lay->emitLayoutIsDirty();
 }
 
 void TextTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     if (m_textEditor.isNull()) {
         return;
     }
     if (canvas()
             && (canvas()->canvasWidget() && canvas()->canvasWidget()->hasFocus())
             && !m_caretTimer.isActive()) { // make sure we blink
         m_caretTimer.start();
         m_caretTimerState = true;
     }
     if (!m_caretTimerState) {
         m_caretTimer.setInterval(500);    // we set it lower during typing, so set it back to normal
     }
 
     if (!m_textShapeData) {
         return;
     }
     if (m_textShapeData->isDirty()) {
         return;
     }
 
     qreal zoomX, zoomY;
     converter.zoom(&zoomX, &zoomY);
 
     painter.save();
     QTransform shapeMatrix = m_textShape->absoluteTransformation(&converter);
     shapeMatrix.scale(zoomX, zoomY);
     shapeMatrix.translate(0, -m_textShapeData->documentOffset());
 
     // Possibly draw table dragging visual cues
     const qreal boxHeight = 20;
     if (m_tableDragInfo.tableHit == KoPointedAt::ColumnDivider) {
         QPointF anchorPos = m_tableDragInfo.tableDividerPos - QPointF(m_dx, 0.0);
         if (m_tableDragInfo.tableColumnDivider > 0) {
             //let's draw left
             qreal w = m_tableDragInfo.tableLeadSize - m_dx;
             QRectF rect(anchorPos - QPointF(w, 0.0), QSizeF(w, 0.0));
             QRectF drawRect(shapeMatrix.map(rect.topLeft()), shapeMatrix.map(rect.bottomRight()));
             drawRect.setHeight(boxHeight);
             drawRect.moveTop(drawRect.top() - 1.5 * boxHeight);
             QString label = m_unit.toUserStringValue(w);
             int labelWidth = QFontMetrics(QToolTip::font()).boundingRect(label).width();
             painter.fillRect(drawRect, QColor(64, 255, 64, 196));
             painter.setPen(QColor(0, 0, 0, 196));
             if (labelWidth + 10 < drawRect.width()) {
                 QPointF centerLeft(drawRect.left(), drawRect.center().y());
                 QPointF centerRight(drawRect.right(), drawRect.center().y());
                 painter.drawLine(centerLeft, drawRect.center() - QPointF(labelWidth / 2 + 5, 0.0));
                 painter.drawLine(centerLeft, centerLeft + QPointF(7, -5));
                 painter.drawLine(centerLeft, centerLeft + QPointF(7, 5));
                 painter.drawLine(drawRect.center() + QPointF(labelWidth / 2 + 5, 0.0), centerRight);
                 painter.drawLine(centerRight, centerRight + QPointF(-7, -5));
                 painter.drawLine(centerRight, centerRight + QPointF(-7, 5));
                 painter.drawText(drawRect, Qt::AlignCenter, label);
             }
         }
         if (m_tableDragInfo.tableColumnDivider <  m_tableDragInfo.table->columns()) {
             //let's draw right
             qreal w = m_tableDragInfo.tableTrailSize + m_dx;
             QRectF rect(anchorPos, QSizeF(w, 0.0));
             QRectF drawRect(shapeMatrix.map(rect.topLeft()), shapeMatrix.map(rect.bottomRight()));
             drawRect.setHeight(boxHeight);
             drawRect.moveTop(drawRect.top() - 1.5 * boxHeight);
             QString label;
             int labelWidth;
             if (m_tableDragWithShift) {
                 label = i18n("follows along");
                 labelWidth = QFontMetrics(QToolTip::font()).boundingRect(label).width();
                 drawRect.setWidth(2 * labelWidth);
                 QLinearGradient g(drawRect.topLeft(), drawRect.topRight());
                 g.setColorAt(0.6, QColor(255, 64, 64, 196));
                 g.setColorAt(1.0, QColor(255, 64, 64, 0));
                 QBrush brush(g);
                 painter.fillRect(drawRect, brush);
             } else {
                 label = m_unit.toUserStringValue(w);
                 labelWidth = QFontMetrics(QToolTip::font()).boundingRect(label).width();
                 drawRect.setHeight(boxHeight);
                 painter.fillRect(drawRect, QColor(64, 255, 64, 196));
             }
             painter.setPen(QColor(0, 0, 0, 196));
             if (labelWidth + 10 < drawRect.width()) {
                 QPointF centerLeft(drawRect.left(), drawRect.center().y());
                 QPointF centerRight(drawRect.right(), drawRect.center().y());
                 painter.drawLine(centerLeft, drawRect.center() - QPointF(labelWidth / 2 + 5, 0.0));
                 painter.drawLine(centerLeft, centerLeft + QPointF(7, -5));
                 painter.drawLine(centerLeft, centerLeft + QPointF(7, 5));
                 if (!m_tableDragWithShift) {
                     painter.drawLine(drawRect.center() + QPointF(labelWidth / 2 + 5, 0.0), centerRight);
                     painter.drawLine(centerRight, centerRight + QPointF(-7, -5));
                     painter.drawLine(centerRight, centerRight + QPointF(-7, 5));
                 }
                 painter.drawText(drawRect, Qt::AlignCenter, label);
             }
             if (!m_tableDragWithShift) {
                 // let's draw a helper text too
                 label = i18n("Press shift to not resize this");
                 labelWidth = QFontMetrics(QToolTip::font()).boundingRect(label).width();
                 labelWidth += 10;
                 //if (labelWidth < drawRect.width())
                 {
                     drawRect.moveTop(drawRect.top() + boxHeight);
                     drawRect.moveLeft(drawRect.left() + (drawRect.width() - labelWidth) / 2);
                     drawRect.setWidth(labelWidth);
                     painter.fillRect(drawRect, QColor(64, 255, 64, 196));
                     painter.drawText(drawRect, Qt::AlignCenter, label);
                 }
             }
         }
     }
     // Possibly draw table dragging visual cues
     if (m_tableDragInfo.tableHit == KoPointedAt::RowDivider) {
         QPointF anchorPos = m_tableDragInfo.tableDividerPos - QPointF(0.0, m_dy);
         if (m_tableDragInfo.tableRowDivider > 0) {
             qreal h = m_tableDragInfo.tableLeadSize - m_dy;
             QRectF rect(anchorPos - QPointF(0.0, h), QSizeF(0.0, h));
             QRectF drawRect(shapeMatrix.map(rect.topLeft()), shapeMatrix.map(rect.bottomRight()));
             drawRect.setWidth(boxHeight);
             drawRect.moveLeft(drawRect.left() - 1.5 * boxHeight);
             QString label = m_unit.toUserStringValue(h);
             QRectF labelRect = QFontMetrics(QToolTip::font()).boundingRect(label);
             labelRect.setHeight(boxHeight);
             labelRect.setWidth(labelRect.width() + 10);
             labelRect.moveTopLeft(drawRect.center() - QPointF(labelRect.width(), labelRect.height()) / 2);
             painter.fillRect(drawRect, QColor(64, 255, 64, 196));
             painter.fillRect(labelRect, QColor(64, 255, 64, 196));
             painter.setPen(QColor(0, 0, 0, 196));
             if (labelRect.height() + 10 < drawRect.height()) {
                 QPointF centerTop(drawRect.center().x(), drawRect.top());
                 QPointF centerBottom(drawRect.center().x(), drawRect.bottom());
                 painter.drawLine(centerTop, drawRect.center() - QPointF(0.0, labelRect.height() / 2 + 5));
                 painter.drawLine(centerTop, centerTop + QPointF(-5, 7));
                 painter.drawLine(centerTop, centerTop + QPointF(5, 7));
                 painter.drawLine(drawRect.center() + QPointF(0.0, labelRect.height() / 2 + 5), centerBottom);
                 painter.drawLine(centerBottom, centerBottom + QPointF(-5, -7));
                 painter.drawLine(centerBottom, centerBottom + QPointF(5, -7));
             }
             painter.drawText(labelRect, Qt::AlignCenter, label);
         }
     }
     if (m_caretTimerState) {
         // Lets draw the caret ourselves, as the Qt method doesn't take cursor
         // charFormat into consideration.
         QTextBlock block = m_textEditor.data()->block();
         if (block.isValid()) {
             int posInParag = m_textEditor.data()->position() - block.position();
             if (posInParag <= block.layout()->preeditAreaPosition()) {
                 posInParag += block.layout()->preeditAreaText().length();
             }
 
             QTextLine tl = block.layout()->lineForTextPosition(m_textEditor.data()->position() - block.position());
             if (tl.isValid()) {
                 painter.setRenderHint(QPainter::Antialiasing, false);
                 QRectF rect = caretRect(m_textEditor.data()->cursor());
                 QPointF baselinePoint;
                 if (tl.ascent() > 0) {
                     QFontMetricsF fm(m_textEditor.data()->charFormat().font(), painter.device());
                     rect.setY(rect.y() + tl.ascent() - qMin(tl.ascent(), fm.ascent()));
                     rect.setHeight(qMin(tl.ascent(), fm.ascent()) + qMin(tl.descent(), fm.descent()));
                     baselinePoint = QPoint(rect.x(), rect.y() + tl.ascent());
                 } else {
                     //line only filled with characters-without-size (eg anchors)
                     // layout will make sure line has height of block font
                     QFontMetricsF fm(block.charFormat().font(), painter.device());
                     rect.setHeight(fm.ascent() + fm.descent());
                     baselinePoint = QPoint(rect.x(), rect.y() + fm.ascent());
                 }
                 QRectF drawRect(shapeMatrix.map(rect.topLeft()), shapeMatrix.map(rect.bottomLeft()));
                 drawRect.setWidth(2);
                 painter.setCompositionMode(QPainter::RasterOp_SourceXorDestination);
                 if (m_textEditor.data()->isEditProtected(true)) {
                     QRectF circleRect(shapeMatrix.map(baselinePoint), QSizeF(14, 14));
                     circleRect.translate(-6.5, -6.5);
                     QPen pen(QColor(16, 255, 255));
                     pen.setWidthF(2.0);
                     painter.setPen(pen);
                     painter.setRenderHint(QPainter::Antialiasing, true);
                     painter.drawEllipse(circleRect);
                     painter.drawLine(circleRect.topLeft() + QPointF(4.5, 4.5),
                                      circleRect.bottomRight() - QPointF(4.5, 4.5));
                 } else {
                     painter.fillRect(drawRect, QColor(128, 255, 128));
                 }
             }
         }
     }
 
     painter.restore();
 }
 
 void TextTool::updateSelectedShape(const QPointF &point, bool noDocumentChange)
 {
     QRectF area(point, QSizeF(1, 1));
     if (m_textEditor.data()->hasSelection()) {
         repaintSelection();
     } else {
         repaintCaret();
     }
     QList<KoShape *> sortedShapes = canvas()->shapeManager()->shapesAt(area, true);
     std::sort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
     for (int count = sortedShapes.count() - 1; count >= 0; count--) {
         KoShape *shape = sortedShapes.at(count);
 
         if (shape->isContentProtected()) {
             continue;
         }
         TextShape *textShape = dynamic_cast<TextShape *>(shape);
         if (textShape) {
             if (textShape != m_textShape) {
                 if (static_cast<KoTextShapeData *>(textShape->userData())->document() != m_textShapeData->document()) {
                     //we should only change to another document if allowed
                     if (noDocumentChange) {
                         return;
                     }
 
                     // if we change to another textdocument we need to remove selection in old document
                     // or it would continue to be painted etc
 
                     m_textEditor.data()->setPosition(m_textEditor.data()->position());
                 }
                 m_textShape = textShape;
 
                 setShapeData(static_cast<KoTextShapeData *>(m_textShape->userData()));
 
                 // This is how we inform the rulers of the active range
                 // For now we will not consider table cells, but just give the shape dimensions
                 QVariant v;
                 QRectF rect(QPoint(), m_textShape->size());
                 rect = m_textShape->absoluteTransformation(0).mapRect(rect);
                 v.setValue(rect);
-                canvas()->resourceManager()->setResource(KoCanvasResourceManager::ActiveRange, v);
+                canvas()->resourceManager()->setResource(KoCanvasResourceProvider::ActiveRange, v);
             }
             return;
         }
     }
 }
 
 void TextTool::mousePressEvent(KoPointerEvent *event)
 {
     if (m_textEditor.isNull()) {
         return;
     }
 
     // request the software keyboard, if any
     if (event->button() == Qt::LeftButton && qApp->autoSipEnabled()) {
         QStyle::RequestSoftwareInputPanel behavior = QStyle::RequestSoftwareInputPanel(qApp->style()->styleHint(QStyle::SH_RequestSoftwareInputPanel));
         // the two following bools just make it all a lot easier to read in the following if()
         // basically, we require a widget for this to work (passing 0 to QApplication::sendEvent
         // crashes) and there are three tests any one of which can be true to trigger the event
         const bool hasWidget = canvas()->canvasWidget();
         if ((behavior == QStyle::RSIP_OnMouseClick && hasWidget) ||
                 (hasWidget && canvas()->canvasWidget()->hasFocus())) {
             QEvent event(QEvent::RequestSoftwareInputPanel);
             if (hasWidget) {
                 QApplication::sendEvent(canvas()->canvasWidget(), &event);
             }
         }
     }
 
     bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
 
     updateSelectedShape(event->point, shiftPressed);
 
     KoSelection *selection = canvas()->selectedShapesProxy()->selection();
     if (m_textShape && !selection->isSelected(m_textShape) && m_textShape->isSelectable()) {
         selection->deselectAll();
         selection->select(m_textShape);
     }
 
     KoPointedAt pointedAt = hitTest(event->point);
     m_tableDraggedOnce = false;
     m_clickWithinSelection = false;
     if (pointedAt.position != -1) {
         m_tablePenMode = false;
 
         if ((event->button() == Qt::LeftButton) && !shiftPressed && m_textEditor.data()->hasSelection() && m_textEditor.data()->isWithinSelection(pointedAt.position)) {
             m_clickWithinSelection = true;
             m_draggingOrigin = event->pos(); //we store the pixel pos
         } else if (!(event->button() == Qt::RightButton && m_textEditor.data()->hasSelection() && m_textEditor.data()->isWithinSelection(pointedAt.position))) {
             m_textEditor.data()->setPosition(pointedAt.position, shiftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor);
             useCursor(Qt::IBeamCursor);
         }
         m_tableDragInfo.tableHit = KoPointedAt::None;
         if (m_caretTimer.isActive()) { // make the caret not blink, (blinks again after first draw)
             m_caretTimer.stop();
             m_caretTimer.setInterval(50);
             m_caretTimer.start();
             m_caretTimerState = true; // turn caret instantly on on click
         }
     } else {
         if (event->button() == Qt::RightButton) {
             m_tablePenMode = false;
             KoTextEditingPlugin *plugin = textEditingPluginContainer()->spellcheck();
             if (plugin) {
                 plugin->setCurrentCursorPosition(m_textShapeData->document(), -1);
             }
 
             event->ignore();
         } else if (m_tablePenMode) {
             m_textEditor.data()->beginEditBlock(kundo2_i18n("Change Border Formatting"));
             if (pointedAt.tableHit == KoPointedAt::ColumnDivider) {
                 if (pointedAt.tableColumnDivider < pointedAt.table->columns()) {
                     m_textEditor.data()->setTableBorderData(pointedAt.table,
                                                             pointedAt.tableRowDivider, pointedAt.tableColumnDivider,
                                                             KoBorder::LeftBorder, m_tablePenBorderData);
                 }
                 if (pointedAt.tableColumnDivider > 0) {
                     m_textEditor.data()->setTableBorderData(pointedAt.table,
                                                             pointedAt.tableRowDivider, pointedAt.tableColumnDivider - 1,
                                                             KoBorder::RightBorder, m_tablePenBorderData);
                 }
             } else if (pointedAt.tableHit == KoPointedAt::RowDivider) {
                 if (pointedAt.tableRowDivider < pointedAt.table->rows()) {
                     m_textEditor.data()->setTableBorderData(pointedAt.table,
                                                             pointedAt.tableRowDivider, pointedAt.tableColumnDivider,
                                                             KoBorder::TopBorder, m_tablePenBorderData);
                 }
                 if (pointedAt.tableRowDivider > 0) {
                     m_textEditor.data()->setTableBorderData(pointedAt.table,
                                                             pointedAt.tableRowDivider - 1, pointedAt.tableColumnDivider,
                                                             KoBorder::BottomBorder, m_tablePenBorderData);
                 }
             }
             m_textEditor.data()->endEditBlock();
         } else {
             m_tableDragInfo = pointedAt;
             m_tablePenMode = false;
         }
         return;
     }
     if (shiftPressed) { // altered selection.
         repaintSelection();
     } else {
         repaintCaret();
     }
 
     updateSelectionHandler();
     updateStyleManager();
 
     updateActions();
 
     //activate context-menu for spelling-suggestions
     if (event->button() == Qt::RightButton) {
         KoTextEditingPlugin *plugin = textEditingPluginContainer()->spellcheck();
         if (plugin) {
             plugin->setCurrentCursorPosition(m_textShapeData->document(), m_textEditor.data()->position());
         }
 
         event->ignore();
     }
 
     if (event->button() ==  Qt::MidButton) { // Paste
         const QMimeData *data = QApplication::clipboard()->mimeData(QClipboard::Selection);
 
         // on windows we do not have data if we try to paste this selection
         if (data) {
             m_prevCursorPosition = m_textEditor.data()->position();
             m_textEditor.data()->paste(canvas(), data, canvas()->resourceManager());
             editingPluginEvents();
         }
     }
 }
 
 void TextTool::setShapeData(KoTextShapeData *data)
 {
     bool docChanged = !data || !m_textShapeData || m_textShapeData->document() != data->document();
     if (m_textShapeData) {
         disconnect(m_textShapeData, SIGNAL(destroyed(QObject*)), this, SLOT(shapeDataRemoved()));
     }
     m_textShapeData = data;
     if (!m_textShapeData) {
         return;
     }
     connect(m_textShapeData, SIGNAL(destroyed(QObject*)), this, SLOT(shapeDataRemoved()));
     if (docChanged) {
         if (!m_textEditor.isNull()) {
             disconnect(m_textEditor.data(), SIGNAL(textFormatChanged()), this, SLOT(updateActions()));
         }
         m_textEditor = KoTextDocument(m_textShapeData->document()).textEditor();
         Q_ASSERT(m_textEditor.data());
         if (!m_toolSelection) {
             m_toolSelection = new TextToolSelection(m_textEditor.data());
         } else {
             m_toolSelection->m_editor = m_textEditor.data();
         }
 
         m_variableMenu->menu()->clear();
         KoTextDocument document(m_textShapeData->document());
         foreach (QAction *action, document.inlineTextObjectManager()->createInsertVariableActions(canvas())) {
             m_variableMenu->addAction(action);
             connect(action, SIGNAL(triggered()), this, SLOT(returnFocusToCanvas()));
         }
 
         connect(m_textEditor.data(), SIGNAL(textFormatChanged()), this, SLOT(updateActions()));
         updateActions();
     }
 }
 
 void TextTool::updateSelectionHandler()
 {
     if (m_textEditor) {
         emit selectionChanged(m_textEditor.data()->hasSelection());
         if (m_textEditor.data()->hasSelection()) {
             QClipboard *clipboard = QApplication::clipboard();
             if (clipboard->supportsSelection()) {
                 clipboard->setText(m_textEditor.data()->selectedText(), QClipboard::Selection);
             }
         }
     }
 
-    KoCanvasResourceManager *p = canvas()->resourceManager();
+    KoCanvasResourceProvider *p = canvas()->resourceManager();
     m_allowResourceManagerUpdates = false;
     if (m_textEditor && m_textShapeData) {
         p->setResource(KoText::CurrentTextPosition, m_textEditor.data()->position());
         p->setResource(KoText::CurrentTextAnchor, m_textEditor.data()->anchor());
         QVariant variant;
         variant.setValue<void *>(m_textShapeData->document());
         p->setResource(KoText::CurrentTextDocument, variant);
     } else {
         p->clearResource(KoText::CurrentTextPosition);
         p->clearResource(KoText::CurrentTextAnchor);
         p->clearResource(KoText::CurrentTextDocument);
     }
     m_allowResourceManagerUpdates = true;
 }
 
 QMimeData *TextTool::generateMimeData() const
 {
     if (!m_textShapeData || m_textEditor.isNull() || !m_textEditor.data()->hasSelection()) {
         return 0;
     }
     int from = m_textEditor.data()->position();
     int to = m_textEditor.data()->anchor();
     KoTextOdfSaveHelper saveHelper(m_textShapeData->document(), from, to);
     KoTextDrag drag;
 
 #ifdef SHOULD_BUILD_RDF
     KoDocumentResourceManager *rm = 0;
     if (canvas()->shapeController()) {
         rm = canvas()->shapeController()->resourceManager();
     }
 
     if (rm && rm->hasResource(KoText::DocumentRdf)) {
         KoDocumentRdfBase *rdf = qobject_cast<KoDocumentRdfBase *>(rm->resource(KoText::DocumentRdf).value<QObject *>());
         if (rdf) {
             saveHelper.setRdfModel(rdf->model());
         }
     }
 #endif
     drag.setOdf(KoOdf::mimeType(KoOdf::Text), saveHelper);
     QTextDocumentFragment fragment = m_textEditor.data()->selection();
     drag.setData("text/html", fragment.toHtml("utf-8").toUtf8());
     drag.setData("text/plain", fragment.toPlainText().toUtf8());
 
     return drag.takeMimeData();
 }
 
 TextEditingPluginContainer *TextTool::textEditingPluginContainer()
 {
     m_textEditingPlugins = canvas()->resourceManager()->
                            resource(TextEditingPluginContainer::ResourceId).value<TextEditingPluginContainer *>();
 
     if (m_textEditingPlugins == 0) {
         m_textEditingPlugins = new TextEditingPluginContainer(canvas()->resourceManager());
         QVariant variant;
         variant.setValue(m_textEditingPlugins.data());
         canvas()->resourceManager()->setResource(TextEditingPluginContainer::ResourceId, variant);
 
         foreach (KoTextEditingPlugin *plugin, m_textEditingPlugins->values()) {
             connect(plugin, SIGNAL(startMacro(QString)),
                     this, SLOT(startMacro(QString)));
             connect(plugin, SIGNAL(stopMacro()), this, SLOT(stopMacro()));
             QHash<QString, QAction *> actions = plugin->actions();
             QHash<QString, QAction *>::iterator i = actions.begin();
             while (i != actions.end()) {
                 addAction(i.key(), i.value());
                 ++i;
             }
         }
 
     }
     return m_textEditingPlugins;
 }
 
 void TextTool::copy() const
 {
     QMimeData *mimeData = generateMimeData();
     if (mimeData) {
         QApplication::clipboard()->setMimeData(mimeData);
     }
 }
 
 void TextTool::deleteSelection()
 {
     m_textEditor.data()->deleteChar();
     editingPluginEvents();
 }
 
 bool TextTool::paste()
 {
     const QMimeData *data = QApplication::clipboard()->mimeData(QClipboard::Clipboard);
 
     // on windows we do not have data if we try to paste the selection
     if (!data) {
         return false;
     }
 
     // since this is not paste-as-text we will not paste in urls, but instead let KoToolProxy solve it
     if (data->hasUrls()) {
         return false;
     }
 
     if (data->hasFormat(KoOdf::mimeType(KoOdf::Text))
             ||  data->hasText()) {
         m_prevCursorPosition = m_textEditor.data()->position();
         m_textEditor.data()->paste(canvas(), data);
         editingPluginEvents();
         return true;
     }
 
     return false;
 }
 
 void TextTool::cut()
 {
     if (m_textEditor.data()->hasSelection()) {
         copy();
         KUndo2Command *topCmd = m_textEditor.data()->beginEditBlock(kundo2_i18n("Cut"));
         m_textEditor.data()->deleteChar(false, topCmd);
         m_textEditor.data()->endEditBlock();
     }
 }
 
 void TextTool::dragMoveEvent(QDragMoveEvent *event, const QPointF &point)
 {
     if (event->mimeData()->hasFormat(KoOdf::mimeType(KoOdf::Text))
             || event->mimeData()->hasFormat(KoOdf::mimeType(KoOdf::OpenOfficeClipboard))
             || event->mimeData()->hasText()) {
         if (m_drag) {
             event->setDropAction(Qt::MoveAction);
             event->accept();
         } else if (event->proposedAction() == Qt::CopyAction) {
             event->acceptProposedAction();
         } else {
             event->ignore();
             return;
         }
         KoPointedAt pointedAt = hitTest(point);
 
         if (pointedAt.position == -1) {
             event->ignore();
         }
         if (m_caretTimer.isActive()) { // make the caret not blink, (blinks again after first draw)
             m_caretTimer.stop();
             m_caretTimer.setInterval(50);
             m_caretTimer.start();
             m_caretTimerState = true; // turn caret instantly on on click
         }
 
         if (m_preDragSelection.cursor.isNull()) {
             repaintSelection();
 
             m_preDragSelection.cursor = QTextCursor(*m_textEditor.data()->cursor());
 
             if (m_drag) {
                 // Make a selection that looks like the current cursor selection
                 // so we can move the real carent around freely
                 QVector< QAbstractTextDocumentLayout::Selection > sels = KoTextDocument(m_textShapeData->document()).selections();
 
                 m_preDragSelection.format = QTextCharFormat();
                 m_preDragSelection.format.setBackground(qApp->palette().brush(QPalette::Highlight));
                 m_preDragSelection.format.setForeground(qApp->palette().brush(QPalette::HighlightedText));
                 sels.append(m_preDragSelection);
                 KoTextDocument(m_textShapeData->document()).setSelections(sels);
             } // else we wantt the selection ot disappaear
         }
         repaintCaret(); // will erase caret
         m_textEditor.data()->setPosition(pointedAt.position);
         repaintCaret(); // will paint caret in new spot
 
         // Selection has visually not appeared at a new spot so no need to repaint it
     }
 }
 
 void TextTool::dragLeaveEvent(QDragLeaveEvent *event)
 {
     if (m_drag) {
         // restore the old selections
         QVector< QAbstractTextDocumentLayout::Selection > sels = KoTextDocument(m_textShapeData->document()).selections();
         sels.pop_back();
         KoTextDocument(m_textShapeData->document()).setSelections(sels);
     }
 
     repaintCaret(); // will erase caret in old spot
     m_textEditor.data()->setPosition(m_preDragSelection.cursor.anchor());
     m_textEditor.data()->setPosition(m_preDragSelection.cursor.position(), QTextCursor::KeepAnchor);
     repaintCaret(); // will paint caret in new spot
 
     if (!m_drag) {
         repaintSelection(); // will paint selection again
     }
 
     // mark that we now are back to normal selection
     m_preDragSelection.cursor = QTextCursor();
     event->accept();
 }
 
 void TextTool::dropEvent(QDropEvent *event, const QPointF &)
 {
     if (m_drag) {
         // restore the old selections
         QVector< QAbstractTextDocumentLayout::Selection > sels = KoTextDocument(m_textShapeData->document()).selections();
         sels.pop_back();
         KoTextDocument(m_textShapeData->document()).setSelections(sels);
     }
 
     QTextCursor insertCursor(*m_textEditor.data()->cursor());
 
     m_textEditor.data()->setPosition(m_preDragSelection.cursor.anchor());
     m_textEditor.data()->setPosition(m_preDragSelection.cursor.position(), QTextCursor::KeepAnchor);
     repaintSelection(); // will erase the selection in new spot
     if (m_drag) {
         m_textEditor.data()->deleteChar();
     }
     m_prevCursorPosition = insertCursor.position();
     m_textEditor.data()->setPosition(m_prevCursorPosition);
     m_textEditor.data()->paste(canvas(), event->mimeData());
     m_textEditor.data()->setPosition(m_prevCursorPosition);
     //since the paste made insertCursor we can now use that for the end position
     m_textEditor.data()->setPosition(insertCursor.position(), QTextCursor::KeepAnchor);
 
     // mark that we no are back to normal selection
     m_preDragSelection.cursor = QTextCursor();
     event->accept();
 }
 
 KoPointedAt TextTool::hitTest(const QPointF &point) const
 {
     if (!m_textShape || !m_textShapeData) {
         return KoPointedAt();
     }
     QPointF p = m_textShape->convertScreenPos(point);
     KoTextLayoutRootArea *rootArea = m_textShapeData->rootArea();
     return rootArea ? rootArea->hitTest(p, Qt::FuzzyHit) : KoPointedAt();
 }
 
 void TextTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     if (canvas()->shapeManager()->shapeAt(event->point) != m_textShape) {
         event->ignore(); // allow the event to be used by another
         return;
     }
 
     if (event->modifiers() & Qt::ShiftModifier) {
         // When whift is pressed we behave as a single press
         return mousePressEvent(event);
     }
 
     m_textEditor.data()->select(QTextCursor::WordUnderCursor);
 
     m_clickWithinSelection = false;
 
     repaintSelection();
     updateSelectionHandler();
 }
 
 void TextTool::mouseTripleClickEvent(KoPointerEvent *event)
 {
     if (canvas()->shapeManager()->shapeAt(event->point) != m_textShape) {
         event->ignore(); // allow the event to be used by another
         return;
     }
 
     if (event->modifiers() & Qt::ShiftModifier) {
         // When whift is pressed we behave as a single press
         return mousePressEvent(event);
     }
 
     m_textEditor.data()->clearSelection();
     m_textEditor.data()->movePosition(QTextCursor::StartOfBlock);
     m_textEditor.data()->movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
 
     m_clickWithinSelection = false;
 
     repaintSelection();
     updateSelectionHandler();
 }
 
 void TextTool::mouseMoveEvent(KoPointerEvent *event)
 {
     m_editTipPos = event->globalPos();
 
     if (event->buttons()) {
         updateSelectedShape(event->point, true);
     }
 
     m_editTipTimer.stop();
 
     if (QToolTip::isVisible()) {
         QToolTip::hideText();
     }
 
     KoPointedAt pointedAt = hitTest(event->point);
 
     if (event->buttons() == Qt::NoButton) {
         if (m_tablePenMode) {
             if (pointedAt.tableHit == KoPointedAt::ColumnDivider || pointedAt.tableHit == KoPointedAt::RowDivider) {
                 useTableBorderCursor();
             } else {
                 useCursor(Qt::IBeamCursor);
             }
             // do nothing else
             return;
         }
 
         if (!m_textShapeData || pointedAt.position < 0) {
             if (pointedAt.tableHit == KoPointedAt::ColumnDivider) {
                 useCursor(Qt::SplitHCursor);
                 m_draggingOrigin = event->point;
             } else if (pointedAt.tableHit == KoPointedAt::RowDivider) {
                 if (pointedAt.tableRowDivider > 0) {
                     useCursor(Qt::SplitVCursor);
                     m_draggingOrigin = event->point;
                 } else {
                     useCursor(Qt::IBeamCursor);
                 }
             } else {
                 useCursor(Qt::IBeamCursor);
             }
             return;
         }
 
         QTextCursor mouseOver(m_textShapeData->document());
         mouseOver.setPosition(pointedAt.position);
 
         if (m_changeTracker && m_changeTracker->containsInlineChanges(mouseOver.charFormat())) {
             m_editTipPointedAt = pointedAt;
             if (QToolTip::isVisible()) {
                 QTimer::singleShot(0, this, SLOT(showEditTip()));
             } else {
                 m_editTipTimer.start();
             }
         }
 
         if ((pointedAt.bookmark || !pointedAt.externalHRef.isEmpty()) || pointedAt.note || (pointedAt.noteReference > 0)) {
             if (event->modifiers() & Qt::ControlModifier) {
                 useCursor(Qt::PointingHandCursor);
             }
             m_editTipPointedAt = pointedAt;
             if (QToolTip::isVisible()) {
                 QTimer::singleShot(0, this, SLOT(showEditTip()));
             } else {
                 m_editTipTimer.start();
             }
             return;
         }
 
         // check if mouse pointer is over shape with hyperlink
         KoShape *selectedShape = canvas()->shapeManager()->shapeAt(event->point);
         if (selectedShape != 0 && selectedShape != m_textShape && selectedShape->hyperLink().size() != 0) {
             useCursor(Qt::PointingHandCursor);
             return;
         }
 
         useCursor(Qt::IBeamCursor);
 
         // Set Arrow Cursor when mouse is on top of annotation shape.
         if (selectedShape) {
             if (selectedShape->shapeId() == "AnnotationTextShapeID") {
                 QPointF point(event->point);
                 if (point.y() <= (selectedShape->position().y() + 25)) {
                     useCursor(Qt::ArrowCursor);
                 }
             }
         }
 
         return;
     } else {
         if (m_tableDragInfo.tableHit == KoPointedAt::ColumnDivider) {
             m_tableDragWithShift = event->modifiers() & Qt::ShiftModifier;
             if (m_tableDraggedOnce) {
                 canvas()->shapeController()->resourceManager()->undoStack()->undo();
             }
             KUndo2Command *topCmd = m_textEditor.data()->beginEditBlock(kundo2_i18n("Adjust Column Width"));
             m_dx = m_draggingOrigin.x() - event->point.x();
             if (m_tableDragInfo.tableColumnDivider < m_tableDragInfo.table->columns()
                     && m_tableDragInfo.tableTrailSize + m_dx < 0) {
                 m_dx = -m_tableDragInfo.tableTrailSize;
             }
             if (m_tableDragInfo.tableColumnDivider > 0) {
                 if (m_tableDragInfo.tableLeadSize - m_dx < 0) {
                     m_dx = m_tableDragInfo.tableLeadSize;
                 }
                 m_textEditor.data()->adjustTableColumnWidth(m_tableDragInfo.table,
                         m_tableDragInfo.tableColumnDivider - 1,
                         m_tableDragInfo.tableLeadSize - m_dx, topCmd);
             } else {
                 m_textEditor.data()->adjustTableWidth(m_tableDragInfo.table, -m_dx, 0.0);
             }
             if (m_tableDragInfo.tableColumnDivider < m_tableDragInfo.table->columns()) {
                 if (!m_tableDragWithShift) {
                     m_textEditor.data()->adjustTableColumnWidth(m_tableDragInfo.table,
                             m_tableDragInfo.tableColumnDivider,
                             m_tableDragInfo.tableTrailSize + m_dx, topCmd);
                 }
             } else {
                 m_tableDragWithShift = true; // act like shift pressed
             }
             if (m_tableDragWithShift) {
                 m_textEditor.data()->adjustTableWidth(m_tableDragInfo.table, 0.0, m_dx);
             }
             m_textEditor.data()->endEditBlock();
             m_tableDragInfo.tableDividerPos.setY(m_textShape->convertScreenPos(event->point).y());
             if (m_tableDraggedOnce) {
                 //we need to redraw like this so we update outside the textshape too
                 if (canvas()->canvasWidget()) {
                     canvas()->canvasWidget()->update();
                 }
             }
             m_tableDraggedOnce = true;
         } else if (m_tableDragInfo.tableHit == KoPointedAt::RowDivider) {
             if (m_tableDraggedOnce) {
                 canvas()->shapeController()->resourceManager()->undoStack()->undo();
             }
             if (m_tableDragInfo.tableRowDivider > 0) {
                 KUndo2Command *topCmd = m_textEditor.data()->beginEditBlock(kundo2_i18n("Adjust Row Height"));
                 m_dy = m_draggingOrigin.y() - event->point.y();
 
                 if (m_tableDragInfo.tableLeadSize - m_dy < 0) {
                     m_dy = m_tableDragInfo.tableLeadSize;
                 }
 
                 m_textEditor.data()->adjustTableRowHeight(m_tableDragInfo.table,
                         m_tableDragInfo.tableRowDivider - 1,
                         m_tableDragInfo.tableLeadSize - m_dy, topCmd);
 
                 m_textEditor.data()->endEditBlock();
 
                 m_tableDragInfo.tableDividerPos.setX(m_textShape->convertScreenPos(event->point).x());
                 if (m_tableDraggedOnce) {
                     //we need to redraw like this so we update outside the textshape too
                     if (canvas()->canvasWidget()) {
                         canvas()->canvasWidget()->update();
                     }
                 }
                 m_tableDraggedOnce = true;
             }
 
         } else if (m_tablePenMode) {
             // do nothing
         } else if (m_clickWithinSelection) {
             if (!m_drag && (event->pos() - m_draggingOrigin).manhattanLength()
                     >= QApplication::startDragDistance()) {
                 QMimeData *mimeData = generateMimeData();
                 if (mimeData) {
                     m_drag = new QDrag(canvas()->canvasWidget());
                     m_drag->setMimeData(mimeData);
 
                     m_drag->exec(Qt::MoveAction | Qt::CopyAction, Qt::CopyAction);
 
                     m_drag = 0;
                 }
             }
         } else {
             useCursor(Qt::IBeamCursor);
             if (pointedAt.position == m_textEditor.data()->position()) {
                 return;
             }
             if (pointedAt.position >= 0) {
                 if (m_textEditor.data()->hasSelection()) {
                     repaintSelection();    // will erase selection
                 } else {
                     repaintCaret();
                 }
 
                 m_textEditor.data()->setPosition(pointedAt.position, QTextCursor::KeepAnchor);
 
                 if (m_textEditor.data()->hasSelection()) {
                     repaintSelection();
                 } else {
                     repaintCaret();
                 }
             }
         }
 
         updateSelectionHandler();
     }
 }
 
 void TextTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     event->ignore();
     editingPluginEvents();
 
     m_tableDragInfo.tableHit = KoPointedAt::None;
     if (m_tableDraggedOnce) {
         m_tableDraggedOnce = false;
         //we need to redraw like this so we update outside the textshape too
         if (canvas()->canvasWidget()) {
             canvas()->canvasWidget()->update();
         }
     }
 
     if (!m_textShapeData) {
         return;
     }
 
     // check if mouse pointer is not over some shape with hyperlink
     KoShape *selectedShape = canvas()->shapeManager()->shapeAt(event->point);
     if (selectedShape != 0 && selectedShape != m_textShape && selectedShape->hyperLink().size() != 0) {
         QString url = selectedShape->hyperLink();
         runUrl(event, url);
         return;
     }
 
     KoPointedAt pointedAt = hitTest(event->point);
 
     if (m_clickWithinSelection && !m_drag) {
         if (m_caretTimer.isActive()) { // make the caret not blink, (blinks again after first draw)
             m_caretTimer.stop();
             m_caretTimer.setInterval(50);
             m_caretTimer.start();
             m_caretTimerState = true; // turn caret instantly on on click
         }
         repaintCaret(); // will erase caret
         repaintSelection(); // will erase selection
         m_textEditor.data()->setPosition(pointedAt.position);
         repaintCaret(); // will paint caret in new spot
     }
 
     // Is there an anchor here ?
     if ((event->modifiers() & Qt::ControlModifier) && !m_textEditor.data()->hasSelection()) {
         if (pointedAt.bookmark) {
             m_textEditor.data()->setPosition(pointedAt.bookmark->rangeStart());
             ensureCursorVisible();
             event->accept();
             return;
         }
         if (pointedAt.note) {
             m_textEditor.data()->setPosition(pointedAt.note->textFrame()->firstPosition());
             ensureCursorVisible();
             event->accept();
             return;
         }
         if (pointedAt.noteReference > 0) {
             m_textEditor.data()->setPosition(pointedAt.noteReference);
             ensureCursorVisible();
             event->accept();
             return;
         }
         if (!pointedAt.externalHRef.isEmpty()) {
             runUrl(event, pointedAt.externalHRef);
         }
     }
 }
 
 void TextTool::keyPressEvent(QKeyEvent *event)
 {
     int destinationPosition = -1; // for those cases where the moveOperation is not relevant;
     QTextCursor::MoveOperation moveOperation = QTextCursor::NoMove;
     KoTextEditor *textEditor = m_textEditor.data();
     m_tablePenMode = false; // keypress always stops the table (border) pen mode
     Q_ASSERT(textEditor);
     if (event->key() == Qt::Key_Backspace) {
         if (!textEditor->hasSelection() && textEditor->block().textList()
                 && (textEditor->position() == textEditor->block().position())
                 && !(m_changeTracker && m_changeTracker->recordChanges())) {
             if (!textEditor->blockFormat().boolProperty(KoParagraphStyle::UnnumberedListItem)) {
                 // backspace at beginning of numbered list item, makes it unnumbered
                 textEditor->toggleListNumbering(false);
             } else {
                 KoListLevelProperties llp;
                 llp.setStyle(KoListStyle::None);
                 llp.setLevel(0);
                 // backspace on numbered, empty parag, removes numbering.
                 textEditor->setListProperties(llp);
             }
         } else if (textEditor->position() > 0 || textEditor->hasSelection()) {
             if (!textEditor->hasSelection() && event->modifiers() & Qt::ControlModifier) { // delete prev word.
                 textEditor->movePosition(QTextCursor::PreviousWord, QTextCursor::KeepAnchor);
             }
             textEditor->deletePreviousChar();
 
             editingPluginEvents();
         }
     } else if ((event->key() == Qt::Key_Tab)
                && ((!textEditor->hasSelection() && (textEditor->position() == textEditor->block().position())) || (textEditor->block().document()->findBlock(textEditor->anchor()) != textEditor->block().document()->findBlock(textEditor->position()))) && textEditor->block().textList()) {
         ChangeListLevelCommand::CommandType type = ChangeListLevelCommand::IncreaseLevel;
         ChangeListLevelCommand *cll = new ChangeListLevelCommand(*textEditor->cursor(), type, 1);
         textEditor->addCommand(cll);
         editingPluginEvents();
     } else if ((event->key() == Qt::Key_Backtab)
                && ((!textEditor->hasSelection() && (textEditor->position() == textEditor->block().position())) || (textEditor->block().document()->findBlock(textEditor->anchor()) != textEditor->block().document()->findBlock(textEditor->position()))) && textEditor->block().textList() && !(m_changeTracker && m_changeTracker->recordChanges())) {
         ChangeListLevelCommand::CommandType type = ChangeListLevelCommand::DecreaseLevel;
         ChangeListLevelCommand *cll = new ChangeListLevelCommand(*textEditor->cursor(), type, 1);
         textEditor->addCommand(cll);
         editingPluginEvents();
     } else if (event->key() == Qt::Key_Delete) {
         if (!textEditor->hasSelection() && event->modifiers() & Qt::ControlModifier) {// delete next word.
             textEditor->movePosition(QTextCursor::NextWord, QTextCursor::KeepAnchor);
         }
         // the event only gets through when the Del is not used in the app
         // if the app forwards Del then deleteSelection is used
         textEditor->deleteChar();
         editingPluginEvents();
     } else if ((event->key() == Qt::Key_Left) && (event->modifiers() & Qt::ControlModifier) == 0) {
         moveOperation = QTextCursor::Left;
     } else if ((event->key() == Qt::Key_Right) && (event->modifiers() & Qt::ControlModifier) == 0) {
         moveOperation = QTextCursor::Right;
     } else if ((event->key() == Qt::Key_Up) && (event->modifiers() & Qt::ControlModifier) == 0) {
         moveOperation = QTextCursor::Up;
     } else if ((event->key() == Qt::Key_Down) && (event->modifiers() & Qt::ControlModifier) == 0) {
         moveOperation = QTextCursor::Down;
     } else {
         // check for shortcuts.
         QKeySequence item(event->key() | ((Qt::ControlModifier | Qt::AltModifier) & event->modifiers()));
         if (hit(item, KStandardShortcut::Begin))
             // Goto beginning of the document. Default: Ctrl-Home
         {
             destinationPosition = 0;
         } else if (hit(item, KStandardShortcut::End)) {
             // Goto end of the document. Default: Ctrl-End
             if (m_textShapeData) {
                 QTextBlock last = m_textShapeData->document()->lastBlock();
                 destinationPosition = last.position() + last.length() - 1;
             }
         } else if (hit(item, KStandardShortcut::Prior)) { // page up
             // Scroll up one page. Default: Prior
             event->ignore(); // let app level actions handle it
             return;
         } else if (hit(item, KStandardShortcut::Next)) {
             // Scroll down one page. Default: Next
             event->ignore(); // let app level actions handle it
             return;
         } else if (hit(item, KStandardShortcut::BeginningOfLine))
             // Goto beginning of current line. Default: Home
         {
             moveOperation = QTextCursor::StartOfLine;
         } else if (hit(item, KStandardShortcut::EndOfLine))
             // Goto end of current line. Default: End
         {
             moveOperation = QTextCursor::EndOfLine;
         } else if (hit(item, KStandardShortcut::BackwardWord)) {
             moveOperation = QTextCursor::WordLeft;
         } else if (hit(item, KStandardShortcut::ForwardWord)) {
             moveOperation = QTextCursor::WordRight;
         }
 #ifdef Q_OS_OSX
         // Don't reject "alt" key, it may be used for typing text on Mac OS
         else if ((event->modifiers() & Qt::ControlModifier) || event->text().length() == 0) {
 #else
         else if ((event->modifiers() & (Qt::ControlModifier | Qt::AltModifier)) || event->text().length() == 0) {
 #endif
             event->ignore();
             return;
         } else if ((event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return)) {
             m_prevCursorPosition = textEditor->position();
             textEditor->newLine();
             updateActions();
             editingPluginEvents();
         } else if ((event->key() == Qt::Key_Tab || !(event->text().length() == 1 && !event->text().at(0).isPrint()))) { // insert the text
             m_prevCursorPosition = textEditor->position();
             startingSimpleEdit(); //signal editing plugins that this is a simple edit
             textEditor->insertText(event->text());
             editingPluginEvents();
         }
     }
     if (moveOperation != QTextCursor::NoMove || destinationPosition != -1) {
         useCursor(Qt::BlankCursor);
         bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
         if (textEditor->hasSelection()) {
             repaintSelection();    // will erase selection
         } else {
             repaintCaret();
         }
         QTextBlockFormat format = textEditor->blockFormat();
 
         KoText::Direction dir = static_cast<KoText::Direction>(format.intProperty(KoParagraphStyle::TextProgressionDirection));
         bool isRtl;
         if (dir == KoText::AutoDirection) {
             isRtl = textEditor->block().text().isRightToLeft();
         } else {
             isRtl =  dir == KoText::RightLeftTopBottom;
         }
 
         if (isRtl) { // if RTL toggle direction of cursor movement.
             switch (moveOperation) {
             case QTextCursor::Left: moveOperation = QTextCursor::Right; break;
             case QTextCursor::Right: moveOperation = QTextCursor::Left; break;
             case QTextCursor::WordRight: moveOperation = QTextCursor::WordLeft; break;
             case QTextCursor::WordLeft: moveOperation = QTextCursor::WordRight; break;
             default: break;
             }
         }
         int prevPosition = textEditor->position();
         if (moveOperation != QTextCursor::NoMove)
             textEditor->movePosition(moveOperation,
                                      shiftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor);
         else
             textEditor->setPosition(destinationPosition,
                                     shiftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor);
         if (moveOperation == QTextCursor::Down && prevPosition == textEditor->position()) {
             // change behavior a little big from Qt; at the bottom of the doc we go to the end of the doc
             textEditor->movePosition(QTextCursor::End,
                                      shiftPressed ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor);
         }
         if (shiftPressed) { // altered selection.
             repaintSelection();
         } else {
             repaintCaret();
         }
         updateActions();
         editingPluginEvents();
     }
     if (m_caretTimer.isActive()) { // make the caret not blink but decide on the action if its visible or not.
         m_caretTimer.stop();
         m_caretTimer.setInterval(50);
         m_caretTimer.start();
         m_caretTimerState = true; // turn caret on while typing
     }
     if (moveOperation != QTextCursor::NoMove)
         // this difference in handling is need to prevent leaving a trail of old cursors onscreen
     {
         ensureCursorVisible();
     } else {
         m_delayedEnsureVisible = true;
     }
     updateActions();
     updateSelectionHandler();
 }
 
 QVariant TextTool::inputMethodQuery(Qt::InputMethodQuery query, const KoViewConverter &converter) const
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor || !m_textShapeData) {
         return QVariant();
     }
 
     switch (query) {
     case Qt::ImMicroFocus: {
         // The rectangle covering the area of the input cursor in widget coordinates.
         QRectF rect = caretRect(textEditor->cursor());
         rect.moveTop(rect.top() - m_textShapeData->documentOffset());
         QTransform shapeMatrix = m_textShape->absoluteTransformation(&converter);
         qreal zoomX, zoomY;
         converter.zoom(&zoomX, &zoomY);
         shapeMatrix.scale(zoomX, zoomY);
         rect = shapeMatrix.mapRect(rect);
         return rect.toRect();
     }
     case Qt::ImFont:
         // The currently used font for text input.
         return textEditor->charFormat().font();
     case Qt::ImCursorPosition:
         // The logical position of the cursor within the text surrounding the input area (see ImSurroundingText).
         return textEditor->position() - textEditor->block().position();
     case Qt::ImSurroundingText:
         // The plain text around the input area, for example the current paragraph.
         return textEditor->block().text();
     case Qt::ImCurrentSelection:
         // The currently selected text.
         return textEditor->selectedText();
     default:
         ; // Qt 4.6 adds ImMaximumTextLength and ImAnchorPosition
     }
     return QVariant();
 }
 
 void TextTool::inputMethodEvent(QInputMethodEvent *event)
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (textEditor == 0) {
         return;
     }
     if (event->replacementLength() > 0) {
         textEditor->setPosition(textEditor->position() + event->replacementStart());
         for (int i = event->replacementLength(); i > 0; --i) {
             textEditor->deleteChar();
         }
     }
     if (!event->commitString().isEmpty()) {
         QKeyEvent ke(QEvent::KeyPress, -1, 0, event->commitString());
         keyPressEvent(&ke);
         // The cursor may reside in a different block before vs. after keyPressEvent.
         QTextBlock block = textEditor->block();
         QTextLayout *layout = block.layout();
         Q_ASSERT(layout);
         layout->setPreeditArea(-1, QString());
     } else {
         QTextBlock block = textEditor->block();
         QTextLayout *layout = block.layout();
         Q_ASSERT(layout);
         layout->setPreeditArea(textEditor->position() - block.position(), event->preeditString());
         const_cast<QTextDocument *>(textEditor->document())->markContentsDirty(textEditor->position(), event->preeditString().length());
     }
     event->accept();
 }
 
 void TextTool::ensureCursorVisible(bool moveView)
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor || !m_textShapeData) {
         return;
     }
 
     bool upToDate;
     QRectF cRect = caretRect(textEditor->cursor(), &upToDate);
 
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(m_textShapeData->document()->documentLayout());
     Q_ASSERT(lay);
     KoTextLayoutRootArea *rootArea = lay->rootAreaForPoint(cRect.center());
     if (rootArea && rootArea->associatedShape() && m_textShapeData->rootArea() != rootArea) {
         // If we have changed root area we need to update m_textShape and m_textShapeData
         m_textShape = static_cast<TextShape *>(rootArea->associatedShape());
         Q_ASSERT(m_textShape);
         disconnect(m_textShapeData, SIGNAL(destroyed(QObject*)), this, SLOT(shapeDataRemoved()));
         m_textShapeData = static_cast<KoTextShapeData *>(m_textShape->userData());
         Q_ASSERT(m_textShapeData);
         connect(m_textShapeData, SIGNAL(destroyed(QObject*)), this, SLOT(shapeDataRemoved()));
     }
 
     if (!moveView) {
         return;
     }
 
     if (!upToDate) { // paragraph is not yet layouted.
         // The number one usecase for this is when the user pressed enter.
         // try to do it on next caret blink
         m_delayedEnsureVisible = true;
         return; // we shouldn't move to an obsolete position
     }
     cRect.moveTop(cRect.top() - m_textShapeData->documentOffset());
     canvas()->ensureVisible(m_textShape->absoluteTransformation(0).mapRect(cRect));
 }
 
 void TextTool::keyReleaseEvent(QKeyEvent *event)
 {
     event->accept();
 }
 
 void TextTool::updateActions()
 {
     bool notInAnnotation = true; // no annotation shape anymore!
     KoTextEditor *textEditor = m_textEditor.data();
     if (textEditor == 0) {
         return;
     }
     m_allowActions = false;
 
     //Update the characterStyle related GUI elements
     QTextCharFormat cf = textEditor->charFormat();
     m_actionFormatBold->setChecked(cf.fontWeight() > QFont::Normal);
     m_actionFormatItalic->setChecked(cf.fontItalic());
     m_actionFormatUnderline->setChecked(cf.intProperty(KoCharacterStyle::UnderlineType) != KoCharacterStyle::NoLineType);
     m_actionFormatStrikeOut->setChecked(cf.intProperty(KoCharacterStyle::StrikeOutType) != KoCharacterStyle::NoLineType);
     bool super = false, sub = false;
     switch (cf.verticalAlignment()) {
     case QTextCharFormat::AlignSuperScript:
         super = true;
         break;
     case QTextCharFormat::AlignSubScript:
         sub = true;
         break;
     default:;
     }
     m_actionFormatSuper->setChecked(super);
     m_actionFormatSub->setChecked(sub);
     m_actionFormatFontSize->setFontSize(cf.font().pointSizeF());
     m_actionFormatFontFamily->setFont(cf.font().family());
 
     KoTextShapeData::ResizeMethod resizemethod = KoTextShapeData::AutoResize;
     if (m_textShapeData) {
         resizemethod = m_textShapeData->resizeMethod();
     }
     m_shrinkToFitAction->setEnabled(resizemethod != KoTextShapeData::AutoResize && notInAnnotation);
     m_shrinkToFitAction->setChecked(resizemethod == KoTextShapeData::ShrinkToFitResize);
 
     m_growWidthAction->setEnabled(resizemethod != KoTextShapeData::AutoResize && notInAnnotation);
     m_growWidthAction->setChecked(resizemethod == KoTextShapeData::AutoGrowWidth || resizemethod == KoTextShapeData::AutoGrowWidthAndHeight);
 
     m_growHeightAction->setEnabled(resizemethod != KoTextShapeData::AutoResize && notInAnnotation);
     m_growHeightAction->setChecked(resizemethod == KoTextShapeData::AutoGrowHeight || resizemethod == KoTextShapeData::AutoGrowWidthAndHeight);
 
     //update paragraphStyle GUI element
     QTextBlockFormat bf = textEditor->blockFormat();
 
     if (bf.hasProperty(KoParagraphStyle::TextProgressionDirection)) {
         switch (bf.intProperty(KoParagraphStyle::TextProgressionDirection)) {
         case KoText::RightLeftTopBottom:
             m_actionChangeDirection->setChecked(true);
             break;
         case KoText::LeftRightTopBottom:
         default:
             m_actionChangeDirection->setChecked(false);
             break;
         }
     } else {
         m_actionChangeDirection->setChecked(textEditor->block().text().isRightToLeft());
     }
     if (bf.alignment() == Qt::AlignLeading || bf.alignment() == Qt::AlignTrailing) {
         bool revert = (textEditor->block().layout()->textOption().textDirection() == Qt::RightToLeft);
         if ((bf.alignment() == Qt::AlignLeading) ^ revert) {
             m_actionAlignLeft->setChecked(true);
         } else {
             m_actionAlignRight->setChecked(true);
         }
     } else if (bf.alignment() == Qt::AlignHCenter) {
         m_actionAlignCenter->setChecked(true);
     }
     if (bf.alignment() == Qt::AlignJustify) {
         m_actionAlignBlock->setChecked(true);
     } else if (bf.alignment() == (Qt::AlignLeft | Qt::AlignAbsolute)) {
         m_actionAlignLeft->setChecked(true);
     } else if (bf.alignment() == (Qt::AlignRight | Qt::AlignAbsolute)) {
         m_actionAlignRight->setChecked(true);
     }
 
     if (textEditor->block().textList()) {
         QTextListFormat listFormat = textEditor->block().textList()->format();
         if (listFormat.intProperty(KoListStyle::Level) > 1) {
             m_actionFormatDecreaseIndent->setEnabled(true);
         } else {
             m_actionFormatDecreaseIndent->setEnabled(false);
         }
 
         if (listFormat.intProperty(KoListStyle::Level) < 10) {
             m_actionFormatIncreaseIndent->setEnabled(true);
         } else {
             m_actionFormatIncreaseIndent->setEnabled(false);
         }
     } else {
         m_actionFormatDecreaseIndent->setEnabled(textEditor->blockFormat().leftMargin() > 0.);
     }
 
     m_allowActions = true;
 
-    bool useAdvancedText = !(canvas()->resourceManager()->intResource(KoCanvasResourceManager::ApplicationSpeciality)
-                             & KoCanvasResourceManager::NoAdvancedText);
+    bool useAdvancedText = !(canvas()->resourceManager()->intResource(KoCanvasResourceProvider::ApplicationSpeciality)
+                             & KoCanvasResourceProvider::NoAdvancedText);
     if (useAdvancedText) {
         action("insert_table")->setEnabled(notInAnnotation);
 
         bool hasTable = textEditor->currentTable();
         action("insert_tablerow_above")->setEnabled(hasTable && notInAnnotation);
         action("insert_tablerow_below")->setEnabled(hasTable && notInAnnotation);
         action("insert_tablecolumn_left")->setEnabled(hasTable && notInAnnotation);
         action("insert_tablecolumn_right")->setEnabled(hasTable && notInAnnotation);
         action("delete_tablerow")->setEnabled(hasTable && notInAnnotation);
         action("delete_tablecolumn")->setEnabled(hasTable && notInAnnotation);
         action("merge_tablecells")->setEnabled(hasTable && notInAnnotation);
         action("split_tablecells")->setEnabled(hasTable && notInAnnotation);
         action("activate_borderpainter")->setEnabled(hasTable && notInAnnotation);
     }
     action("insert_annotation")->setEnabled(notInAnnotation);
 
     ///TODO if selection contains several different format
     emit blockChanged(textEditor->block());
     emit charFormatChanged(cf, textEditor->blockCharFormat());
     emit blockFormatChanged(bf);
 }
 
 QMenu *TextTool::popupActionsMenu()
 {
     return m_contextMenu.data();
 }
 
 void TextTool::updateStyleManager()
 {
     if (!m_textShapeData) {
         return;
     }
     KoStyleManager *styleManager = KoTextDocument(m_textShapeData->document()).styleManager();
     emit styleManagerChanged(styleManager);
 
     //TODO move this to its own method
     m_changeTracker = KoTextDocument(m_textShapeData->document()).changeTracker();
 }
 
 void TextTool::activate(ToolActivation activation, const QSet<KoShape *> &shapes)
 {
     KoToolBase::activate(activation, shapes);
 
     m_caretTimer.start();
     m_caretTimerState = true;
     foreach (KoShape *shape, shapes) {
         m_textShape = dynamic_cast<TextShape *>(shape);
         if (m_textShape) {
             break;
         }
     }
     if (!m_textShape) { // none found
         emit done();
         // This is how we inform the rulers of the active range
         // No shape means no active range
-        canvas()->resourceManager()->setResource(KoCanvasResourceManager::ActiveRange, QVariant(QRectF()));
+        canvas()->resourceManager()->setResource(KoCanvasResourceProvider::ActiveRange, QVariant(QRectF()));
         return;
     }
 
     // This is how we inform the rulers of the active range
     // For now we will not consider table cells, but just give the shape dimensions
     QVariant v;
     QRectF rect(QPoint(), m_textShape->size());
     rect = m_textShape->absoluteTransformation(0).mapRect(rect);
     v.setValue(rect);
-    canvas()->resourceManager()->setResource(KoCanvasResourceManager::ActiveRange, v);
+    canvas()->resourceManager()->setResource(KoCanvasResourceProvider::ActiveRange, v);
     if ((!m_oldTextEditor.isNull()) && m_oldTextEditor.data()->document() != static_cast<KoTextShapeData *>(m_textShape->userData())->document()) {
         m_oldTextEditor.data()->setPosition(m_oldTextEditor.data()->position());
         //we need to redraw like this so we update the old textshape wherever it may be
         if (canvas()->canvasWidget()) {
             canvas()->canvasWidget()->update();
         }
     }
     setShapeData(static_cast<KoTextShapeData *>(m_textShape->userData()));
     useCursor(Qt::IBeamCursor);
 
     updateStyleManager();
     repaintSelection();
     updateSelectionHandler();
     updateActions();
     if (m_specialCharacterDocker) {
         m_specialCharacterDocker->setEnabled(true);
     }
 }
 
 void TextTool::deactivate()
 {
     m_caretTimer.stop();
     m_caretTimerState = false;
     repaintCaret();
     m_textShape = 0;
 
     // This is how we inform the rulers of the active range
     // No shape means no active range
-    canvas()->resourceManager()->setResource(KoCanvasResourceManager::ActiveRange, QVariant(QRectF()));
+    canvas()->resourceManager()->setResource(KoCanvasResourceProvider::ActiveRange, QVariant(QRectF()));
 
     m_oldTextEditor = m_textEditor;
     setShapeData(0);
 
     updateSelectionHandler();
     if (m_specialCharacterDocker) {
         m_specialCharacterDocker->setEnabled(false);
         m_specialCharacterDocker->setVisible(false);
     }
 
     KoToolBase::deactivate();
 }
 
 void TextTool::repaintDecorations()
 {
     if (m_textShapeData) {
         repaintSelection();
     }
 }
 
 void TextTool::repaintCaret()
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor || !m_textShapeData) {
         return;
     }
 
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(m_textShapeData->document()->documentLayout());
     Q_ASSERT(lay); Q_UNUSED(lay);
 
     // If we have changed root area we need to update m_textShape and m_textShapeData
     if (m_delayedEnsureVisible) {
         m_delayedEnsureVisible = false;
         ensureCursorVisible();
         return;
     }
 
     ensureCursorVisible(false); // ensures the various vars are updated
 
     bool upToDate;
     QRectF repaintRect = caretRect(textEditor->cursor(), &upToDate);
     repaintRect.moveTop(repaintRect.top() - m_textShapeData->documentOffset());
     if (repaintRect.isValid()) {
         repaintRect = m_textShape->absoluteTransformation(0).mapRect(repaintRect);
 
         // Make sure there is enough space to show an icon
         QRectF iconSize = canvas()->viewConverter()->viewToDocument(QRect(0, 0, 18, 18));
         repaintRect.setX(repaintRect.x() - iconSize.width() / 2);
         repaintRect.setRight(repaintRect.right() + iconSize.width() / 2);
         repaintRect.setTop(repaintRect.y() - iconSize.height() / 2);
         repaintRect.setBottom(repaintRect.bottom() + iconSize.height() / 2);
         canvas()->updateCanvas(repaintRect);
     }
 }
 
 void TextTool::repaintSelection()
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (textEditor == 0) {
         return;
     }
     QTextCursor cursor = *textEditor->cursor();
 
     QList<TextShape *> shapes;
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(textEditor->document()->documentLayout());
     Q_ASSERT(lay);
     foreach (KoShape *shape, lay->shapes()) {
         TextShape *textShape = dynamic_cast<TextShape *>(shape);
         if (textShape == 0) { // when the shape is being deleted its no longer a TextShape but a KoShape
             continue;
         }
 
         //Q_ASSERT(!shapes.contains(textShape));
         if (!shapes.contains(textShape)) {
             shapes.append(textShape);
         }
     }
 
     // loop over all shapes that contain the text and update per shape.
     QRectF repaintRect = textRect(cursor);
     foreach (TextShape *ts, shapes) {
         QRectF rect = repaintRect;
         rect.moveTop(rect.y() - ts->textShapeData()->documentOffset());
         rect = ts->absoluteTransformation(0).mapRect(rect);
         QRectF r = ts->boundingRect().intersected(rect);
         canvas()->updateCanvas(r);
     }
 }
 
 QRectF TextTool::caretRect(QTextCursor *cursor, bool *upToDate) const
 {
     QTextCursor tmpCursor(*cursor);
     tmpCursor.setPosition(cursor->position()); // looses the anchor
 
     QRectF rect = textRect(tmpCursor);
     if (rect.size() == QSizeF(0, 0)) {
         if (upToDate) {
             *upToDate = false;
         }
         rect = m_lastImMicroFocus; // prevent block changed but layout not done
     } else {
         if (upToDate) {
             *upToDate = true;
         }
         m_lastImMicroFocus = rect;
     }
     return rect;
 }
 
 QRectF TextTool::textRect(QTextCursor &cursor) const
 {
     if (!m_textShapeData) {
         return QRectF();
     }
     KoTextEditor *textEditor = m_textEditor.data();
     KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(textEditor->document()->documentLayout());
     return lay->selectionBoundingBox(cursor);
 }
 
 KoToolSelection *TextTool::selection()
 {
     return m_toolSelection;
 }
 
 QList<QPointer<QWidget> > TextTool::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgets;
     SimpleCharacterWidget *scw = new SimpleCharacterWidget(this, 0);
     SimpleParagraphWidget *spw = new SimpleParagraphWidget(this, 0);
     if (m_textEditor.data()) {
 //        connect(m_textEditor.data(), SIGNAL(paragraphStyleApplied(KoParagraphStyle*)), spw, SLOT(slotParagraphStyleApplied(KoParagraphStyle*)));
 //        connect(m_textEditor.data(), SIGNAL(characterStyleApplied(KoCharacterStyle*)), scw, SLOT(slotCharacterStyleApplied(KoCharacterStyle*)));
         //initialise the char- and par- widgets with the current block and formats.
         scw->setCurrentBlockFormat(m_textEditor.data()->blockFormat());
         scw->setCurrentFormat(m_textEditor.data()->charFormat(), m_textEditor.data()-> blockCharFormat());
         spw->setCurrentBlock(m_textEditor.data()->block());
         spw->setCurrentFormat(m_textEditor.data()->blockFormat());
     }
     SimpleTableWidget *stw = new SimpleTableWidget(this, 0);
     SimpleInsertWidget *siw = new SimpleInsertWidget(this, 0);
 
     /* We do not use these for now. Let's see if they become useful at a certain point in time. If not, we can remove the whole chain (SimpleCharWidget, SimpleParWidget, DockerStyleComboModel)
         if (m_textShapeData && KoTextDocument(m_textShapeData->document()).styleManager()) {
             scw->setInitialUsedStyles(KoTextDocument(m_textShapeData->document()).styleManager()->usedCharacterStyles());
             spw->setInitialUsedStyles(KoTextDocument(m_textShapeData->document()).styleManager()->usedParagraphStyles());
         }
     */
     // Connect to/with simple character widget (docker)
     connect(this, SIGNAL(styleManagerChanged(KoStyleManager*)), scw, SLOT(setStyleManager(KoStyleManager*)));
     connect(this, SIGNAL(charFormatChanged(QTextCharFormat,QTextCharFormat)), scw, SLOT(setCurrentFormat(QTextCharFormat,QTextCharFormat)));
     connect(this, SIGNAL(blockFormatChanged(QTextBlockFormat)), scw, SLOT(setCurrentBlockFormat(QTextBlockFormat)));
     connect(scw, SIGNAL(doneWithFocus()), this, SLOT(returnFocusToCanvas()));
     connect(scw, SIGNAL(characterStyleSelected(KoCharacterStyle*)), this, SLOT(setStyle(KoCharacterStyle*)));
     connect(scw, SIGNAL(newStyleRequested(QString)), this, SLOT(createStyleFromCurrentCharFormat(QString)));
     connect(scw, SIGNAL(showStyleManager(int)), this, SLOT(showStyleManager(int)));
 
     // Connect to/with simple paragraph widget (docker)
     connect(this, SIGNAL(styleManagerChanged(KoStyleManager*)), spw, SLOT(setStyleManager(KoStyleManager*)));
     connect(this, SIGNAL(blockChanged(QTextBlock)), spw, SLOT(setCurrentBlock(QTextBlock)));
     connect(this, SIGNAL(blockFormatChanged(QTextBlockFormat)), spw, SLOT(setCurrentFormat(QTextBlockFormat)));
     connect(spw, SIGNAL(doneWithFocus()), this, SLOT(returnFocusToCanvas()));
     connect(spw, SIGNAL(paragraphStyleSelected(KoParagraphStyle*)), this, SLOT(setStyle(KoParagraphStyle*)));
     connect(spw, SIGNAL(newStyleRequested(QString)), this, SLOT(createStyleFromCurrentBlockFormat(QString)));
     connect(spw, SIGNAL(showStyleManager(int)), this, SLOT(showStyleManager(int)));
 
     // Connect to/with simple table widget (docker)
     connect(this, SIGNAL(styleManagerChanged(KoStyleManager*)), stw, SLOT(setStyleManager(KoStyleManager*)));
     connect(stw, SIGNAL(doneWithFocus()), this, SLOT(returnFocusToCanvas()));
     connect(stw, SIGNAL(tableBorderDataUpdated(KoBorder::BorderData)), this, SLOT(setTableBorderData(KoBorder::BorderData)));
 
     // Connect to/with simple insert widget (docker)
     connect(siw, SIGNAL(doneWithFocus()), this, SLOT(returnFocusToCanvas()));
     connect(siw, SIGNAL(insertTableQuick(int,int)), this, SLOT(insertTableQuick(int,int)));
 
     updateStyleManager();
     if (m_textShape) {
         updateActions();
     }
     scw->setWindowTitle(i18n("Character"));
     widgets.append(scw);
     spw->setWindowTitle(i18n("Paragraph"));
     widgets.append(spw);
 
-    bool useAdvancedText = !(canvas()->resourceManager()->intResource(KoCanvasResourceManager::ApplicationSpeciality)
-                             & KoCanvasResourceManager::NoAdvancedText);
+    bool useAdvancedText = !(canvas()->resourceManager()->intResource(KoCanvasResourceProvider::ApplicationSpeciality)
+                             & KoCanvasResourceProvider::NoAdvancedText);
     if (useAdvancedText) {
         stw->setWindowTitle(i18n("Table"));
         widgets.append(stw);
         siw->setWindowTitle(i18n("Insert"));
         widgets.append(siw);
     }
     return widgets;
 }
 
 void TextTool::returnFocusToCanvas()
 {
     canvas()->canvasWidget()->setFocus();
 }
 
 void TextTool::startEditing(KUndo2Command *command)
 {
     m_currentCommand = command;
     m_currentCommandHasChildren = true;
 }
 
 void TextTool::stopEditing()
 {
     m_currentCommand = 0;
     m_currentCommandHasChildren = false;
 }
 
 void TextTool::insertNewSection()
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor) {
         return;
     }
 
     textEditor->newSection();
 }
 
 void TextTool::configureSection()
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor) {
         return;
     }
 
     SectionFormatDialog *dia = new SectionFormatDialog(0, m_textEditor.data());
     dia->exec();
     delete dia;
 
     returnFocusToCanvas();
     updateActions();
 }
 
 void TextTool::splitSections()
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor) {
         return;
     }
 
     SectionsSplitDialog *dia = new SectionsSplitDialog(0, m_textEditor.data());
     dia->exec();
     delete dia;
 
     returnFocusToCanvas();
     updateActions();
 }
 
 void TextTool::pasteAsText()
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor) {
         return;
     }
 
     const QMimeData *data = QApplication::clipboard()->mimeData(QClipboard::Clipboard);
     // on windows we do not have data if we try to paste this selection
     if (!data) {
         return;
     }
 
     if (data->hasFormat(KoOdf::mimeType(KoOdf::Text))
             ||  data->hasText()) {
         m_prevCursorPosition = m_textEditor.data()->position();
         m_textEditor.data()->paste(canvas(), data, true);
         editingPluginEvents();
     }
 }
 
 void TextTool::bold(bool bold)
 {
     m_textEditor.data()->bold(bold);
 }
 
 void TextTool::italic(bool italic)
 {
     m_textEditor.data()->italic(italic);
 }
 
 void TextTool::underline(bool underline)
 {
     m_textEditor.data()->underline(underline);
 }
 
 void TextTool::strikeOut(bool strikeOut)
 {
     m_textEditor.data()->strikeOut(strikeOut);
 }
 
 void TextTool::nonbreakingSpace()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->insertText(QString(QChar(Qt::Key_nobreakspace)));
 }
 
 void TextTool::nonbreakingHyphen()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->insertText(QString(QChar(0x2013)));
 }
 
 void TextTool::softHyphen()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->insertText(QString(QChar(Qt::Key_hyphen)));
 }
 
 void TextTool::lineBreak()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->insertText(QString(QChar(0x2028)));
 }
 
 void TextTool::alignLeft()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->setHorizontalTextAlignment(Qt::AlignLeft | Qt::AlignAbsolute);
 }
 
 void TextTool::alignRight()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->setHorizontalTextAlignment(Qt::AlignRight | Qt::AlignAbsolute);
 }
 
 void TextTool::alignCenter()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->setHorizontalTextAlignment(Qt::AlignHCenter);
 }
 
 void TextTool::alignBlock()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->setHorizontalTextAlignment(Qt::AlignJustify);
 }
 
 void TextTool::superScript(bool on)
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     if (on) {
         m_actionFormatSub->setChecked(false);
     }
     m_textEditor.data()->setVerticalTextAlignment(on ? Qt::AlignTop : Qt::AlignVCenter);
 }
 
 void TextTool::subScript(bool on)
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     if (on) {
         m_actionFormatSuper->setChecked(false);
     }
     m_textEditor.data()->setVerticalTextAlignment(on ? Qt::AlignBottom : Qt::AlignVCenter);
 }
 
 void TextTool::increaseIndent()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     if (m_textEditor.data()->block().textList()) {
         ChangeListLevelCommand::CommandType type = ChangeListLevelCommand::IncreaseLevel;
         ChangeListLevelCommand *cll = new ChangeListLevelCommand(*(m_textEditor.data()->cursor()), type, 1);
         m_textEditor.data()->addCommand(cll);
         editingPluginEvents();
     } else {
         m_textEditor.data()->increaseIndent();
     }
     updateActions();
 }
 
 void TextTool::decreaseIndent()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     if (m_textEditor.data()->block().textList()) {
         ChangeListLevelCommand::CommandType type = ChangeListLevelCommand::DecreaseLevel;
         ChangeListLevelCommand *cll = new ChangeListLevelCommand(*(m_textEditor.data()->cursor()), type, 1);
         m_textEditor.data()->addCommand(cll);
         editingPluginEvents();
     } else {
         m_textEditor.data()->decreaseIndent();
     }
     updateActions();
 }
 
 void TextTool::decreaseFontSize()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->decreaseFontSize();
 }
 
 void TextTool::increaseFontSize()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->increaseFontSize();
 }
 
 void TextTool::setFontFamily(const QString &font)
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
     m_textEditor.data()->setFontFamily(font);
 }
 
 void TextTool::setFontSize(qreal size)
 {
     if (!m_allowActions || !m_textEditor.data() || m_textEditor.isNull()) {
         return;
     }
     m_textEditor.data()->setFontSize(size);
 }
 
 void TextTool::insertIndexMarker()
 {
     // TODO handle result when we figure out how to report errors from a tool.
     m_textEditor.data()->insertIndexMarker();
 }
 
 void TextTool::insertFrameBreak()
 {
     m_textEditor.data()->insertFrameBreak();
 
     ensureCursorVisible();
     m_delayedEnsureVisible = true;
 }
 
 void TextTool::setStyle(KoCharacterStyle *style)
 {
     KoCharacterStyle *charStyle = style;
     //if the given KoCharacterStyle is null, set the KoParagraphStyle character properties
     if (!charStyle) {
         charStyle = static_cast<KoCharacterStyle *>(KoTextDocument(m_textShapeData->document()).styleManager()->paragraphStyle(m_textEditor.data()->blockFormat().intProperty(KoParagraphStyle::StyleId)));
     }
     if (charStyle) {
         m_textEditor.data()->setStyle(charStyle);
         updateActions();
     }
 }
 
 void TextTool::setStyle(KoParagraphStyle *style)
 {
     m_textEditor.data()->setStyle(style);
     updateActions();
 }
 
 void TextTool::insertTable()
 {
     TableDialog *dia = new TableDialog(0);
     if (dia->exec() == TableDialog::Accepted) {
         m_textEditor.data()->insertTable(dia->rows(), dia->columns());
     }
     delete dia;
 
     updateActions();
 }
 
 void TextTool::insertTableQuick(int rows, int columns)
 {
     m_textEditor.data()->insertTable(rows, columns);
     updateActions();
 }
 
 void TextTool::insertTableRowAbove()
 {
     m_textEditor.data()->insertTableRowAbove();
 }
 
 void TextTool::insertTableRowBelow()
 {
     m_textEditor.data()->insertTableRowBelow();
 }
 
 void TextTool::insertTableColumnLeft()
 {
     m_textEditor.data()->insertTableColumnLeft();
 }
 
 void TextTool::insertTableColumnRight()
 {
     m_textEditor.data()->insertTableColumnRight();
 }
 
 void TextTool::deleteTableColumn()
 {
     m_textEditor.data()->deleteTableColumn();
 }
 
 void TextTool::deleteTableRow()
 {
     m_textEditor.data()->deleteTableRow();
 }
 
 void TextTool::mergeTableCells()
 {
     m_textEditor.data()->mergeTableCells();
 }
 
 void TextTool::splitTableCells()
 {
     m_textEditor.data()->splitTableCells();
 }
 
 void TextTool::useTableBorderCursor()
 {
     static const unsigned char data[] = {
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x68, 0x00,
         0x00, 0x00, 0xf4, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0xfd, 0x00,
         0x00, 0x80, 0x7e, 0x00, 0x00, 0x40, 0x3f, 0x00, 0x00, 0xa0, 0x1f, 0x00,
         0x00, 0xd0, 0x0f, 0x00, 0x00, 0xe8, 0x07, 0x00, 0x00, 0xf4, 0x03, 0x00,
         0x00, 0xe4, 0x01, 0x00, 0x00, 0xc2, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00,
         0x40, 0x32, 0x00, 0x00, 0xa0, 0x0f, 0x00, 0x00, 0xd0, 0x0f, 0x00, 0x00,
         0xd0, 0x0f, 0x00, 0x00, 0xe8, 0x07, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00,
         0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     };
 
     QBitmap result(32, 32);
     result.fill(Qt::color0);
     QPainter painter(&result);
     painter.drawPixmap(0, 0, QBitmap::fromData(QSize(25, 23), data));
     QBitmap brushMask = result.createHeuristicMask(false);
 
     useCursor(QCursor(result, brushMask, 1, 21));
 }
 
 void TextTool::setTableBorderData(const KoBorder::BorderData &data)
 {
     m_tablePenMode = true;
     m_tablePenBorderData = data;
 }
 
 void TextTool::formatParagraph()
 {
     ParagraphSettingsDialog *dia = new ParagraphSettingsDialog(this, m_textEditor.data());
     dia->setUnit(canvas()->unit());
     dia->setImageCollection(m_textShape->imageCollection());
     dia->exec();
     delete dia;
     returnFocusToCanvas();
 }
 
 void TextTool::testSlot(bool on)
 {
     qDebug() << "signal received. bool:" << on;
 }
 
 void TextTool::selectAll()
 {
     KoTextEditor *textEditor = m_textEditor.data();
     if (!textEditor || !m_textShapeData) {
         return;
     }
     const int selectionLength = qAbs(textEditor->position() - textEditor->anchor());
     textEditor->movePosition(QTextCursor::End);
     textEditor->setPosition(0, QTextCursor::KeepAnchor);
     repaintSelection();
     if (selectionLength != qAbs(textEditor->position() - textEditor->anchor())) { // it actually changed
         emit selectionChanged(true);
     }
 }
 
 void TextTool::startMacro(const QString &title)
 {
     if (title != i18n("Key Press") && title != i18n("Autocorrection")) { //dirty hack while waiting for refactor of text editing
         m_textTyping = false;
     } else {
         m_textTyping = true;
     }
 
     if (title != i18n("Delete") && title != i18n("Autocorrection")) { //same dirty hack as above
         m_textDeleting = false;
     } else {
         m_textDeleting = true;
     }
 
     if (m_currentCommand) {
         return;
     }
 
     class MacroCommand : public KUndo2Command
     {
     public:
         MacroCommand(const KUndo2MagicString &title) : KUndo2Command(title), m_first(true) {}
         void redo() override
         {
             if (!m_first) {
                 KUndo2Command::redo();
             }
             m_first = false;
         }
         bool mergeWith(const KUndo2Command *) override
         {
             return false;
         }
         bool m_first;
     };
 
     /**
      * FIXME: The messages genearted by the Text Tool might not be
      *        properly translated, since we don't control it in
      *        type-safe way.
      *
      *        The title is already translated string, we just don't
      *        have any type control over it.
      */
     KUndo2MagicString title_workaround = kundo2_noi18n(title);
     m_currentCommand = new MacroCommand(title_workaround);
     m_currentCommandHasChildren = false;
 }
 
 void TextTool::stopMacro()
 {
     if (!m_currentCommand) {
         return;
     }
     if (!m_currentCommandHasChildren) {
         delete m_currentCommand;
     }
     m_currentCommand = 0;
 }
 
 void TextTool::showStyleManager(int styleId)
 {
     if (!m_textShapeData) {
         return;
     }
     KoStyleManager *styleManager = KoTextDocument(m_textShapeData->document()).styleManager();
     Q_ASSERT(styleManager);
     if (!styleManager) {
         return;    //don't crash
     }
     StyleManagerDialog *dia = new StyleManagerDialog(canvas()->canvasWidget());
     dia->setStyleManager(styleManager);
     dia->setUnit(canvas()->unit());
 
     KoParagraphStyle *paragraphStyle = styleManager->paragraphStyle(styleId);
     if (paragraphStyle) {
         dia->setParagraphStyle(paragraphStyle);
     }
     KoCharacterStyle *characterStyle = styleManager->characterStyle(styleId);
     if (characterStyle) {
         dia->setCharacterStyle(characterStyle);
     }
     dia->show();
 }
 
 void TextTool::startTextEditingPlugin(const QString &pluginId)
 {
     KoTextEditingPlugin *plugin = textEditingPluginContainer()->plugin(pluginId);
     if (plugin) {
         if (m_textEditor.data()->hasSelection()) {
             plugin->checkSection(m_textShapeData->document(), m_textEditor.data()->selectionStart(), m_textEditor.data()->selectionEnd());
         } else {
             plugin->finishedWord(m_textShapeData->document(), m_textEditor.data()->position());
         }
     }
 }
 
 void TextTool::canvasResourceChanged(int key, const QVariant &var)
 {
     if (m_textEditor.isNull()) {
         return;
     }
     if (!m_textShapeData) {
         return;
     }
     if (m_allowResourceManagerUpdates == false) {
         return;
     }
     if (key == KoText::CurrentTextPosition) {
         repaintSelection();
         m_textEditor.data()->setPosition(var.toInt());
         ensureCursorVisible();
     } else if (key == KoText::CurrentTextAnchor) {
         repaintSelection();
         int pos = m_textEditor.data()->position();
         m_textEditor.data()->setPosition(var.toInt());
         m_textEditor.data()->setPosition(pos, QTextCursor::KeepAnchor);
-    } else if (key == KoCanvasResourceManager::Unit) {
+    } else if (key == KoCanvasResourceProvider::Unit) {
         m_unit = var.value<KoUnit>();
     } else {
         return;
     }
 
     repaintSelection();
 }
 
 void TextTool::insertSpecialCharacter()
 {
     if (m_specialCharacterDocker == 0) {
         m_specialCharacterDocker = new InsertCharacter(canvas()->canvasWidget());
         connect(m_specialCharacterDocker, SIGNAL(insertCharacter(QString)),
                 this, SLOT(insertString(QString)));
     }
 
     m_specialCharacterDocker->show();
 }
 
 void TextTool::insertString(const QString &string)
 {
     m_textEditor.data()->insertText(string);
     returnFocusToCanvas();
 }
 
 void TextTool::selectFont()
 {
     FontDia *fontDlg = new FontDia(m_textEditor.data());
     fontDlg->exec();
     delete fontDlg;
     returnFocusToCanvas();
 }
 
 void TextTool::shapeAddedToCanvas()
 {
     qDebug();
     if (m_textShape) {
         KoSelection *selection = canvas()->selectedShapesProxy()->selection();
         KoShape *shape = selection->firstSelectedShape();
         if (shape != m_textShape && canvas()->shapeManager()->shapes().contains(m_textShape)) {
             // this situation applies when someone, not us, changed the selection by selecting another
             // text shape. Possibly by adding one.
             // Deselect the new shape again, so we can keep editing what we were already editing
             selection->select(m_textShape);
             selection->deselect(shape);
         }
     }
 }
 
 void TextTool::shapeDataRemoved()
 {
     m_textShapeData = 0;
     m_textShape = 0;
     if (!m_textEditor.isNull() && !m_textEditor.data()->cursor()->isNull()) {
         const QTextDocument *doc = m_textEditor.data()->document();
         Q_ASSERT(doc);
         KoTextDocumentLayout *lay = qobject_cast<KoTextDocumentLayout *>(doc->documentLayout());
         if (!lay || lay->shapes().isEmpty()) {
             emit done();
             return;
         }
         m_textShape = static_cast<TextShape *>(lay->shapes().first());
         m_textShapeData = static_cast<KoTextShapeData *>(m_textShape->userData());
         connect(m_textShapeData, SIGNAL(destroyed(QObject*)), this, SLOT(shapeDataRemoved()));
     }
 }
 
 void TextTool::createStyleFromCurrentBlockFormat(const QString &name)
 {
     KoTextDocument document(m_textShapeData->document());
     KoStyleManager *styleManager = document.styleManager();
     KoParagraphStyle *paragraphStyle = new KoParagraphStyle(m_textEditor.data()->blockFormat(), m_textEditor.data()->charFormat());
     paragraphStyle->setName(name);
     styleManager->add(paragraphStyle);
     m_textEditor.data()->setStyle(paragraphStyle);
     emit charFormatChanged(m_textEditor.data()->charFormat(), m_textEditor.data()->blockCharFormat());
     emit blockFormatChanged(m_textEditor.data()->blockFormat());
 }
 
 void TextTool::createStyleFromCurrentCharFormat(const QString &name)
 {
     KoCharacterStyle blankStyle;
     KoTextDocument document(m_textShapeData->document());
     KoStyleManager *styleManager = document.styleManager();
     KoCharacterStyle *originalCharStyle = styleManager->characterStyle(m_textEditor.data()->charFormat().intProperty(KoCharacterStyle::StyleId));
     KoCharacterStyle *autoStyle;
     if (!originalCharStyle) {
         originalCharStyle = &blankStyle;
         autoStyle = originalCharStyle->autoStyle(m_textEditor.data()->charFormat(), m_textEditor.data()->blockCharFormat());
         autoStyle->setParentStyle(0);
     } else {
         autoStyle = originalCharStyle->autoStyle(m_textEditor.data()->charFormat(), m_textEditor.data()->blockCharFormat());
     }
     autoStyle->setName(name);
     styleManager->add(autoStyle);
     m_textEditor.data()->setStyle(autoStyle);
     emit charFormatChanged(m_textEditor.data()->charFormat(), m_textEditor.data()->blockCharFormat());
 }
 
 // ---------- editing plugins methods.
 void TextTool::editingPluginEvents()
 {
     if (m_prevCursorPosition == -1 || m_prevCursorPosition == m_textEditor.data()->position()) {
         qDebug() << "m_prevCursorPosition=" << m_prevCursorPosition << "m_textEditor.data()->position()=" << m_textEditor.data()->position();
         return;
     }
 
     QTextBlock block = m_textEditor.data()->block();
     if (!block.contains(m_prevCursorPosition)) {
         qDebug() << "m_prevCursorPosition=" << m_prevCursorPosition;
         finishedWord();
         finishedParagraph();
         m_prevCursorPosition = -1;
     } else {
         int from = m_prevCursorPosition;
         int to = m_textEditor.data()->position();
         if (from > to) {
             std::swap(from, to);
         }
         QString section = block.text().mid(from - block.position(), to - from);
         qDebug() << "from=" << from << "to=" << to;
         if (section.contains(' ')) {
             finishedWord();
             m_prevCursorPosition = -1;
         }
     }
 }
 
 void TextTool::finishedWord()
 {
     if (m_textShapeData && textEditingPluginContainer()) {
         foreach (KoTextEditingPlugin *plugin, textEditingPluginContainer()->values()) {
             plugin->finishedWord(m_textShapeData->document(), m_prevCursorPosition);
         }
     }
 }
 
 void TextTool::finishedParagraph()
 {
     if (m_textShapeData && textEditingPluginContainer()) {
         foreach (KoTextEditingPlugin *plugin, textEditingPluginContainer()->values()) {
             plugin->finishedParagraph(m_textShapeData->document(), m_prevCursorPosition);
         }
     }
 }
 
 void TextTool::startingSimpleEdit()
 {
     if (m_textShapeData && textEditingPluginContainer()) {
         foreach (KoTextEditingPlugin *plugin, textEditingPluginContainer()->values()) {
             plugin->startingSimpleEdit(m_textShapeData->document(), m_prevCursorPosition);
         }
     }
 
 }
 
 void TextTool::setTextColor(const KoColor &color)
 {
     m_textEditor.data()->setTextColor(color.toQColor());
 }
 
 void TextTool::setBackgroundColor(const KoColor &color)
 {
     m_textEditor.data()->setTextBackgroundColor(color.toQColor());
 }
 
 void TextTool::setGrowWidthToFit(bool enabled)
 {
     m_textEditor.data()->addCommand(new AutoResizeCommand(m_textShapeData, KoTextShapeData::AutoGrowWidth, enabled));
     updateActions();
 }
 
 void TextTool::setGrowHeightToFit(bool enabled)
 {
     m_textEditor.data()->addCommand(new AutoResizeCommand(m_textShapeData, KoTextShapeData::AutoGrowHeight, enabled));
     updateActions();
 }
 
 void TextTool::setShrinkToFit(bool enabled)
 {
     m_textEditor.data()->addCommand(new AutoResizeCommand(m_textShapeData, KoTextShapeData::ShrinkToFitResize, enabled));
     updateActions();
 }
 
 void TextTool::runUrl(KoPointerEvent *event, QString &url)
 {
     QUrl _url = QUrl::fromUserInput(url);
     if (!_url.isLocalFile()) {
         QDesktopServices::openUrl(_url);
     }
     event->accept();
 }
 
 void TextTool::debugTextDocument()
 {
 #ifndef NDEBUG
     if (!m_textShapeData) {
         return;
     }
     const int CHARSPERLINE = 80; // TODO Make configurable using ENV var?
     const int CHARPOSITION = 278301935;
     KoTextDocument document(m_textShapeData->document());
     KoStyleManager *styleManager = document.styleManager();
     KoInlineTextObjectManager *inlineManager = document.inlineTextObjectManager();
 
     QTextBlock block = m_textShapeData->document()->begin();
     for (; block.isValid(); block = block.next()) {
         QVariant var = block.blockFormat().property(KoParagraphStyle::StyleId);
         if (!var.isNull()) {
             KoParagraphStyle *ps = styleManager->paragraphStyle(var.toInt());
             qDebug() << "--- Paragraph Style:" << (ps ? ps->name() : QString()) << var.toInt();
         }
         var = block.charFormat().property(KoCharacterStyle::StyleId);
         if (!var.isNull()) {
             KoCharacterStyle *cs = styleManager->characterStyle(var.toInt());
             qDebug() << "--- Character Style:" << (cs ? cs->name() : QString()) << var.toInt();
         }
         int lastPrintedChar = -1;
         QTextBlock::iterator it;
         QString fragmentText;
         QList<QTextCharFormat> inlineCharacters;
         for (it = block.begin(); !it.atEnd(); ++it) {
             QTextFragment fragment = it.fragment();
             if (!fragment.isValid()) {
                 continue;
             }
             QTextCharFormat fmt = fragment.charFormat();
             qDebug() << "changeId: " << fmt.property(KoCharacterStyle::ChangeTrackerId);
             const int fragmentStart = fragment.position() - block.position();
             for (int i = fragmentStart; i < fragmentStart + fragment.length(); i += CHARSPERLINE) {
                 if (lastPrintedChar == fragmentStart - 1) {
                     fragmentText += '|';
                 }
                 if (lastPrintedChar < fragmentStart || i > fragmentStart) {
                     QString debug = block.text().mid(lastPrintedChar, CHARSPERLINE);
                     lastPrintedChar += CHARSPERLINE;
                     if (lastPrintedChar > block.length()) {
                         debug += "\\n";
                     }
                     qDebug() << debug;
                 }
                 var = fmt.property(KoCharacterStyle::StyleId);
                 QString charStyleLong, charStyleShort;
                 if (!var.isNull()) { // named style
                     charStyleShort = QString::number(var.toInt());
                     KoCharacterStyle *cs = styleManager->characterStyle(var.toInt());
                     if (cs) {
                         charStyleLong = cs->name();
                     }
                 }
                 if (inlineManager && fmt.hasProperty(KoCharacterStyle::InlineInstanceId)) {
                     QTextCharFormat inlineFmt = fmt;
                     inlineFmt.setProperty(CHARPOSITION, fragmentStart);
                     inlineCharacters << inlineFmt;
                 }
 
                 if (fragment.length() > charStyleLong.length()) {
                     fragmentText += charStyleLong;
                 } else if (fragment.length() > charStyleShort.length()) {
                     fragmentText += charStyleShort;
                 } else if (fragment.length() >= 2) {
                     fragmentText += QChar(8230);    // elipses
                 }
 
                 int rest =  fragmentStart - (lastPrintedChar - CHARSPERLINE) + fragment.length() - fragmentText.length();
                 rest = qMin(rest, CHARSPERLINE - fragmentText.length());
                 if (rest >= 2) {
                     fragmentText = QString("%1%2").arg(fragmentText).arg(' ', rest);
                 }
                 if (rest >= 0) {
                     fragmentText += '|';
                 }
                 if (fragmentText.length() >= CHARSPERLINE) {
                     qDebug() << fragmentText;
                     fragmentText.clear();
                 }
             }
         }
         if (!fragmentText.isEmpty()) {
             qDebug() << fragmentText;
         } else if (block.length() == 1) { // no actual tet
             qDebug() << "\\n";
         }
         foreach (const QTextCharFormat &cf, inlineCharacters) {
             KoInlineObject *object = inlineManager->inlineTextObject(cf);
             qDebug() << "At pos:" << cf.intProperty(CHARPOSITION) << object;
             // qDebug() << "-> id:" << cf.intProperty(577297549);
         }
         QTextList *list = block.textList();
         if (list) {
             if (list->format().hasProperty(KoListStyle::StyleId)) {
                 KoListStyle *ls = styleManager->listStyle(list->format().intProperty(KoListStyle::StyleId));
                 qDebug() << "   List style applied:" << ls->styleId() << ls->name();
             } else {
                 qDebug() << " +- is a list..." << list;
             }
         }
     }
 #endif
 }
 
 void TextTool::debugTextStyles()
 {
 #ifndef NDEBUG
     if (!m_textShapeData) {
         return;
     }
     KoTextDocument document(m_textShapeData->document());
     KoStyleManager *styleManager = document.styleManager();
 
     QSet<int> seenStyles;
 
     foreach (KoParagraphStyle *style, styleManager->paragraphStyles()) {
         qDebug() << style->styleId() << style->name() << (styleManager->defaultParagraphStyle() == style ? "[Default]" : "");
         KoListStyle *ls = style->listStyle();
         if (ls) { // optional ;)
             qDebug() << "  +- ListStyle: " << ls->styleId() << ls->name()
                      << (ls == styleManager->defaultListStyle() ? "[Default]" : "");
             foreach (int level, ls->listLevels()) {
                 KoListLevelProperties llp = ls->levelProperties(level);
                 qDebug() << "  |  level" << llp.level() << " style (enum):" << llp.style();
                 if (llp.bulletCharacter().unicode() != 0) {
                     qDebug() << "  |  bullet" << llp.bulletCharacter();
                 }
             }
             seenStyles << ls->styleId();
         }
     }
 
     bool first = true;
     foreach (KoCharacterStyle *style, styleManager->characterStyles()) {
         if (seenStyles.contains(style->styleId())) {
             continue;
         }
         if (first) {
             qDebug() << "--- Character styles ---";
             first = false;
         }
         qDebug() << style->styleId() << style->name();
         qDebug() << style->font();
     }
 
     first = true;
     foreach (KoListStyle *style, styleManager->listStyles()) {
         if (seenStyles.contains(style->styleId())) {
             continue;
         }
         if (first) {
             qDebug() << "--- List styles ---";
             first = false;
         }
         qDebug() << style->styleId() << style->name()
                  << (style == styleManager->defaultListStyle() ? "[Default]" : "");
     }
 #endif
 }
 
 void TextTool::textDirectionChanged()
 {
     if (!m_allowActions || !m_textEditor.data()) {
         return;
     }
 
     QTextBlockFormat blockFormat;
     if (m_actionChangeDirection->isChecked()) {
         blockFormat.setProperty(KoParagraphStyle::TextProgressionDirection, KoText::RightLeftTopBottom);
     } else {
         blockFormat.setProperty(KoParagraphStyle::TextProgressionDirection, KoText::LeftRightTopBottom);
     }
     m_textEditor.data()->mergeBlockFormat(blockFormat);
 }
 
 void TextTool::setListLevel(int level)
 {
     if (level < 1 || level > 10) {
         return;
     }
 
     KoTextEditor *textEditor = m_textEditor.data();
     if (textEditor->block().textList()) {
         ChangeListLevelCommand::CommandType type = ChangeListLevelCommand::SetLevel;
         ChangeListLevelCommand *cll = new ChangeListLevelCommand(*textEditor->cursor(), type, level);
         textEditor->addCommand(cll);
         editingPluginEvents();
     }
 }
 
 void TextTool::insertAnnotation()
 {
     // no annotations anymore, sorry :(
 }
diff --git a/plugins/flake/textshape/kotext/KoText.h b/plugins/flake/textshape/kotext/KoText.h
index 37a8eeaa16..2f89bbef61 100644
--- a/plugins/flake/textshape/kotext/KoText.h
+++ b/plugins/flake/textshape/kotext/KoText.h
@@ -1,131 +1,131 @@
 /* This file is part of the KDE project
  * Copyright (C)  2006, 2010 Thomas Zander <zander@kde.org>
  * Copyright (C)  2008 Girish Ramakrishnan <girish@forwardbias.in>
  * Copyright (C)  2011 Pierre Ducroquet <pinaraf@pinaraf.info>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KOTEXT_H
 #define KOTEXT_H
 
 #include "kritatext_export.h"
 
 #include <KoDocumentResourceManager.h>
 #include <styles/KoCharacterStyle.h>
 
 #include <QChar>
 #include <QMetaType>
 #include <QTextOption>
 
 class QStringList;
 
 /**
  * Generic namespace of the Calligra Text library for helper methods and data.
  */
 namespace KoText
 {
 KRITATEXT_EXPORT QStringList underlineTypeList();
 KRITATEXT_EXPORT QStringList underlineStyleList();
 KRITATEXT_EXPORT Qt::Alignment alignmentFromString(const QString &align);
 KRITATEXT_EXPORT QString alignmentToString(Qt::Alignment align);
 KRITATEXT_EXPORT Qt::Alignment valignmentFromString(const QString &align);
 KRITATEXT_EXPORT QString valignmentToString(Qt::Alignment align);
 
-/// This enum contains values to be used as keys in KoCanvasResourceManager
+/// This enum contains values to be used as keys in KoCanvasResourceProvider
 enum CanvasResource {
     CurrentTextDocument = 382490375, ///< set by the text plugin whenever the document is changed
     CurrentTextPosition = 183523,   ///<  used by the text plugin whenever the position is changed
     CurrentTextAnchor = 341899485,   ///<  used by the text plugin whenever the anchor-position is changed
     SelectedTextPosition = 21314576,   ///<  used by the text plugin whenever the alternative selection is changed
     ///  used by the text plugin whenever the alternative selection anchor-position is changed
     SelectedTextAnchor = 3344189
 };
 
 /// For paragraphs each tab definition is represented by this struct.
 struct KRITATEXT_EXPORT Tab {
     Tab();
     qreal position;    ///< distance in ps-points from the edge of the text-shape
     QTextOption::TabType type;       ///< Determine which type is used.
     QChar delimiter;    ///< If type is DelimitorTab; tab until this char was found in the text.
     KoCharacterStyle::LineType leaderType; // none/single/double
     KoCharacterStyle::LineStyle leaderStyle; // solid/dotted/dash/...
     KoCharacterStyle::LineWeight leaderWeight; // auto/bold/thin/length/percentage/...
     qreal leaderWidth; // the width value if length/percentage
     QColor leaderColor; ///< if color is valid, then use this instead of the (current) text color
     QString leaderText;   ///< character to print as the leader (filler of the tabbed space)
 
     bool operator==(const Tab &tab) const;
 };
 
 /**
  * Text resources per calligra-document.
  * \sa KoDocumentResourceManager KoShapeController::resourceManager()
  */
 enum DocumentResource {
     ChangeTracker = KoDocumentResourceManager::KoTextStart + 1, ///< KoChangeTracker
     InlineTextObjectManager, ///< The KoText inline-text-object manager. KoInlineTextObjectManager
     TextRangeManager, ///< The KoText inline-text-object manager. KoInlineTextObjectManager
     StyleManager,           ///< The KoStyleManager
     PageProvider,            ///< The KoPageProvider
     /** The KoDocumentRdf for the document,
         this will be a KoDocumentRdfBase when Soprano support is not compiled in. */
     DocumentRdf
 
 };
 
 enum KoTextFrameProperty {
     SubFrameType = QTextFormat::UserProperty + 1
 };
 
 enum KoSubFrameType {
     AuxillaryFrameType = 1,
     NoteFrameType
 };
 
 /// Text in the objects will be positioned according to the direction.
 enum Direction {
     AutoDirection,      ///< Take the direction from the text.
     LeftRightTopBottom, ///< Text layout for most western languages
     RightLeftTopBottom, ///< Text layout for languages like Hebrew
     TopBottomRightLeft,  ///< Vertical text layout.
     TopBottomLeftRight,  ///< Vertical text layout. ?
     InheritDirection    ///< Direction is unspecified and should come from the container
 };
 
 /// convert the string version of directions (as specified in XSL and ODF) to the Direction enum
 KRITATEXT_EXPORT Direction directionFromString(const QString &direction);
 /// convert the Direction enum to the string version of directions (as specified in XSL and ODF)
 KRITATEXT_EXPORT QString directionToString(Direction direction);
 
 /// There are several possible text breaks
 enum KoTextBreakProperty {
     NoBreak = 0,         ///< No text break
     ColumnBreak,     ///< Column break
     PageBreak        ///< Page break
 };
 
 /// convert the string version of text break (as specified in ODF) to the KoTextBreakProperty enum
 KRITATEXT_EXPORT KoTextBreakProperty textBreakFromString(const QString &textBreak);
 /// convert the KoTextBreakProperty enum to the string version of text break (as specified in ODF)
 KRITATEXT_EXPORT QString textBreakToString (KoTextBreakProperty textBreak);
 
 ///@TODO: move to KoUnit ?
 KRITATEXT_EXPORT QTextLength parseLength (const QString &length);
 }
 
 Q_DECLARE_METATYPE(KoText::Tab)
 
 #endif
diff --git a/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp b/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp
index 8979adeaa9..f6bbb6fe56 100644
--- a/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp
+++ b/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp
@@ -1,242 +1,242 @@
 /*
  *  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_brushop_test.h"
 
 #include <QTest>
 #include <qimage_based_test.h>
 #include <stroke_testing_utils.h>
 #include <brushengine/kis_paint_information.h>
 #include <kis_canvas_resource_provider.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <kis_pressure_mirror_option.h>
 #include <kis_pressure_rotation_option.h>
 
 class TestBrushOp : public TestUtil::QImageBasedTest
 {
 public:
     TestBrushOp(const QString &presetFileName, const QString &prefix = "simple")
         : QImageBasedTest("brushop") {
         m_presetFileName = presetFileName;
         m_prefix = prefix;
     }
 
     virtual ~TestBrushOp() {}
 
     void test() {
         test(false, false,  0.0);
         test(false, false, 10.0);
         test(false, false, 20.0);
 
         test(true, false,  0.0);
         test(true, false, 10.0);
         test(true, false, 20.0);
 
         test(false, true,  0.0);
         test(false, true, 10.0);
         test(false, true, 20.0);
 
         test(true, true,  0.0);
         test(true, true, 10.0);
         test(true, true, 20.0);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation) {
         test(mirrorX, mirrorY, rotation, false, false);
         test(mirrorX, mirrorY, rotation, true,  false);
         test(mirrorX, mirrorY, rotation, false, true);
         test(mirrorX, mirrorY, rotation, true,  true);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY) {
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 0.0);
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 360.0 - 10.0);
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 360.0 - 20.0);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY, qreal dabRotation) {
 
         KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
         KisImageSP image = createTrivialImage(undoStore);
         image->initialRefreshGraph();
 
         KisNodeSP paint1 = findNode(image->root(), "paint1");
 
         QVERIFY(paint1->extent().isEmpty());
 
         KisPainter gc(paint1->paintDevice());
 
-        QScopedPointer<KoCanvasResourceManager> manager(
+        QScopedPointer<KoCanvasResourceProvider> manager(
             utils::createResourceManager(image, 0, m_presetFileName));
 
         KisPaintOpPresetSP preset =
             manager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 
         preset->settings()->setCanvasRotation(rotation);
         preset->settings()->setCanvasMirroring(mirrorY, mirrorX);
 
 
         if (mirrorDabX || mirrorDabY) {
             KisPaintOpSettingsSP settings = preset->settings()->clone();
 
             KisPressureMirrorOption mirrorOption;
             mirrorOption.readOptionSetting(settings);
 
             mirrorOption.setChecked(true);
             mirrorOption.setCurveUsed(false);
 
             mirrorOption.enableHorizontalMirror(mirrorDabX);
             mirrorOption.enableVerticalMirror(mirrorDabY);
 
             mirrorOption.writeOptionSetting(settings.data());
 
             preset->setSettings(settings);
         }
 
         if (dabRotation != 0.0) {
             KisPaintOpSettingsSP settings = preset->settings()->clone();
 
             KisPressureRotationOption rotationOption;
             rotationOption.readOptionSetting(settings);
 
             rotationOption.setChecked(true);
             rotationOption.setCurveUsed(false);
 
             rotationOption.setValue(dabRotation / 360.0);
 
             rotationOption.writeOptionSetting(settings.data());
 
             preset->setSettings(settings);
         }
 
 
         QString testName =
             QString("%7_cmY_%1_cmX_%2_cR_%3_dmX_%4_dmY_%5_dR_%6")
             .arg(mirrorY)
             .arg(mirrorX)
             .arg(rotation)
             .arg(mirrorDabX)
             .arg(mirrorDabY)
             .arg(std::fmod(360.0 - dabRotation, 360.0))
             .arg(m_prefix);
 
         KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(image,
                                      paint1,
                                      manager.data());
 
         resources->setupPainter(&gc);
 
         doPaint(gc);
 
         checkOneLayer(image, paint1, testName);
     }
 
     virtual void doPaint(KisPainter &gc) {
         KisPaintInformation pi(QPointF(100, 100), 1.0);
 
         KisDistanceInformation dist;
         gc.paintAt(pi, &dist);
     }
 
     QString m_presetFileName;
     QString m_prefix;
 };
 
 class TestBrushOpLines : public TestBrushOp
 {
 public:
     TestBrushOpLines(const QString &presetFileName)
         : TestBrushOp(presetFileName) {
     }
 
     void doPaint(KisPainter &gc) override {
 
         QVector<KisPaintInformation> vector;
 
         vector << KisPaintInformation(QPointF(100, 100));
         vector << KisPaintInformation(QPointF(200, 150));
         vector << KisPaintInformation(QPointF(100, 350));
 
         KisDistanceInformation dist;
 
         for (int i = 1; i < vector.size(); i++) {
             gc.paintLine(vector[i - 1], vector[i], &dist);
         }
     }
 };
 
 class TestBrushOpPressureLines : public TestBrushOp
 {
 public:
     TestBrushOpPressureLines(const QString &presetFileName, const QString &prefix)
         : TestBrushOp(presetFileName, prefix) {
     }
 
     void doPaint(KisPainter &gc) override {
 
         QVector<KisPaintInformation> vector;
 
         vector << KisPaintInformation(QPointF(0, 0), 0.2);
         vector << KisPaintInformation(QPointF(200, 50), 1.0);
         vector << KisPaintInformation(QPointF(100, 250), 0.0);
         vector << KisPaintInformation(QPointF(200, 150), 1.0);
         vector << KisPaintInformation(QPointF(100, 350), 1.0);
 
         KisDistanceInformation dist;
 
         for (int i = 1; i < vector.size(); i++) {
             gc.paintLine(vector[i - 1], vector[i], &dist);
         }
     }
 };
 
 #include <KoResourcePaths.h>
 void KisBrushOpTest::initTestCase()
 {
     KoResourcePaths::addResourceDir("kis_brushes", QString(SYSTEM_RESOURCES_DATA_DIR) + "/brushes");
 }
 
 void KisBrushOpTest::testRotationMirroring()
 {
     TestBrushOp t("LR_simple.kpp");
     t.test();
 }
 
 void KisBrushOpTest::testRotationMirroringDrawingAngle()
 {
     TestBrushOpLines t("LR_drawing_angle.kpp");
     t.test();
 }
 
 void KisBrushOpTest::testMagicSeven()
 {
     /**
      * A special preset that forces Qt to bug:
      *     mask size: 56
      *     brush size: 7
      *     therefore scale is: 0.125
      *     which causes QTransform work as a pure Translate in the mipmap
      */
 
     TestBrushOpPressureLines t("magic_seven.kpp", "magicseven");
     t.test();
 }
 
 QTEST_MAIN(KisBrushOpTest)
diff --git a/plugins/tools/basictools/kis_tool_colorpicker.cc b/plugins/tools/basictools/kis_tool_colorpicker.cc
index 600cce5b4b..5fd0d69c2a 100644
--- a/plugins/tools/basictools/kis_tool_colorpicker.cc
+++ b/plugins/tools/basictools/kis_tool_colorpicker.cc
@@ -1,358 +1,358 @@
 /*
  *  Copyright (c) 1999 Matthias Elter <me@kde.org>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2018 Emmet & Eoin O'Neill <emmetoneill.pdx@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_colorpicker.h"
 
 #include <boost/thread/locks.hpp>
 #include <QMessageBox>
 #include "kis_cursor.h"
 #include "KisDocument.h"
 #include "kis_canvas2.h"
 #include "KisReferenceImagesLayer.h"
 #include "KoCanvasBase.h"
 #include "kis_random_accessor_ng.h"
 #include "KoResourceServerProvider.h"
 #include <KoMixColorsOp.h>
 #include "kis_wrapped_rect.h"
 #include "kis_tool_utils.h"
 
 namespace
 {
 // GUI ComboBox index constants
 const int SAMPLE_MERGED = 0;
 }
 
 KisToolColorPicker::KisToolColorPicker(KoCanvasBase *canvas)
     : KisTool(canvas, KisCursor::pickerCursor()),
       m_config(new KisToolUtils::ColorPickerConfig)
 {
     setObjectName("tool_colorpicker");
     m_isActivated = false;
     m_optionsWidget = 0;
     m_pickedColor = KoColor();
 }
 
 KisToolColorPicker::~KisToolColorPicker()
 {
     if (m_isActivated) {
         m_config->save(m_toolActivationSource == KisTool::DefaultActivation);
     }
 }
 
 void KisToolColorPicker::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(gc);
     Q_UNUSED(converter);
 }
 
 void KisToolColorPicker::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     m_isActivated = true;
     m_toolActivationSource = activation;
     m_config->load(m_toolActivationSource == KisTool::DefaultActivation);
     updateOptionWidget();
 
     KisTool::activate(activation, shapes);
 }
 
 void KisToolColorPicker::deactivate()
 {
     m_config->save(m_toolActivationSource == KisTool::DefaultActivation);
     m_isActivated = false;
     KisTool::deactivate();
 }
 
 bool KisToolColorPicker::pickColor(const QPointF &pos)
 {
     // Timer check.
     if (m_colorPickerDelayTimer.isActive()) {
         return false;
     }
     else {
         m_colorPickerDelayTimer.setSingleShot(true);
         m_colorPickerDelayTimer.start(100);
     }
 
     QScopedPointer<boost::lock_guard<KisImage>> imageLocker;
 
     m_pickedColor.setOpacity(0.0);
 
     // Pick from reference images.
     if (m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED) {
         auto *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(kisCanvas, false);
         KisSharedPtr<KisReferenceImagesLayer> referenceImageLayer =
             kisCanvas->imageView()->document()->referenceImagesLayer();
 
         if (referenceImageLayer && kisCanvas->referenceImagesDecoration()->visible()) {
             QColor color = referenceImageLayer->getPixel(pos);
             if (color.isValid()) {
                 m_pickedColor.fromQColor(color);
             }
         }
     }
 
     if (m_pickedColor.opacityU8() == OPACITY_TRANSPARENT_U8) {
         if (!currentImage()->bounds().contains(pos.toPoint()) &&
             !currentImage()->wrapAroundModePermitted()) {
             return false;
         }
 
         KisPaintDeviceSP dev;
 
         if (m_optionsWidget->cmbSources->currentIndex() != SAMPLE_MERGED &&
             currentNode() && currentNode()->colorPickSourceDevice()) {
             dev = currentNode()->colorPickSourceDevice();
         }
         else {
             imageLocker.reset(new boost::lock_guard<KisImage>(*currentImage()));
             dev = currentImage()->projection();
         }
 
         KoColor previousColor = canvas()->resourceManager()->foregroundColor();
 
         KisToolUtils::pickColor(m_pickedColor, dev, pos.toPoint(), &previousColor, m_config->radius, m_config->blend); /*!*/
     }
 
     if (m_config->updateColor &&
         m_pickedColor.opacityU8() != OPACITY_TRANSPARENT_U8) {
 
         KoColor publicColor = m_pickedColor;
         publicColor.setOpacity(OPACITY_OPAQUE_U8);
 
         if (m_config->toForegroundColor) {
-            canvas()->resourceManager()->setResource(KoCanvasResourceManager::ForegroundColor, publicColor);
+            canvas()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, publicColor);
         }
         else {
-            canvas()->resourceManager()->setResource(KoCanvasResourceManager::BackgroundColor, publicColor);
+            canvas()->resourceManager()->setResource(KoCanvasResourceProvider::BackgroundColor, publicColor);
         }
     }
 
     return true;
 }
 
 void KisToolColorPicker::beginPrimaryAction(KoPointerEvent *event)
 {
     bool sampleMerged = m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED;
     if (!sampleMerged) {
         if (!currentNode()) {
             QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as no layer is active."));
             event->ignore();
             return;
         }
         if (!currentNode()->visible()) {
             QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as the active layer is not visible."));
             event->ignore();
             return;
         }
     }
 
     QPoint pos = convertToImagePixelCoordFloored(event);
 
     setMode(KisTool::PAINT_MODE);
 
     bool picked = pickColor(pos);
     if (!picked) {
         // Color picking has to start in the visible part of the layer
         event->ignore();
         return;
     }
 
     displayPickedColor();
 }
 
 void KisToolColorPicker::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     QPoint pos = convertToImagePixelCoordFloored(event);
     pickColor(pos);
     displayPickedColor();
 }
 
 void KisToolColorPicker::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     if (m_config->addPalette) {
         KoColorSetEntry ent;
         ent.setColor(m_pickedColor);
         // We don't ask for a name, too intrusive here
 
         KoColorSet *palette = m_palettes.at(m_optionsWidget->cmbPalette->currentIndex());
         palette->add(ent);
 
         if (!palette->save()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Cannot write to palette file %1. Maybe it is read-only.", palette->filename()));
         }
     }
 }
 
 struct PickedChannel {
     QString name;
     QString valueText;
 };
 
 void KisToolColorPicker::displayPickedColor()
 {
     if (m_pickedColor.data() && m_optionsWidget) {
 
         QList<KoChannelInfo *> channels = m_pickedColor.colorSpace()->channels();
         m_optionsWidget->listViewChannels->clear();
 
         QVector<PickedChannel> pickedChannels;
         for (int i = 0; i < channels.count(); ++i) {
             pickedChannels.append(PickedChannel());
         }
 
         for (int i = 0; i < channels.count(); ++i) {
 
             PickedChannel pc;
             pc.name = channels[i]->name();
 
             if (m_config->normaliseValues) {
                 pc.valueText = m_pickedColor.colorSpace()->normalisedChannelValueText(m_pickedColor.data(), i);
             } else {
                 pc.valueText = m_pickedColor.colorSpace()->channelValueText(m_pickedColor.data(), i);
             }
 
             pickedChannels[channels[i]->displayPosition()] = pc;
 
         }
 
         Q_FOREACH (const PickedChannel &pc, pickedChannels) {
             QTreeWidgetItem *item = new QTreeWidgetItem(m_optionsWidget->listViewChannels);
             item->setText(0, pc.name);
             item->setText(1, pc.valueText);
         }
     }
 }
 
 QWidget* KisToolColorPicker::createOptionWidget()
 {
     m_optionsWidget = new ColorPickerOptionsWidget(0);
     m_optionsWidget->setObjectName(toolId() + " option widget");
     m_optionsWidget->listViewChannels->setSortingEnabled(false);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(m_optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     m_optionsWidget->layout()->addWidget(specialSpacer);
 
     // Initialize blend KisSliderSpinBox
     m_optionsWidget->blend->setRange(0,100);
     m_optionsWidget->blend->setSuffix("%");
 
     updateOptionWidget();
 
     connect(m_optionsWidget->cbUpdateCurrentColor, SIGNAL(toggled(bool)), SLOT(slotSetUpdateColor(bool)));
     connect(m_optionsWidget->cbNormaliseValues, SIGNAL(toggled(bool)), SLOT(slotSetNormaliseValues(bool)));
     connect(m_optionsWidget->cbPalette, SIGNAL(toggled(bool)),
             SLOT(slotSetAddPalette(bool)));
     connect(m_optionsWidget->radius, SIGNAL(valueChanged(int)),
             SLOT(slotChangeRadius(int)));
     connect(m_optionsWidget->blend, SIGNAL(valueChanged(int)),
             SLOT(slotChangeBlend(int)));
     connect(m_optionsWidget->cmbSources, SIGNAL(currentIndexChanged(int)),
             SLOT(slotSetColorSource(int)));
 
     KoResourceServer<KoColorSet> *srv = KoResourceServerProvider::instance()->paletteServer();
 
     if (!srv) {
         return m_optionsWidget;
     }
 
     QList<KoColorSet*> palettes = srv->resources();
 
     Q_FOREACH (KoColorSet *palette, palettes) {
         if (palette) {
             m_optionsWidget->cmbPalette->addSqueezedItem(palette->name());
             m_palettes.append(palette);
         }
     }
 
     return m_optionsWidget;
 }
 
 void KisToolColorPicker::updateOptionWidget()
 {
     if (!m_optionsWidget) return;
 
     m_optionsWidget->cbNormaliseValues->setChecked(m_config->normaliseValues);
     m_optionsWidget->cbUpdateCurrentColor->setChecked(m_config->updateColor);
     m_optionsWidget->cmbSources->setCurrentIndex(SAMPLE_MERGED + !m_config->sampleMerged);
     m_optionsWidget->cbPalette->setChecked(m_config->addPalette);
     m_optionsWidget->radius->setValue(m_config->radius);
     m_optionsWidget->blend->setValue(m_config->blend);
 }
 
 void KisToolColorPicker::setToForeground(bool newValue)
 {
     m_config->toForegroundColor = newValue;
     emit toForegroundChanged();
 }
 
 bool KisToolColorPicker::toForeground() const
 {
     return m_config->toForegroundColor;
 }
 
 void KisToolColorPicker::slotSetUpdateColor(bool state)
 {
     m_config->updateColor = state;
 }
 
 void KisToolColorPicker::slotSetNormaliseValues(bool state)
 {
     m_config->normaliseValues = state;
     displayPickedColor();
 }
 
 void KisToolColorPicker::slotSetAddPalette(bool state)
 {
     m_config->addPalette = state;
 }
 
 void KisToolColorPicker::slotChangeRadius(int value)
 {
     m_config->radius = value;
 }
 
 void KisToolColorPicker::slotChangeBlend(int value)
 {
     m_config->blend = value;
 }
 
 void KisToolColorPicker::slotSetColorSource(int value)
 {
     m_config->sampleMerged = value == SAMPLE_MERGED;
 }
 
 void KisToolColorPicker::slotAddPalette(KoResource *resource)
 {
     KoColorSet *palette = dynamic_cast<KoColorSet*>(resource);
     if (palette) {
         m_optionsWidget->cmbPalette->addSqueezedItem(palette->name());
         m_palettes.append(palette);
     }
 }
diff --git a/plugins/tools/basictools/kis_tool_line_helper.cpp b/plugins/tools/basictools/kis_tool_line_helper.cpp
index 230b358999..4e1726a3da 100644
--- a/plugins/tools/basictools/kis_tool_line_helper.cpp
+++ b/plugins/tools/basictools/kis_tool_line_helper.cpp
@@ -1,184 +1,184 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_line_helper.h"
 
 #include "kis_algebra_2d.h"
 #include "kis_painting_information_builder.h"
 #include "kis_image.h"
 
 struct KisToolLineHelper::Private
 {
     Private(KisPaintingInformationBuilder *_infoBuilder)
         : infoBuilder(_infoBuilder),
           useSensors(true),
           enabled(true)
     {
     }
 
     QVector<KisPaintInformation> linePoints;
     KisPaintingInformationBuilder *infoBuilder;
     bool useSensors;
     bool enabled;
 };
 
 KisToolLineHelper::KisToolLineHelper(KisPaintingInformationBuilder *infoBuilder,
                                      const KUndo2MagicString &transactionText)
     : KisToolFreehandHelper(infoBuilder,
                             transactionText,
                             new KisSmoothingOptions(false)),
       m_d(new Private(infoBuilder))
 {
 }
 
 KisToolLineHelper::~KisToolLineHelper()
 {
     delete m_d;
 }
 
 void KisToolLineHelper::setEnabled(bool value)
 {
     m_d->enabled = value;
 }
 
 void KisToolLineHelper::setUseSensors(bool value)
 {
     m_d->useSensors = value;
 }
 
-void KisToolLineHelper::repaintLine(KoCanvasResourceManager *resourceManager,
+void KisToolLineHelper::repaintLine(KoCanvasResourceProvider *resourceManager,
                                     KisImageWSP image, KisNodeSP node,
                                     KisStrokesFacade *strokesFacade)
 {
     if (!m_d->enabled) return;
 
     cancelPaint();
     if (m_d->linePoints.isEmpty()) return;
 
     qreal startAngle = 0.0;
     if (m_d->linePoints.length() > 1) {
         startAngle = KisAlgebra2D::directionBetweenPoints(m_d->linePoints[0].pos(),
                                                           m_d->linePoints[1].pos(),
                                                           0.0);
     }
 
     QVector<KisPaintInformation>::const_iterator it = m_d->linePoints.constBegin();
     QVector<KisPaintInformation>::const_iterator end = m_d->linePoints.constEnd();
 
     initPaintImpl(startAngle, *it, resourceManager, image, node, strokesFacade);
     ++it;
 
     while (it != end) {
         paintLine(*(it - 1), *it);
         ++it;
     }
 }
 
-void KisToolLineHelper::start(KoPointerEvent *event, KoCanvasResourceManager *resourceManager)
+void KisToolLineHelper::start(KoPointerEvent *event, KoCanvasResourceProvider *resourceManager)
 {
     if (!m_d->enabled) return;
 
     // Ignore the elapsed stroke time, so that the line tool will behave as if the whole stroke is
     // drawn at once. This should prevent any possible spurious dabs caused by airbrushing features.
     KisPaintInformation pi =
             m_d->infoBuilder->startStroke(event, 0, resourceManager);
 
     if (!m_d->useSensors) {
         pi = KisPaintInformation(pi.pos());
     }
 
     m_d->linePoints.append(pi);
 }
 
 void KisToolLineHelper::addPoint(KoPointerEvent *event, const QPointF &overridePos)
 {
     if (!m_d->enabled) return;
 
     // Ignore the elapsed stroke time, so that the line tool will behave as if the whole stroke is
     // drawn at once. This should prevent any possible spurious dabs caused by airbrushing features.
     KisPaintInformation pi =
             m_d->infoBuilder->continueStroke(event, 0);
 
     if (!m_d->useSensors) {
         pi = KisPaintInformation(pi.pos());
     }
 
     if (!overridePos.isNull()) {
         pi.setPos(overridePos);
     }
 
     if (m_d->linePoints.size() > 1) {
         const QPointF startPos = m_d->linePoints.first().pos();
         const QPointF endPos = pi.pos();
         const qreal maxDistance = kisDistance(startPos, endPos);
         const QPointF unit = (endPos - startPos) / maxDistance;
 
         QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
         ++it;
         while (it != m_d->linePoints.end()) {
             qreal dist = kisDistance(startPos, it->pos());
             if (dist < maxDistance) {
                 QPointF pos = startPos + unit * dist;
                 it->setPos(pos);
                 ++it;
             } else {
                 it = m_d->linePoints.erase(it);
             }
         }
     }
 
     m_d->linePoints.append(pi);
 }
 
 void KisToolLineHelper::translatePoints(const QPointF &offset)
 {
     if (!m_d->enabled) return;
 
     QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
     while (it != m_d->linePoints.end()) {
         it->setPos(it->pos() + offset);
         ++it;
     }
 }
 
 void KisToolLineHelper::end()
 {
     if (!m_d->enabled) return;
     KIS_ASSERT_RECOVER_RETURN(isRunning());
 
     endPaint();
     m_d->linePoints.clear();
 }
 
 
 void KisToolLineHelper::cancel()
 {
     if (!m_d->enabled) return;
     KIS_ASSERT_RECOVER_RETURN(isRunning());
 
     cancelPaint();
     m_d->linePoints.clear();
 }
 
 
 void KisToolLineHelper::clearPaint()
 {
     if (!m_d->enabled) return;
 
     cancelPaint();
 }
diff --git a/plugins/tools/basictools/kis_tool_line_helper.h b/plugins/tools/basictools/kis_tool_line_helper.h
index a8f15e1516..8835c6a02a 100644
--- a/plugins/tools/basictools/kis_tool_line_helper.h
+++ b/plugins/tools/basictools/kis_tool_line_helper.h
@@ -1,55 +1,55 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_TOOL_LINE_HELPER_H
 #define __KIS_TOOL_LINE_HELPER_H
 
 #include "kis_tool_freehand_helper.h"
 
 
 class KisToolLineHelper : private KisToolFreehandHelper
 {
 public:
     KisToolLineHelper(KisPaintingInformationBuilder *infoBuilder,
                       const KUndo2MagicString &transactionText);
 
     ~KisToolLineHelper() override;
 
     void setEnabled(bool value);
     void setUseSensors(bool value);
 
-    void repaintLine(KoCanvasResourceManager *resourceManager,
+    void repaintLine(KoCanvasResourceProvider *resourceManager,
                      KisImageWSP image,
                      KisNodeSP node,
                      KisStrokesFacade *strokesFacade);
 
-    void start(KoPointerEvent *event, KoCanvasResourceManager *resourceManager);
+    void start(KoPointerEvent *event, KoCanvasResourceProvider *resourceManager);
     void addPoint(KoPointerEvent *event, const QPointF &overridePos = QPointF());
     void translatePoints(const QPointF &offset);
     void end();
     void cancel();
     void clearPaint();
 
     using KisToolFreehandHelper::isRunning;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* __KIS_TOOL_LINE_HELPER_H */
diff --git a/plugins/tools/basictools/tests/move_selection_stroke_test.cpp b/plugins/tools/basictools/tests/move_selection_stroke_test.cpp
index 80e5844ed6..2be473ccd1 100644
--- a/plugins/tools/basictools/tests/move_selection_stroke_test.cpp
+++ b/plugins/tools/basictools/tests/move_selection_stroke_test.cpp
@@ -1,129 +1,129 @@
 /*
  *  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 "move_selection_stroke_test.h"
 
 #include <QTest>
 
 #include <KoColor.h>
 
 #include "kis_image.h"
 #include "strokes/move_selection_stroke_strategy.h"
 #include "stroke_testing_utils.h"
 #include "kis_selection.h"
 #include "commands/kis_selection_commands.h"
 #include "strokes/move_stroke_strategy.h"
 #include "kis_paint_layer.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_paint_device_frames_interface.h"
 #include "kis_paint_device_debug_utils.h"
 
 
 KisPaintDeviceSP lodDevice(KisPaintDeviceSP dev)
 {
     KisPaintDeviceSP tmp = new KisPaintDevice(dev->colorSpace());
     dev->tesingFetchLodDevice(tmp);
     return tmp;
 }
 
 
 void MoveSelectionStrokeTest::test()
 {
     const QRect imageRect(0,0,800,800);
     KisImageSP image = utils::createImage(0, imageRect.size());
-    QScopedPointer<KoCanvasResourceManager> manager(
+    QScopedPointer<KoCanvasResourceProvider> manager(
         utils::createResourceManager(image));
 
     image->setDesiredLevelOfDetail(2);
     image->waitForDone();
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image,
                                  image->root()->firstChild(),
                                  manager.data());
 
     KisNodeSP currentNode = resources->currentNode();
     KisPaintLayerSP currentPaintLayer = dynamic_cast<KisPaintLayer*>(currentNode.data());
     Q_ASSERT(currentPaintLayer);
 
     KisPaintDeviceSP device = currentNode->paintDevice();
 
     {
         KisImageBarrierLocker locker(image);
 
         device->fill(QRect(0,0,400,400),     KoColor(Qt::red, image->colorSpace()));
         device->fill(QRect(400,0,400,400),   KoColor(Qt::green, image->colorSpace()));
         device->fill(QRect(0,400,400,400),   KoColor(Qt::blue, image->colorSpace()));
         device->fill(QRect(400,400,400,400), KoColor(Qt::yellow, image->colorSpace()));
     }
 
     {
         KisSelectionSP newSelection = new KisSelection();
         newSelection->pixelSelection()->select(QRect(200,200,400,400), OPACITY_OPAQUE_U8);
 
         KisSetGlobalSelectionCommand cmd(image, newSelection);
         cmd.redo();
     }
 
     KIS_DUMP_DEVICE_2(device, imageRect, "00_0_device", "mm");
     KIS_DUMP_DEVICE_2(image->globalSelection()->projection(), imageRect, "01_0_selection", "mm");
 
     {
         MoveSelectionStrokeStrategy *strategy =
             new MoveSelectionStrokeStrategy(currentPaintLayer,
                                             image->globalSelection(),
                                             image.data(),
                                             image.data());
 
         KisStrokeId id = image->startStroke(strategy);
         image->addJob(id, new MoveStrokeStrategy::Data(QPoint(100,100)));
         image->endStroke(id);
 
         image->waitForDone();
 
         KIS_DUMP_DEVICE_2(device, imageRect, "02_0_device", "mm");
         KIS_DUMP_DEVICE_2(lodDevice(device), imageRect, "02_1_device_lod", "mm");
 
         KIS_DUMP_DEVICE_2(image->globalSelection()->projection(), imageRect, "03_0_selection", "mm");
         KIS_DUMP_DEVICE_2(lodDevice(image->globalSelection()->projection()), imageRect, "03_1_selection_lod", "mm");
 
     }
 
     {
         MoveSelectionStrokeStrategy *strategy =
             new MoveSelectionStrokeStrategy(currentPaintLayer,
                                             image->globalSelection(),
                                             image.data(),
                                             image.data());
 
         KisStrokeId id = image->startStroke(strategy);
         image->addJob(id, new MoveStrokeStrategy::Data(QPoint(-200,50)));
         image->endStroke(id);
 
         image->waitForDone();
 
         KIS_DUMP_DEVICE_2(device, imageRect, "04_0_device", "mm");
         KIS_DUMP_DEVICE_2(lodDevice(device), imageRect, "04_1_device_lod", "mm");
 
         KIS_DUMP_DEVICE_2(image->globalSelection()->projection(), imageRect, "05_0_selection", "mm");
         KIS_DUMP_DEVICE_2(lodDevice(image->globalSelection()->projection()), imageRect, "05_1_selection_lod", "mm");
     }
 
 }
 
 QTEST_GUILESS_MAIN(MoveSelectionStrokeTest)
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp b/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp
index b3e3fb5840..0d8193dab6 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp
+++ b/plugins/tools/defaulttool/defaulttool/DefaultTool.cpp
@@ -1,1779 +1,1779 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006-2008 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
    Copyright (C) 2008-2009 Jan Hambrecht <jaham@gmx.net>
    Copyright (C) 2008 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 "DefaultTool.h"
 #include "DefaultToolGeometryWidget.h"
 #include "DefaultToolTabbedWidget.h"
 #include "SelectionDecorator.h"
 #include "ShapeMoveStrategy.h"
 #include "ShapeRotateStrategy.h"
 #include "ShapeShearStrategy.h"
 #include "ShapeResizeStrategy.h"
 
 #include <KoPointerEvent.h>
 #include <KoToolSelection.h>
 #include <KoToolManager.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoShapeGroup.h>
 #include <KoShapeLayer.h>
 #include <KoShapeOdfSaveHelper.h>
 #include <KoPathShape.h>
 #include <KoDrag.h>
 #include <KoCanvasBase.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoShapeRubberSelectStrategy.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <commands/KoShapeTransformCommand.h>
 #include <commands/KoShapeDeleteCommand.h>
 #include <commands/KoShapeCreateCommand.h>
 #include <commands/KoShapeGroupCommand.h>
 #include <commands/KoShapeUngroupCommand.h>
 #include <commands/KoShapeDistributeCommand.h>
 #include <commands/KoKeepShapesSelectedCommand.h>
 #include <KoSnapGuide.h>
 #include <KoStrokeConfigWidget.h>
 #include "kis_action_registry.h"
 #include "kis_node.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include <KoInteractionStrategyFactory.h>
 
 #include "kis_document_aware_spin_box_unit_manager.h"
 
 #include <KoIcon.h>
 
 #include <QPointer>
 #include <QAction>
 #include <QKeyEvent>
 #include <QSignalMapper>
 #include <KoResourcePaths.h>
 
 #include <KoCanvasController.h>
 #include <kactioncollection.h>
 #include <QMenu>
 
 #include <math.h>
 #include "kis_assert.h"
 #include "kis_global.h"
 #include "kis_debug.h"
 
 #include <QVector2D>
 
 #define HANDLE_DISTANCE 10
 #define HANDLE_DISTANCE_SQ (HANDLE_DISTANCE * HANDLE_DISTANCE)
 
 #define INNER_HANDLE_DISTANCE_SQ 16
 
 namespace {
 static const QString EditFillGradientFactoryId = "edit_fill_gradient";
 static const QString EditStrokeGradientFactoryId = "edit_stroke_gradient";
 
 enum TransformActionType {
     TransformRotate90CW,
     TransformRotate90CCW,
     TransformRotate180,
     TransformMirrorX,
     TransformMirrorY,
     TransformReset
 };
 
 enum BooleanOp {
     BooleanUnion,
     BooleanIntersection,
     BooleanSubtraction
 };
 
 }
 
 class NopInteractionStrategy : public KoInteractionStrategy
 {
 public:
     explicit NopInteractionStrategy(KoToolBase *parent)
         : KoInteractionStrategy(parent)
     {
     }
 
     KUndo2Command *createCommand() override
     {
         return 0;
     }
 
     void handleMouseMove(const QPointF & /*mouseLocation*/, Qt::KeyboardModifiers /*modifiers*/) override {}
     void finishInteraction(Qt::KeyboardModifiers /*modifiers*/) override {}
 
     void paint(QPainter &painter, const KoViewConverter &converter) override {
         Q_UNUSED(painter);
         Q_UNUSED(converter);
     }
 };
 
 class SelectionInteractionStrategy : public KoShapeRubberSelectStrategy
 {
 public:
     explicit SelectionInteractionStrategy(KoToolBase *parent, const QPointF &clicked, bool useSnapToGrid)
         : KoShapeRubberSelectStrategy(parent, clicked, useSnapToGrid)
     {
     }
 
     void paint(QPainter &painter, const KoViewConverter &converter) override {
         KoShapeRubberSelectStrategy::paint(painter, converter);
     }
 
     void finishInteraction(Qt::KeyboardModifiers modifiers = 0) override
     {
         Q_UNUSED(modifiers);
         DefaultTool *defaultTool = dynamic_cast<DefaultTool*>(tool());
         KIS_SAFE_ASSERT_RECOVER_RETURN(defaultTool);
 
         KoSelection * selection = defaultTool->koSelection();
 
         const bool useContainedMode = currentMode() == CoveringSelection;
 
         QList<KoShape *> shapes =
                 defaultTool->shapeManager()->
                         shapesAt(selectedRectangle(), true, useContainedMode);
 
         Q_FOREACH (KoShape * shape, shapes) {
                 if (!shape->isSelectable()) continue;
 
                 selection->select(shape);
             }
 
         defaultTool->repaintDecorations();
         defaultTool->canvas()->updateCanvas(selectedRectangle());
     }
 };
 #include <KoGradientBackground.h>
 #include "KoShapeGradientHandles.h"
 #include "ShapeGradientEditStrategy.h"
 
 class DefaultTool::MoveGradientHandleInteractionFactory : public KoInteractionStrategyFactory
 {
 public:
     MoveGradientHandleInteractionFactory(KoFlake::FillVariant fillVariant,
                                          int priority, const QString &id, DefaultTool *_q)
         : KoInteractionStrategyFactory(priority, id),
           q(_q),
           m_fillVariant(fillVariant)
     {
     }
 
     KoInteractionStrategy* createStrategy(KoPointerEvent *ev) override
     {
         m_currentHandle = handleAt(ev->point);
 
         if (m_currentHandle.type != KoShapeGradientHandles::Handle::None) {
             KoShape *shape = onlyEditableShape();
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape, 0);
 
             return new ShapeGradientEditStrategy(q, m_fillVariant, shape, m_currentHandle.type, ev->point);
         }
 
         return 0;
     }
 
     bool hoverEvent(KoPointerEvent *ev) override
     {
         m_currentHandle = handleAt(ev->point);
         return false;
     }
 
     bool paintOnHover(QPainter &painter, const KoViewConverter &converter) override
     {
         Q_UNUSED(painter);
         Q_UNUSED(converter);
         return false;
     }
 
     bool tryUseCustomCursor() override {
         if (m_currentHandle.type != KoShapeGradientHandles::Handle::None) {
             q->useCursor(Qt::OpenHandCursor);
         }
 
         return m_currentHandle.type != KoShapeGradientHandles::Handle::None;
     }
 
 private:
 
     KoShape* onlyEditableShape() const {
         KoSelection *selection = q->koSelection();
         QList<KoShape*> shapes = selection->selectedEditableShapes();
 
         KoShape *shape = 0;
         if (shapes.size() == 1) {
             shape = shapes.first();
         }
 
         return shape;
     }
 
     KoShapeGradientHandles::Handle handleAt(const QPointF &pos) {
         KoShapeGradientHandles::Handle result;
 
         KoShape *shape = onlyEditableShape();
         if (shape) {
             KoFlake::SelectionHandle globalHandle = q->handleAt(pos);
             const qreal distanceThresholdSq =
                 globalHandle == KoFlake::NoHandle ?
                     HANDLE_DISTANCE_SQ : 0.25 * HANDLE_DISTANCE_SQ;
 
             const KoViewConverter *converter = q->canvas()->viewConverter();
             const QPointF viewPoint = converter->documentToView(pos);
             qreal minDistanceSq = std::numeric_limits<qreal>::max();
 
             KoShapeGradientHandles sh(m_fillVariant, shape);
             Q_FOREACH (const KoShapeGradientHandles::Handle &handle, sh.handles()) {
                 const QPointF handlePoint = converter->documentToView(handle.pos);
                 const qreal distanceSq = kisSquareDistance(viewPoint, handlePoint);
 
                 if (distanceSq < distanceThresholdSq && distanceSq < minDistanceSq) {
                     result = handle;
                     minDistanceSq = distanceSq;
                 }
             }
         }
 
         return result;
     }
 
 private:
     DefaultTool *q;
     KoFlake::FillVariant m_fillVariant;
     KoShapeGradientHandles::Handle m_currentHandle;
 };
 
 class SelectionHandler : public KoToolSelection
 {
 public:
     SelectionHandler(DefaultTool *parent)
         : KoToolSelection(parent)
         , m_selection(parent->koSelection())
     {
     }
 
     bool hasSelection() override
     {
         if (m_selection) {
             return m_selection->count();
         }
         return false;
     }
 
 private:
     QPointer<KoSelection> m_selection;
 };
 
 DefaultTool::DefaultTool(KoCanvasBase *canvas)
     : KoInteractionTool(canvas)
     , m_lastHandle(KoFlake::NoHandle)
     , m_hotPosition(KoFlake::TopLeft)
     , m_mouseWasInsideHandles(false)
     , m_decorator(0)
     , m_selectionHandler(new SelectionHandler(this))
     , m_tabbedOptionWidget(0)
 {
     setupActions();
 
     QPixmap rotatePixmap, shearPixmap;
     rotatePixmap.load(":/cursor_rotate.png");
     Q_ASSERT(!rotatePixmap.isNull());
     shearPixmap.load(":/cursor_shear.png");
     Q_ASSERT(!shearPixmap.isNull());
 
     m_rotateCursors[0] = QCursor(rotatePixmap.transformed(QTransform().rotate(45)));
     m_rotateCursors[1] = QCursor(rotatePixmap.transformed(QTransform().rotate(90)));
     m_rotateCursors[2] = QCursor(rotatePixmap.transformed(QTransform().rotate(135)));
     m_rotateCursors[3] = QCursor(rotatePixmap.transformed(QTransform().rotate(180)));
     m_rotateCursors[4] = QCursor(rotatePixmap.transformed(QTransform().rotate(225)));
     m_rotateCursors[5] = QCursor(rotatePixmap.transformed(QTransform().rotate(270)));
     m_rotateCursors[6] = QCursor(rotatePixmap.transformed(QTransform().rotate(315)));
     m_rotateCursors[7] = QCursor(rotatePixmap);
     /*
         m_rotateCursors[0] = QCursor(Qt::RotateNCursor);
         m_rotateCursors[1] = QCursor(Qt::RotateNECursor);
         m_rotateCursors[2] = QCursor(Qt::RotateECursor);
         m_rotateCursors[3] = QCursor(Qt::RotateSECursor);
         m_rotateCursors[4] = QCursor(Qt::RotateSCursor);
         m_rotateCursors[5] = QCursor(Qt::RotateSWCursor);
         m_rotateCursors[6] = QCursor(Qt::RotateWCursor);
         m_rotateCursors[7] = QCursor(Qt::RotateNWCursor);
     */
     m_shearCursors[0] = QCursor(shearPixmap);
     m_shearCursors[1] = QCursor(shearPixmap.transformed(QTransform().rotate(45)));
     m_shearCursors[2] = QCursor(shearPixmap.transformed(QTransform().rotate(90)));
     m_shearCursors[3] = QCursor(shearPixmap.transformed(QTransform().rotate(135)));
     m_shearCursors[4] = QCursor(shearPixmap.transformed(QTransform().rotate(180)));
     m_shearCursors[5] = QCursor(shearPixmap.transformed(QTransform().rotate(225)));
     m_shearCursors[6] = QCursor(shearPixmap.transformed(QTransform().rotate(270)));
     m_shearCursors[7] = QCursor(shearPixmap.transformed(QTransform().rotate(315)));
     m_sizeCursors[0] = Qt::SizeVerCursor;
     m_sizeCursors[1] = Qt::SizeBDiagCursor;
     m_sizeCursors[2] = Qt::SizeHorCursor;
     m_sizeCursors[3] = Qt::SizeFDiagCursor;
     m_sizeCursors[4] = Qt::SizeVerCursor;
     m_sizeCursors[5] = Qt::SizeBDiagCursor;
     m_sizeCursors[6] = Qt::SizeHorCursor;
     m_sizeCursors[7] = Qt::SizeFDiagCursor;
 
     connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(updateActions()));
 }
 
 DefaultTool::~DefaultTool()
 {
 }
 
 void DefaultTool::slotActivateEditFillGradient(bool value)
 {
     if (value) {
         addInteractionFactory(
             new MoveGradientHandleInteractionFactory(KoFlake::Fill,
                                                      1, EditFillGradientFactoryId, this));
     } else {
         removeInteractionFactory(EditFillGradientFactoryId);
     }
     repaintDecorations();
 }
 
 void DefaultTool::slotActivateEditStrokeGradient(bool value)
 {
     if (value) {
         addInteractionFactory(
             new MoveGradientHandleInteractionFactory(KoFlake::StrokeFill,
                                                      0, EditStrokeGradientFactoryId, this));
     } else {
         removeInteractionFactory(EditStrokeGradientFactoryId);
     }
     repaintDecorations();
 }
 
 bool DefaultTool::wantsAutoScroll() const
 {
     return true;
 }
 
 void DefaultTool::addMappedAction(QSignalMapper *mapper, const QString &actionId, int commandType)
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
     QAction *action = actionRegistry->makeQAction(actionId, this);
     addAction(actionId, action);
     connect(action, SIGNAL(triggered()), mapper, SLOT(map()));
     mapper->setMapping(action, commandType);
 }
 
 void DefaultTool::setupActions()
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
     QAction *actionBringToFront = actionRegistry->makeQAction("object_order_front", this);
     addAction("object_order_front", actionBringToFront);
     connect(actionBringToFront, SIGNAL(triggered()), this, SLOT(selectionBringToFront()));
 
     QAction *actionRaise = actionRegistry->makeQAction("object_order_raise", this);
     addAction("object_order_raise", actionRaise);
     connect(actionRaise, SIGNAL(triggered()), this, SLOT(selectionMoveUp()));
 
     QAction *actionLower = actionRegistry->makeQAction("object_order_lower", this);
     addAction("object_order_lower", actionLower);
     connect(actionLower, SIGNAL(triggered()), this, SLOT(selectionMoveDown()));
 
     QAction *actionSendToBack = actionRegistry->makeQAction("object_order_back", this);
     addAction("object_order_back", actionSendToBack);
     connect(actionSendToBack, SIGNAL(triggered()), this, SLOT(selectionSendToBack()));
 
 
     QSignalMapper *alignSignalsMapper = new QSignalMapper(this);
     connect(alignSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionAlign(int)));
 
     addMappedAction(alignSignalsMapper, "object_align_horizontal_left", KoShapeAlignCommand::HorizontalLeftAlignment);
     addMappedAction(alignSignalsMapper, "object_align_horizontal_center", KoShapeAlignCommand::HorizontalCenterAlignment);
     addMappedAction(alignSignalsMapper, "object_align_horizontal_right", KoShapeAlignCommand::HorizontalRightAlignment);
     addMappedAction(alignSignalsMapper, "object_align_vertical_top", KoShapeAlignCommand::VerticalTopAlignment);
     addMappedAction(alignSignalsMapper, "object_align_vertical_center", KoShapeAlignCommand::VerticalCenterAlignment);
     addMappedAction(alignSignalsMapper, "object_align_vertical_bottom", KoShapeAlignCommand::VerticalBottomAlignment);
 
     QSignalMapper *distributeSignalsMapper = new QSignalMapper(this);
     connect(distributeSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionDistribute(int)));
 
     addMappedAction(distributeSignalsMapper, "object_distribute_horizontal_left", KoShapeDistributeCommand::HorizontalLeftDistribution);
     addMappedAction(distributeSignalsMapper, "object_distribute_horizontal_center", KoShapeDistributeCommand::HorizontalCenterDistribution);
     addMappedAction(distributeSignalsMapper, "object_distribute_horizontal_right", KoShapeDistributeCommand::HorizontalRightDistribution);
     addMappedAction(distributeSignalsMapper, "object_distribute_horizontal_gaps", KoShapeDistributeCommand::HorizontalGapsDistribution);
 
     addMappedAction(distributeSignalsMapper, "object_distribute_vertical_top", KoShapeDistributeCommand::VerticalTopDistribution);
     addMappedAction(distributeSignalsMapper, "object_distribute_vertical_center", KoShapeDistributeCommand::VerticalCenterDistribution);
     addMappedAction(distributeSignalsMapper, "object_distribute_vertical_bottom", KoShapeDistributeCommand::VerticalBottomDistribution);
     addMappedAction(distributeSignalsMapper, "object_distribute_vertical_gaps", KoShapeDistributeCommand::VerticalGapsDistribution);
 
     QAction *actionGroupBottom = actionRegistry->makeQAction("object_group", this);
     addAction("object_group", actionGroupBottom);
     connect(actionGroupBottom, SIGNAL(triggered()), this, SLOT(selectionGroup()));
 
     QAction *actionUngroupBottom = actionRegistry->makeQAction("object_ungroup", this);
     addAction("object_ungroup", actionUngroupBottom);
     connect(actionUngroupBottom, SIGNAL(triggered()), this, SLOT(selectionUngroup()));
 
     QSignalMapper *transformSignalsMapper = new QSignalMapper(this);
     connect(transformSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionTransform(int)));
 
     addMappedAction(transformSignalsMapper, "object_transform_rotate_90_cw", TransformRotate90CW);
     addMappedAction(transformSignalsMapper, "object_transform_rotate_90_ccw", TransformRotate90CCW);
     addMappedAction(transformSignalsMapper, "object_transform_rotate_180", TransformRotate180);
     addMappedAction(transformSignalsMapper, "object_transform_mirror_horizontally", TransformMirrorX);
     addMappedAction(transformSignalsMapper, "object_transform_mirror_vertically", TransformMirrorY);
     addMappedAction(transformSignalsMapper, "object_transform_reset", TransformReset);
 
     QSignalMapper *booleanSignalsMapper = new QSignalMapper(this);
     connect(booleanSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionBooleanOp(int)));
 
     addMappedAction(booleanSignalsMapper, "object_unite", BooleanUnion);
     addMappedAction(booleanSignalsMapper, "object_intersect", BooleanIntersection);
     addMappedAction(booleanSignalsMapper, "object_subtract", BooleanSubtraction);
 
     QAction *actionSplit = actionRegistry->makeQAction("object_split", this);
     addAction("object_split", actionSplit);
     connect(actionSplit, SIGNAL(triggered()), this, SLOT(selectionSplitShapes()));
 
     m_contextMenu.reset(new QMenu());
 }
 
 qreal DefaultTool::rotationOfHandle(KoFlake::SelectionHandle handle, bool useEdgeRotation)
 {
     QPointF selectionCenter = koSelection()->absolutePosition();
     QPointF direction;
 
     switch (handle) {
     case KoFlake::TopMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::TopRight)
                         - koSelection()->absolutePosition(KoFlake::TopLeft);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopLeft);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::TopRight) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::TopRightHandle:
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::TopRight) - koSelection()->absolutePosition(KoFlake::TopLeft)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::TopRight) - koSelection()->absolutePosition(KoFlake::BottomRight)).normalized()).toPointF();
         break;
     case KoFlake::RightMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::BottomRight)
                         - koSelection()->absolutePosition(KoFlake::TopRight);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopRight);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomRight) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::BottomRightHandle:
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::BottomRight) - koSelection()->absolutePosition(KoFlake::BottomLeft)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::BottomRight) - koSelection()->absolutePosition(KoFlake::TopRight)).normalized()).toPointF();
         break;
     case KoFlake::BottomMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::BottomLeft)
                         - koSelection()->absolutePosition(KoFlake::BottomRight);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::BottomLeft);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomRight) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::BottomLeftHandle:
         direction = koSelection()->absolutePosition(KoFlake::BottomLeft) - selectionCenter;
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::BottomLeft) - koSelection()->absolutePosition(KoFlake::BottomRight)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::BottomLeft) - koSelection()->absolutePosition(KoFlake::TopLeft)).normalized()).toPointF();
         break;
     case KoFlake::LeftMiddleHandle:
         if (useEdgeRotation) {
             direction = koSelection()->absolutePosition(KoFlake::TopLeft)
                         - koSelection()->absolutePosition(KoFlake::BottomLeft);
         } else {
             QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopLeft);
             handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomLeft) - handlePosition);
             direction = handlePosition - selectionCenter;
         }
         break;
     case KoFlake::TopLeftHandle:
         direction = koSelection()->absolutePosition(KoFlake::TopLeft) - selectionCenter;
         direction = (QVector2D(koSelection()->absolutePosition(KoFlake::TopLeft) - koSelection()->absolutePosition(KoFlake::TopRight)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::TopLeft) - koSelection()->absolutePosition(KoFlake::BottomLeft)).normalized()).toPointF();
         break;
     case KoFlake::NoHandle:
         return 0.0;
         break;
     }
 
     qreal rotation = atan2(direction.y(), direction.x()) * 180.0 / M_PI;
 
     switch (handle) {
     case KoFlake::TopMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 0.0;
         } else {
             rotation -= 270.0;
         }
         break;
     case KoFlake::TopRightHandle:
         rotation -= 315.0;
         break;
     case KoFlake::RightMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 90.0;
         } else {
             rotation -= 0.0;
         }
         break;
     case KoFlake::BottomRightHandle:
         rotation -= 45.0;
         break;
     case KoFlake::BottomMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 180.0;
         } else {
             rotation -= 90.0;
         }
         break;
     case KoFlake::BottomLeftHandle:
         rotation -= 135.0;
         break;
     case KoFlake::LeftMiddleHandle:
         if (useEdgeRotation) {
             rotation -= 270.0;
         } else {
             rotation -= 180.0;
         }
         break;
     case KoFlake::TopLeftHandle:
         rotation -= 225.0;
         break;
     case KoFlake::NoHandle:
         break;
     }
 
     if (rotation < 0.0) {
         rotation += 360.0;
     }
 
     return rotation;
 }
 
 void DefaultTool::updateCursor()
 {
     if (tryUseCustomCursor()) return;
 
     QCursor cursor = Qt::ArrowCursor;
 
     QString statusText;
 
     KoSelection *selection = koSelection();
     if (selection && selection->count() > 0) { // has a selection
         bool editable = !selection->selectedEditableShapes().isEmpty();
 
         if (!m_mouseWasInsideHandles) {
             m_angle = rotationOfHandle(m_lastHandle, true);
             int rotOctant = 8 + int(8.5 + m_angle / 45);
 
             bool rotateHandle = false;
             bool shearHandle = false;
             switch (m_lastHandle) {
             case KoFlake::TopMiddleHandle:
                 cursor = m_shearCursors[(0 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::TopRightHandle:
                 cursor = m_rotateCursors[(1 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::RightMiddleHandle:
                 cursor = m_shearCursors[(2 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::BottomRightHandle:
                 cursor = m_rotateCursors[(3 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::BottomMiddleHandle:
                 cursor = m_shearCursors[(4 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::BottomLeftHandle:
                 cursor = m_rotateCursors[(5 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::LeftMiddleHandle:
                 cursor = m_shearCursors[(6 + rotOctant) % 8];
                 shearHandle = true;
                 break;
             case KoFlake::TopLeftHandle:
                 cursor = m_rotateCursors[(7 + rotOctant) % 8];
                 rotateHandle = true;
                 break;
             case KoFlake::NoHandle:
                 cursor = Qt::ArrowCursor;
                 break;
             }
             if (rotateHandle) {
                 statusText = i18n("Left click rotates around center, right click around highlighted position.");
             }
             if (shearHandle) {
                 statusText = i18n("Click and drag to shear selection.");
             }
 
             if (m_decorator->isOverTextEditorButton()) {
                 cursor = Qt::PointingHandCursor;
             } else {
                 cursor = Qt::ArrowCursor;
             }
 
         } else {
             statusText = i18n("Click and drag to resize selection.");
             m_angle = rotationOfHandle(m_lastHandle, false);
             int rotOctant = 8 + int(8.5 + m_angle / 45);
             bool cornerHandle = false;
             switch (m_lastHandle) {
             case KoFlake::TopMiddleHandle:
                 cursor = m_sizeCursors[(0 + rotOctant) % 8];
                 break;
             case KoFlake::TopRightHandle:
                 cursor = m_sizeCursors[(1 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::RightMiddleHandle:
                 cursor = m_sizeCursors[(2 + rotOctant) % 8];
                 break;
             case KoFlake::BottomRightHandle:
                 cursor = m_sizeCursors[(3 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::BottomMiddleHandle:
                 cursor = m_sizeCursors[(4 + rotOctant) % 8];
                 break;
             case KoFlake::BottomLeftHandle:
                 cursor = m_sizeCursors[(5 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::LeftMiddleHandle:
                 cursor = m_sizeCursors[(6 + rotOctant) % 8];
                 break;
             case KoFlake::TopLeftHandle:
                 cursor = m_sizeCursors[(7 + rotOctant) % 8];
                 cornerHandle = true;
                 break;
             case KoFlake::NoHandle:
                 cursor = Qt::SizeAllCursor;
                 statusText = i18n("Click and drag to move selection.");
                 break;
             }
             if (cornerHandle) {
                 statusText = i18n("Click and drag to resize selection. Middle click to set highlighted position.");
             }
         }
         if (!editable) {
             cursor = Qt::ArrowCursor;
         }
     } else {
         // there used to be guides... :'''(
     }
     useCursor(cursor);
     if (currentStrategy() == 0) {
         emit statusTextChanged(statusText);
     }
 }
 
 void DefaultTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     KoSelection *selection = koSelection();
     if (selection) {
         this->m_decorator = new SelectionDecorator(canvas()->resourceManager());
 
         {
             /**
              * Selection masks don't render the outline of the shapes, so we should
              * do that explicitly when rendering them via selection
              */
 
             KisCanvas2 *kisCanvas = static_cast<KisCanvas2 *>(canvas());
             KisNodeSP node = kisCanvas->viewManager()->nodeManager()->activeNode();
             const bool isSelectionMask = node && node->inherits("KisSelectionMask");
             m_decorator->setForceShapeOutlines(isSelectionMask);
         }
 
         m_decorator->setSelection(selection);
         m_decorator->setHandleRadius(handleRadius());
         m_decorator->setShowFillGradientHandles(hasInteractioFactory(EditFillGradientFactoryId));
         m_decorator->setShowStrokeFillGradientHandles(hasInteractioFactory(EditStrokeGradientFactoryId));
         m_decorator->paint(painter, converter);
     }
 
     KoInteractionTool::paint(painter, converter);
 
     painter.save();
     KoShape::applyConversion(painter, converter);
     canvas()->snapGuide()->paint(painter, converter);
     painter.restore();
 }
 
 bool DefaultTool::isValidForCurrentLayer() const
 {
     // if the currently active node has a shape manager, then it is
     // probably our client :)
 
     KisCanvas2 *kisCanvas = static_cast<KisCanvas2 *>(canvas());
     return bool(kisCanvas->localShapeManager());
 }
 
 KoShapeManager *DefaultTool::shapeManager() const {
     return canvas()->shapeManager();
 }
 
 void DefaultTool::mousePressEvent(KoPointerEvent *event)
 {
     // this tool only works on a vector layer right now, so give a warning if another layer type is trying to use it
     if (!isValidForCurrentLayer()) {
         KisCanvas2 *kiscanvas = static_cast<KisCanvas2 *>(canvas());
         kiscanvas->viewManager()->showFloatingMessage(
                 i18n("This tool only works on vector layers. You probably want the move tool."),
                 QIcon(), 2000, KisFloatingMessage::Medium, Qt::AlignCenter);
         return;
     }
 
     KoInteractionTool::mousePressEvent(event);
     updateCursor();
 }
 
 void DefaultTool::mouseMoveEvent(KoPointerEvent *event)
 {
     KoInteractionTool::mouseMoveEvent(event);
     if (currentStrategy() == 0 && koSelection() && koSelection()->count() > 0) {
         QRectF bound = handlesSize();
 
         if (bound.contains(event->point)) {
             bool inside;
             KoFlake::SelectionHandle newDirection = handleAt(event->point, &inside);
 
             if (inside != m_mouseWasInsideHandles || m_lastHandle != newDirection) {
                 m_lastHandle = newDirection;
                 m_mouseWasInsideHandles = inside;
                 //repaintDecorations();
             }
         } else {
             /*if (m_lastHandle != KoFlake::NoHandle)
                 repaintDecorations(); */
             m_lastHandle = KoFlake::NoHandle;
             m_mouseWasInsideHandles = false;
 
             // there used to be guides... :'''(
         }
     } else {
         // there used to be guides... :'''(
     }
 
     isSelectingTextEditorButton(event->point);
 
     updateCursor();
 }
 
 QRectF DefaultTool::handlesSize()
 {
     KoSelection *selection = koSelection();
     if (!selection || !selection->count()) return QRectF();
 
     recalcSelectionBox(selection);
 
     QRectF bound = m_selectionOutline.boundingRect();
 
     // expansion Border
     if (!canvas() || !canvas()->viewConverter()) {
         return bound;
     }
 
     QPointF border = canvas()->viewConverter()->viewToDocument(QPointF(HANDLE_DISTANCE, HANDLE_DISTANCE));
     bound.adjust(-border.x(), -border.y(), border.x(), border.y());
     return bound;
 }
 
 void DefaultTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     KoInteractionTool::mouseReleaseEvent(event);
     updateCursor();
 
     // test to see if we are selecting button before we decide to check for a selection/de-selection
     const bool selectingTextEditorButton = isSelectingTextEditorButton(event->point);
 
     // this helps tell the next tool that we ned to enter edit mode when it gets activated
     canvas()->selectedShapesProxy()->setRequestingToBeEdited(selectingTextEditorButton);
 
 
     if (selectingTextEditorButton) { // activate text tool
         KoToolManager::instance()->switchToolRequested(KoToolManager::instance()->preferredToolForSelection(koSelection()->selectedShapes()));
     }
 
     // This makes sure the decorations that are shown are refreshed. especally the "T" icon
     canvas()->updateCanvas(QRectF(0,0,canvas()->canvasWidget()->width(), canvas()->canvasWidget()->height()));
 }
 
 void DefaultTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     KoSelection *selection = koSelection();
 
     KoShape *shape = shapeManager()->shapeAt(event->point, KoFlake::ShapeOnTop);
     if (shape && selection && !selection->isSelected(shape)) {
 
         if (!(event->modifiers() & Qt::ShiftModifier)) {
             selection->deselectAll();
         }
 
         selection->select(shape);
     }
 
     explicitUserStrokeEndRequest();
 }
 
 bool DefaultTool::moveSelection(int direction, Qt::KeyboardModifiers modifiers)
 {
     bool result = false;
 
     qreal x = 0.0, y = 0.0;
     if (direction == Qt::Key_Left) {
         x = -5;
     } else if (direction == Qt::Key_Right) {
         x = 5;
     } else if (direction == Qt::Key_Up) {
         y = -5;
     } else if (direction == Qt::Key_Down) {
         y = 5;
     }
 
     if (x != 0.0 || y != 0.0) { // actually move
 
         if ((modifiers & Qt::ShiftModifier) != 0) {
             x *= 10;
             y *= 10;
         } else if ((modifiers & Qt::AltModifier) != 0) { // more precise
             x /= 5;
             y /= 5;
         }
 
         QList<KoShape *> shapes = koSelection()->selectedEditableShapes();
 
         if (!shapes.isEmpty()) {
             canvas()->addCommand(new KoShapeMoveCommand(shapes, QPointF(x, y)));
             result = true;
         }
     }
 
     return result;
 }
 
 void DefaultTool::keyPressEvent(QKeyEvent *event)
 {
     KoInteractionTool::keyPressEvent(event);
     if (currentStrategy() == 0) {
         switch (event->key()) {
         case Qt::Key_Left:
         case Qt::Key_Right:
         case Qt::Key_Up:
         case Qt::Key_Down:
             if (moveSelection(event->key(), event->modifiers())) {
                 event->accept();
             }
             break;
         case Qt::Key_1:
         case Qt::Key_2:
         case Qt::Key_3:
         case Qt::Key_4:
         case Qt::Key_5:
             canvas()->resourceManager()->setResource(HotPosition, event->key() - Qt::Key_1);
             event->accept();
             break;
         default:
             return;
         }
     }
 }
 
 void DefaultTool::repaintDecorations()
 {
     if (koSelection() && koSelection()->count() > 0) {
         canvas()->updateCanvas(handlesSize());
     }
 }
 
 void DefaultTool::copy() const
 {
     // all the selected shapes, not only editable!
     QList<KoShape *> shapes = koSelection()->selectedShapes();
 
     if (!shapes.isEmpty()) {
         KoDrag drag;
         drag.setSvg(shapes);
         drag.addToClipboard();
     }
 }
 
 void DefaultTool::deleteSelection()
 {
     QList<KoShape *> shapes;
     foreach (KoShape *s, koSelection()->selectedShapes()) {
         if (s->isGeometryProtected()) {
             continue;
         }
         shapes << s;
     }
     if (!shapes.empty()) {
         canvas()->addCommand(canvas()->shapeController()->removeShapes(shapes));
     }
 }
 
 bool DefaultTool::paste()
 {
     // we no longer have to do anything as tool Proxy will do it for us
     return false;
 }
 
 KoSelection *DefaultTool::koSelection() const
 {
     Q_ASSERT(canvas());
     Q_ASSERT(canvas()->selectedShapesProxy());
     return canvas()->selectedShapesProxy()->selection();
 }
 
 KoFlake::SelectionHandle DefaultTool::handleAt(const QPointF &point, bool *innerHandleMeaning)
 {
     // check for handles in this order; meaning that when handles overlap the one on top is chosen
     static const KoFlake::SelectionHandle handleOrder[] = {
         KoFlake::BottomRightHandle,
         KoFlake::TopLeftHandle,
         KoFlake::BottomLeftHandle,
         KoFlake::TopRightHandle,
         KoFlake::BottomMiddleHandle,
         KoFlake::RightMiddleHandle,
         KoFlake::LeftMiddleHandle,
         KoFlake::TopMiddleHandle,
         KoFlake::NoHandle
     };
 
     const KoViewConverter *converter = canvas()->viewConverter();
     KoSelection *selection = koSelection();
 
     if (!selection || !selection->count() || !converter) {
         return KoFlake::NoHandle;
     }
 
     recalcSelectionBox(selection);
 
     if (innerHandleMeaning) {
         QPainterPath path;
         path.addPolygon(m_selectionOutline);
         *innerHandleMeaning = path.contains(point) || path.intersects(handlePaintRect(point));
     }
 
     const QPointF viewPoint = converter->documentToView(point);
 
     for (int i = 0; i < KoFlake::NoHandle; ++i) {
         KoFlake::SelectionHandle handle = handleOrder[i];
 
         const QPointF handlePoint = converter->documentToView(m_selectionBox[handle]);
         const qreal distanceSq = kisSquareDistance(viewPoint, handlePoint);
 
         // if just inside the outline
         if (distanceSq < HANDLE_DISTANCE_SQ) {
 
             if (innerHandleMeaning) {
                 if (distanceSq < INNER_HANDLE_DISTANCE_SQ) {
                     *innerHandleMeaning = true;
                 }
             }
 
             return handle;
         }
     }
     return KoFlake::NoHandle;
 }
 
 void DefaultTool::recalcSelectionBox(KoSelection *selection)
 {
     KIS_ASSERT_RECOVER_RETURN(selection->count());
 
     QTransform matrix = selection->absoluteTransformation(0);
     m_selectionOutline = matrix.map(QPolygonF(selection->outlineRect()));
     m_angle = 0.0;
 
     QPolygonF outline = m_selectionOutline; //shorter name in the following :)
     m_selectionBox[KoFlake::TopMiddleHandle] = (outline.value(0) + outline.value(1)) / 2;
     m_selectionBox[KoFlake::TopRightHandle] = outline.value(1);
     m_selectionBox[KoFlake::RightMiddleHandle] = (outline.value(1) + outline.value(2)) / 2;
     m_selectionBox[KoFlake::BottomRightHandle] = outline.value(2);
     m_selectionBox[KoFlake::BottomMiddleHandle] = (outline.value(2) + outline.value(3)) / 2;
     m_selectionBox[KoFlake::BottomLeftHandle] = outline.value(3);
     m_selectionBox[KoFlake::LeftMiddleHandle] = (outline.value(3) + outline.value(0)) / 2;
     m_selectionBox[KoFlake::TopLeftHandle] = outline.value(0);
     if (selection->count() == 1) {
 #if 0        // TODO detect mirroring
         KoShape *s = koSelection()->firstSelectedShape();
 
         if (s->scaleX() < 0) { // vertically mirrored: swap left / right
             std::swap(m_selectionBox[KoFlake::TopLeftHandle], m_selectionBox[KoFlake::TopRightHandle]);
             std::swap(m_selectionBox[KoFlake::LeftMiddleHandle], m_selectionBox[KoFlake::RightMiddleHandle]);
             std::swap(m_selectionBox[KoFlake::BottomLeftHandle], m_selectionBox[KoFlake::BottomRightHandle]);
         }
         if (s->scaleY() < 0) { // vertically mirrored: swap top / bottom
             std::swap(m_selectionBox[KoFlake::TopLeftHandle], m_selectionBox[KoFlake::BottomLeftHandle]);
             std::swap(m_selectionBox[KoFlake::TopMiddleHandle], m_selectionBox[KoFlake::BottomMiddleHandle]);
             std::swap(m_selectionBox[KoFlake::TopRightHandle], m_selectionBox[KoFlake::BottomRightHandle]);
         }
 #endif
     }
 }
 
 void DefaultTool::activate(ToolActivation activation, const QSet<KoShape *> &shapes)
 {
     KoToolBase::activate(activation, shapes);
 
     m_mouseWasInsideHandles = false;
     m_lastHandle = KoFlake::NoHandle;
     useCursor(Qt::ArrowCursor);
     repaintDecorations();
     updateActions();
 
     if (m_tabbedOptionWidget) {
         m_tabbedOptionWidget->activate();
     }
 }
 
 void DefaultTool::deactivate()
 {
     KoToolBase::deactivate();
 
     if (m_tabbedOptionWidget) {
         m_tabbedOptionWidget->deactivate();
     }
 }
 
 void DefaultTool::selectionGroup()
 {
     KoSelection *selection = koSelection();
     if (!selection) return;
 
     QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
     std::sort(selectedShapes.begin(), selectedShapes.end(), KoShape::compareShapeZIndex);
     if (selectedShapes.isEmpty()) return;
 
     const int groupZIndex = selectedShapes.last()->zIndex();
 
     KoShapeGroup *group = new KoShapeGroup();
     group->setZIndex(groupZIndex);
     // TODO what if only one shape is left?
     KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Group shapes"));
     new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
     canvas()->shapeController()->addShapeDirect(group, 0, cmd);
     new KoShapeGroupCommand(group, selectedShapes, true, cmd);
     new KoKeepShapesSelectedCommand({}, {group}, canvas()->selectedShapesProxy(), true, cmd);
     canvas()->addCommand(cmd);
 
     // update selection so we can ungroup immediately again
     selection->deselectAll();
     selection->select(group);
 }
 
 void DefaultTool::selectionUngroup()
 {
     KoSelection *selection = koSelection();
     if (!selection) return;
 
     QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
     std::sort(selectedShapes.begin(), selectedShapes.end(), KoShape::compareShapeZIndex);
 
     KUndo2Command *cmd = 0;
     QList<KoShape*> newShapes;
 
     // add a ungroup command for each found shape container to the macro command
     Q_FOREACH (KoShape *shape, selectedShapes) {
         KoShapeGroup *group = dynamic_cast<KoShapeGroup *>(shape);
         if (group) {
             if (!cmd) {
                 cmd = new KUndo2Command(kundo2_i18n("Ungroup shapes"));
                 new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
             }
             newShapes << group->shapes();
             new KoShapeUngroupCommand(group, group->shapes(),
                                       group->parent() ? QList<KoShape *>() : shapeManager()->topLevelShapes(),
                                       cmd);
             canvas()->shapeController()->removeShape(group, cmd);
         }
     }
     if (cmd) {
         new KoKeepShapesSelectedCommand({}, newShapes, canvas()->selectedShapesProxy(), true, cmd);
         canvas()->addCommand(cmd);
     }
 }
 
 void DefaultTool::selectionTransform(int transformAction)
 {
     KoSelection *selection = koSelection();
     if (!selection) return;
 
     QList<KoShape *> editableShapes = selection->selectedEditableShapes();
     if (editableShapes.isEmpty()) {
         return;
     }
 
     QTransform applyTransform;
     bool shouldReset = false;
     KUndo2MagicString actionName = kundo2_noi18n("BUG: No transform action");
 
 
     switch (TransformActionType(transformAction)) {
     case TransformRotate90CW:
         applyTransform.rotate(90.0);
         actionName = kundo2_i18n("Rotate Object 90° CW");
         break;
     case TransformRotate90CCW:
         applyTransform.rotate(-90.0);
         actionName = kundo2_i18n("Rotate Object 90° CCW");
         break;
     case TransformRotate180:
         applyTransform.rotate(180.0);
         actionName = kundo2_i18n("Rotate Object 180°");
         break;
     case TransformMirrorX:
         applyTransform.scale(-1.0, 1.0);
         actionName = kundo2_i18n("Mirror Object Horizontally");
         break;
     case TransformMirrorY:
         applyTransform.scale(1.0, -1.0);
         actionName = kundo2_i18n("Mirror Object Vertically");
         break;
     case TransformReset:
         shouldReset = true;
         actionName = kundo2_i18n("Reset Object Transformations");
         break;
     }
 
     if (!shouldReset && applyTransform.isIdentity()) return;
 
     QList<QTransform> oldTransforms;
     QList<QTransform> newTransforms;
 
     const QRectF outlineRect = KoShape::absoluteOutlineRect(editableShapes);
     const QPointF centerPoint = outlineRect.center();
     const QTransform centerTrans = QTransform::fromTranslate(centerPoint.x(), centerPoint.y());
     const QTransform centerTransInv = QTransform::fromTranslate(-centerPoint.x(), -centerPoint.y());
 
     // we also add selection to the list of trasformed shapes, so that its outline is updated correctly
     QList<KoShape*> transformedShapes = editableShapes;
     transformedShapes << selection;
 
     Q_FOREACH (KoShape *shape, transformedShapes) {
         oldTransforms.append(shape->transformation());
 
         QTransform t;
 
         if (!shouldReset) {
             const QTransform world = shape->absoluteTransformation(0);
             t =  world * centerTransInv * applyTransform * centerTrans * world.inverted() * shape->transformation();
         } else {
             const QPointF center = shape->outlineRect().center();
             const QPointF offset = shape->transformation().map(center) - center;
             t = QTransform::fromTranslate(offset.x(), offset.y());
         }
 
         newTransforms.append(t);
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(transformedShapes, oldTransforms, newTransforms);
     cmd->setText(actionName);
     canvas()->addCommand(cmd);
 }
 
 void DefaultTool::selectionBooleanOp(int booleanOp)
 {
     KoSelection *selection = koSelection();
     if (!selection) return;
 
     QList<KoShape *> editableShapes = selection->selectedEditableShapes();
     if (editableShapes.isEmpty()) {
         return;
     }
 
     QVector<QPainterPath> srcOutlines;
     QPainterPath dstOutline;
     KUndo2MagicString actionName = kundo2_noi18n("BUG: boolean action name");
 
     // TODO: implement a reference shape selection dialog!
     const int referenceShapeIndex = 0;
     KoShape *referenceShape = editableShapes[referenceShapeIndex];
 
     Q_FOREACH (KoShape *shape, editableShapes) {
         srcOutlines << shape->absoluteTransformation(0).map(shape->outline());
     }
 
     if (booleanOp == BooleanUnion) {
         Q_FOREACH (const QPainterPath &path, srcOutlines) {
             dstOutline |= path;
         }
         actionName = kundo2_i18n("Unite Shapes");
     } else if (booleanOp == BooleanIntersection) {
         for (int i = 0; i < srcOutlines.size(); i++) {
             if (i == 0) {
                 dstOutline = srcOutlines[i];
             } else {
                 dstOutline &= srcOutlines[i];
             }
         }
 
         // there is a bug in Qt, sometimes it leaves the resulting
         // outline open, so just close it explicitly.
         dstOutline.closeSubpath();
 
         actionName = kundo2_i18n("Intersect Shapes");
 
     } else if (booleanOp == BooleanSubtraction) {
         for (int i = 0; i < srcOutlines.size(); i++) {
             dstOutline = srcOutlines[referenceShapeIndex];
             if (i != referenceShapeIndex) {
                 dstOutline -= srcOutlines[i];
             }
         }
 
         actionName = kundo2_i18n("Subtract Shapes");
     }
 
     KoShape *newShape = 0;
 
     if (!dstOutline.isEmpty()) {
         newShape = KoPathShape::createShapeFromPainterPath(dstOutline);
     }
 
     KUndo2Command *cmd = new KUndo2Command(actionName);
 
     new KoKeepShapesSelectedCommand(editableShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
 
     QList<KoShape*> newSelectedShapes;
 
     if (newShape) {
         newShape->setBackground(referenceShape->background());
         newShape->setStroke(referenceShape->stroke());
         newShape->setZIndex(referenceShape->zIndex());
 
         KoShapeContainer *parent = referenceShape->parent();
         canvas()->shapeController()->addShapeDirect(newShape, parent, cmd);
 
         newSelectedShapes << newShape;
     }
 
     canvas()->shapeController()->removeShapes(editableShapes, cmd);
 
     new KoKeepShapesSelectedCommand({}, newSelectedShapes, canvas()->selectedShapesProxy(), true, cmd);
 
     canvas()->addCommand(cmd);
 }
 
 void DefaultTool::selectionSplitShapes()
 {
     KoSelection *selection = koSelection();
     if (!selection) return;
 
     QList<KoShape *> editableShapes = selection->selectedEditableShapes();
     if (editableShapes.isEmpty()) {
         return;
     }
 
     KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Split Shapes"));
 
     new KoKeepShapesSelectedCommand(editableShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
     QList<KoShape*> newShapes;
 
     Q_FOREACH (KoShape *shape, editableShapes) {
         KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
         if (!pathShape) return;
 
         QList<KoPathShape*> splitShapes;
         if (pathShape->separate(splitShapes)) {
             QList<KoShape*> normalShapes = implicitCastList<KoShape*>(splitShapes);
 
             KoShapeContainer *parent = shape->parent();
             canvas()->shapeController()->addShapesDirect(normalShapes, parent, cmd);
             canvas()->shapeController()->removeShape(shape, cmd);
             newShapes << normalShapes;
         }
     }
 
     new KoKeepShapesSelectedCommand({}, newShapes, canvas()->selectedShapesProxy(), true, cmd);
 
     canvas()->addCommand(cmd);
 }
 
 void DefaultTool::selectionAlign(int _align)
 {
     KoShapeAlignCommand::Align align =
         static_cast<KoShapeAlignCommand::Align>(_align);
 
     KoSelection *selection = koSelection();
     if (!selection) return;
 
     QList<KoShape *> editableShapes = selection->selectedEditableShapes();
     if (editableShapes.isEmpty()) {
         return;
     }
 
     // TODO add an option to the widget so that one can align to the page
     // with multiple selected shapes too
 
     QRectF bb;
 
     // single selected shape is automatically aligned to document rect
     if (editableShapes.count() == 1) {
-        if (!canvas()->resourceManager()->hasResource(KoCanvasResourceManager::PageSize)) {
+        if (!canvas()->resourceManager()->hasResource(KoCanvasResourceProvider::PageSize)) {
             return;
         }
-        bb = QRectF(QPointF(0, 0), canvas()->resourceManager()->sizeResource(KoCanvasResourceManager::PageSize));
+        bb = QRectF(QPointF(0, 0), canvas()->resourceManager()->sizeResource(KoCanvasResourceProvider::PageSize));
     } else {
         bb = KoShape::absoluteOutlineRect(editableShapes);
     }
 
     KoShapeAlignCommand *cmd = new KoShapeAlignCommand(editableShapes, align, bb);
     canvas()->addCommand(cmd);
 }
 
 void DefaultTool::selectionDistribute(int _distribute)
 {
     KoShapeDistributeCommand::Distribute distribute =
         static_cast<KoShapeDistributeCommand::Distribute>(_distribute);
 
     KoSelection *selection = koSelection();
     if (!selection) return;
 
     QList<KoShape *> editableShapes = selection->selectedEditableShapes();
     if (editableShapes.size() < 3) {
         return;
     }
 
     QRectF bb = KoShape::absoluteOutlineRect(editableShapes);
     KoShapeDistributeCommand *cmd = new KoShapeDistributeCommand(editableShapes, distribute, bb);
     canvas()->addCommand(cmd);
 }
 
 void DefaultTool::selectionBringToFront()
 {
     selectionReorder(KoShapeReorderCommand::BringToFront);
 }
 
 void DefaultTool::selectionMoveUp()
 {
     selectionReorder(KoShapeReorderCommand::RaiseShape);
 }
 
 void DefaultTool::selectionMoveDown()
 {
     selectionReorder(KoShapeReorderCommand::LowerShape);
 }
 
 void DefaultTool::selectionSendToBack()
 {
     selectionReorder(KoShapeReorderCommand::SendToBack);
 }
 
 void DefaultTool::selectionReorder(KoShapeReorderCommand::MoveShapeType order)
 {
     KoSelection *selection = koSelection();
     if (!selection) {
         return;
     }
 
     QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
     if (selectedShapes.isEmpty()) {
         return;
     }
 
     KUndo2Command *cmd = KoShapeReorderCommand::createCommand(selectedShapes, shapeManager(), order);
     if (cmd) {
         canvas()->addCommand(cmd);
     }
 }
 
 QList<QPointer<QWidget> > DefaultTool::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgets;
 
     m_tabbedOptionWidget = new DefaultToolTabbedWidget(this);
 
     if (isActivated()) {
         m_tabbedOptionWidget->activate();
     }
     widgets.append(m_tabbedOptionWidget);
 
     connect(m_tabbedOptionWidget,
             SIGNAL(sigSwitchModeEditFillGradient(bool)),
             SLOT(slotActivateEditFillGradient(bool)));
 
     connect(m_tabbedOptionWidget,
             SIGNAL(sigSwitchModeEditStrokeGradient(bool)),
             SLOT(slotActivateEditStrokeGradient(bool)));
 
     return widgets;
 }
 
 void DefaultTool::canvasResourceChanged(int key, const QVariant &res)
 {
     if (key == HotPosition) {
         m_hotPosition = KoFlake::AnchorPosition(res.toInt());
         repaintDecorations();
     }
 }
 
 KoInteractionStrategy *DefaultTool::createStrategy(KoPointerEvent *event)
 {
     KoSelection *selection = koSelection();
     if (!selection) return nullptr;
 
     bool insideSelection = false;
     KoFlake::SelectionHandle handle = handleAt(event->point, &insideSelection);
 
     bool editableShape = !selection->selectedEditableShapes().isEmpty();
 
     const bool selectMultiple = event->modifiers() & Qt::ShiftModifier;
     const bool selectNextInStack = event->modifiers() & Qt::ControlModifier;
     const bool avoidSelection = event->modifiers() & Qt::AltModifier;
 
     if (selectNextInStack) {
         // change the hot selection position when middle clicking on a handle
         KoFlake::AnchorPosition newHotPosition = m_hotPosition;
         switch (handle) {
         case KoFlake::TopMiddleHandle:
             newHotPosition = KoFlake::Top;
             break;
         case KoFlake::TopRightHandle:
             newHotPosition = KoFlake::TopRight;
             break;
         case KoFlake::RightMiddleHandle:
             newHotPosition = KoFlake::Right;
             break;
         case KoFlake::BottomRightHandle:
             newHotPosition = KoFlake::BottomRight;
             break;
         case KoFlake::BottomMiddleHandle:
             newHotPosition = KoFlake::Bottom;
             break;
         case KoFlake::BottomLeftHandle:
             newHotPosition = KoFlake::BottomLeft;
             break;
         case KoFlake::LeftMiddleHandle:
             newHotPosition = KoFlake::Left;
             break;
         case KoFlake::TopLeftHandle:
             newHotPosition = KoFlake::TopLeft;
             break;
         case KoFlake::NoHandle:
         default:
             // check if we had hit the center point
             const KoViewConverter *converter = canvas()->viewConverter();
             QPointF pt = converter->documentToView(event->point);
 
             // TODO: use calculated values instead!
             QPointF centerPt = converter->documentToView(selection->absolutePosition());
 
             if (kisSquareDistance(pt, centerPt) < HANDLE_DISTANCE_SQ) {
                 newHotPosition = KoFlake::Center;
             }
 
             break;
         }
 
         if (m_hotPosition != newHotPosition) {
             canvas()->resourceManager()->setResource(HotPosition, newHotPosition);
             return new NopInteractionStrategy(this);
         }
     }
 
     if (!avoidSelection && editableShape) {
         // manipulation of selected shapes goes first
         if (handle != KoFlake::NoHandle) {
             // resizing or shearing only with left mouse button
             if (insideSelection) {
                 bool forceUniformScaling = m_tabbedOptionWidget && m_tabbedOptionWidget->useUniformScaling();
                 return new ShapeResizeStrategy(this, selection, event->point, handle, forceUniformScaling);
             }
 
             if (handle == KoFlake::TopMiddleHandle || handle == KoFlake::RightMiddleHandle ||
                 handle == KoFlake::BottomMiddleHandle || handle == KoFlake::LeftMiddleHandle) {
 
                 return new ShapeShearStrategy(this, selection, event->point, handle);
             }
 
             // rotating is allowed for right mouse button too
             if (handle == KoFlake::TopLeftHandle || handle == KoFlake::TopRightHandle ||
                     handle == KoFlake::BottomLeftHandle || handle == KoFlake::BottomRightHandle) {
 
                 return new ShapeRotateStrategy(this, selection, event->point, event->buttons());
             }
         }
 
         if (!selectMultiple && !selectNextInStack) {
 
             // move the selection if we hold and drag with the text editor button
             // this also helps with how the click events flow to resolve this createStrategy
             const bool selectingTextEditorButton = isSelectingTextEditorButton(event->point);
 
             if (selectingTextEditorButton) { // ignore the event if we are selecting the text editor button
                 return new SelectionInteractionStrategy(this, event->point, false);
             }
 
             if (insideSelection) {
                 return new ShapeMoveStrategy(this, selection, event->point);
             }
         }
     }
 
     KoShape *shape = shapeManager()->shapeAt(event->point, selectNextInStack ? KoFlake::NextUnselected : KoFlake::ShapeOnTop);
 
     if (avoidSelection || (!shape && handle == KoFlake::NoHandle)) {
         if (!selectMultiple) {
             repaintDecorations();
             selection->deselectAll();
         }
         return new SelectionInteractionStrategy(this, event->point, false);
     }
 
     if (selection->isSelected(shape)) {
         if (selectMultiple) {
             repaintDecorations();
             selection->deselect(shape);
         }
     } else if (handle == KoFlake::NoHandle) { // clicked on shape which is not selected
         repaintDecorations();
         if (!selectMultiple) {
             selection->deselectAll();
         }
         selection->select(shape);
         repaintDecorations();
         // tablet selection isn't precise and may lead to a move, preventing that
         if (event->isTabletEvent()) {
             return new NopInteractionStrategy(this);
         }
         return new ShapeMoveStrategy(this, selection, event->point);
     }
     return 0;
 }
 
 void DefaultTool::updateActions()
 {
     QList<KoShape*> editableShapes;
 
     if (koSelection()) {
         editableShapes = koSelection()->selectedEditableShapes();
     }
 
     const bool hasEditableShapes = !editableShapes.isEmpty();
 
     action("object_order_front")->setEnabled(hasEditableShapes);
     action("object_order_raise")->setEnabled(hasEditableShapes);
     action("object_order_lower")->setEnabled(hasEditableShapes);
     action("object_order_back")->setEnabled(hasEditableShapes);
 
     action("object_transform_rotate_90_cw")->setEnabled(hasEditableShapes);
     action("object_transform_rotate_90_ccw")->setEnabled(hasEditableShapes);
     action("object_transform_rotate_180")->setEnabled(hasEditableShapes);
     action("object_transform_mirror_horizontally")->setEnabled(hasEditableShapes);
     action("object_transform_mirror_vertically")->setEnabled(hasEditableShapes);
     action("object_transform_reset")->setEnabled(hasEditableShapes);
 
     const bool multipleSelected = editableShapes.size() > 1;
 
     const bool alignmentEnabled =
        multipleSelected ||
        (!editableShapes.isEmpty() &&
-        canvas()->resourceManager()->hasResource(KoCanvasResourceManager::PageSize));
+        canvas()->resourceManager()->hasResource(KoCanvasResourceProvider::PageSize));
 
     action("object_align_horizontal_left")->setEnabled(alignmentEnabled);
     action("object_align_horizontal_center")->setEnabled(alignmentEnabled);
     action("object_align_horizontal_right")->setEnabled(alignmentEnabled);
     action("object_align_vertical_top")->setEnabled(alignmentEnabled);
     action("object_align_vertical_center")->setEnabled(alignmentEnabled);
     action("object_align_vertical_bottom")->setEnabled(alignmentEnabled);
 
     const bool distributionEnabled = editableShapes.size() > 2;
 
     action("object_distribute_horizontal_left")->setEnabled(distributionEnabled);
     action("object_distribute_horizontal_center")->setEnabled(distributionEnabled);
     action("object_distribute_horizontal_right")->setEnabled(distributionEnabled);
     action("object_distribute_horizontal_gaps")->setEnabled(distributionEnabled);
 
     action("object_distribute_vertical_top")->setEnabled(distributionEnabled);
     action("object_distribute_vertical_center")->setEnabled(distributionEnabled);
     action("object_distribute_vertical_bottom")->setEnabled(distributionEnabled);
     action("object_distribute_vertical_gaps")->setEnabled(distributionEnabled);
 
     updateDistinctiveActions(editableShapes);
 
     emit selectionChanged(editableShapes.size());
 }
 
 void DefaultTool::updateDistinctiveActions(const QList<KoShape*> &editableShapes) {
     const bool multipleSelected = editableShapes.size() > 1;
 
     action("object_group")->setEnabled(multipleSelected);
 
     action("object_unite")->setEnabled(multipleSelected);
     action("object_intersect")->setEnabled(multipleSelected);
     action("object_subtract")->setEnabled(multipleSelected);
 
     bool hasShapesWithMultipleSegments = false;
     Q_FOREACH (KoShape *shape, editableShapes) {
             KoPathShape *pathShape = dynamic_cast<KoPathShape *>(shape);
             if (pathShape && pathShape->subpathCount() > 1) {
                 hasShapesWithMultipleSegments = true;
                 break;
             }
         }
     action("object_split")->setEnabled(hasShapesWithMultipleSegments);
 
 
     bool hasGroupShape = false;
             foreach (KoShape *shape, editableShapes) {
             if (dynamic_cast<KoShapeGroup *>(shape)) {
                 hasGroupShape = true;
                 break;
             }
         }
     action("object_ungroup")->setEnabled(hasGroupShape);
 }
 
 
 KoToolSelection *DefaultTool::selection()
 {
     return m_selectionHandler;
 }
 
 QMenu* DefaultTool::popupActionsMenu()
 {
     if (m_contextMenu) {
         m_contextMenu->clear();
 
         KActionCollection *collection = this->canvas()->canvasController()->actionCollection();
 
         m_contextMenu->addAction(collection->action("edit_cut"));
         m_contextMenu->addAction(collection->action("edit_copy"));
         m_contextMenu->addAction(collection->action("edit_paste"));
 
         m_contextMenu->addSeparator();
 
         m_contextMenu->addAction(action("object_order_front"));
         m_contextMenu->addAction(action("object_order_raise"));
         m_contextMenu->addAction(action("object_order_lower"));
         m_contextMenu->addAction(action("object_order_back"));
 
         if (action("object_group")->isEnabled() || action("object_ungroup")->isEnabled()) {
             m_contextMenu->addSeparator();
             m_contextMenu->addAction(action("object_group"));
             m_contextMenu->addAction(action("object_ungroup"));
         }
 
         m_contextMenu->addSeparator();
 
         QMenu *transform = m_contextMenu->addMenu(i18n("Transform"));
         transform->addAction(action("object_transform_rotate_90_cw"));
         transform->addAction(action("object_transform_rotate_90_ccw"));
         transform->addAction(action("object_transform_rotate_180"));
         transform->addSeparator();
         transform->addAction(action("object_transform_mirror_horizontally"));
         transform->addAction(action("object_transform_mirror_vertically"));
         transform->addSeparator();
         transform->addAction(action("object_transform_reset"));
 
         if (action("object_unite")->isEnabled() ||
             action("object_intersect")->isEnabled() ||
             action("object_subtract")->isEnabled() ||
             action("object_split")->isEnabled()) {
 
             QMenu *transform = m_contextMenu->addMenu(i18n("Logical Operations"));
             transform->addAction(action("object_unite"));
             transform->addAction(action("object_intersect"));
             transform->addAction(action("object_subtract"));
             transform->addAction(action("object_split"));
         }
     }
 
     return m_contextMenu.data();
 }
 
 void DefaultTool::addTransformActions(QMenu *menu) const {
     menu->addAction(action("object_transform_rotate_90_cw"));
     menu->addAction(action("object_transform_rotate_90_ccw"));
     menu->addAction(action("object_transform_rotate_180"));
     menu->addSeparator();
     menu->addAction(action("object_transform_mirror_horizontally"));
     menu->addAction(action("object_transform_mirror_vertically"));
     menu->addSeparator();
     menu->addAction(action("object_transform_reset"));
 }
 
 void DefaultTool::explicitUserStrokeEndRequest()
 {
     QList<KoShape *> shapes = koSelection()->selectedEditableShapesAndDelegates();
     emit activateTemporary(KoToolManager::instance()->preferredToolForSelection(shapes));
 }
 
 bool DefaultTool::isSelectingTextEditorButton(const QPointF &mousePosition)
 {
 
     if (!canvas() || !m_decorator) {
         return false;
     }
 
     // calculate position for textEditorBoxButton
     KoSelection *selection = koSelection();
     const KoViewConverter *converter = canvas()->viewConverter();
 
     if (!selection || !selection->count() || !converter) {
         return false;
     }
 
     QRectF outline = selection->boundingRect();
 
     QPointF absoluteTransormPosition(
         outline.x() + outline.width()*0.5,
         outline.y() + outline.height());
 
 
     QPointF textEditorAbsPosition =  converter->documentToView(absoluteTransormPosition);
     textEditorAbsPosition += decoratorIconPositions.uiOffset;
 
     // check to see if the text decorator is checked (only for text objects)
     const QPointF viewPoint = converter->documentToView(mousePosition);
     const QPointF handlePoint = textEditorAbsPosition;
     const qreal distanceSq = kisSquareDistance(viewPoint, handlePoint);
 
     if (distanceSq < 18 * 18) { // 18 is "handle" area
         m_decorator->setIsOverTextEditorButton(true);
         return true;
     }
     else {
         m_decorator->setIsOverTextEditorButton(false);
         return false;
     }
 }
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.cpp b/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.cpp
index 18053bf125..07085c7a78 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.cpp
+++ b/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.cpp
@@ -1,463 +1,463 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Martin Pfeiffer <hubipete@gmx.net>
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
    Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 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 "DefaultToolGeometryWidget.h"
 #include "DefaultTool.h"
 
 #include <KoInteractionTool.h>
 #include <KoCanvasBase.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include <commands/KoShapeResizeCommand.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <commands/KoShapeSizeCommand.h>
 #include <commands/KoShapeTransformCommand.h>
 #include <commands/KoShapeKeepAspectRatioCommand.h>
 #include <commands/KoShapeTransparencyCommand.h>
 #include "SelectionDecorator.h"
 #include <KoShapeGroup.h>
 
 #include "KoAnchorSelectionWidget.h"
 
 #include <QAction>
 #include <QSize>
 #include <QRadioButton>
 #include <QLabel>
 #include <QCheckBox>
 #include <QDoubleSpinBox>
 #include <QList>
 #include <QTransform>
 #include <kis_algebra_2d.h>
 
 #include "kis_aspect_ratio_locker.h"
 #include "kis_debug.h"
 #include "kis_acyclic_signal_connector.h"
 #include "kis_signal_compressor.h"
 #include "kis_signals_blocker.h"
 
 
 DefaultToolGeometryWidget::DefaultToolGeometryWidget(KoInteractionTool *tool, QWidget *parent)
     : QWidget(parent)
     , m_tool(tool)
     , m_sizeAspectLocker(new KisAspectRatioLocker())
     , m_savedUniformScaling(false)
 {
     setupUi(this);
 
     setUnit(m_tool->canvas()->unit());
 
     // Connect and initialize automated aspect locker
     m_sizeAspectLocker->connectSpinBoxes(widthSpinBox, heightSpinBox, aspectButton);
     aspectButton->setKeepAspectRatio(false);
 
 
     // TODO: use valueChanged() instead!
     connect(positionXSpinBox, SIGNAL(valueChangedPt(qreal)), this, SLOT(slotRepositionShapes()));
     connect(positionYSpinBox, SIGNAL(valueChangedPt(qreal)), this, SLOT(slotRepositionShapes()));
 
     KoSelectedShapesProxy *selectedShapesProxy = m_tool->canvas()->selectedShapesProxy();
 
     connect(selectedShapesProxy, SIGNAL(selectionChanged()), this, SLOT(slotUpdateCheckboxes()));
     connect(selectedShapesProxy, SIGNAL(selectionChanged()), this, SLOT(slotUpdatePositionBoxes()));
     connect(selectedShapesProxy, SIGNAL(selectionChanged()), this, SLOT(slotUpdateOpacitySlider()));
 
     connect(selectedShapesProxy, SIGNAL(selectionContentChanged()), this, SLOT(slotUpdatePositionBoxes()));
     connect(selectedShapesProxy, SIGNAL(selectionContentChanged()), this, SLOT(slotUpdateOpacitySlider()));
 
     connect(chkGlobalCoordinates, SIGNAL(toggled(bool)), SLOT(slotUpdateSizeBoxes()));
 
 
     /**
      * A huge block of self-blocking acycled connections
      */
     KisAcyclicSignalConnector *acyclicConnector = new KisAcyclicSignalConnector(this);
     acyclicConnector->connectForwardVoid(m_sizeAspectLocker.data(), SIGNAL(aspectButtonChanged()), this, SLOT(slotAspectButtonToggled()));
     acyclicConnector->connectBackwardVoid(selectedShapesProxy, SIGNAL(selectionChanged()), this, SLOT(slotUpdateAspectButton()));
     acyclicConnector->connectBackwardVoid(selectedShapesProxy, SIGNAL(selectionContentChanged()), this, SLOT(slotUpdateAspectButton()));
 
     KisAcyclicSignalConnector *sizeConnector = acyclicConnector->createCoordinatedConnector();
     sizeConnector->connectForwardVoid(m_sizeAspectLocker.data(), SIGNAL(sliderValueChanged()), this, SLOT(slotResizeShapes()));
     sizeConnector->connectBackwardVoid(selectedShapesProxy, SIGNAL(selectionChanged()), this, SLOT(slotUpdateSizeBoxes()));
 
     KisAcyclicSignalConnector *contentSizeConnector = acyclicConnector->createCoordinatedConnector();
     contentSizeConnector->connectBackwardVoid(selectedShapesProxy, SIGNAL(selectionContentChanged()), this, SLOT(slotUpdateSizeBoxesNoAspectChange()));
 
 
     // Connect and initialize anchor point resource
-    KoCanvasResourceManager *resourceManager = m_tool->canvas()->resourceManager();
+    KoCanvasResourceProvider *resourceManager = m_tool->canvas()->resourceManager();
     connect(resourceManager,
             SIGNAL(canvasResourceChanged(int,QVariant)),
             SLOT(resourceChanged(int,QVariant)));
     resourceManager->setResource(DefaultTool::HotPosition, int(KoFlake::AnchorPosition::Center));
     positionSelector->setValue(KoFlake::AnchorPosition(resourceManager->resource(DefaultTool::HotPosition).toInt()));
 
     // Connect anchor point selector
     connect(positionSelector, SIGNAL(valueChanged(KoFlake::AnchorPosition)), SLOT(slotAnchorPointChanged()));
 
 
     dblOpacity->setRange(0.0, 1.0, 2);
     dblOpacity->setSingleStep(0.01);
     dblOpacity->setFastSliderStep(0.1);
     dblOpacity->setPrefixes(i18n("Opacity: "), i18n("Opacity [*varies*]: "));
 
     dblOpacity->setValueGetter(
         [](KoShape *s) { return 1.0 - s->transparency(); }
     );
 
     connect(dblOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderChanged(qreal)));
 
     // cold init
     slotUpdateOpacitySlider();
 }
 
 DefaultToolGeometryWidget::~DefaultToolGeometryWidget()
 {
 }
 
 namespace {
 
 void tryAnchorPosition(KoFlake::AnchorPosition anchor,
                        const QRectF &rect,
                        QPointF *position)
 {
     bool valid = false;
     QPointF anchoredPosition = KoFlake::anchorToPoint(anchor, rect, &valid);
 
     if (valid) {
         *position = anchoredPosition;
     }
 }
 
 QRectF calculateSelectionBounds(KoSelection *selection,
                                 KoFlake::AnchorPosition anchor,
                                 bool useGlobalSize,
                                 QList<KoShape*> *outShapes = 0)
 {
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     KoShape *shape = shapes.size() == 1 ? shapes.first() : selection;
 
     QRectF resultRect = shape->outlineRect();
 
     QPointF resultPoint = resultRect.topLeft();
     tryAnchorPosition(anchor, resultRect, &resultPoint);
 
     if (useGlobalSize) {
         resultRect = shape->absoluteTransformation(0).mapRect(resultRect);
     } else {
         /**
          * Some shapes, e.g. KoSelection and KoShapeGroup don't have real size() and
          * do all the resizing with transformation(), just try to cover this case and
          * fetch their scale using the transform.
          */
 
         KisAlgebra2D::DecomposedMatix matrix(shape->transformation());
         resultRect = matrix.scaleTransform().mapRect(resultRect);
     }
 
     resultPoint = shape->absoluteTransformation(0).map(resultPoint);
 
     if (outShapes) {
         *outShapes = shapes;
     }
 
     return QRectF(resultPoint, resultRect.size());
 }
 
 }
 
 void DefaultToolGeometryWidget::slotAnchorPointChanged()
 {
     if (!isVisible()) return;
 
     QVariant newValue(positionSelector->value());
     m_tool->canvas()->resourceManager()->setResource(DefaultTool::HotPosition, newValue);
     slotUpdatePositionBoxes();
 }
 
 void DefaultToolGeometryWidget::slotUpdateCheckboxes()
 {
     if (!isVisible()) return;
 
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     KoShapeGroup *onlyGroupShape = 0;
 
     if (shapes.size() == 1) {
         onlyGroupShape = dynamic_cast<KoShapeGroup*>(shapes.first());
     }
 
     const bool uniformScalingAvailable = shapes.size() <= 1 && !onlyGroupShape;
 
     if (uniformScalingAvailable && !chkUniformScaling->isEnabled()) {
         chkUniformScaling->setChecked(m_savedUniformScaling);
         chkUniformScaling->setEnabled(uniformScalingAvailable);
     } else if (!uniformScalingAvailable && chkUniformScaling->isEnabled()) {
         m_savedUniformScaling = chkUniformScaling->isChecked();
         chkUniformScaling->setChecked(true);
         chkUniformScaling->setEnabled(uniformScalingAvailable);
     }
 
     // TODO: not implemented yet!
     chkAnchorLock->setEnabled(false);
 }
 
 void DefaultToolGeometryWidget::slotAspectButtonToggled()
 {
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     KUndo2Command *cmd =
         new KoShapeKeepAspectRatioCommand(shapes, aspectButton->keepAspectRatio());
 
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolGeometryWidget::slotUpdateAspectButton()
 {
     if (!isVisible()) return;
 
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     bool hasKeepAspectRatio = false;
     bool hasNotKeepAspectRatio = false;
 
     Q_FOREACH (KoShape *shape, shapes) {
         if (shape->keepAspectRatio()) {
             hasKeepAspectRatio = true;
         } else {
             hasNotKeepAspectRatio = true;
         }
 
         if (hasKeepAspectRatio && hasNotKeepAspectRatio) break;
     }
 
     Q_UNUSED(hasNotKeepAspectRatio); // TODO: use for tristated mode of the checkbox
 
     aspectButton->setKeepAspectRatio(hasKeepAspectRatio);
 }
 
 //namespace {
 //qreal calculateCommonShapeTransparency(const QList<KoShape*> &shapes)
 //{
 //    qreal commonTransparency = -1.0;
 
 //    Q_FOREACH (KoShape *shape, shapes) {
 //        if (commonTransparency < 0) {
 //            commonTransparency = shape->transparency();
 //        } else if (!qFuzzyCompare(commonTransparency, shape->transparency())) {
 //            commonTransparency = -1.0;
 //            break;
 //        }
 //    }
 
 //    return commonTransparency;
 //}
 //}
 
 void DefaultToolGeometryWidget::slotOpacitySliderChanged(qreal newOpacity)
 {
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QList<KoShape*> shapes = selection->selectedEditableShapes();
     if (shapes.isEmpty()) return;
 
     KUndo2Command *cmd =
         new KoShapeTransparencyCommand(shapes, 1.0 - newOpacity);
 
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolGeometryWidget::slotUpdateOpacitySlider()
 {
     if (!isVisible()) return;
 
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     dblOpacity->setSelection(shapes);
 }
 
 void DefaultToolGeometryWidget::slotUpdateSizeBoxes(bool updateAspect)
 {
     if (!isVisible()) return;
 
     const bool useGlobalSize = chkGlobalCoordinates->isChecked();
     const KoFlake::AnchorPosition anchor = positionSelector->value();
 
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QRectF bounds = calculateSelectionBounds(selection, anchor, useGlobalSize);
 
     const bool hasSizeConfiguration = !bounds.isNull();
 
     widthSpinBox->setEnabled(hasSizeConfiguration);
     heightSpinBox->setEnabled(hasSizeConfiguration);
 
     if (hasSizeConfiguration) {
         KisSignalsBlocker b(widthSpinBox, heightSpinBox);
         widthSpinBox->changeValue(bounds.width());
         heightSpinBox->changeValue(bounds.height());
         if (updateAspect) {
             m_sizeAspectLocker->updateAspect();
         }
     }
 }
 
 void DefaultToolGeometryWidget::slotUpdateSizeBoxesNoAspectChange()
 {
     slotUpdateSizeBoxes(false);
 }
 
 void DefaultToolGeometryWidget::slotUpdatePositionBoxes()
 {
     if (!isVisible()) return;
 
     const bool useGlobalSize = chkGlobalCoordinates->isChecked();
     const KoFlake::AnchorPosition anchor = positionSelector->value();
 
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QRectF bounds = calculateSelectionBounds(selection, anchor, useGlobalSize);
 
     const bool hasSizeConfiguration = !bounds.isNull();
 
     positionXSpinBox->setEnabled(hasSizeConfiguration);
     positionYSpinBox->setEnabled(hasSizeConfiguration);
 
     if (hasSizeConfiguration) {
         KisSignalsBlocker b(positionXSpinBox, positionYSpinBox);
         positionXSpinBox->changeValue(bounds.x());
         positionYSpinBox->changeValue(bounds.y());
     }
 }
 
 void DefaultToolGeometryWidget::slotRepositionShapes()
 {
     static const qreal eps = 1e-6;
 
     const bool useGlobalSize = chkGlobalCoordinates->isChecked();
     const KoFlake::AnchorPosition anchor = positionSelector->value();
 
     QList<KoShape*> shapes;
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QRectF bounds = calculateSelectionBounds(selection, anchor, useGlobalSize, &shapes);
 
     if (bounds.isNull()) return;
 
     const QPointF oldPosition = bounds.topLeft();
     const QPointF newPosition(positionXSpinBox->value(), positionYSpinBox->value());
     const QPointF diff = newPosition - oldPosition;
 
     if (diff.manhattanLength() < eps) return;
 
     QList<QPointF> oldPositions;
     QList<QPointF> newPositions;
 
     Q_FOREACH (KoShape *shape, shapes) {
         const QPointF oldShapePosition = shape->absolutePosition(anchor);
 
         oldPositions << shape->absolutePosition(anchor);
         newPositions << oldShapePosition + diff;
     }
 
     KUndo2Command *cmd = new KoShapeMoveCommand(shapes, oldPositions, newPositions, anchor);
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolGeometryWidget::slotResizeShapes()
 {
     static const qreal eps = 1e-4;
 
     const bool useGlobalSize = chkGlobalCoordinates->isChecked();
     const KoFlake::AnchorPosition anchor = positionSelector->value();
 
     QList<KoShape*> shapes;
     KoSelection *selection = m_tool->canvas()->selectedShapesProxy()->selection();
     QRectF bounds = calculateSelectionBounds(selection, anchor, useGlobalSize, &shapes);
 
     if (bounds.isNull()) return;
 
     const QSizeF oldSize(bounds.size());
 
     QSizeF newSize(widthSpinBox->value(), heightSpinBox->value());
     newSize = KisAlgebra2D::ensureSizeNotSmaller(newSize, QSizeF(eps, eps));
 
     const qreal scaleX = newSize.width() / oldSize.width();
     const qreal scaleY = newSize.height() / oldSize.height();
 
     if (qAbs(scaleX - 1.0) < eps && qAbs(scaleY - 1.0) < eps) return;
 
     const bool usePostScaling =
         shapes.size() > 1 || chkUniformScaling->isChecked();
 
     KUndo2Command *cmd = new KoShapeResizeCommand(shapes,
                                                   scaleX, scaleY,
                                                   bounds.topLeft(),
                                                   useGlobalSize,
                                                   usePostScaling,
                                                   selection->transformation());
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolGeometryWidget::setUnit(const KoUnit &unit)
 {
     positionXSpinBox->setUnit(unit);
     positionYSpinBox->setUnit(unit);
     widthSpinBox->setUnit(unit);
     heightSpinBox->setUnit(unit);
 
     positionXSpinBox->setLineStep(1.0);
     positionYSpinBox->setLineStep(1.0);
     widthSpinBox->setLineStep(1.0);
     heightSpinBox->setLineStep(1.0);
 
     slotUpdatePositionBoxes();
     slotUpdateSizeBoxes();
 }
 
 bool DefaultToolGeometryWidget::useUniformScaling() const
 {
     return chkUniformScaling->isChecked();
 }
 
 void DefaultToolGeometryWidget::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     slotUpdatePositionBoxes();
     slotUpdateSizeBoxes();
     slotUpdateOpacitySlider();
     slotUpdateAspectButton();
     slotUpdateCheckboxes();
     slotAnchorPointChanged();
 }
 
 void DefaultToolGeometryWidget::resourceChanged(int key, const QVariant &res)
 {
-    if (key == KoCanvasResourceManager::Unit) {
+    if (key == KoCanvasResourceProvider::Unit) {
         setUnit(res.value<KoUnit>());
     } else if (key == DefaultTool::HotPosition) {
         positionSelector->setValue(KoFlake::AnchorPosition(res.toInt()));
     }
 }
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp b/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp
index 37461e944e..5231e99d64 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp
+++ b/plugins/tools/defaulttool/defaulttool/DefaultToolTransformWidget.cpp
@@ -1,286 +1,286 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Martin Pfeiffer <hubipete@gmx.net>
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2008 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 "DefaultToolTransformWidget.h"
 
 #include <KoInteractionTool.h>
 #include <KoCanvasBase.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <commands/KoShapeSizeCommand.h>
 #include <commands/KoShapeTransformCommand.h>
 #include "SelectionDecorator.h"
 
 #include <QSize>
 #include <QRadioButton>
 #include <QLabel>
 #include <QCheckBox>
 #include <QDoubleSpinBox>
 #include <QList>
 #include <QTransform>
 
 #include "kis_document_aware_spin_box_unit_manager.h"
 
 DefaultToolTransformWidget::DefaultToolTransformWidget(KoInteractionTool *tool, QWidget *parent)
     : QMenu(parent)
 {
     m_tool = tool;
 
     setupUi(this);
 
     setUnit(m_tool->canvas()->unit());
 
     connect(m_tool->canvas()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(resourceChanged(int,QVariant)));
 
     connect(rotateButton, SIGNAL(clicked()), this, SLOT(rotationChanged()));
     connect(shearXButton, SIGNAL(clicked()), this, SLOT(shearXChanged()));
     connect(shearYButton, SIGNAL(clicked()), this, SLOT(shearYChanged()));
     connect(scaleXButton, SIGNAL(clicked()), this, SLOT(scaleXChanged()));
     connect(scaleYButton, SIGNAL(clicked()), this, SLOT(scaleYChanged()));
     connect(scaleAspectCheckBox, SIGNAL(toggled(bool)), scaleYSpinBox, SLOT(setDisabled(bool)));
     connect(scaleAspectCheckBox, SIGNAL(toggled(bool)), scaleYButton, SLOT(setDisabled(bool)));
     connect(resetButton, SIGNAL(clicked()), this, SLOT(resetTransformations()));
 }
 
 void DefaultToolTransformWidget::setUnit(const KoUnit &unit)
 {
     shearXSpinBox->setUnit(unit);
     shearYSpinBox->setUnit(unit);
 }
 
 void DefaultToolTransformWidget::resourceChanged(int key, const QVariant &res)
 {
-    if (key == KoCanvasResourceManager::Unit) {
+    if (key == KoCanvasResourceProvider::Unit) {
         setUnit(res.value<KoUnit>());
     }
 }
 
 void DefaultToolTransformWidget::rotationChanged()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal angle = rotateSpinBox->value();
     QPointF rotationCenter = m_tool->canvas()->shapeManager()->selection()->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(rotationCenter.x(), rotationCenter.y());
     matrix.rotate(angle);
     matrix.translate(-rotationCenter.x(), -rotationCenter.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Rotate"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::shearXChanged()
 {
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal shearX = shearXSpinBox->value() / selection->size().height();
     QPointF basePoint = selection->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
     matrix.shear(shearX, 0.0);
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     selection->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Shear X"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::shearYChanged()
 {
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal shearY = shearYSpinBox->value() / selection->size().width();
     QPointF basePoint = selection->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
     matrix.shear(0.0, shearY);
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     selection->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Shear Y"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::scaleXChanged()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal scale = scaleXSpinBox->value() * 0.01; // Input is in per cent
     QPointF basePoint = m_tool->canvas()->shapeManager()->selection()->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
 
     if (scaleAspectCheckBox->isChecked()) {
         matrix.scale(scale, scale);
     } else {
         matrix.scale(scale, 1.0);
     }
 
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Scale"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::scaleYChanged()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     qreal scale = scaleYSpinBox->value() * 0.01; // Input is in per cent
     QPointF basePoint = m_tool->canvas()->shapeManager()->selection()->absolutePosition(SelectionDecorator::hotPosition());
     QTransform matrix;
     matrix.translate(basePoint.x(), basePoint.y());
     matrix.scale(1.0, scale);
     matrix.translate(-basePoint.x(), -basePoint.y());
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->applyAbsoluteTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Scale"));
     m_tool->canvas()->addCommand(cmd);
 }
 
 void DefaultToolTransformWidget::resetTransformations()
 {
     QList<KoShape *> selectedShapes = m_tool->canvas()->shapeManager()->selection()->selectedShapes(KoFlake::TopLevelSelection);
     QList<QTransform> oldTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldTransforms << shape->transformation();
     }
 
     QTransform matrix;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         shape->update();
         shape->setTransformation(matrix);
         shape->update();
     }
 
     m_tool->canvas()->shapeManager()->selection()->applyAbsoluteTransformation(matrix);
     QList<QTransform> newTransforms;
 
     Q_FOREACH (KoShape *shape, selectedShapes) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(selectedShapes, oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Reset Transformations"));
     m_tool->canvas()->addCommand(cmd);
 }
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp b/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp
index 408daa2358..820e9f0a92 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp
+++ b/plugins/tools/defaulttool/defaulttool/DefaultToolWidget.cpp
@@ -1,282 +1,282 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007 Martin Pfeiffer <hubipete@gmx.net>
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
    Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 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 "DefaultToolWidget.h"
 #include "DefaultTool.h"
 
 #include <KoInteractionTool.h>
 #include <KoCanvasBase.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
 #include <KoUnit.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <commands/KoShapeSizeCommand.h>
 #include <commands/KoShapeTransformCommand.h>
 #include <KoPositionSelector.h>
 #include "SelectionDecorator.h"
 #include "DefaultToolTransformWidget.h"
 
 #include <QAction>
 #include <QSize>
 #include <QRadioButton>
 #include <QLabel>
 #include <QCheckBox>
 #include <QDoubleSpinBox>
 #include <QList>
 #include <QTransform>
 
 #include "kis_document_aware_spin_box_unit_manager.h"
 
 DefaultToolWidget::DefaultToolWidget(KoInteractionTool *tool, QWidget *parent)
     : QWidget(parent)
     , m_tool(tool)
     , m_blockSignals(false)
 {
     setupUi(this);
 
     setUnit(m_tool->canvas()->unit());
 
     aspectButton->setKeepAspectRatio(false);
     updatePosition();
     updateSize();
 
     connect(positionSelector, SIGNAL(positionSelected(KoFlake::Position)),
             this, SLOT(positionSelected(KoFlake::Position)));
 
     connect(positionXSpinBox, SIGNAL(editingFinished()), this, SLOT(positionHasChanged()));
     connect(positionYSpinBox, SIGNAL(editingFinished()), this, SLOT(positionHasChanged()));
 
     connect(widthSpinBox, SIGNAL(editingFinished()), this, SLOT(sizeHasChanged()));
     connect(heightSpinBox, SIGNAL(editingFinished()), this, SLOT(sizeHasChanged()));
 
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     connect(selection, SIGNAL(selectionChanged()), this, SLOT(updatePosition()));
     connect(selection, SIGNAL(selectionChanged()), this, SLOT(updateSize()));
     KoShapeManager *manager = m_tool->canvas()->shapeManager();
     connect(manager, SIGNAL(selectionContentChanged()), this, SLOT(updatePosition()));
     connect(manager, SIGNAL(selectionContentChanged()), this, SLOT(updateSize()));
 
     connect(m_tool->canvas()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(resourceChanged(int,QVariant)));
 
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)),
             this, SLOT(aspectButtonToggled(bool)));
 }
 
 void DefaultToolWidget::positionSelected(KoFlake::Position position)
 {
     m_tool->canvas()->resourceManager()->setResource(DefaultTool::HotPosition, QVariant(position));
     updatePosition();
 }
 
 void DefaultToolWidget::updatePosition()
 {
     QPointF selPosition(0, 0);
     KoFlake::Position position = positionSelector->position();
 
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     if (selection && selection->count()) {
         selPosition = selection->absolutePosition(position);
     }
 
     positionXSpinBox->setEnabled(selection && selection->count());
     positionYSpinBox->setEnabled(selection && selection->count());
 
     if (m_blockSignals) {
         return;
     }
     m_blockSignals = true;
     positionXSpinBox->changeValue(selPosition.x());
     positionYSpinBox->changeValue(selPosition.y());
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     bool aspectLocked = false;
     foreach (KoShape *shape, selectedShapes) {
         aspectLocked = aspectLocked | shape->keepAspectRatio();
     }
     aspectButton->setKeepAspectRatio(aspectLocked);
     m_blockSignals = false;
 }
 
 void DefaultToolWidget::positionHasChanged()
 {
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     if (!selection || selection->count() <= 0) {
         return;
     }
 
     KoFlake::Position position = positionSelector->position();
     QPointF newPos(positionXSpinBox->value(), positionYSpinBox->value());
     QPointF oldPos = selection->absolutePosition(position);
     if (oldPos == newPos) {
         return;
     }
 
     QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::TopLevelSelection);
     QPointF moveBy = newPos - oldPos;
     QList<QPointF> oldPositions;
     QList<QPointF> newPositions;
     Q_FOREACH (KoShape *shape, selectedShapes) {
         oldPositions.append(shape->position());
         newPositions.append(shape->position() + moveBy);
     }
     selection->setPosition(selection->position() + moveBy);
     m_tool->canvas()->addCommand(new KoShapeMoveCommand(selectedShapes, oldPositions, newPositions));
     updatePosition();
 }
 
 void DefaultToolWidget::updateSize()
 {
     QSizeF selSize(0, 0);
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     uint selectionCount = 0;
     if (selection && selection->count()) {
         selectionCount = selection->count();
     }
     if (selectionCount) {
         selSize = selection->boundingRect().size();
     }
 
     widthSpinBox->setEnabled(selectionCount);
     heightSpinBox->setEnabled(selectionCount);
 
     if (m_blockSignals) {
         return;
     }
     m_blockSignals = true;
     widthSpinBox->changeValue(selSize.width());
     heightSpinBox->changeValue(selSize.height());
     m_blockSignals = false;
 }
 
 void DefaultToolWidget::sizeHasChanged()
 {
     if (aspectButton->hasFocus()) {
         return;
     }
     if (m_blockSignals) {
         return;
     }
 
     QSizeF newSize(widthSpinBox->value(), heightSpinBox->value());
 
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     QRectF rect = selection->boundingRect();
 
     if (aspectButton->keepAspectRatio()) {
         qreal aspect = rect.width() / rect.height();
         if (rect.width() != newSize.width()) {
             newSize.setHeight(newSize.width() / aspect);
         } else if (rect.height() != newSize.height()) {
             newSize.setWidth(newSize.height() * aspect);
         }
     }
 
     if (rect.width() != newSize.width() || rect.height() != newSize.height()) {
         // get the scale/resize center from the position selector
         QPointF scaleCenter = selection->absolutePosition(positionSelector->position());
 
         QTransform resizeMatrix;
         resizeMatrix.translate(scaleCenter.x(), scaleCenter.y());
         // make sure not to divide by 0 in case the selection is a line and has no width. In this case just scale by 1.
         resizeMatrix.scale(rect.width() ? newSize.width() / rect.width() : 1, rect.height() ? newSize.height() / rect.height() : 1);
         resizeMatrix.translate(-scaleCenter.x(), -scaleCenter.y());
 
         QList<KoShape *> selectedShapes = selection->selectedShapes(KoFlake::StrippedSelection);
         QList<QSizeF> oldSizes, newSizes;
         QList<QTransform> oldState;
         QList<QTransform> newState;
 
         Q_FOREACH (KoShape *shape, selectedShapes) {
             shape->update();
             QSizeF oldSize = shape->size();
             oldState << shape->transformation();
             QTransform shapeMatrix = shape->absoluteTransformation(0);
 
             // calculate the matrix we would apply to the local shape matrix
             // that tells us the effective scale values we have to use for the resizing
             QTransform localMatrix = shapeMatrix * resizeMatrix * shapeMatrix.inverted();
             // save the effective scale values, without any mirroring portion
             const qreal scaleX = qAbs(localMatrix.m11());
             const qreal scaleY = qAbs(localMatrix.m22());
 
             // calculate the scale matrix which is equivalent to our resizing above
             QTransform scaleMatrix = (QTransform().scale(scaleX, scaleY));
             scaleMatrix =  shapeMatrix.inverted() * scaleMatrix * shapeMatrix;
 
             // calculate the new size of the shape, using the effective scale values
             oldSizes << oldSize;
             QSizeF newSize = QSizeF(scaleX * oldSize.width(), scaleY * oldSize.height());
             newSizes << newSize;
             shape->setSize(newSize);
 
             // apply the rest of the transformation without the resizing part
             shape->applyAbsoluteTransformation(scaleMatrix.inverted() * resizeMatrix);
             newState << shape->transformation();
         }
         m_tool->repaintDecorations();
         selection->applyAbsoluteTransformation(resizeMatrix);
         KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Resize"));
         new KoShapeSizeCommand(selectedShapes, oldSizes, newSizes, cmd);
         new KoShapeTransformCommand(selectedShapes, oldState, newState, cmd);
         m_tool->canvas()->addCommand(cmd);
         updateSize();
         updatePosition();
     }
 }
 
 void DefaultToolWidget::setUnit(const KoUnit &unit)
 {
     m_blockSignals = true;
     positionXSpinBox->setUnit(unit);
     positionYSpinBox->setUnit(unit);
     widthSpinBox->setUnit(unit);
     heightSpinBox->setUnit(unit);
     m_blockSignals = false;
 
     updatePosition();
     updateSize();
 }
 
 void DefaultToolWidget::resourceChanged(int key, const QVariant &res)
 {
-    if (key == KoCanvasResourceManager::Unit) {
+    if (key == KoCanvasResourceProvider::Unit) {
         setUnit(res.value<KoUnit>());
     } else if (key == DefaultTool::HotPosition) {
         if (res.toInt() != positionSelector->position()) {
             positionSelector->setPosition(static_cast<KoFlake::Position>(res.toInt()));
             updatePosition();
         }
     }
 }
 
 void DefaultToolWidget::aspectButtonToggled(bool keepAspect)
 {
     if (m_blockSignals) {
         return;
     }
     KoSelection *selection = m_tool->canvas()->shapeManager()->selection();
     foreach (KoShape *shape, selection->selectedShapes(KoFlake::TopLevelSelection)) {
         shape->setKeepAspectRatio(keepAspect);
     }
 }
diff --git a/plugins/tools/defaulttool/defaulttool/SelectionDecorator.cpp b/plugins/tools/defaulttool/defaulttool/SelectionDecorator.cpp
index abf1280c23..bcd159604e 100644
--- a/plugins/tools/defaulttool/defaulttool/SelectionDecorator.cpp
+++ b/plugins/tools/defaulttool/defaulttool/SelectionDecorator.cpp
@@ -1,244 +1,244 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-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 "SelectionDecorator.h"
 
 #include <KoShape.h>
 #include <KoSelection.h>
 #include <KoResourcePaths.h>
 #include "kis_algebra_2d.h"
 
 #include "kis_debug.h"
 #include <KisHandlePainterHelper.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KisQPainterStateSaver.h>
 #include "KoShapeGradientHandles.h"
 #include <KoCanvasBase.h>
 #include <KoSvgTextShape.h>
 
 #include "kis_painting_tweaks.h"
 #include "kis_coordinates_converter.h"
 #include "kis_icon_utils.h"
 
 
 
 #define HANDLE_DISTANCE 10
 
-SelectionDecorator::SelectionDecorator(KoCanvasResourceManager *resourceManager)
+SelectionDecorator::SelectionDecorator(KoCanvasResourceProvider *resourceManager)
     : m_hotPosition(KoFlake::Center)
     , m_handleRadius(7)
     , m_lineWidth(2)
     , m_showFillGradientHandles(false)
     , m_showStrokeFillGradientHandles(false)
     , m_forceShapeOutlines(false)
 {
     m_hotPosition =
         KoFlake::AnchorPosition(
             resourceManager->resource(KoFlake::HotPosition).toInt());
 }
 
 void SelectionDecorator::setSelection(KoSelection *selection)
 {
     m_selection = selection;
 }
 
 void SelectionDecorator::setHandleRadius(int radius)
 {
     m_handleRadius = radius;
     m_lineWidth = qMax(1, (int)(radius / 2));
 }
 
 void SelectionDecorator::setShowFillGradientHandles(bool value)
 {
     m_showFillGradientHandles = value;
 }
 
 void SelectionDecorator::setShowStrokeFillGradientHandles(bool value)
 {
     m_showStrokeFillGradientHandles = value;
 }
 
 void SelectionDecorator::paint(QPainter &painter, const KoViewConverter &converter)
 {
     QList<KoShape*> selectedShapes = m_selection->selectedVisibleShapes();
     if (selectedShapes.isEmpty()) return;
 
     const bool haveOnlyOneEditableShape =
         m_selection->selectedEditableShapes().size() == 1 &&
         selectedShapes.size() == 1;
 
     bool editable = false;
     bool forceBoundngRubberLine = false;
 
     Q_FOREACH (KoShape *shape, KoShape::linearizeSubtree(selectedShapes)) {
         if (!haveOnlyOneEditableShape || !m_showStrokeFillGradientHandles) {
             KisHandlePainterHelper helper =
                 KoShape::createHandlePainterHelper(&painter, shape, converter, m_handleRadius);
 
             helper.setHandleStyle(KisHandleStyle::secondarySelection());
 
             if (!m_forceShapeOutlines) {
                 helper.drawRubberLine(shape->outlineRect());
             } else {
                 QList<QPolygonF> polys = shape->outline().toSubpathPolygons();
 
                 if (polys.size() == 1) {
                     const QPolygonF poly1 = polys[0];
                     const QPolygonF poly2 = QPolygonF(polys[0].boundingRect());
                     const QPolygonF nonoverlap = poly2.subtracted(poly1);
 
                     forceBoundngRubberLine |= !nonoverlap.isEmpty();
                 }
 
                 Q_FOREACH (const QPolygonF &poly, polys) {
                     helper.drawRubberLine(poly);
                 }
             }
         }
 
         if (shape->isShapeEditable()) {
             editable = true;
         }
     }
 
     const QRectF handleArea = m_selection->outlineRect();
 
     // draw extra rubber line around all the shapes
     if (selectedShapes.size() > 1 || forceBoundngRubberLine) {
         KisHandlePainterHelper helper =
             KoShape::createHandlePainterHelper(&painter, m_selection, converter, m_handleRadius);
 
         helper.setHandleStyle(KisHandleStyle::primarySelection());
         helper.drawRubberLine(handleArea);
     }
 
     // if we have no editable shape selected there
     // is no need drawing the selection handles
     if (editable) {
         KisHandlePainterHelper helper =
             KoShape::createHandlePainterHelper(&painter, m_selection, converter, m_handleRadius);
         helper.setHandleStyle(KisHandleStyle::primarySelection());
 
         QPolygonF outline = handleArea;
 
         {
             helper.drawHandleRect(outline.value(0));
             helper.drawHandleRect(outline.value(1));
             helper.drawHandleRect(outline.value(2));
             helper.drawHandleRect(outline.value(3));
             helper.drawHandleRect(0.5 * (outline.value(0) + outline.value(1)));
             helper.drawHandleRect(0.5 * (outline.value(1) + outline.value(2)));
             helper.drawHandleRect(0.5 * (outline.value(2) + outline.value(3)));
             helper.drawHandleRect(0.5 * (outline.value(3) + outline.value(0)));
 
             QPointF hotPos = KoFlake::anchorToPoint(m_hotPosition, handleArea);
             helper.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles());
             helper.drawHandleRect(hotPos);
         }
     }
 
     if (haveOnlyOneEditableShape) {
         KoShape *shape = selectedShapes.first();
 
         // draw a button with "edit text" on it that activates the text editor
         KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
         if (textShape) {
             KisHandlePainterHelper helper = KoShape::createHandlePainterHelper(&painter, m_selection, converter, m_handleRadius);
 
             QPolygonF outline = handleArea;
             m_textEditorButtonPosition = QPointF(0.5 * (outline.value(2) + outline.value(3)));
 
             const QPointF finalHandleRect = m_textEditorButtonPosition;
             helper.drawHandleRect(finalHandleRect, 15, decoratorIconPositions.uiOffset );
             helper.fillHandleRect(finalHandleRect, 15, Qt::white, decoratorIconPositions.uiOffset);
 
             // T icon inside box
             QSize buttonSize(20,20);
             const QPixmap textEditorIcon = KisIconUtils::loadIcon("draw-text").pixmap(buttonSize);
             const QRectF iconSourceRect(QPointF(0, 0), textEditorIcon.size());
             helper.drawPixmap(textEditorIcon, m_textEditorButtonPosition, 20, iconSourceRect); // icon, position, size, sourceRect
 
         }
 
 
         if (m_showFillGradientHandles) {
             paintGradientHandles(shape, KoFlake::Fill, painter, converter);
         } else if (m_showStrokeFillGradientHandles) {
             paintGradientHandles(shape, KoFlake::StrokeFill, painter, converter);
         }
     }
 }
 
 void SelectionDecorator::paintGradientHandles(KoShape *shape, KoFlake::FillVariant fillVariant, QPainter &painter, const KoViewConverter &converter)
 {
     KoShapeGradientHandles gradientHandles(fillVariant, shape);
     QVector<KoShapeGradientHandles::Handle> handles = gradientHandles.handles();
 
     KisHandlePainterHelper helper =
         KoShape::createHandlePainterHelper(&painter, shape, converter, m_handleRadius);
 
     const QTransform t = shape->absoluteTransformation(0).inverted();
 
     if (gradientHandles.type() == QGradient::LinearGradient) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(handles.size() == 2);
 
         if (handles.size() == 2) {
             helper.setHandleStyle(KisHandleStyle::gradientArrows());
             helper.drawGradientArrow(t.map(handles[0].pos), t.map(handles[1].pos), 1.5 * m_handleRadius);
         }
     }
 
     helper.setHandleStyle(KisHandleStyle::gradientHandles());
 
     Q_FOREACH (const KoShapeGradientHandles::Handle &h, handles) {
         if (h.type == KoShapeGradientHandles::Handle::RadialCenter) {
             helper.drawGradientCrossHandle(t.map(h.pos), 1.2 * m_handleRadius);
         } else {
             helper.drawGradientHandle(t.map(h.pos), 1.2 * m_handleRadius);
         }
     }
 }
 
 void SelectionDecorator::setForceShapeOutlines(bool value)
 {
     m_forceShapeOutlines = value;
 }
 
 QPointF SelectionDecorator::textEditorButtonPos()
 {
     return m_textEditorButtonPosition;
 }
 
 void SelectionDecorator::setIsOverTextEditorButton(bool value)
 {
     if (value) { // null check
         m_isHoveringOverTextButton = value;
     } else {
         m_isHoveringOverTextButton = false;
     }
 
 
 }
 
 bool SelectionDecorator::isOverTextEditorButton()
 {
     return m_isHoveringOverTextButton;
 }
diff --git a/plugins/tools/defaulttool/defaulttool/SelectionDecorator.h b/plugins/tools/defaulttool/defaulttool/SelectionDecorator.h
index 82f940531f..88abd79129 100644
--- a/plugins/tools/defaulttool/defaulttool/SelectionDecorator.h
+++ b/plugins/tools/defaulttool/defaulttool/SelectionDecorator.h
@@ -1,110 +1,110 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-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.
 */
 
 #ifndef SELECTIONDECORATOR_H
 #define SELECTIONDECORATOR_H
 
 #include <KoViewConverter.h>
 #include <KoFlake.h>
 
 #include <QPainter>
 #include <QPointer>
 
 class KoSelection;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 static const struct DecoratorIconPositions {
     QPoint uiOffset = QPoint(0, 40);
 } decoratorIconPositions;
 
 /**
  * The SelectionDecorator is used to paint extra user-interface items on top of a selection.
  */
 class SelectionDecorator
 {
 public:
     /**
      * Constructor.
      * @param arrows the direction that needs highlighting. (currently unused)
      * @param rotationHandles if true; the rotation handles will be drawn
      * @param shearHandles if true; the shearhandles will be drawn
      */
-    SelectionDecorator(KoCanvasResourceManager *resourceManager);
+    SelectionDecorator(KoCanvasResourceProvider *resourceManager);
     ~SelectionDecorator() {}
 
     /**
      * paint the decortations.
      * @param painter the painter to paint to.
      * @param converter to convert between internal and view coordinates.
      */
     void paint(QPainter &painter, const KoViewConverter &converter);
 
     /**
      * set the selection that is to be painted.
      * @param selection the current selection.
      */
     void setSelection(KoSelection *selection);
 
     /**
      * set the radius of the selection handles
      * @param radius the new handle radius
      */
     void setHandleRadius(int radius);
 
     /**
      * Set true if you want to render gradient handles on the canvas.
      * Default value: false
      */
     void setShowFillGradientHandles(bool value);
 
     /**
      * Set true if you want to render gradient handles on the canvas.
      * Default value: false
      */
     void setShowStrokeFillGradientHandles(bool value);
 
     /**
      * Text vector objects GUI button for editing text
      */
     QPointF textEditorButtonPos();
     void setIsOverTextEditorButton(bool value);
     bool isOverTextEditorButton();
 
 
     void setForceShapeOutlines(bool value);
 
 private:
     void paintGradientHandles(KoShape *shape, KoFlake::FillVariant fillVariant, QPainter &painter, const KoViewConverter &converter);
 
 private:
     KoFlake::AnchorPosition m_hotPosition;
     KoSelection *m_selection;
     int m_handleRadius;
     int m_lineWidth;
     bool m_showFillGradientHandles;
     bool m_showStrokeFillGradientHandles;
     bool m_forceShapeOutlines;
 
     QPointF m_textEditorButtonPosition;
     bool m_isHoveringOverTextButton;
 };
 
 #endif
diff --git a/plugins/tools/defaulttool/defaulttool/ShapeGradientEditStrategy.cpp b/plugins/tools/defaulttool/defaulttool/ShapeGradientEditStrategy.cpp
index 7373fa74cd..626032923b 100644
--- a/plugins/tools/defaulttool/defaulttool/ShapeGradientEditStrategy.cpp
+++ b/plugins/tools/defaulttool/defaulttool/ShapeGradientEditStrategy.cpp
@@ -1,111 +1,111 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "ShapeGradientEditStrategy.h"
 
 #include <KoToolBase.h>
 #include <KoCanvasBase.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoShapeManager.h>
 #include <KoShape.h>
 #include "kis_assert.h"
 #include "SelectionDecorator.h"
 #include <kundo2command.h>
 #include <KoSnapGuide.h>
 #include <KisSnapPointStrategy.h>
 
 #include "kis_debug.h"
 
 
 struct ShapeGradientEditStrategy::Private
 {
     Private(const QPointF &_start, KoShape *shape, KoFlake::FillVariant fillVariant)
         : start(_start),
           gradientHandles(fillVariant, shape)
     {
     }
 
     QPointF start;
     QPointF initialOffset;
     KoShapeGradientHandles gradientHandles;
     KoShapeGradientHandles::Handle::Type handleType;
     QScopedPointer<KUndo2Command> intermediateCommand;
 };
 
 
 ShapeGradientEditStrategy::ShapeGradientEditStrategy(KoToolBase *tool,
                                                      KoFlake::FillVariant fillVariant,
                                                      KoShape *shape,
                                                      KoShapeGradientHandles::Handle::Type startHandleType,
                                                      const QPointF &clicked)
     : KoInteractionStrategy(tool)
     , m_d(new Private(clicked, shape, fillVariant))
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(shape);
 
     m_d->handleType = startHandleType;
 
     KoShapeGradientHandles::Handle handle = m_d->gradientHandles.getHandle(m_d->handleType);
     m_d->initialOffset = handle.pos - clicked;
 
     KisSnapPointStrategy *strategy = new KisSnapPointStrategy();
     Q_FOREACH (const KoShapeGradientHandles::Handle &h, m_d->gradientHandles.handles()) {
         strategy->addPoint(h.pos);
     }
     tool->canvas()->snapGuide()->addCustomSnapStrategy(strategy);
 }
 
 ShapeGradientEditStrategy::~ShapeGradientEditStrategy()
 {
 }
 
 void ShapeGradientEditStrategy::handleMouseMove(const QPointF &mouseLocation, Qt::KeyboardModifiers modifiers)
 {
     if (m_d->intermediateCommand) {
         m_d->intermediateCommand->undo();
         m_d->intermediateCommand.reset();
     }
 
     const QPointF snappedPosition = tool()->canvas()->snapGuide()->snap(mouseLocation, m_d->initialOffset, modifiers);
     const QPointF diff = snappedPosition- m_d->start;
     m_d->intermediateCommand.reset(m_d->gradientHandles.moveGradientHandle(m_d->handleType, diff));
     m_d->intermediateCommand->redo();
 
     tool()->canvas()->updateCanvas(tool()->canvas()->snapGuide()->boundingRect());
 }
 
 KUndo2Command *ShapeGradientEditStrategy::createCommand()
 {
     return m_d->intermediateCommand.take();
 }
 
 void ShapeGradientEditStrategy::finishInteraction(Qt::KeyboardModifiers modifiers)
 {
     Q_UNUSED(modifiers);
 
     const QRectF dirtyRect = tool()->canvas()->snapGuide()->boundingRect();
     tool()->canvas()->snapGuide()->reset();
     tool()->canvas()->updateCanvas(dirtyRect);
 }
 
 void ShapeGradientEditStrategy::paint(QPainter &painter, const KoViewConverter &converter)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
 }
 
diff --git a/plugins/tools/defaulttool/defaulttool/ShapeMoveStrategy.cpp b/plugins/tools/defaulttool/defaulttool/ShapeMoveStrategy.cpp
index 34eead6ddf..7e9866692d 100644
--- a/plugins/tools/defaulttool/defaulttool/ShapeMoveStrategy.cpp
+++ b/plugins/tools/defaulttool/defaulttool/ShapeMoveStrategy.cpp
@@ -1,127 +1,127 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-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 "ShapeMoveStrategy.h"
 #include "SelectionDecorator.h"
 
 #include <KoCanvasBase.h>
 #include <KoShapeManager.h>
 #include <KoShapeContainer.h>
 #include <KoShapeContainerModel.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <commands/KoShapeMoveCommand.h>
 #include <KoSnapGuide.h>
 #include <KoPointerEvent.h>
 #include <KoToolBase.h>
 #include <KoSelection.h>
 #include <klocalizedstring.h>
 #include <kis_global.h>
 
 #include "kis_debug.h"
 
 ShapeMoveStrategy::ShapeMoveStrategy(KoToolBase *tool, KoSelection *selection, const QPointF &clicked)
     : KoInteractionStrategy(tool)
     , m_start(clicked)
     , m_canvas(tool->canvas())
 {
     QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
 
     QRectF boundingRect;
     Q_FOREACH (KoShape *shape, selectedShapes) {
         m_selectedShapes << shape;
         m_previousPositions << shape->absolutePosition(KoFlake::Center);
         m_newPositions << shape->absolutePosition(KoFlake::Center);
         boundingRect = boundingRect.united(shape->boundingRect());
     }
 
     KoFlake::AnchorPosition anchor =
             KoFlake::AnchorPosition(
                 m_canvas->resourceManager()->resource(KoFlake::HotPosition).toInt());
 
     m_initialOffset = selection->absolutePosition(anchor) - m_start;
     m_canvas->snapGuide()->setIgnoredShapes(KoShape::linearizeSubtree(m_selectedShapes));
 
     tool->setStatusText(i18n("Press Shift to hold x- or y-position."));
 }
 
 void ShapeMoveStrategy::handleMouseMove(const QPointF &point, Qt::KeyboardModifiers modifiers)
 {
     if (m_selectedShapes.isEmpty()) {
         return;
     }
     QPointF diff = point - m_start;
 
     if (modifiers & Qt::ShiftModifier) {
         // Limit change to one direction only
         diff = snapToClosestAxis(diff);
     } else {
         QPointF positionToSnap = point + m_initialOffset;
         tool()->canvas()->updateCanvas(tool()->canvas()->snapGuide()->boundingRect());
         QPointF snappedPosition = tool()->canvas()->snapGuide()->snap(positionToSnap, modifiers);
         tool()->canvas()->updateCanvas(tool()->canvas()->snapGuide()->boundingRect());
         diff = snappedPosition - m_initialOffset - m_start;
     }
 
     moveSelection(diff);
     m_finalMove = diff;
 }
 
 void ShapeMoveStrategy::moveSelection(const QPointF &diff)
 {
     Q_ASSERT(m_newPositions.count());
 
     int i = 0;
     Q_FOREACH (KoShape *shape, m_selectedShapes) {
         QPointF delta = m_previousPositions.at(i) + diff - shape->absolutePosition(KoFlake::Center);
         if (shape->parent()) {
             shape->parent()->model()->proposeMove(shape, delta);
         }
         tool()->canvas()->clipToDocument(shape, delta);
         QPointF newPos(shape->absolutePosition(KoFlake::Center) + delta);
         m_newPositions[i] = newPos;
 
         const QRectF oldDirtyRect = shape->boundingRect();
         shape->setAbsolutePosition(newPos, KoFlake::Center);
         shape->updateAbsolute(oldDirtyRect | oldDirtyRect.translated(delta));
         i++;
     }
 }
 
 KUndo2Command *ShapeMoveStrategy::createCommand()
 {
     tool()->canvas()->snapGuide()->reset();
     if (m_finalMove.isNull()) {
         return 0;
     }
     return new KoShapeMoveCommand(m_selectedShapes, m_previousPositions, m_newPositions);
 }
 
 void ShapeMoveStrategy::finishInteraction(Qt::KeyboardModifiers modifiers)
 {
     Q_UNUSED(modifiers);
     tool()->canvas()->updateCanvas(tool()->canvas()->snapGuide()->boundingRect());
 }
 
 void ShapeMoveStrategy::paint(QPainter &painter, const KoViewConverter &converter)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
 }
diff --git a/plugins/tools/defaulttool/defaulttool/ShapeRotateStrategy.cpp b/plugins/tools/defaulttool/defaulttool/ShapeRotateStrategy.cpp
index 1e17821a77..52625109bb 100644
--- a/plugins/tools/defaulttool/defaulttool/ShapeRotateStrategy.cpp
+++ b/plugins/tools/defaulttool/defaulttool/ShapeRotateStrategy.cpp
@@ -1,124 +1,124 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006-2007 Thomas Zander <zander@kde.org>
  * Copyright (C) 2007-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 "ShapeRotateStrategy.h"
 #include "SelectionDecorator.h"
 
 #include <KoToolBase.h>
 #include <KoCanvasBase.h>
 #include <KoSelection.h>
 #include <KoPointerEvent.h>
 #include <KoShapeManager.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <commands/KoShapeTransformCommand.h>
 
 #include <QPointF>
 #include <math.h>
 #include <klocalizedstring.h>
 
 ShapeRotateStrategy::ShapeRotateStrategy(KoToolBase *tool, KoSelection *selection, const QPointF &clicked, Qt::MouseButtons buttons)
     : KoInteractionStrategy(tool)
     , m_start(clicked)
 {
     /**
      * The outline of the selection should look as if it is also rotated, so we
      * add it to the transformed shapes list.
      */
     m_transformedShapesAndSelection = selection->selectedEditableShapes();
     m_transformedShapesAndSelection << selection;
 
     Q_FOREACH (KoShape *shape, m_transformedShapesAndSelection) {
         m_oldTransforms << shape->transformation();
     }
 
     KoFlake::AnchorPosition anchor = !(buttons & Qt::RightButton) ?
                 KoFlake::Center :
                 KoFlake::AnchorPosition(tool->canvas()->resourceManager()->resource(KoFlake::HotPosition).toInt());
 
     m_rotationCenter = selection->absolutePosition(anchor);
 
     tool->setStatusText(i18n("Press ALT to rotate in 45 degree steps."));
 }
 
 void ShapeRotateStrategy::handleMouseMove(const QPointF &point, Qt::KeyboardModifiers modifiers)
 {
     qreal angle = atan2(point.y() - m_rotationCenter.y(), point.x() - m_rotationCenter.x()) -
                   atan2(m_start.y() - m_rotationCenter.y(), m_start.x() - m_rotationCenter.x());
     angle = angle / M_PI * 180;  // convert to degrees.
     if (modifiers & (Qt::AltModifier | Qt::ControlModifier)) {
         // limit to 45 degree angles
         qreal modula = qAbs(angle);
         while (modula > 45.0) {
             modula -= 45.0;
         }
         if (modula > 22.5) {
             modula -= 45.0;
         }
         angle += (angle > 0 ? -1 : 1) * modula;
     }
 
     rotateBy(angle);
 }
 
 void ShapeRotateStrategy::rotateBy(qreal angle)
 {
     QTransform matrix;
     matrix.translate(m_rotationCenter.x(), m_rotationCenter.y());
     matrix.rotate(angle);
     matrix.translate(-m_rotationCenter.x(), -m_rotationCenter.y());
 
     QRectF totalDirtyRect;
     QTransform applyMatrix = matrix * m_rotationMatrix.inverted();
     m_rotationMatrix = matrix;
     Q_FOREACH (KoShape *shape, m_transformedShapesAndSelection) {
         QRectF dirtyRect = shape->boundingRect();
         shape->applyAbsoluteTransformation(applyMatrix);
 
         dirtyRect |= shape->boundingRect();
         totalDirtyRect |= dirtyRect;
 
         shape->updateAbsolute(dirtyRect);
     }
 
     tool()->canvas()->updateCanvas(totalDirtyRect);
 }
 
 void ShapeRotateStrategy::paint(QPainter &painter, const KoViewConverter &converter)
 {
     // paint the rotation center
     painter.setPen(QPen(Qt::red));
     painter.setBrush(QBrush(Qt::red));
     painter.setRenderHint(QPainter::Antialiasing, true);
     QRectF circle(0, 0, 5, 5);
     circle.moveCenter(converter.documentToView(m_rotationCenter));
     painter.drawEllipse(circle);
 }
 
 KUndo2Command *ShapeRotateStrategy::createCommand()
 {
     QList<QTransform> newTransforms;
     Q_FOREACH (KoShape *shape, m_transformedShapesAndSelection) {
         newTransforms << shape->transformation();
     }
 
     KoShapeTransformCommand *cmd = new KoShapeTransformCommand(m_transformedShapesAndSelection, m_oldTransforms, newTransforms);
     cmd->setText(kundo2_i18n("Rotate"));
     return cmd;
 }
diff --git a/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyTool.cpp b/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyTool.cpp
index 7e031832fc..68e4e00d3c 100644
--- a/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyTool.cpp
+++ b/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyTool.cpp
@@ -1,516 +1,516 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Fela Winkelmolen <fela.kde@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 "KarbonCalligraphyTool.h"
 #include "KarbonCalligraphicShape.h"
 #include "KarbonCalligraphyOptionWidget.h"
 
 #include <KoPathShape.h>
 #include <KoShapeGroup.h>
 #include <KoPointerEvent.h>
 #include <KoPathPoint.h>
 #include <KoCanvasBase.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoSelection.h>
 #include <KoCurveFit.h>
 #include <KoColorBackground.h>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include <KoColor.h>
 #include <KoShapePaintingContext.h>
 #include <KoViewConverter.h>
 
 #include <QAction>
 #include <QDebug>
 #include <klocalizedstring.h>
 #include <QPainter>
 
 #include <cmath>
 
 #undef M_PI
 const qreal M_PI = 3.1415927;
 using std::pow;
 using std::sqrt;
 
 KarbonCalligraphyTool::KarbonCalligraphyTool(KoCanvasBase *canvas)
     : KoToolBase(canvas)
     , m_shape(0)
     , m_angle(0)
     , m_selectedPath(0)
     , m_isDrawing(false)
     , m_speed(0, 0)
     , m_lastShape(0)
 {
     connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), SLOT(updateSelectedPath()));
 
     updateSelectedPath();
 }
 
 KarbonCalligraphyTool::~KarbonCalligraphyTool()
 {
 }
 
 void KarbonCalligraphyTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     if (m_selectedPath) {
         painter.save();
         painter.setRenderHints(QPainter::Antialiasing, false);
         painter.setPen(Qt::red);   // TODO make configurable
         QRectF rect = m_selectedPath->boundingRect();
         QPointF p1 = converter.documentToView(rect.topLeft());
         QPointF p2 = converter.documentToView(rect.bottomRight());
         painter.drawRect(QRectF(p1, p2));
         painter.restore();
     }
 
     if (!m_shape) {
         return;
     }
 
     painter.save();
 
     painter.setTransform(m_shape->absoluteTransformation(&converter) *
                          painter.transform());
     KoShapePaintingContext paintContext; //FIXME
     m_shape->paint(painter, converter, paintContext);
 
     painter.restore();
 }
 
 void KarbonCalligraphyTool::mousePressEvent(KoPointerEvent *event)
 {
     if (m_isDrawing) {
         return;
     }
 
     m_lastPoint = event->point;
     m_speed = QPointF(0, 0);
 
     m_isDrawing = true;
     m_pointCount = 0;
     m_shape = new KarbonCalligraphicShape(m_caps);
     m_shape->setBackground(QSharedPointer<KoShapeBackground>(new KoColorBackground(canvas()->resourceManager()->foregroundColor().toQColor())));
     //addPoint( event );
 }
 
 void KarbonCalligraphyTool::mouseMoveEvent(KoPointerEvent *event)
 {
     if (!m_isDrawing) {
         return;
     }
 
     addPoint(event);
 }
 
 void KarbonCalligraphyTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     if (!m_isDrawing) {
         return;
     }
 
     if (m_pointCount == 0) {
         // handle click: select shape (if any)
         if (event->point == m_lastPoint) {
             KoShapeManager *shapeManager = canvas()->shapeManager();
             KoShape *selectedShape = shapeManager->shapeAt(event->point);
             if (selectedShape != 0) {
                 shapeManager->selection()->deselectAll();
                 shapeManager->selection()->select(selectedShape);
             }
         }
 
         delete m_shape;
         m_shape = 0;
         m_isDrawing = false;
         return;
     } else {
         m_endOfPath = false;    // allow last point being added
         addPoint(event);        // add last point
         m_isDrawing = false;
     }
 
     m_shape->simplifyGuidePath();
 
     KUndo2Command *cmd = canvas()->shapeController()->addShape(m_shape, 0);
     if (cmd) {
         m_lastShape = m_shape;
         canvas()->addCommand(cmd);
         canvas()->updateCanvas(m_shape->boundingRect());
     } else {
         // don't leak shape when command could not be created
         delete m_shape;
     }
 
     m_shape = 0;
 }
 
 void KarbonCalligraphyTool::addPoint(KoPointerEvent *event)
 {
     if (m_pointCount == 0) {
         if (m_usePath && m_selectedPath) {
             m_selectedPathOutline = m_selectedPath->outline();
         }
         m_pointCount = 1;
         m_endOfPath = false;
         m_followPathPosition = 0;
         m_lastMousePos = event->point;
         m_lastPoint = calculateNewPoint(event->point, &m_speed);
         m_deviceSupportsTilt = (event->xTilt() != 0 || event->yTilt() != 0);
         return;
     }
 
     if (m_endOfPath) {
         return;
     }
 
     ++m_pointCount;
 
     setAngle(event);
 
     QPointF newSpeed;
     QPointF newPoint = calculateNewPoint(event->point, &newSpeed);
     qreal width = calculateWidth(event->pressure());
     qreal angle = calculateAngle(m_speed, newSpeed);
 
     // add the previous point
     m_shape->appendPoint(m_lastPoint, angle, width);
 
     m_speed = newSpeed;
     m_lastPoint = newPoint;
     canvas()->updateCanvas(m_shape->lastPieceBoundingRect());
 
     if (m_usePath && m_selectedPath) {
         m_speed = QPointF(0, 0);    // following path
     }
 }
 
 void KarbonCalligraphyTool::setAngle(KoPointerEvent *event)
 {
     if (!m_useAngle) {
         m_angle = (360 - m_customAngle + 90) / 180.0 * M_PI;
         return;
     }
 
     // setting m_angle to the angle of the device
     if (event->xTilt() != 0 || event->yTilt() != 0) {
         m_deviceSupportsTilt = false;
     }
 
     if (m_deviceSupportsTilt) {
         if (event->xTilt() == 0 && event->yTilt() == 0) {
             return;    // leave as is
         }
         qDebug() << "using tilt" << m_angle;
 
         if (event->x() == 0) {
             m_angle = M_PI / 2;
             return;
         }
 
         // y is inverted in qt painting
         m_angle = std::atan(static_cast<double>(-event->yTilt() / event->xTilt())) + M_PI / 2;
     } else {
         m_angle = event->rotation() + M_PI / 2;
         qDebug() << "using rotation" << m_angle;
     }
 }
 
 QPointF KarbonCalligraphyTool::calculateNewPoint(const QPointF &mousePos, QPointF *speed)
 {
     if (!m_usePath || !m_selectedPath) { // don't follow path
         QPointF force = mousePos - m_lastPoint;
         QPointF dSpeed = force / m_mass;
         *speed = m_speed * (1.0 - m_drag) + dSpeed;
         return m_lastPoint + *speed;
     }
 
     QPointF sp = mousePos - m_lastMousePos;
     m_lastMousePos = mousePos;
 
     // follow selected path
     qreal step = QLineF(QPointF(0, 0), sp).length();
     m_followPathPosition += step;
 
     qreal t;
     if (m_followPathPosition >= m_selectedPathOutline.length()) {
         t = 1.0;
         m_endOfPath = true;
     } else {
         t = m_selectedPathOutline.percentAtLength(m_followPathPosition);
     }
 
     QPointF res = m_selectedPathOutline.pointAtPercent(t)
             + m_selectedPath->position();
     *speed = res - m_lastPoint;
     return res;
 }
 
 qreal KarbonCalligraphyTool::calculateWidth(qreal pressure)
 {
     // calculate the modulo of the speed
     qreal speed = std::sqrt(pow(m_speed.x(), 2) + pow(m_speed.y(), 2));
     qreal thinning =  m_thinning * (speed + 1) / 10.0; // can be negative
 
     if (thinning > 1) {
         thinning = 1;
     }
 
     if (!m_usePressure) {
         pressure = 1.0;
     }
 
     qreal strokeWidth = m_strokeWidth * pressure * (1 - thinning);
 
     const qreal MINIMUM_STROKE_WIDTH = 1.0;
     if (strokeWidth < MINIMUM_STROKE_WIDTH) {
         strokeWidth = MINIMUM_STROKE_WIDTH;
     }
 
     return strokeWidth;
 }
 
 qreal KarbonCalligraphyTool::calculateAngle(const QPointF &oldSpeed, const QPointF &newSpeed)
 {
     // calculate the avarage of the speed (sum of the normalized values)
     qreal oldLength = QLineF(QPointF(0, 0), oldSpeed).length();
     qreal newLength = QLineF(QPointF(0, 0), newSpeed).length();
     QPointF oldSpeedNorm = !qFuzzyCompare(oldLength + 1, 1) ?
                 oldSpeed / oldLength : QPointF(0, 0);
     QPointF newSpeedNorm = !qFuzzyCompare(newLength + 1, 1) ?
                 newSpeed / newLength : QPointF(0, 0);
     QPointF speed = oldSpeedNorm + newSpeedNorm;
 
     // angle solely based on the speed
     qreal speedAngle = 0;
     if (speed.x() != 0) { // avoid division by zero
         speedAngle = std::atan(speed.y() / speed.x());
     } else if (speed.y() > 0) {
         // x == 0 && y != 0
         speedAngle = M_PI / 2;
     } else if (speed.y() < 0) {
         // x == 0 && y != 0
         speedAngle = -M_PI / 2;
     }
     if (speed.x() < 0) {
         speedAngle += M_PI;
     }
 
     // move 90 degrees
     speedAngle += M_PI / 2;
 
     qreal fixedAngle = m_angle;
     // check if the fixed angle needs to be flipped
     qreal diff = fixedAngle - speedAngle;
     while (diff >= M_PI) { // normalize diff between -180 and 180
         diff -= 2 * M_PI;
     }
     while (diff < -M_PI) {
         diff += 2 * M_PI;
     }
 
     if (std::abs(diff) > M_PI / 2) { // if absolute value < 90
         fixedAngle += M_PI;    // += 180
     }
 
     qreal dAngle = speedAngle - fixedAngle;
 
     // normalize dAngle between -90 and +90
     while (dAngle >= M_PI / 2) {
         dAngle -= M_PI;
     }
     while (dAngle < -M_PI / 2) {
         dAngle += M_PI;
     }
 
     qreal angle = fixedAngle + dAngle * (1.0 - m_fixation);
 
     return angle;
 }
 
 void KarbonCalligraphyTool::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KoToolBase::activate(activation, shapes);
 
     useCursor(Qt::CrossCursor);
     m_lastShape = 0;
 }
 
 void KarbonCalligraphyTool::deactivate()
 {
     if (m_lastShape && canvas()->shapeManager()->shapes().contains(m_lastShape)) {
         KoSelection *selection = canvas()->shapeManager()->selection();
         selection->deselectAll();
         selection->select(m_lastShape);
     }
 
     KoToolBase::deactivate();
 }
 
 QList<QPointer<QWidget> > KarbonCalligraphyTool::createOptionWidgets()
 {
     // if the widget don't exists yet create it
     QList<QPointer<QWidget> > widgets;
 
     //KoFillConfigWidget *fillWidget = new KoFillConfigWidget(0);
     //fillWidget->setWindowTitle(i18n("Fill"));
     //widgets.append(fillWidget);
 
     KarbonCalligraphyOptionWidget *widget = new KarbonCalligraphyOptionWidget;
     connect(widget, SIGNAL(usePathChanged(bool)),
             this, SLOT(setUsePath(bool)));
 
     connect(widget, SIGNAL(usePressureChanged(bool)),
             this, SLOT(setUsePressure(bool)));
 
     connect(widget, SIGNAL(useAngleChanged(bool)),
             this, SLOT(setUseAngle(bool)));
 
     connect(widget, SIGNAL(widthChanged(double)),
             this, SLOT(setStrokeWidth(double)));
 
     connect(widget, SIGNAL(thinningChanged(double)),
             this, SLOT(setThinning(double)));
 
     connect(widget, SIGNAL(angleChanged(int)),
             this, SLOT(setAngle(int)));
 
     connect(widget, SIGNAL(fixationChanged(double)),
             this, SLOT(setFixation(double)));
 
     connect(widget, SIGNAL(capsChanged(double)),
             this, SLOT(setCaps(double)));
 
     connect(widget, SIGNAL(massChanged(double)),
             this, SLOT(setMass(double)));
 
     connect(widget, SIGNAL(dragChanged(double)),
             this, SLOT(setDrag(double)));
 
     connect(this, SIGNAL(pathSelectedChanged(bool)),
             widget, SLOT(setUsePathEnabled(bool)));
 
     // add shortcuts
     QAction *action = new QAction(i18n("Calligraphy: increase width"), this);
     action->setShortcut(Qt::Key_Right);
     connect(action, SIGNAL(triggered()), widget, SLOT(increaseWidth()));
     addAction("calligraphy_increase_width", action);
 
     action = new QAction(i18n("Calligraphy: decrease width"), this);
     action->setShortcut(Qt::Key_Left);
     connect(action, SIGNAL(triggered()), widget, SLOT(decreaseWidth()));
     addAction("calligraphy_decrease_width", action);
 
     action = new QAction(i18n("Calligraphy: increase angle"), this);
     action->setShortcut(Qt::Key_Up);
     connect(action, SIGNAL(triggered()), widget, SLOT(increaseAngle()));
     addAction("calligraphy_increase_angle", action);
 
     action = new QAction(i18n("Calligraphy: decrease angle"), this);
     action->setShortcut(Qt::Key_Down);
     connect(action, SIGNAL(triggered()), widget, SLOT(decreaseAngle()));
     addAction("calligraphy_decrease_angle", action);
 
     // sync all parameters with the loaded profile
     widget->emitAll();
     widget->setObjectName(i18n("Calligraphy"));
     widget->setWindowTitle(i18n("Calligraphy"));
     widgets.append(widget);
 
     return widgets;
 }
 
 void KarbonCalligraphyTool::setStrokeWidth(double width)
 {
     m_strokeWidth = width;
 }
 
 void KarbonCalligraphyTool::setThinning(double thinning)
 {
     m_thinning = thinning;
 }
 
 void KarbonCalligraphyTool::setAngle(int angle)
 {
     m_customAngle = angle;
 }
 
 void KarbonCalligraphyTool::setFixation(double fixation)
 {
     m_fixation = fixation;
 }
 
 void KarbonCalligraphyTool::setMass(double mass)
 {
     m_mass = mass * mass + 1;
 }
 
 void KarbonCalligraphyTool::setDrag(double drag)
 {
     m_drag = drag;
 }
 
 void KarbonCalligraphyTool::setUsePath(bool usePath)
 {
     m_usePath = usePath;
 }
 
 void KarbonCalligraphyTool::setUsePressure(bool usePressure)
 {
     m_usePressure = usePressure;
 }
 
 void KarbonCalligraphyTool::setUseAngle(bool useAngle)
 {
     m_useAngle = useAngle;
 }
 
 void KarbonCalligraphyTool::setCaps(double caps)
 {
     m_caps = caps;
 }
 
 void KarbonCalligraphyTool::updateSelectedPath()
 {
     KoPathShape *oldSelectedPath = m_selectedPath; // save old value
 
     KoSelection *selection = canvas()->shapeManager()->selection();
     if (selection) {
         // null pointer if it the selection isn't a KoPathShape
         // or if the selection is empty
         m_selectedPath =
                 dynamic_cast<KoPathShape *>(selection->firstSelectedShape());
 
         // or if it's a KoPathShape but with no or more than one subpaths
         if (m_selectedPath && m_selectedPath->subpathCount() != 1) {
             m_selectedPath = 0;
         }
 
         // or if there ora none or more than 1 shapes selected
         if (selection->count() != 1) {
             m_selectedPath = 0;
         }
 
         // emit signal it there wasn't a selected path and now there is
         // or the other way around
         if ((m_selectedPath != 0) != (oldSelectedPath != 0)) {
             emit pathSelectedChanged(m_selectedPath != 0);
         }
     }
 }
diff --git a/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp b/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp
index 82bcf34f7b..03a3c00643 100644
--- a/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp
+++ b/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp
@@ -1,142 +1,142 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_liquify_paint_helper.h"
 
 #include "kis_algebra_2d.h"
 #include "KoPointerEvent.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_painting_information_builder.h"
 #include "kis_liquify_transform_worker.h"
 #include <brushengine/kis_paintop_utils.h>
 #include "kis_coordinates_converter.h"
 #include "kis_liquify_paintop.h"
 #include "kis_liquify_properties.h"
 
 struct KisLiquifyPaintHelper::Private
 {
     Private(const KisCoordinatesConverter *_converter)
         : converter(_converter),
           infoBuilder(new KisConverterPaintingInformationBuilder(converter)),
           hasPaintedAtLeastOnce(false)
     {
     }
 
     KisPaintInformation previousPaintInfo;
 
     QScopedPointer<KisLiquifyPaintop> paintOp;
     KisDistanceInformation currentDistance;
     const KisCoordinatesConverter *converter;
     QScopedPointer<KisPaintingInformationBuilder> infoBuilder;
 
     QTime strokeTime;
 
     bool hasPaintedAtLeastOnce;
 
     KisDistanceInformation previousDistanceInfo;
     KisPaintOpUtils::PositionHistory lastOutlinePos;
     void updatePreviousPaintInfo(const KisPaintInformation &info);
 };
 
 
 KisLiquifyPaintHelper::KisLiquifyPaintHelper(const KisCoordinatesConverter *converter)
     : m_d(new Private(converter))
 {
 }
 
 KisLiquifyPaintHelper::~KisLiquifyPaintHelper()
 {
 }
 
 void KisLiquifyPaintHelper::Private::updatePreviousPaintInfo(const KisPaintInformation &info)
 {
     QPointF prevPos = lastOutlinePos.pushThroughHistory(info.pos());
     qreal angle = KisAlgebra2D::directionBetweenPoints(prevPos, info.pos(), 0);
 
     previousDistanceInfo =
         KisDistanceInformation(prevPos, angle);
 
     previousPaintInfo = info;
 }
 
 QPainterPath KisLiquifyPaintHelper::brushOutline(const KisLiquifyProperties &props)
 {
     KisPaintInformation::DistanceInformationRegistrar registrar =
         m_d->previousPaintInfo.registerDistanceInformation(&m_d->previousDistanceInfo);
 
     return KisLiquifyPaintop::brushOutline(props, m_d->previousPaintInfo);
 }
 
 void KisLiquifyPaintHelper::configurePaintOp(const KisLiquifyProperties &props,
                                              KisLiquifyTransformWorker *worker)
 {
     m_d->paintOp.reset(new KisLiquifyPaintop(props, worker));
 }
 
-void KisLiquifyPaintHelper::startPaint(KoPointerEvent *event, const KoCanvasResourceManager *manager)
+void KisLiquifyPaintHelper::startPaint(KoPointerEvent *event, const KoCanvasResourceProvider *manager)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->paintOp);
 
     m_d->strokeTime.start();
     KisPaintInformation pi =
         m_d->infoBuilder->startStroke(event, m_d->strokeTime.elapsed(), manager);
 
     m_d->updatePreviousPaintInfo(pi);
     m_d->hasPaintedAtLeastOnce = false;
 }
 
 void KisLiquifyPaintHelper::continuePaint(KoPointerEvent *event)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->paintOp);
 
     KisPaintInformation pi =
         m_d->infoBuilder->continueStroke(event, m_d->strokeTime.elapsed());
 
     KisPaintOpUtils::paintLine(*m_d->paintOp.data(),
                                m_d->previousPaintInfo,
                                pi,
                                &m_d->currentDistance,
                                false, false);
 
     m_d->updatePreviousPaintInfo(pi);
     m_d->hasPaintedAtLeastOnce = true;
 }
 
 bool KisLiquifyPaintHelper::endPaint(KoPointerEvent *event)
 {
     KIS_ASSERT_RECOVER(m_d->paintOp) { return false; }
 
     if (!m_d->hasPaintedAtLeastOnce) {
         KisPaintInformation pi =
             m_d->infoBuilder->continueStroke(event, m_d->strokeTime.elapsed());
 
         pi.paintAt(*m_d->paintOp.data(), &m_d->previousDistanceInfo);
     }
 
     m_d->paintOp.reset();
 
     return !m_d->hasPaintedAtLeastOnce;
 }
 
 void KisLiquifyPaintHelper::hoverPaint(KoPointerEvent *event)
 {
     QPointF imagePoint = m_d->converter->documentToImage(event->pos());
     KisPaintInformation pi = m_d->infoBuilder->hover(imagePoint, event);
 
     m_d->updatePreviousPaintInfo(pi);
 }
diff --git a/plugins/tools/tool_transform2/kis_liquify_paint_helper.h b/plugins/tools/tool_transform2/kis_liquify_paint_helper.h
index 9aa765d52f..1da0b72732 100644
--- a/plugins/tools/tool_transform2/kis_liquify_paint_helper.h
+++ b/plugins/tools/tool_transform2/kis_liquify_paint_helper.h
@@ -1,53 +1,53 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_LIQUIFY_PAINT_HELPER_H
 #define __KIS_LIQUIFY_PAINT_HELPER_H
 
 #include <QScopedPointer>
 
 class KisLiquifyTransformWorker;
 class KisCoordinatesConverter;
 class KoPointerEvent;
 class KisLiquifyProperties;
 class QPainterPath;
-class KoCanvasResourceManager;
+class KoCanvasResourceProvider;
 
 class KisLiquifyPaintHelper
 {
 public:
     KisLiquifyPaintHelper(const KisCoordinatesConverter *converter);
     ~KisLiquifyPaintHelper();
 
     void configurePaintOp(const KisLiquifyProperties &_props,
                           KisLiquifyTransformWorker *worker);
 
-    void startPaint(KoPointerEvent *event, const KoCanvasResourceManager *manager);
+    void startPaint(KoPointerEvent *event, const KoCanvasResourceProvider *manager);
     void continuePaint(KoPointerEvent *event);
     bool endPaint(KoPointerEvent *event);
 
     void hoverPaint(KoPointerEvent *event);
 
     QPainterPath brushOutline(const KisLiquifyProperties &props);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_LIQUIFY_PAINT_HELPER_H */
diff --git a/plugins/tools/tool_transform2/kis_liquify_transform_strategy.cpp b/plugins/tools/tool_transform2/kis_liquify_transform_strategy.cpp
index 9ed3659259..96628801aa 100644
--- a/plugins/tools/tool_transform2/kis_liquify_transform_strategy.cpp
+++ b/plugins/tools/tool_transform2/kis_liquify_transform_strategy.cpp
@@ -1,309 +1,309 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_liquify_transform_strategy.h"
 
 #include <algorithm>
 
 #include <QPointF>
 #include <QPainter>
 
 #include "KoPointerEvent.h"
 
 #include "kis_coordinates_converter.h"
 #include "tool_transform_args.h"
 #include "transform_transaction_properties.h"
 #include "krita_utils.h"
 #include "kis_cursor.h"
 #include "kis_transform_utils.h"
 #include "kis_algebra_2d.h"
 #include "kis_liquify_paint_helper.h"
 #include "kis_liquify_transform_worker.h"
-#include "KoCanvasResourceManager.h"
+#include "KoCanvasResourceProvider.h"
 
 
 struct KisLiquifyTransformStrategy::Private
 {
     Private(KisLiquifyTransformStrategy *_q,
             const KisCoordinatesConverter *_converter,
             ToolTransformArgs &_currentArgs,
             TransformTransactionProperties &_transaction,
-            const KoCanvasResourceManager *_manager)
+            const KoCanvasResourceProvider *_manager)
         : manager(_manager),
           q(_q),
           converter(_converter),
           currentArgs(_currentArgs),
           transaction(_transaction),
           helper(_converter),
           recalculateOnNextRedraw(false)
     {
     }
 
-    const KoCanvasResourceManager *manager;
+    const KoCanvasResourceProvider *manager;
 
     KisLiquifyTransformStrategy * const q;
 
     /// standard members ///
 
     const KisCoordinatesConverter *converter;
 
     //////
     ToolTransformArgs &currentArgs;
     //////
     TransformTransactionProperties &transaction;
 
     QTransform paintingTransform;
     QPointF paintingOffset;
 
     QTransform handlesTransform;
 
     /// custom members ///
 
     QImage transformedImage;
 
     // size-gesture-related
     QPointF lastMouseWidgetPos;
     QPointF startResizeImagePos;
     QPoint startResizeGlobalCursorPos;
 
     KisLiquifyPaintHelper helper;
 
     bool recalculateOnNextRedraw;
 
     void recalculateTransformations();
     inline QPointF imageToThumb(const QPointF &pt, bool useFlakeOptimization);
 };
 
 KisLiquifyTransformStrategy::KisLiquifyTransformStrategy(const KisCoordinatesConverter *converter,
                                                          ToolTransformArgs &currentArgs,
                                                          TransformTransactionProperties &transaction,
-                                                         const KoCanvasResourceManager *manager)
+                                                         const KoCanvasResourceProvider *manager)
 
     : m_d(new Private(this, converter, currentArgs, transaction, manager))
 {
 }
 
 KisLiquifyTransformStrategy::~KisLiquifyTransformStrategy()
 {
 }
 
 QPainterPath KisLiquifyTransformStrategy::getCursorOutline() const
 {
     return m_d->helper.brushOutline(*m_d->currentArgs.liquifyProperties());
 }
 
 void KisLiquifyTransformStrategy::setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive)
 {
     Q_UNUSED(mousePos);
     Q_UNUSED(perspectiveModifierActive);
 }
 
 QCursor KisLiquifyTransformStrategy::getCurrentCursor() const
 {
     return Qt::BlankCursor;
 }
 
 void KisLiquifyTransformStrategy::paint(QPainter &gc)
 {
     // Draw preview image
 
     if (m_d->recalculateOnNextRedraw) {
         m_d->recalculateTransformations();
         m_d->recalculateOnNextRedraw = false;
     }
 
     gc.save();
 
     gc.setOpacity(m_d->transaction.basePreviewOpacity());
     gc.setTransform(m_d->paintingTransform, true);
     gc.drawImage(m_d->paintingOffset, m_d->transformedImage);
 
     gc.restore();
 }
 
 void KisLiquifyTransformStrategy::externalConfigChanged()
 {
     if (!m_d->currentArgs.liquifyWorker()) return;
     m_d->recalculateTransformations();
 }
 
 bool KisLiquifyTransformStrategy::acceptsClicks() const
 {
     return true;
 }
 
 bool KisLiquifyTransformStrategy::beginPrimaryAction(KoPointerEvent *event)
 {
     m_d->helper.configurePaintOp(*m_d->currentArgs.liquifyProperties(), m_d->currentArgs.liquifyWorker());
     m_d->helper.startPaint(event, m_d->manager);
 
     m_d->recalculateTransformations();
 
     return true;
 }
 
 void KisLiquifyTransformStrategy::continuePrimaryAction(KoPointerEvent *event)
 {
     m_d->helper.continuePaint(event);
 
     // the updates should be compressed
     m_d->recalculateOnNextRedraw = true;
     emit requestCanvasUpdate();
 }
 
 bool KisLiquifyTransformStrategy::endPrimaryAction(KoPointerEvent *event)
 {
     if (m_d->helper.endPaint(event)) {
         m_d->recalculateTransformations();
         emit requestCanvasUpdate();
     }
 
     return true;
 }
 
 void KisLiquifyTransformStrategy::hoverActionCommon(KoPointerEvent *event)
 {
     m_d->helper.hoverPaint(event);
 }
 
 void KisLiquifyTransformStrategy::activateAlternateAction(KisTool::AlternateAction action)
 {
     if (action == KisTool::PickFgNode || action == KisTool::PickBgNode ||
         action == KisTool::PickFgImage || action == KisTool::PickBgImage) {
 
         KisLiquifyProperties *props = m_d->currentArgs.liquifyProperties();
         props->setReverseDirection(!props->reverseDirection());
         emit requestUpdateOptionWidget();
     }
 }
 
 void KisLiquifyTransformStrategy::deactivateAlternateAction(KisTool::AlternateAction action)
 {
     if (action == KisTool::PickFgNode || action == KisTool::PickBgNode ||
         action == KisTool::PickFgImage || action == KisTool::PickBgImage) {
 
         KisLiquifyProperties *props = m_d->currentArgs.liquifyProperties();
         props->setReverseDirection(!props->reverseDirection());
         emit requestUpdateOptionWidget();
     }
 }
 
 bool KisLiquifyTransformStrategy::beginAlternateAction(KoPointerEvent *event, KisTool::AlternateAction action)
 {
     if (action == KisTool::ChangeSize) {
         QPointF widgetPoint = m_d->converter->documentToWidget(event->point);
         m_d->lastMouseWidgetPos = widgetPoint;
         m_d->startResizeImagePos = m_d->converter->documentToImage(event->point);
         m_d->startResizeGlobalCursorPos = QCursor::pos();
         return true;
     } else if (action == KisTool::PickFgNode || action == KisTool::PickBgNode ||
                action == KisTool::PickFgImage || action == KisTool::PickBgImage) {
 
         return beginPrimaryAction(event);
     }
 
 
     return false;
 }
 
 void KisLiquifyTransformStrategy::continueAlternateAction(KoPointerEvent *event, KisTool::AlternateAction action)
 {
     if (action == KisTool::ChangeSize) {
         QPointF widgetPoint = m_d->converter->documentToWidget(event->point);
 
         QPointF diff = widgetPoint - m_d->lastMouseWidgetPos;
 
         KisLiquifyProperties *props = m_d->currentArgs.liquifyProperties();
         const qreal linearizedOffset = diff.x() / KisTransformUtils::scaleFromAffineMatrix(m_d->converter->imageToWidgetTransform());
         const qreal newSize = qBound(props->minSize(), props->size() + linearizedOffset, props->maxSize());
         props->setSize(newSize);
         m_d->currentArgs.saveLiquifyTransformMode();
 
         m_d->lastMouseWidgetPos = widgetPoint;
 
         emit requestCursorOutlineUpdate(m_d->startResizeImagePos);
     } else if (action == KisTool::PickFgNode || action == KisTool::PickBgNode ||
                action == KisTool::PickFgImage || action == KisTool::PickBgImage) {
 
         return continuePrimaryAction(event);
     }
 }
 
 bool KisLiquifyTransformStrategy::endAlternateAction(KoPointerEvent *event, KisTool::AlternateAction action)
 {
     Q_UNUSED(event);
 
     if (action == KisTool::ChangeSize) {
         QCursor::setPos(m_d->startResizeGlobalCursorPos);
         return true;
     } else if (action == KisTool::PickFgNode || action == KisTool::PickBgNode ||
                action == KisTool::PickFgImage || action == KisTool::PickBgImage) {
         return endPrimaryAction(event);
     }
 
     return false;
 }
 
 inline QPointF KisLiquifyTransformStrategy::Private::imageToThumb(const QPointF &pt, bool useFlakeOptimization)
 {
     return useFlakeOptimization ? converter->imageToDocument(converter->documentToFlake((pt))) : q->thumbToImageTransform().inverted().map(pt);
 }
 
 void KisLiquifyTransformStrategy::Private::recalculateTransformations()
 {
     KIS_ASSERT_RECOVER_RETURN(currentArgs.liquifyWorker());
 
     QTransform scaleTransform = KisTransformUtils::imageToFlakeTransform(converter);
 
     QTransform resultThumbTransform = q->thumbToImageTransform() * scaleTransform;
     qreal scale = KisTransformUtils::scaleFromAffineMatrix(resultThumbTransform);
     bool useFlakeOptimization = scale < 1.0 &&
         !KisTransformUtils::thumbnailTooSmall(resultThumbTransform, q->originalImage().rect());
 
     paintingOffset = transaction.originalTopLeft();
     if (!q->originalImage().isNull()) {
         if (useFlakeOptimization) {
             transformedImage = q->originalImage().transformed(resultThumbTransform);
             paintingTransform = QTransform();
         } else {
             transformedImage = q->originalImage();
             paintingTransform = resultThumbTransform;
         }
 
         QTransform imageToRealThumbTransform =
             useFlakeOptimization ?
             scaleTransform :
             q->thumbToImageTransform().inverted();
 
         QPointF origTLInFlake =
             imageToRealThumbTransform.map(transaction.originalTopLeft());
 
         transformedImage =
             currentArgs.liquifyWorker()->runOnQImage(transformedImage,
                                                      origTLInFlake,
                                                      imageToRealThumbTransform,
                                                      &paintingOffset);
     } else {
         transformedImage = q->originalImage();
         paintingOffset = imageToThumb(transaction.originalTopLeft(), false);
         paintingTransform = resultThumbTransform;
     }
 
     handlesTransform = scaleTransform;
 }
 
diff --git a/plugins/tools/tool_transform2/kis_liquify_transform_strategy.h b/plugins/tools/tool_transform2/kis_liquify_transform_strategy.h
index 5a6b69d2b0..56e9363e33 100644
--- a/plugins/tools/tool_transform2/kis_liquify_transform_strategy.h
+++ b/plugins/tools/tool_transform2/kis_liquify_transform_strategy.h
@@ -1,75 +1,75 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_LIQUIFY_TRANSFORM_STRATEGY_H
 #define __KIS_LIQUIFY_TRANSFORM_STRATEGY_H
 
 #include <QObject>
 #include <QScopedPointer>
 
 #include "kis_transform_strategy_base.h"
 
 class QPointF;
 class QPainter;
 class KisCoordinatesConverter;
 class ToolTransformArgs;
 class TransformTransactionProperties;
 class QCursor;
 
 
 class KisLiquifyTransformStrategy : public KisTransformStrategyBase
 {
     Q_OBJECT
 public:
     KisLiquifyTransformStrategy(const KisCoordinatesConverter *converter,
                              ToolTransformArgs &currentArgs,
-                             TransformTransactionProperties &transaction, const KoCanvasResourceManager *manager);
+                             TransformTransactionProperties &transaction, const KoCanvasResourceProvider *manager);
     ~KisLiquifyTransformStrategy() override;
 
     void setTransformFunction(const QPointF &mousePos, bool perspectiveModifierActive);
     void paint(QPainter &gc) override;
     QCursor getCurrentCursor() const override;
     QPainterPath getCursorOutline() const override;
 
     bool acceptsClicks() const override;
 
     void externalConfigChanged() override;
 
     bool beginPrimaryAction(KoPointerEvent *event) override;
     void continuePrimaryAction(KoPointerEvent *event) override;
     bool endPrimaryAction(KoPointerEvent *event) override;
     void hoverActionCommon(KoPointerEvent *event) override;
 
     void activateAlternateAction(KisTool::AlternateAction action) override;
     void deactivateAlternateAction(KisTool::AlternateAction action) override;
 
     bool beginAlternateAction(KoPointerEvent *event, KisTool::AlternateAction action) override;
     void continueAlternateAction(KoPointerEvent *event, KisTool::AlternateAction action) override;
     bool endAlternateAction(KoPointerEvent *event, KisTool::AlternateAction action) override;
 
 Q_SIGNALS:
     void requestCanvasUpdate();
     void requestUpdateOptionWidget();
     void requestCursorOutlineUpdate(const QPointF &imagePoint);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_LIQUIFY_TRANSFORM_STRATEGY_H */
diff --git a/sdk/tests/stroke_testing_utils.cpp b/sdk/tests/stroke_testing_utils.cpp
index 4e8942b15d..0a7bac2c2d 100644
--- a/sdk/tests/stroke_testing_utils.cpp
+++ b/sdk/tests/stroke_testing_utils.cpp
@@ -1,369 +1,369 @@
 /*
  *  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 "stroke_testing_utils.h"
 
 #include <QtTest>
 
 #include <QDir>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoCompositeOpRegistry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <resources/KoPattern.h>
 #include "kis_canvas_resource_provider.h"
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_group_layer.h"
 #include <KisViewManager.h>
 
 #include "testutil.h"
 
 
 KisImageSP utils::createImage(KisUndoStore *undoStore, const QSize &imageSize) {
     QRect imageRect(0,0,imageSize.width(),imageSize.height());
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(undoStore, imageRect.width(), imageRect.height(), cs, "stroke test");
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
     KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8);
     KisPaintLayerSP paintLayer3 = new KisPaintLayer(image, "paint3", OPACITY_OPAQUE_U8);
     KisPaintLayerSP paintLayer4 = new KisPaintLayer(image, "paint4", OPACITY_OPAQUE_U8);
     KisPaintLayerSP paintLayer5 = new KisPaintLayer(image, "paint5", OPACITY_OPAQUE_U8);
 
     image->lock();
     image->addNode(paintLayer1);
     image->addNode(paintLayer2);
     image->addNode(paintLayer3);
     image->addNode(paintLayer4);
     image->addNode(paintLayer5);
     image->unlock();
     return image;
 }
 
-KoCanvasResourceManager* utils::createResourceManager(KisImageWSP image,
+KoCanvasResourceProvider* utils::createResourceManager(KisImageWSP image,
                                                 KisNodeSP node,
                                                 const QString &presetFileName)
 {
-    KoCanvasResourceManager *manager = new KoCanvasResourceManager();
+    KoCanvasResourceProvider *manager = new KoCanvasResourceProvider();
     KisViewManager::initializeResourceManager(manager);
 
     QVariant i;
 
     i.setValue(KoColor(Qt::black, image->colorSpace()));
-    manager->setResource(KoCanvasResourceManager::ForegroundColor, i);
+    manager->setResource(KoCanvasResourceProvider::ForegroundColor, i);
 
     i.setValue(KoColor(Qt::white, image->colorSpace()));
-    manager->setResource(KoCanvasResourceManager::BackgroundColor, i);
+    manager->setResource(KoCanvasResourceProvider::BackgroundColor, i);
 
     i.setValue(static_cast<void*>(0));
     manager->setResource(KisCanvasResourceProvider::CurrentPattern, i);
     manager->setResource(KisCanvasResourceProvider::CurrentGradient, i);
     manager->setResource(KisCanvasResourceProvider::CurrentGeneratorConfiguration, i);
 
     if(!node) {
         node = image->root();
 
         while(node && !dynamic_cast<KisPaintLayer*>(node.data())) {
             node = node->firstChild();
         }
 
         Q_ASSERT(node && dynamic_cast<KisPaintLayer*>(node.data()));
     }
 
     i.setValue(node);
     manager->setResource(KisCanvasResourceProvider::CurrentKritaNode, 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);
         manager->setResource(KisCanvasResourceProvider::CurrentPaintOpPreset, i);
     }
 
     i.setValue(COMPOSITE_OVER);
     manager->setResource(KisCanvasResourceProvider::CurrentCompositeOp, i);
 
     i.setValue(false);
     manager->setResource(KisCanvasResourceProvider::MirrorHorizontal, i);
 
     i.setValue(false);
     manager->setResource(KisCanvasResourceProvider::MirrorVertical, i);
 
     i.setValue(1.0);
     manager->setResource(KisCanvasResourceProvider::Opacity, i);
 
     i.setValue(1.0);
     manager->setResource(KisCanvasResourceProvider::HdrExposure, i);
 
     return manager;
 }
 
 utils::StrokeTester::StrokeTester(const QString &name, const QSize &imageSize, const QString &presetFilename)
     : m_name(name),
       m_imageSize(imageSize),
       m_presetFilename(presetFilename),
       m_numIterations(1),
       m_baseFuzziness(1)
 {
 }
 
 utils::StrokeTester::~StrokeTester()
 {
 }
 
 void utils::StrokeTester::setNumIterations(int value)
 {
     m_numIterations = value;
 }
 
 void utils::StrokeTester::setBaseFuzziness(int value)
 {
     m_baseFuzziness = value;
 }
 
 void utils::StrokeTester::testSimpleStroke()
 {
     testOneStroke(false, true, false, true);
 }
 
 int utils::StrokeTester::lastStrokeTime() const
 {
     return m_strokeTime;
 }
 
 void utils::StrokeTester::test()
 {
     testOneStroke(false, false, false);
     testOneStroke(false, true, false);
     testOneStroke(true, false, false);
     testOneStroke(true, true, false);
 
     // The same but with updates (compare against projection)
 
     testOneStroke(false, false, false, true);
     testOneStroke(false, true, false, true);
     testOneStroke(true, false, false, true);
     testOneStroke(true, true, false, true);
 
     // The same, but with an external layer
 
     testOneStroke(false, false, true);
     testOneStroke(false, true, true);
     testOneStroke(true, false, true);
     testOneStroke(true, true, true);
 }
 
 void utils::StrokeTester::benchmark()
 {
     // not cancelled, indirect painting, internal, no updates, no qimage
     doStroke(false, false, false, false);
 }
 
 void utils::StrokeTester::testSimpleStrokeNoVerification()
 {
     doStroke(false, false, true, false);
 }
 
 void utils::StrokeTester::testOneStroke(bool cancelled,
                                         bool indirectPainting,
                                         bool externalLayer,
                                         bool testUpdates)
 {
     // TODO: indirectPainting option is not used anymore! The real value is
     //       taken from the preset!
 
     QString testName = formatTestName(m_name,
                                       cancelled,
                                       indirectPainting,
                                       externalLayer);
 
     dbgKrita << "Testcase:" << testName
              << "(comare against " << (testUpdates ? "projection" : "layer") << ")";
 
     QImage resultImage;
     resultImage = doStroke(cancelled, externalLayer, testUpdates);
 
     QImage refImage;
     refImage.load(referenceFile(testName));
 
     QPoint temp;
     if(!TestUtil::compareQImages(temp, refImage, resultImage, m_baseFuzziness, m_baseFuzziness)) {
         refImage.save(dumpReferenceFile(testName));
         resultImage.save(resultFile(testName));
 
         QFAIL("Images do not coincide");
     }
 }
 
 QString utils::StrokeTester::formatTestName(const QString &baseName,
                                             bool cancelled,
                                             bool indirectPainting,
                                             bool externalLayer)
 {
     QString result = baseName;
     result += "_" + m_presetFilename;
     result += indirectPainting ? "_indirect" : "_incremental";
     result += cancelled ? "_cancelled" : "_finished";
     result += externalLayer ? "_external" : "_internal";
     return result;
 }
 
 QString utils::StrokeTester::referenceFile(const QString &testName)
 {
     QString path =
         QString(FILES_DATA_DIR) + QDir::separator() +
         m_name + QDir::separator();
 
     path += testName;
     path += ".png";
     return path;
 }
 
 QString utils::StrokeTester::dumpReferenceFile(const QString &testName)
 {
     QString path = QString(FILES_OUTPUT_DIR) + QDir::separator();
     path += testName;
     path += "_expected";
     path += ".png";
     return path;
 }
 
 QString utils::StrokeTester::resultFile(const QString &testName)
 {
     QString path = QString(FILES_OUTPUT_DIR) + QDir::separator();
     path += testName;
     path += ".png";
     return path;
 }
 
 QImage utils::StrokeTester::doStroke(bool cancelled,
                                      bool externalLayer,
                                      bool testUpdates,
                                      bool needQImage)
 {
     KisImageSP image = utils::createImage(0, m_imageSize);
-    KoCanvasResourceManager *manager = utils::createResourceManager(image, 0, m_presetFilename);
+    KoCanvasResourceProvider *manager = utils::createResourceManager(image, 0, m_presetFilename);
     KisNodeSP currentNode;
 
     for (int i = 0; i < m_numIterations; i++) {
         modifyResourceManager(manager, image, i);
 
         KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(image,
                                      image->rootLayer()->firstChild(),
                                      manager);
 
         if(externalLayer) {
             KisNodeSP externalNode = new KisPaintLayer(0, "extlyr", OPACITY_OPAQUE_U8, image->colorSpace());
             resources->setCurrentNode(externalNode);
             Q_ASSERT(resources->currentNode() == externalNode);
         }
 
         initImage(image, resources->currentNode(), i);
 
         QElapsedTimer strokeTime;
         strokeTime.start();
 
         KisStrokeStrategy *stroke = createStroke(resources, image);
         m_strokeId = image->startStroke(stroke);
         addPaintingJobs(image, resources, i);
 
         if(!cancelled) {
             image->endStroke(m_strokeId);
         }
         else {
             image->cancelStroke(m_strokeId);
         }
 
         image->waitForDone();
 
         m_strokeTime = strokeTime.elapsed();
         currentNode = resources->currentNode();
     }
 
     beforeCheckingResult(image, currentNode);
 
     QImage resultImage;
     if(needQImage) {
         KisPaintDeviceSP device = testUpdates ?
             image->projection() :
             currentNode->paintDevice();
 
         resultImage = device->convertToQImage(0, 0, 0, image->width(), image->height());
     }
 
     image = 0;
     delete manager;
     return resultImage;
 }
 
-void utils::StrokeTester::modifyResourceManager(KoCanvasResourceManager *manager,
+void utils::StrokeTester::modifyResourceManager(KoCanvasResourceProvider *manager,
                                                 KisImageWSP image, int iteration)
 {
     Q_UNUSED(iteration);
     modifyResourceManager(manager, image);
 }
 
-void utils::StrokeTester::modifyResourceManager(KoCanvasResourceManager *manager,
+void utils::StrokeTester::modifyResourceManager(KoCanvasResourceProvider *manager,
                                                 KisImageWSP image)
 {
     Q_UNUSED(manager);
     Q_UNUSED(image);
 }
 
 void utils::StrokeTester::initImage(KisImageWSP image, KisNodeSP activeNode, int iteration)
 {
     Q_UNUSED(iteration);
     initImage(image, activeNode);
 }
 
 void utils::StrokeTester::initImage(KisImageWSP image, KisNodeSP activeNode)
 {
     Q_UNUSED(image);
     Q_UNUSED(activeNode);
 }
 
 void utils::StrokeTester::addPaintingJobs(KisImageWSP image,
                                           KisResourcesSnapshotSP resources,
                                           int iteration)
 {
     Q_UNUSED(iteration);
     addPaintingJobs(image, resources);
 }
 
 void utils::StrokeTester::addPaintingJobs(KisImageWSP image,
                                           KisResourcesSnapshotSP resources)
 {
     Q_UNUSED(image);
     Q_UNUSED(resources);
 }
 
 void utils::StrokeTester::beforeCheckingResult(KisImageWSP image, KisNodeSP activeNode)
 {
     Q_UNUSED(image);
     Q_UNUSED(activeNode);
 }
diff --git a/sdk/tests/stroke_testing_utils.h b/sdk/tests/stroke_testing_utils.h
index b8a6b33333..1a43f48bf8 100644
--- a/sdk/tests/stroke_testing_utils.h
+++ b/sdk/tests/stroke_testing_utils.h
@@ -1,110 +1,110 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __STROKE_TESTING_UTILS_H
 #define __STROKE_TESTING_UTILS_H
 
 #include <QString>
-#include <KoCanvasResourceManager.h>
+#include <KoCanvasResourceProvider.h>
 #include "kis_node.h"
 #include "kis_types.h"
 #include "kis_stroke_strategy.h"
 #include "kis_resources_snapshot.h"
 
 
 class KisUndoStore;
 
 
 namespace utils {
 
     KisImageSP createImage(KisUndoStore *undoStore, const QSize &imageSize);
-    KoCanvasResourceManager* createResourceManager(KisImageWSP image,
+    KoCanvasResourceProvider* createResourceManager(KisImageWSP image,
                                              KisNodeSP node = 0,
                                              const QString &presetFileName = "autobrush_300px.kpp");
 
     class StrokeTester
     {
     public:
         StrokeTester(const QString &name, const QSize &imageSize, const QString &presetFileName = "autobrush_300px.kpp");
         virtual ~StrokeTester();
 
         void testSimpleStroke();
         void test();
         void benchmark();
         void testSimpleStrokeNoVerification();
 
         void setNumIterations(int value);
         void setBaseFuzziness(int value);
 
         int lastStrokeTime() const;
 
     protected:
         KisStrokeId strokeId() {
             return m_strokeId;
         }
 
-        virtual void modifyResourceManager(KoCanvasResourceManager *manager,
+        virtual void modifyResourceManager(KoCanvasResourceProvider *manager,
                                            KisImageWSP image, int iteration);
 
         virtual void initImage(KisImageWSP image, KisNodeSP activeNode, int iteration);
 
         // overload
-        virtual void modifyResourceManager(KoCanvasResourceManager *manager,
+        virtual void modifyResourceManager(KoCanvasResourceProvider *manager,
                                            KisImageWSP image);
 
         // overload
         virtual void initImage(KisImageWSP image, KisNodeSP activeNode);
         virtual void beforeCheckingResult(KisImageWSP image, KisNodeSP activeNode);
 
         virtual KisStrokeStrategy* createStroke(KisResourcesSnapshotSP resources,
                                                 KisImageWSP image) = 0;
 
         virtual void addPaintingJobs(KisImageWSP image,
                                      KisResourcesSnapshotSP resources,
                                      int iteration);
 
         // overload
         virtual void addPaintingJobs(KisImageWSP image,
                                      KisResourcesSnapshotSP resources);
 
     private:
         void testOneStroke(bool cancelled, bool indirectPainting,
                            bool externalLayer, bool testUpdates = false);
 
         QImage doStroke(bool cancelled,
                         bool externalLayer, bool testUpdates = false,
                         bool needQImage = true);
 
         QString formatTestName(const QString &baseName, bool cancelled,
                                bool indirectPainting, bool externalLayer);
         QString referenceFile(const QString &testName);
         QString dumpReferenceFile(const QString &testName);
         QString resultFile(const QString &testName);
 
     private:
         KisStrokeId m_strokeId;
         QString m_name;
         QSize m_imageSize;
         QString m_presetFilename;
         int m_numIterations;
         int m_baseFuzziness;
         int m_strokeTime = 0;
     };
 }
 
 #endif /* __STROKE_TESTING_UTILS_H */