diff --git a/libs/libkis/Document.cpp b/libs/libkis/Document.cpp
index 1cf0c17211..ab0311054a 100644
--- a/libs/libkis/Document.cpp
+++ b/libs/libkis/Document.cpp
@@ -1,341 +1,357 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Document.h"
 #include <QPointer>
 #include <QUrl>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <KisPart.h>
 #include <kis_paint_device.h>
+#include <KisMainWindow.h>
+#include <kis_node_manager.h>
+#include <kis_node_selection_adapter.h>
+#include <KisViewManager.h>
+
 
 #include <InfoObject.h>
 #include <Node.h>
 
 struct Document::Private {
     Private() {}
     QPointer<KisDocument> document;
     bool ownsDocument {false};
 };
 
 Document::Document(KisDocument *document, bool ownsDocument, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->document = document;
     d->ownsDocument = ownsDocument;
 }
 
 Document::~Document()
 {
     qDebug() << "Document" << this << "deleted";
     delete d;
 }
 
 bool Document::batchmode() const
 {
     if (!d->document) return false;
     return d->document->fileBatchMode();
 }
 
 void Document::setBatchmode(bool value)
 {
     if (!d->document) return;
     d->document->setFileBatchMode(value);
 }
 
 Node *Document::activeNode() const
 {
     QList<KisNodeSP> activeNodes;
     Q_FOREACH(QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->document() == d->document) {
             activeNodes << view->currentNode();
         }
     }
     if (activeNodes.size() > 0) {
         return new Node(d->document->image(), activeNodes.first());
     }
     return new Node(d->document->image(), d->document->image()->root()->firstChild());
 }
 
 void Document::setActiveNode(Node* value)
 {
+    if (!value->node()) return;
+    KisMainWindow *mainWin = KisPart::currentMainwindow();
+    if (!mainWin) return;
+    KisViewManager *viewManager = mainWin->viewManager();
+    if (!viewManager) return;
+    KisNodeManager *nodeManager = viewManager->nodeManager();
+    if (!nodeManager) return;
+    KisNodeSelectionAdapter *selectionAdapter = nodeManager->nodeSelectionAdapter();
+    if (!selectionAdapter) return;
+    selectionAdapter->setActiveNode(value->node());
+
 }
 
 
 ColorDepth* Document::colorDepth() const
 {
     return 0;
 }
 
 void Document::setColorDepth(ColorDepth* value)
 {
 }
 
 
 ColorModel* Document::colorModel() const
 {
     return 0;
 }
 
 void Document::setColorModel(ColorModel* value)
 {
 }
 
 
 ColorProfile* Document::colorProfile() const
 {
     return 0;
 }
 
 void Document::setColorProfile(ColorProfile* value)
 {
 }
 
 
 InfoObject* Document::documentInfo() const
 {
     return 0;
 }
 
 void Document::setDocumentInfo(InfoObject* value)
 {
 }
 
 
 QString Document::fileName() const
 {
     if (!d->document) return QString::null;
     return d->document->url().toLocalFile();
 }
 
 void Document::setFileName(QString value)
 {
 }
 
 
 int Document::height() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->height();
 }
 
 void Document::setHeight(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setHeight(value);
     image->resizeImage(rc);
 }
 
 
 InfoObject* Document::metaData() const
 {
     return 0;
 }
 
 void Document::setMetaData(InfoObject* value)
 {
 }
 
 
 QString Document::name() const
 {
     return QString();
 }
 
 void Document::setName(QString value)
 {
 }
 
 
 int Document::resolution() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return qRound(d->document->image()->xRes() * 72);
 }
 
 void Document::setResolution(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
 
     d->document->image()->setResolution(value / 72.0, value / 72.0);
 }
 
 
 Node *Document::rootNode() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return new Node(image, image->root());
 }
 
 Selection *Document::selection() const
 {
     return 0;
 }
 
 void Document::setSelection(Selection* value)
 {
 }
 
 
 int Document::width() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->width();
 }
 
 void Document::setWidth(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setWidth(value);
     image->resizeImage(rc);
 }
 
 double Document::xRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->xRes();
 }
 
 void Document::setXRes(double xRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(xRes, d->document->image()->yRes());
 }
 
 double Document::yRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->yRes();
 }
 
 void Document::setyRes(double yRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(d->document->image()->xRes(), yRes);
 }
 
 
 QByteArray Document::pixelData() const
 {
     QByteArray ba;
 
     if (!d->document) return ba;
     KisImageSP image = d->document->image();
     if (!image) return ba;
 
     KisPaintDeviceSP dev = image->projection();
     quint8 *data = new quint8[image->width() * image->height() * dev->pixelSize()];
     dev->readBytes(data, 0, 0, image->width(), image->height());
     ba = QByteArray((const char*)data, (int)(image->width() * image->height() * dev->pixelSize()));
     delete[] data;
     return ba;
 }
 
 bool Document::close()
 {
     if (d->ownsDocument) {
         KisPart::instance()->removeDocument(d->document);
     }
     return d->document->closeUrl(false);
 }
 
 bool Document::convert(const QString &colorModel, const ColorProfile *profile)
 {
     return false;
 }
 
 void Document::crop(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc(x, y, w, h);
     image->cropImage(rc);
 }
 
 bool Document::exportImage(const QString &filename, const InfoObject &exportConfiguration)
 {
     if (!d->document) return false;
     return d->document->exportDocument(QUrl::fromLocalFile(filename));
 }
 
 void Document::flatten()
 {
 }
 
 void Document::resizeImage(int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setWidth(w);
     rc.setHeight(h);
     image->resizeImage(rc);
 }
 
 bool Document::save()
 {
     if (!d->document) return false;
     return d->document->save();
 }
 
 bool Document::saveAs(const QString &filename)
 {
     if (!d->document) return false;
     return d->document->saveAs(QUrl::fromLocalFile(filename));
 }
 
 void Document::openView()
 {
 }
 
 Node* Document::createNode(const QString &name, const QString &nodeType)
 {
     return 0;
 }
 
 QPointer<KisDocument> Document::document() const
 {
     return d->document;
 }
 
 
 
diff --git a/libs/libkis/Node.cpp b/libs/libkis/Node.cpp
index 7abb55c5db..9e18646e9a 100644
--- a/libs/libkis/Node.cpp
+++ b/libs/libkis/Node.cpp
@@ -1,414 +1,419 @@
 /*
  *  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 <QUrl>
 #include <QScopedPointer>
 
 #include <KoColorSpace.h>
 
 #include <KisDocument.h>
 #include <KisMimeDatabase.h>
 #include <KisPart.h>
 #include <kis_image.h>
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 
 #include "Krita.h"
 #include "Node.h"
 #include "Channel.h"
 #include "ColorDepth.h"
 #include "ColorModel.h"
 #include "ColorProfile.h"
 #include "Generator.h"
 #include "Filter.h"
 #include "Transformation.h"
 #include "Selection.h"
 
 
 struct Node::Private {
     Private() {}
     KisImageSP image;
     KisNodeSP node;
 };
 
 Node::Node(KisImageSP image, KisNodeSP node, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->image = image;
     d->node = node;
 }
 
 Node::~Node()
 {
     delete d;
 }
 
 bool Node::alphaLocked() const
 {
     if (!d->node) return false;
     KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
     if (paintLayer) {
         return paintLayer->alphaLocked();
     }
     return false;
 }
 
 void Node::setAlphaLocked(bool value)
 {
     if (!d->node) return;
     KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
     if (paintLayer) {
         paintLayer->setAlphaLocked(value);
     }
 }
 
 
 QString Node::blendingMode() const
 {
     if (!d->node) return QString();
 
     return d->node->compositeOpId();
 }
 
 void Node::setBlendingMode(QString value)
 {
     if (!d->node) return;
     d->node->setCompositeOpId(value);
 }
 
 
 QList<Channel*> Node::channels() const
 {
     QList<Channel*> channels;
 
     if (!d->node) return channels;
     if (!d->node->inherits("KisLayer")) return channels;
 
     Q_FOREACH(KoChannelInfo *info, d->node->colorSpace()->channels()) {
         Channel *channel = new Channel(d->node, info);
         channels << channel;
     }
 
     return channels;
 }
 
 QList<Node*> Node::childNodes() const
 {
     QList<Node*> nodes;
     if (d->node) {
         int childCount = d->node->childCount();
         for (int i = 0; i < childCount; ++i) {
             nodes << new Node(d->image, d->node->at(i));
         }
     }
     return nodes;
 }
 
 void Node::setChildNodes(QList<Node*> value)
 {
     if (!d->node) return;
 }
 
 
 ColorDepth* Node::colorDepth() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setColorDepth(ColorDepth* value)
 {
     if (!d->node) return;
 }
 
 
 QString Node::colorLabel() const
 {
     if (!d->node) return QString();
     return QString();
 }
 
 void Node::setColorLabel(QString value)
 {
     if (!d->node) return;
 }
 
 
 ColorModel* Node::colorModel() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setColorModel(ColorModel* value)
 {
     if (!d->node) return;
 }
 
 
 ColorProfile* Node::colorProfile() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setColorProfile(ColorProfile* value)
 {
     if (!d->node) return;
 }
 
 
 bool Node::inheritAlpha() const
 {
     if (!d->node) return false;
     return false;
 }
 
 void Node::setInheritAlpha(bool value)
 {
     if (!d->node) return;
 }
 
 
 bool Node::locked() const
 {
     if (!d->node) return false;
     return false;
 }
 
 void Node::setLocked(bool value)
 {
     if (!d->node) return;
 }
 
 
 QString Node::name() const
 {
     if (!d->node) return QString();
     return d->node->name();
 }
 
 void Node::setName(QString value)
 {
     if (!d->node) return;
 }
 
 
 int Node::opacity() const
 {
     if (!d->node) return 0;
     return d->node->opacity();
 }
 
 void Node::setOpacity(int value)
 {
     if (!d->node) return;
     d->node->setOpacity(value);
 }
 
 
 Node* Node::parentNode() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setParentNode(Node* value)
 {
     if (!d->node) return;
 }
 
 
 QString Node::type() const
 {
     if (!d->node) return QString();
     return QString();
 }
 
 void Node::setType(QString value)
 {
     if (!d->node) return;
 }
 
 
 bool Node::visible() const
 {
     if (!d->node) return false;
     return false;
 }
 
 void Node::setVisible(bool value)
 {
     if (!d->node) return;
 }
 
 
 InfoObject* Node::metaDataInfo() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setMetaDataInfo(InfoObject* value)
 {
     if (!d->node) return;
 }
 
 
 Generator* Node::generator() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setGenerator(Generator* value)
 {
     if (!d->node) return;
 }
 
 
 Filter* Node::filter() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setFilter(Filter* value)
 {
     if (!d->node) return;
 }
 
 
 Transformation* Node::transformation() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setTransformation(Transformation* value)
 {
     if (!d->node) return;
 }
 
 
 Selection* Node::selection() const
 {
     if (!d->node) return 0;
     return 0;
 }
 
 void Node::setSelection(Selection* value)
 {
     if (!d->node) return;
 }
 
 
 QString Node::fileName() const
 {
     if (!d->node) return QString();
     return QString();
 }
 
 void Node::setFileName(QString value)
 {
     if (!d->node) return;
 }
 
 
 QByteArray Node::pixelData() const
 {
     if (!d->node) return QByteArray();
     return QByteArray();
 }
 
 void Node::setPixelData(QByteArray value)
 {
     if (!d->node) return;
 }
 
 QRect Node::bounds() const
 {
     if (!d->node) return QRect();
     return d->node->exactBounds();
 }
 
 void Node::move(int x, int y)
 {
     if (!d->node) return;
 }
 
 void Node::moveToParent(Node *parent)
 {
     if (!d->node) return;
 }
 
 void Node::remove()
 {
     if (!d->node) return;
 }
 
 Node* Node::duplicate()
 {
     if (!d->node) return 0;
     return 0;
 }
 
 bool Node::save(const QString &filename, double xRes, double yRes)
 {
     if (!d->node) return false;
     if (filename.isEmpty()) return false;
 
     KisPaintDeviceSP projection = d->node->projection();
     QRect bounds = d->node->exactBounds();
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(filename);;
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   projection->compositionSourceColorSpace(),
                                   d->node->name());
     dst->setResolution(xRes, yRes);
     doc->setFileBatchMode(Krita::instance()->batchmode());
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", d->node->opacity());
     paintLayer->paintDevice()->makeCloneFrom(projection, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
     dst->initialRefreshGraph();
     doc->setOutputMimeType(mimefilter.toLatin1());
 
     bool r = doc->exportDocument(QUrl::fromLocalFile(filename));
     if (!r) {
         qWarning() << doc->errorMessage();
     }
     return r;
 }
 
 KisPaintDeviceSP Node::paintDevice() const
 {
     return d->node->paintDevice();
 }
 
 KisImageSP Node::image() const
 {
     return d->image;
 }
+
+KisNodeSP Node::node() const
+{
+    return d->node;
+}
diff --git a/libs/libkis/Node.h b/libs/libkis/Node.h
index 6eb3b10621..409f685059 100644
--- a/libs/libkis/Node.h
+++ b/libs/libkis/Node.h
@@ -1,173 +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.
  */
 #ifndef LIBKIS_NODE_H
 #define LIBKIS_NODE_H
 
 #include <QObject>
 
 #include <kis_types.h>
 
 #include "kritalibkis_export.h"
 #include "libkis.h"
 
 /**
  * Node
  */
 class KRITALIBKIS_EXPORT Node : public QObject
 {
     Q_OBJECT
     Q_DISABLE_COPY(Node)
 
 public:
     explicit Node(KisImageSP image, KisNodeSP node, QObject *parent = 0);
     virtual ~Node();
 
     /**
      * @brief alphaLocked checks whether the node is a paint layer and returns whether it is alpha locked
      * @return whether the paint layer is alpha locked, or false if the node is not a paint layer
      */
     bool alphaLocked() const;
 
     /**
      * @brief setAlphaLocked set the layer to value if the the node is paint layer.
      */
     void setAlphaLocked(bool value);
 
     /**
      * @return the blending mode of the layer. The values of the blending modes are defined in @see KoCompositeOpRegistry.h
      */
     QString blendingMode() const;
 
     /**
      * @brief setBlendingMode set the blending mode of the node to the given value
      * @param value one of the string values from @see KoCompositeOpRegistry.h
      */
     void setBlendingMode(QString value);
 
     /**
      * @brief channels creates a list of Channel objects that can be used individually to
      * show or hide certain channels, and to retrieve the contents of each channel in a
      * node separately.
      *
      * Only layers have channels, masks do not, and calling channels on a Node that is a mask
      * will return an empty list.
      *
      * @return the list of channels ordered in by position of the channels in pixel position
      */
     QList<Channel*> channels() const;
 
     /**
      * Return a list of child nodes of the current node. The nodes are ordered from the bottommost up.
      * The function is not recursive.
      */
     QList<Node*> childNodes() const;
     void setChildNodes(QList<Node*> value);
 
     ColorDepth* colorDepth() const;
     void setColorDepth(ColorDepth* value);
 
     QString colorLabel() const;
     void setColorLabel(QString value);
 
     ColorModel* colorModel() const;
     void setColorModel(ColorModel* value);
 
     ColorProfile* colorProfile() const;
     void setColorProfile(ColorProfile* value);
 
     bool inheritAlpha() const;
     void setInheritAlpha(bool value);
 
     bool locked() const;
     void setLocked(bool value);
 
     QString name() const;
     void setName(QString value);
 
     int opacity() const;
     void setOpacity(int value);
 
     Node* parentNode() const;
     void setParentNode(Node* value);
 
     QString type() const;
     void setType(QString value);
 
     bool visible() const;
     void setVisible(bool value);
 
     InfoObject* metaDataInfo() const;
     void setMetaDataInfo(InfoObject* value);
 
     Generator* generator() const;
     void setGenerator(Generator* value);
 
     Filter* filter() const;
     void setFilter(Filter* value);
 
     Transformation* transformation() const;
     void setTransformation(Transformation* value);
 
     Selection* selection() const;
     void setSelection(Selection* value);
 
     QString fileName() const;
     void setFileName(QString value);
 
     QByteArray pixelData() const;
     void setPixelData(QByteArray value);
 
     QRect bounds() const;
 
 
 public Q_SLOTS:
 
     void move(int x, int y);
 
     void moveToParent(Node *parent);
 
     void remove();
 
     Node* duplicate();
 
     /**
      * @brief save exports the given node with this filename. The extension of the filename determins the filetype.
      * @param filename the filename including extension
      * @param xRes the horizontal resolution in pixels per pt (there are 72 pts in an inch)
      * @param yRes the horizontal resolution in pixels per pt (there are 72 pts in an inch)
      * @return true if saving succeeded, false if it failed.
      */
     bool save(const QString &filename, double xRes, double yRes);
 
 private:
 
     friend class Filter;
-
+    friend class Document;
     /**
      * @brief paintDevice gives access to the internal paint device of this Node
      * @return the paintdevice or 0 if the node does not have an editable paint device.
      */
     KisPaintDeviceSP paintDevice() const;
     KisImageSP image() const;
+    KisNodeSP node() const;
 
     struct Private;
     Private *d;
 
 };
 
 #endif // LIBKIS_NODE_H
diff --git a/libs/ui/kis_node_manager.h b/libs/ui/kis_node_manager.h
index 5253f0c9cc..cc9842bb68 100644
--- a/libs/ui/kis_node_manager.h
+++ b/libs/ui/kis_node_manager.h
@@ -1,256 +1,256 @@
 /*
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_NODE_MANAGER
 #define KIS_NODE_MANAGER
 
 #include <QObject>
 #include <QList>
 
 #include "kis_types.h"
 #include <kritaui_export.h>
 
 class KActionCollection;
 
 class KoCompositeOp;
 class KoColorSpace;
 class KUndo2MagicString;
 
 class KisFilterStrategy;
 class KisViewManager;
 class KisActionManager;
 class KisView;
 class KisNodeSelectionAdapter;
 class KisNodeInsertionAdapter;
 class KisNodeJugglerCompressed;
 class KoProperties;
 
 /**
  * The node manager passes requests for new layers or masks on to the mask and layer
  * managers.
  */
 class KRITAUI_EXPORT KisNodeManager : public QObject
 {
 
     Q_OBJECT
 
 public:
 
     KisNodeManager(KisViewManager * view);
     ~KisNodeManager();
     
     void setView(QPointer<KisView>imageView);
 
 Q_SIGNALS:
 
     /// emitted whenever a node is selected.
     void sigNodeActivated(KisNodeSP node);
     
     /// emitted whenever a different layer is selected.
     void sigLayerActivated(KisLayerSP layer);
     
     /// for the layer box: this sets the current node in the layerbox
     /// without telling the node manager that the node is activated,
     /// preventing loops (I think...)
     void sigUiNeedChangeActiveNode(KisNodeSP node);
 
     void sigUiNeedChangeSelectedNodes(const KisNodeList &nodes);
     
 public:
     
     void setup(KActionCollection * collection, KisActionManager* actionManager);
     void updateGUI();
 
     /// Convenience function to get the active layer or mask
     KisNodeSP activeNode();
 
     /// convenience function to get the active layer. If a mask is
     /// active, it's parent layer is the active layer.
     KisLayerSP activeLayer();
     
     /// Get the paint device the user wants to paint on now
     KisPaintDeviceSP activePaintDevice();
 
     /**
      * @return the active color space used for composition, meaning the color space
      * of the active mask, or the color space of the parent of the active layer
      */
     const KoColorSpace* activeColorSpace();
 
     /**
      * Sets opacity for the node in a universal way (masks/layers)
      */
     void setNodeOpacity(KisNodeSP node, qint32 opacity, bool finalChange);
 
     /**
      * Sets compositeOp for the node in a universal way (masks/layers)
      */
     void setNodeCompositeOp(KisNodeSP node, const KoCompositeOp* compositeOp);
 
     KisNodeList selectedNodes();
 
     KisNodeSelectionAdapter* nodeSelectionAdapter() const;
     KisNodeInsertionAdapter* nodeInsertionAdapter() const;
 
 public Q_SLOTS:
 
     /**
      * Explicitly activates \p node
      * The UI will be noticed that active node has been changed.
      * Both sigNodeActivated and sigUiNeedChangeActiveNode are emitted.
      *
      * WARNING: normally you needn't call this method manually. It is
      * automatically called when a node is added to the graph. If you
      * have some special cases when you need to activate a node, consider
      * adding them to KisDummiesFacadeBase instead. Calling this method
      * directly  should be the last resort.
      *
      * \see slotUiActivatedNode for comparison
      */
     void slotNonUiActivatedNode(KisNodeSP node);
 
     /**
      * Activates \p node.
      * All non-ui listeners are notified with sigNodeActivated,
      * sigUiNeedChangeActiveNode is *not* emitted.
      *
      * \see activateNode
      */
-    void slotUiActivatedNode(KisNodeSP node);
+    void slotUiActiatedNode(KisNodeSP node);
 
     /**
      * Adds a list of nodes without searching appropriate position for
      * it.  You *must* ensure that the nodes are allowed to be added
      * to the parent, otherwise you'll get an assert.
      */
     void addNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis);
 
     /**
      * Moves a list of nodes without searching appropriate position
      * for it.  You *must* ensure that the nodes are allowed to be
      * added to the parent, otherwise you'll get an assert.
      */
     void moveNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis);
 
     /**
      * Copies a list of nodes without searching appropriate position
      * for it.  You *must* ensure that the nodes are allowed to be
      * added to the parent, otherwise you'll get an assert.
      */
     void copyNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis);
 
     /**
      * Create new layer from actually visible
      */
     void createFromVisible();
 
     void toggleIsolateActiveNode();
     void toggleIsolateMode(bool checked);
     void slotUpdateIsolateModeAction();
     void slotTryFinishIsolatedMode();
 
     void moveNodeAt(KisNodeSP node, KisNodeSP parent, int index);
     void createNode(const QString& nodeType, bool quiet = false, KisPaintDeviceSP copyFrom = 0);
     void convertNode(const QString &nodeType);
     void nodesUpdated();
     void nodeProperties(KisNodeSP node);
     void nodeOpacityChanged(qreal opacity, bool finalChange);
     void nodeCompositeOpChanged(const KoCompositeOp* op);
     void duplicateActiveNode();
     void removeNode();
     void mirrorNodeX();
     void mirrorNodeY();
     void mirrorNode(KisNodeSP node, const KUndo2MagicString& commandName, Qt::Orientation orientation);
     void activateNextNode();
     void activatePreviousNode();
     void switchToPreviouslyActiveNode();
 
     /**
      * move the active node up the nodestack.
      */
     void raiseNode();
 
     /**
      * move the active node down the nodestack
      */
     void lowerNode();
 
     void rotate(double radians);
     void rotate180();
     void rotateLeft90();
     void rotateRight90();
 
     void saveNodeAsImage();
 
     // merges the active layer with the layer below it.
     void mergeLayer();
 
     void slotSplitAlphaIntoMask();
     void slotSplitAlphaWrite();
     void slotSplitAlphaSaveMerged();
 
     /**
      * @brief slotSetSelectedNodes set the list of nodes selected in the layerbox. Selected nodes are not necessarily active nodes.
      * @param nodes the selected nodes
      */
     void slotSetSelectedNodes(const KisNodeList &nodes);
 
     void slotImageRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes);
 
     void cutLayersToClipboard();
     void copyLayersToClipboard();
     void pasteLayersFromClipboard();
 
     void createQuickGroup();
     void createQuickClippingGroup();
     void quickUngroup();
 
     void selectAllNodes();
     void selectVisibleNodes();
     void selectLockedNodes();
     void selectInvisibleNodes();
     void selectUnlockedNodes();
 
 public:
 
     
     void shear(double angleX, double angleY);
 
     void scale(double sx, double sy, KisFilterStrategy *filterStrategy);
 
     void removeSingleNode(KisNodeSP node);
     KisLayerSP createPaintLayer();
 
 private:
     /**
      * Scales opacity from the range 0...1
      * to the integer range 0...255
      */
     qint32 convertOpacityToInt(qreal opacity);
     void removeSelectedNodes(KisNodeList selectedNodes);
     void slotSomethingActivatedNodeImpl(KisNodeSP node);
     void createQuickGroupImpl(KisNodeJugglerCompressed *juggler,
                               const QString &overrideGroupName,
                               KisNodeSP *newGroup,
                               KisNodeSP *newLastChild);
     void selectLayersImpl(const KoProperties &props, const KoProperties &invertedProps);
 
     struct Private;
     Private * const m_d;
 };
 
 #endif
diff --git a/plugins/dockers/defaultdockers/kis_layer_box.cpp b/plugins/dockers/defaultdockers/kis_layer_box.cpp
index 3e95d24c72..c07d751a88 100644
--- a/plugins/dockers/defaultdockers/kis_layer_box.cpp
+++ b/plugins/dockers/defaultdockers/kis_layer_box.cpp
@@ -1,929 +1,929 @@
 /*
  *  kis_layer_box.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer_box.h"
 
 
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 #include <QMenu>
 #include <QWidgetAction>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KisNodeView.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_base_node.h>
 #include <kis_composite_ops_model.h>
 #include <kis_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 
 #include "canvas/kis_canvas2.h"
 #include "KisDocument.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "sync_button_and_action.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_signals_blocker.h"
 #include "kis_color_filter_combo.h"
 #include "kis_node_filter_proxy_model.h"
 
 #include "kis_layer_utils.h"
 
 #include "ui_wdglayerbox.h"
 
 inline void KisLayerBox::connectActionToButton(KisViewManager* view, QAbstractButton *button, const QString &id)
 {
     if (!view || !button) return;
 
     KisAction *action = view->actionManager()->actionByName(id);
 
     if (!action) return;
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
 }
 
 inline void KisLayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     if (m_canvas) {
         menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
     }
 }
 
 KisLayerBox::KisLayerBox()
     : QDockWidget(i18n("Layers"))
     , m_canvas(0)
     , m_wdgLayerBox(new Ui_WdgLayerBox)
     , m_thumbnailCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_colorLabelCompressor(900, KisSignalCompressor::FIRST_INACTIVE)
 {
     KisConfig cfg;
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(contextMenuRequested(const QPoint&, const QModelIndex&)),
             this, SLOT(slotContextMenuRequested(const QPoint&, const QModelIndex&)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(collapsed(const QModelIndex&)), SLOT(slotCollapsed(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(expanded(const QModelIndex&)), SLOT(slotExpanded(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(selectionChanged(const QModelIndexList&)), SLOT(selectionChanged(const QModelIndexList&)));
 
     m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
 
     m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnRaise->setEnabled(false);
     m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowupblr"));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix("%");
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_selectOpaque = new KisAction(i18n("&Select Opaque"), this);
     m_selectOpaque->setActivationFlags(KisAction::ACTIVE_LAYER);
     m_selectOpaque->setActivationConditions(KisAction::SELECTION_EDITABLE);
     m_selectOpaque->setObjectName("select_opaque");
     connect(m_selectOpaque, SIGNAL(triggered(bool)), this, SLOT(slotSelectOpaque()));
     m_actions.append(m_selectOpaque);
 
     m_newLayerMenu = new QMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
     m_filteringModel = new KisNodeFilterProxyModel(this);
     m_filteringModel->setNodeModel(m_nodeModel);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_colorSelector = new KisColorLabelSelectorWidget(this);
     connect(m_colorSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
     m_colorSelectorAction = new QWidgetAction(this);
     m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
     connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
             &m_colorLabelCompressor, SLOT(start()));
 
     m_wdgLayerBox->listLayers->setModel(m_filteringModel);
     // this connection should be done *after* the setModel() call to
     // happen later than the internal selection model
     connect(m_filteringModel.data(), &KisNodeFilterProxyModel::rowsAboutToBeRemoved,
             this, &KisLayerBox::slotAboutToRemoveRows);
 
     connect(m_wdgLayerBox->cmbFilter, SIGNAL(selectedColorsChanged()), SLOT(updateLayerFiltering()));
 
     setEnabled(false);
 
     connect(&m_thumbnailCompressor, SIGNAL(timeout()), SLOT(updateThumbnail()));
     connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 }
 
 KisLayerBox::~KisLayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeFilterProxyModel> filteringModel, KisNodeView *nodeView)
 {
     if (!root) return;
     if (filteringModel.isNull()) return;
     if (!nodeView) return;
 
     nodeView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = filteringModel->indexFromNode(node);
         if (idx.isValid()) {
             nodeView->setExpanded(idx, !node->collapsed());
         }
         if (node->childCount() > 0) {
             expandNodesRecursively(node, filteringModel, nodeView);
         }
         node = node->nextSibling();
     }
     nodeView->blockSignals(false);
 }
 
 void KisLayerBox::setMainWindow(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
     Q_FOREACH (KisAction *action, m_actions) {
         kisview->actionManager()->
                 addAction(action->objectName(),
                           action);
     }
 
     connectActionToButton(kisview, m_wdgLayerBox->bnAdd, "add_new_paint_layer");
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
     KisActionManager *actionManager = kisview->actionManager();
 
     KisAction *action = actionManager->createAction("RenameCurrentLayer");
     Q_ASSERT(action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
     m_propertiesAction = actionManager->createAction("layer_properties");
     Q_ASSERT(m_propertiesAction);
     new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
     m_removeAction = actionManager->createAction("remove_layer");
     Q_ASSERT(m_removeAction);
     new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
     action = actionManager->createAction("move_layer_up");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
     action = actionManager->createAction("move_layer_down");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 }
 
 void KisLayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if(m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
 
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
             animation->disconnect(this);
         }
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         m_nodeManager->slotSetSelectedNodes(KisNodeList());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), &m_thumbnailCompressor, SLOT(start()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade =
                 static_cast<KisDummiesFacadeBase*>(kritaShapeController);
         m_nodeModel->setDummiesFacade(kritaDummiesFacade, m_image, kritaShapeController, m_nodeManager->nodeSelectionAdapter(), m_nodeManager->nodeInsertionAdapter());
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
             // Connection KisNodeManager -> KisLayerBox
             connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                     this, SLOT(setCurrentNode(KisNodeSP)));
 
             connect(m_nodeManager,
                     SIGNAL(sigUiNeedChangeSelectedNodes(const QList<KisNodeSP> &)),
                     SLOT(slotNodeManagerChangedSelection(const QList<KisNodeSP> &)));
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection KisLayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                 m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         KisImageAnimationInterface *animation = m_image->animationInterface();
         connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &KisLayerBox::slotImageTimeChanged);
 
         expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
         updateAvailableLabels();
 
         addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
         addActionToMenu(m_newLayerMenu, "add_new_group_layer");
         addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
         addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
         addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
         addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
         addActionToMenu(m_newLayerMenu, "add_new_file_layer");
         m_newLayerMenu->addSeparator();
         addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
         addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
         addActionToMenu(m_newLayerMenu, "add_new_colorize_mask");
         addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void KisLayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
 
     m_filteringModel->unsetDummiesFacade();
     disconnect(m_image, 0, this, 0);
     disconnect(m_nodeManager, 0, this, 0);
     disconnect(m_nodeModel, 0, m_nodeManager, 0);
     m_nodeManager->slotSetSelectedNodes(KisNodeList());
 
     m_canvas = 0;
 }
 
 void KisLayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void KisLayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     if (activeNode != m_activeNode) {
         if( !m_activeNode.isNull() )
             m_activeNode->disconnect(this);
         m_activeNode = activeNode;
 
         if (activeNode) {
             KisKeyframeChannel *opacityChannel = activeNode->getKeyframeChannel(KisKeyframeChannel::Opacity.id(), false);
             if (opacityChannel) {
                 watchOpacityChannel(opacityChannel);
             } else {
                 watchOpacityChannel(0);
                 connect(activeNode.data(), &KisNode::keyframeChannelAdded, this, &KisLayerBox::slotKeyframeChannelAdded);
             }
         }
     }
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
 
     if (activeNode) {
         if (m_nodeManager->activePaintDevice()) {
             slotFillCompositeOps(m_nodeManager->activeColorSpace());
         } else {
             slotFillCompositeOps(m_image->colorSpace());
         }
 
         if (activeNode->inherits("KisColorizeMask") ||
                 activeNode->inherits("KisLayer")) {
 
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             slotSetOpacity(activeNode->opacity() * 100.0 / 255);
 
             const KoCompositeOp* compositeOp = activeNode->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         } else if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         }
     }
 }
 
 
 /**
- * This method is callen *only* when non-GUI code requested the
+ * This method is called *only* when non-GUI code requested the
  * change of the current node
  */
 void KisLayerBox::setCurrentNode(KisNodeSP node)
 {
     m_filteringModel->setActiveNode(node);
 
     QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
     m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
     updateUI();
 }
 
 void KisLayerBox::slotModelReset()
 {
     if(m_nodeModel->hasDummiesFacade()) {
         QItemSelection selection;
         Q_FOREACH (const KisNodeSP node, m_nodeManager->selectedNodes()) {
             const QModelIndex &idx = m_filteringModel->indexFromNode(node);
             if(idx.isValid()){
                 QItemSelectionRange selectionRange(idx);
                 selection << selectionRange;
             }
         }
 
         m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
     }
 
     updateUI();
 }
 
 void KisLayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 void KisLayerBox::slotFillCompositeOps(const KoColorSpace* colorSpace)
 {
     m_wdgLayerBox->cmbComposite->validate(colorSpace);
 }
 
 // range: 0-100
 void KisLayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void KisLayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
     KisNodeSP activeNode = m_nodeManager->activeNode();
     if (nodes.isEmpty() || !activeNode) return;
 
     if (m_canvas) {
         QMenu menu;
 
         const bool singleLayer = nodes.size() == 1;
 
         if (index.isValid()) {
             menu.addAction(m_propertiesAction);
 
             if (singleLayer) {
                 addActionToMenu(&menu, "layer_style");
             }
 
             {
                 KisSignalsBlocker b(m_colorSelector);
                 m_colorSelector->setCurrentIndex(singleLayer ? activeNode->colorLabelIndex() : -1);
             }
             menu.addAction(m_colorSelectorAction);
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "cut_layer_clipboard");
             addActionToMenu(&menu, "copy_layer_clipboard");
             addActionToMenu(&menu, "paste_layer_from_clipboard");
             menu.addAction(m_removeAction);
             addActionToMenu(&menu, "duplicatelayer");
             addActionToMenu(&menu, "merge_layer");
 
             if (singleLayer) {
                 addActionToMenu(&menu, "flatten_image");
                 addActionToMenu(&menu, "flatten_layer");
             }
 
             menu.addSeparator();
             QMenu *selectMenu = menu.addMenu(i18n("&Select"));
             addActionToMenu(selectMenu, "select_all_layers");
             addActionToMenu(selectMenu, "select_visible_layers");
             addActionToMenu(selectMenu, "select_invisible_layers");
             addActionToMenu(selectMenu, "select_locked_layers");
             addActionToMenu(selectMenu, "select_unlocked_layers");
             QMenu *groupMenu = menu.addMenu(i18n("&Group"));
             addActionToMenu(groupMenu, "create_quick_group");
             addActionToMenu(groupMenu, "create_quick_clipping_group");
             addActionToMenu(groupMenu, "quick_ungroup");
 
             if (singleLayer) {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_transparency_mask");
                 addActionToMenu(addLayerMenu, "add_new_filter_mask");
                 addActionToMenu(addLayerMenu, "add_new_colorize_mask");
                 addActionToMenu(addLayerMenu, "add_new_transform_mask");
                 addActionToMenu(addLayerMenu, "add_new_selection_mask");
 
                 QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
                 addActionToMenu(convertToMenu, "convert_to_paint_layer");
                 addActionToMenu(convertToMenu, "convert_to_transparency_mask");
                 addActionToMenu(convertToMenu, "convert_to_filter_mask");
                 addActionToMenu(convertToMenu, "convert_to_selection_mask");
 
                 QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
                 addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
                 addActionToMenu(splitAlphaMenu, "split_alpha_write");
                 addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
             }
 
             menu.addSeparator();
 
             if (singleLayer) {
                 addActionToMenu(&menu, "show_in_timeline");
 
                 KisNodeSP node = m_filteringModel->nodeFromIndex(index);
                 if (node && !node->inherits("KisTransformMask")) {
                     addActionToMenu(&menu, "isolate_layer");
                 }
 
                 menu.addAction(m_selectOpaque);
             }
         }
         menu.exec(pos);
     }
 }
 
 void KisLayerBox::slotMergeLayer()
 {
     if (!m_canvas) return;
     m_nodeManager->mergeLayer();
 }
 
 void KisLayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::MinimalMode);
 }
 
 void KisLayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::DetailedMode);
 }
 
 void KisLayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisNodeView::ThumbnailMode);
 }
 
 void KisLayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void KisLayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->raiseNode();
 }
 
 void KisLayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->lowerNode();
 }
 
 void KisLayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void KisLayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void KisLayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_blockOpacityUpdate = true;
     m_nodeManager->nodeOpacityChanged(m_newOpacity, true);
     m_blockOpacityUpdate = false;
 }
 
 void KisLayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void KisLayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void KisLayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void KisLayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void KisLayerBox::slotNodeCollapsedChanged()
 {
     expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP KisLayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (isSelectionMask(startNode) &&
             startNode->parent() &&
             !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && isSelectionMask(node)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && isSelectionMask(node)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && isSelectionMask(node)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void KisLayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     if (showSelections) {
         KisNodeSP newMask = m_image->rootLayer()->selectionMask();
         if (newMask) {
             activateNode = newMask;
         }
     }
 
     if (activateNode) {
         if (lastActiveNode != activateNode) {
             m_nodeManager->slotNonUiActivatedNode(activateNode);
         } else {
             setCurrentNode(lastActiveNode);
         }
     }
 }
 
 void KisLayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     /**
      * When the user clears the extended selection by clicking on the
      * empty area of the docker, the selection should be reset on to
      * the active layer, which might be even unselected(!).
      */
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         QModelIndex selectedIndex =
                 m_filteringModel->indexFromNode(m_nodeManager->activeNode());
 
         m_wdgLayerBox->listLayers->selectionModel()->
                 setCurrentIndex(selectedIndex, QItemSelectionModel::ClearAndSelect);
         return;
     }
 
     QList<KisNodeSP> selectedNodes;
     Q_FOREACH (const QModelIndex &idx, selection) {
         selectedNodes << m_filteringModel->nodeFromIndex(idx);
     }
 
     m_nodeManager->slotSetSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void KisLayerBox::slotAboutToRemoveRows(const QModelIndex &parent, int start, int end)
 {
     /**
      * Qt has changed its behavior when deleting an item. Previously
      * the selection priority was on the next item in the list, and
      * now it has shanged to the previous item. Here we just adjust
      * the selected item after the node removal. Please take care that
      * this method overrides what was done by the corresponding method
      * of QItemSelectionModel, which *has already done* its work. That
      * is why we use (start - 1) and (end + 1) in the activation
      * condition.
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=345601
      */
 
     QModelIndex currentIndex = m_wdgLayerBox->listLayers->currentIndex();
     QAbstractItemModel *model = m_filteringModel;
 
     if (currentIndex.isValid() && parent == currentIndex.parent()
             && currentIndex.row() >= start - 1 && currentIndex.row() <= end + 1) {
         QModelIndex old = currentIndex;
         if (model && end < model->rowCount(parent) - 1) // there are rows left below the change
             currentIndex = model->index(end + 1, old.column(), parent);
         else if (start > 0) // there are rows left above the change
             currentIndex = model->index(start - 1, old.column(), parent);
         else // there are no rows left in the table
             currentIndex = QModelIndex();
 
         if (currentIndex.isValid() && currentIndex != old) {
             m_wdgLayerBox->listLayers->setCurrentIndex(currentIndex);
         }
     }
 }
 
 void KisLayerBox::slotNodeManagerChangedSelection(const KisNodeList &nodes)
 {
     if (!m_nodeManager) return;
 
     QModelIndexList newSelection;
     Q_FOREACH(KisNodeSP node, nodes) {
         newSelection << m_filteringModel->indexFromNode(node);
     }
 
     QItemSelectionModel *model = m_wdgLayerBox->listLayers->selectionModel();
 
     if (KritaUtils::compareListsUnordered(newSelection, model->selectedIndexes())) {
         return;
     }
 
     QItemSelection selection;
     Q_FOREACH(const QModelIndex &idx, newSelection) {
         selection.select(idx, idx);
     }
 
     model->select(selection, QItemSelectionModel::ClearAndSelect);
 }
 
 void KisLayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void KisLayerBox::slotRenameCurrentNode()
 {
     m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void KisLayerBox::slotColorLabelChanged(int label)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
 
     Q_FOREACH(KisNodeSP node, nodes) {
         auto applyLabelFunc =
                 [label](KisNodeSP node) {
             node->setColorLabelIndex(label);
         };
 
         KisLayerUtils::recursiveApplyNodes(node, applyLabelFunc);
     }
 }
 
 void KisLayerBox::updateAvailableLabels()
 {
     if (!m_image) return;
     m_wdgLayerBox->cmbFilter->updateAvailableLabels(m_image->root());
 }
 
 void KisLayerBox::updateLayerFiltering()
 {
     m_filteringModel->setAcceptedLabels(m_wdgLayerBox->cmbFilter->selectedColors());
 }
 
 void KisLayerBox::slotKeyframeChannelAdded(KisKeyframeChannel *channel)
 {
     if (channel->id() == KisKeyframeChannel::Opacity.id()) {
         watchOpacityChannel(channel);
     }
 }
 
 void KisLayerBox::watchOpacityChannel(KisKeyframeChannel *channel)
 {
     if (m_opacityChannel) {
         m_opacityChannel->disconnect(this);
     }
 
     m_opacityChannel = channel;
     if (m_opacityChannel) {
         connect(m_opacityChannel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeMoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeMoved(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeChanged(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
     }
 }
 
 void KisLayerBox::slotOpacityKeyframeChanged(KisKeyframeSP keyframe)
 {
     Q_UNUSED(keyframe);
     if (m_blockOpacityUpdate) return;
     updateUI();
 }
 
 void KisLayerBox::slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime)
 {
     Q_UNUSED(fromTime);
     slotOpacityKeyframeChanged(keyframe);
 }
 
 void KisLayerBox::slotImageTimeChanged(int time)
 {
     Q_UNUSED(time);
     updateUI();
 }
 
 #include "moc_kis_layer_box.cpp"