diff --git a/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp b/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp
index a081409cbb..9dbef76382 100644
--- a/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp
+++ b/libs/libqml/plugins/kritasketchplugin/models/LayerModel.cpp
@@ -1,984 +1,982 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Dan Leinir Turthra Jensen <admin@leinir.dk>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "LayerModel.h"
 #include "LayerThumbProvider.h"
 #include <PropertyContainer.h>
 #include <kis_node_model.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_node_manager.h>
 #include <kis_dummies_facade_base.h>
 #include <KisDocument.h>
 #include <kis_composite_ops_model.h>
 #include <kis_node.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_shape_controller.h>
 #include <kis_adjustment_layer.h>
 #include <kis_selection_manager.h>
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <filter/kis_filter_registry.h>
 #include <KoShapeControllerBase.h>
 #include <KoProperties.h>
 #include <QQmlEngine>
 #include <kis_base_node.h>
 #include "KisSelectionActionsAdapter.h"
 
 struct LayerModelMetaInfo {
     LayerModelMetaInfo()
     : canMoveUp(false)
     , canMoveRight(false)
     , canMoveDown(false)
     , canMoveLeft(false)
     , depth(-1)
     {}
     bool canMoveUp;
     bool canMoveRight;
     bool canMoveDown;
     bool canMoveLeft;
     int depth;
 };
 
 class LayerModel::Private {
 public:
     Private(LayerModel* qq)
         : q(qq)
         , nodeModel(new KisNodeModel(qq))
         , aboutToRemoveRoots(false)
         , canvas(0)
         , nodeManager(0)
         , image(0)
         , activeNode(0)
         , declarativeEngine(0)
         , thumbProvider(0)
         , updateActiveLayerWithNewFilterConfigTimer(new QTimer(qq))
         , imageChangedTimer(new QTimer(qq))
     {
         QList<KisFilterSP> tmpFilters = KisFilterRegistry::instance()->values();
         Q_FOREACH (const KisFilterSP& filter, tmpFilters)
         {
             filters[filter.data()->id()] = filter.data();
         }
         updateActiveLayerWithNewFilterConfigTimer->setInterval(0);
         updateActiveLayerWithNewFilterConfigTimer->setSingleShot(true);
         connect(updateActiveLayerWithNewFilterConfigTimer, SIGNAL(timeout()), qq, SLOT(updateActiveLayerWithNewFilterConfig()));
 
         imageChangedTimer->setInterval(250);
         imageChangedTimer->setSingleShot(true);
         connect(imageChangedTimer, SIGNAL(timeout()), qq, SLOT(imageHasChanged()));
     }
 
     LayerModel* q;
     QList<KisNodeSP> layers;
     QHash<const KisNode*, LayerModelMetaInfo> layerMeta;
     KisNodeModel* nodeModel;
     bool aboutToRemoveRoots;
     KisViewManager* view;
     KisCanvas2* canvas;
     QScopedPointer<KisSelectionActionsAdapter> selectionActionsAdapter;
     QPointer<KisNodeManager> nodeManager;
     KisImageWSP image;
     KisNodeSP activeNode;
     QQmlEngine* declarativeEngine;
     LayerThumbProvider* thumbProvider;
     QHash<QString, const KisFilter*> filters;
 
     KisFilterConfigurationSP newConfig;
     QTimer* updateActiveLayerWithNewFilterConfigTimer;
 
     QTimer* imageChangedTimer;
     static int counter()
     {
         static int count = 0;
         return count++;
     }
 
     static QStringList layerClassNames()
     {
         QStringList list;
         list << "KisGroupLayer";
         list << "KisPaintLayer";
         list << "KisFilterMask";
         list << "KisAdjustmentLayer";
         return list;
     }
 
     int deepChildCount(KisNodeSP layer)
     {
         quint32 childCount = layer->childCount();
         QList<KisNodeSP> children = layer->childNodes(layerClassNames(), KoProperties());
         for(quint32 i = 0; i < childCount; ++i)
             childCount += deepChildCount(children.at(i));
         return childCount;
     }
 
     void rebuildLayerList(KisNodeSP layer = 0)
     {
         bool refreshingFromRoot = false;
         if (!image)
         {
             layers.clear();
             return;
         }
         if (layer == 0)
         {
             refreshingFromRoot = true;
             layers.clear();
             layer = image->rootLayer();
         }
         // implementation node: The root node is not a visible node, and so
         // is never added to the list of layers
         QList<KisNodeSP> children = layer->childNodes(layerClassNames(), KoProperties());
         if (children.count() == 0)
             return;
         for(quint32 i = children.count(); i > 0; --i)
         {
             layers << children.at(i-1);
             rebuildLayerList(children.at(i-1));
         }
 
         if (refreshingFromRoot)
             refreshLayerMovementAbilities();
     }
 
     void refreshLayerMovementAbilities()
     {
         layerMeta.clear();
         if (layers.count() == 0)
             return;
         for(int i = 0; i < layers.count(); ++i)
         {
             const KisNodeSP layer = layers.at(i);
             LayerModelMetaInfo ability;
 
             if (i > 0)
                 ability.canMoveUp = true;
 
             if (i < layers.count() - 1)
                 ability.canMoveDown = true;
 
             KisNodeSP parent = layer;
             while(parent)
             {
                 ++ability.depth;
                 parent = parent->parent();
             }
 
             if (ability.depth > 1)
                 ability.canMoveLeft = true;
 
             if (i < layers.count() - 1 && qobject_cast<const KisGroupLayer*>(layers.at(i + 1).constData()))
                 ability.canMoveRight = true;
 
             layerMeta[layer] = ability;
         }
     }
 };
 
 LayerModel::LayerModel(QObject* parent)
     : QAbstractListModel(parent)
     , d(new Private(this))
 {
 
     connect(d->nodeModel, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
             this, SLOT(source_rowsAboutToBeInserted(QModelIndex,int,int)));
     connect(d->nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
             this, SLOT(source_rowsInserted(QModelIndex,int,int)));
 
     connect(d->nodeModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
             this, SLOT(source_rowsAboutToBeRemoved(QModelIndex,int,int)));
     connect(d->nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SLOT(source_rowsRemoved(QModelIndex,int,int)));
 
     connect(d->nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(source_dataChanged(QModelIndex,QModelIndex)));
     connect(d->nodeModel, SIGNAL(modelReset()),
             this, SLOT(source_modelReset()));
 
     connect(d->nodeModel, SIGNAL(layoutAboutToBeChanged()), this, SIGNAL(layoutAboutToBeChanged()));
     connect(d->nodeModel, SIGNAL(layoutChanged()), this, SIGNAL(layoutChanged()));
 }
 
 LayerModel::~LayerModel()
 {
     delete d;
 }
 
 QHash<int, QByteArray> LayerModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
     roles[IconRole] = "icon";
     roles[NameRole] = "name";
     roles[ActiveLayerRole] = "activeLayer";
     roles[OpacityRole] = "opacity";
     roles[PercentOpacityRole] = "percentOpacity";
     roles[VisibleRole] = "visible";
     roles[CompositeDetailsRole] = "compositeDetails";
     roles[FilterRole] = "filter";
     roles[ChildCountRole] = "childCount";
     roles[DeepChildCountRole] = "deepChildCount";
     roles[DepthRole] = "depth";
     roles[PreviousItemDepthRole] = "previousItemDepth";
     roles[NextItemDepthRole] = "nextItemDepth";
     roles[CanMoveDownRole] = "canMoveDown";
     roles[CanMoveLeftRole] = "canMoveLeft";
     roles[CanMoveRightRole] = "canMoveRight";
     roles[CanMoveUpRole] = "canMoveUp";
 
     return roles;
 }
 
 QObject* LayerModel::view() const
 {
     return d->view;
 }
 
 void LayerModel::setView(QObject *newView)
 {
     KisViewManager* view = qobject_cast<KisViewManager*>(newView);
     // This has to happen very early, and we will be filling it back up again soon anyway...
     if (d->canvas) {
         d->canvas->disconnectCanvasObserver(this);
         disconnect(d->image, 0, this, 0);
         disconnect(d->nodeManager, 0, this, 0);
         disconnect(d->nodeModel, 0, d->nodeManager, 0);
         disconnect(d->nodeModel, SIGNAL(nodeActivated(KisNodeSP)), this, SLOT(currentNodeChanged(KisNodeSP)));
         d->image = 0;
         d->nodeManager = 0;
         d->layers.clear();
         d->activeNode.clear();
         d->canvas = 0;
-        d->nodeModel->setDummiesFacade(0, 0, 0, 0, 0, 0, 0);
+        d->nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
         d->selectionActionsAdapter.reset();
 
     }
 
     d->view = view;
     if (!d->view) {
         return;
     }
 
     d->canvas = view->canvasBase();
     d->thumbProvider = new LayerThumbProvider();
     d->thumbProvider->setLayerModel(this);
     d->thumbProvider->setLayerID(Private::counter());
 // QT5TODO: results in a crash
      d->declarativeEngine->addImageProvider(QString("layerthumb%1").arg(d->thumbProvider->layerID()), d->thumbProvider);
 
     if (d->canvas) {
         d->image = d->canvas->imageView()->image();
         d->nodeManager = d->canvas->viewManager()->nodeManager();
 
         KisDummiesFacadeBase *kritaDummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(d->canvas->imageView()->document()->shapeController());
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(d->canvas->imageView()->document()->shapeController());
 
         d->selectionActionsAdapter.reset(new KisSelectionActionsAdapter(d->canvas->viewManager()->selectionManager()));
         d->nodeModel->setDummiesFacade(kritaDummiesFacade,
                                        d->image,
                                        shapeController,
-                                       d->nodeManager->nodeSelectionAdapter(),
-                                       d->nodeManager->nodeInsertionAdapter(),
                                        d->selectionActionsAdapter.data(),
-                                       d->nodeManager->nodeDisplayModeAdapter());
+                                       d->nodeManager);
 
         connect(d->image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(d->image, SIGNAL(sigNodeChanged(KisNodeSP)), SLOT(nodeChanged(KisNodeSP)));
         connect(d->image, SIGNAL(sigImageUpdated(QRect)), SLOT(imageChanged()));
         connect(d->image, SIGNAL(sigRemoveNodeAsync(KisNodeSP)), SLOT(aboutToRemoveNode(KisNodeSP)));
 
         // cold start
         currentNodeChanged(d->nodeManager->activeNode());
 
         // Connection KisNodeManager -> KisLayerBox
         connect(d->nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)), this, SLOT(currentNodeChanged(KisNodeSP)));
 
         d->rebuildLayerList();
         beginResetModel();
         endResetModel();
     }
 }
 
 QObject* LayerModel::engine() const
 {
     return d->declarativeEngine;
 }
 
 void LayerModel::setEngine(QObject* newEngine)
 {
     d->declarativeEngine = qobject_cast<QQmlEngine*>(newEngine);
     emit engineChanged();
 }
 
 QString LayerModel::fullImageThumbUrl() const
 {
     return QString("image://layerthumb%1/fullimage/%2").arg(d->thumbProvider->layerID()).arg(QDateTime::currentMSecsSinceEpoch());
 }
 
 void LayerModel::currentNodeChanged(KisNodeSP newActiveNode)
 {
     if (!d->activeNode.isNull()) {
         QModelIndex oldIndex = d->nodeModel->indexFromNode(d->activeNode);
         source_dataChanged(oldIndex, oldIndex);
     }
     d->activeNode = newActiveNode;
     emitActiveChanges();
     if (!d->activeNode.isNull()) {
         QModelIndex oldIndex = d->nodeModel->indexFromNode(d->activeNode);
         source_dataChanged(oldIndex, oldIndex);
     }
 }
 
 QVariant LayerModel::data(const QModelIndex& index, int role) const
 {
     QVariant data;
     if (index.isValid()) {
         index.internalPointer();
         KisNodeSP node = d->layers.at(index.row());
         if (node.isNull())
             return data;
         KisNodeSP parent;
         switch(role)
         {
         case IconRole:
             if (dynamic_cast<const KisGroupLayer*>(node.constData()))
                 data = QLatin1String("../images/svg/icon-layer_group-black.svg");
             else if (dynamic_cast<const KisFilterMask*>(node.constData()))
                 data = QLatin1String("../images/svg/icon-layer_filter-black.svg");
             else if (dynamic_cast<const KisAdjustmentLayer*>(node.constData()))
                 data = QLatin1String("../images/svg/icon-layer_filter-black.svg");
             else
                 // We add the currentMSecsSinceEpoch to ensure we force an update (even with cache turned
                 // off, we still apparently get some caching behaviour on delegates in QML)
                 data = QString("image://layerthumb%1/%2/%3").arg(d->thumbProvider->layerID()).arg(index.row()).arg(QDateTime::currentMSecsSinceEpoch());
             break;
         case NameRole:
             data = node->name();
             break;
         case ActiveLayerRole:
             data = (node == d->activeNode);
             break;
         case OpacityRole:
             data = node->opacity();
             break;
         case PercentOpacityRole:
             data = node->percentOpacity();
             break;
         case VisibleRole:
             data = node->visible();
             break;
         case CompositeDetailsRole:
             // composite op goes here...
             if (node->compositeOp())
                 data = node->compositeOp()->description();
             break;
         case FilterRole:
             break;
         case ChildCountRole:
             data = node->childNodes(d->layerClassNames(), KoProperties()).count();
             break;
         case DeepChildCountRole:
             data = d->deepChildCount(d->layers.at(index.row()));
             break;
         case DepthRole:
             data = d->layerMeta[node.data()].depth;
             break;
         case PreviousItemDepthRole:
             if (index.row() == 0)
                 data = -1;
             else
                 data = d->layerMeta[d->layers[index.row() - 1].data()].depth;
             break;
         case NextItemDepthRole:
             if (index.row() == d->layers.count() - 1)
                 data = -1;
             else
                 data = d->layerMeta[d->layers[index.row() + 1].data()].depth;
             break;
         case CanMoveDownRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveDown;
             break;
         case CanMoveLeftRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveLeft;
             break;
         case CanMoveRightRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveRight;
             break;
         case CanMoveUpRole:
             data = (node == d->activeNode) && d->layerMeta[node.data()].canMoveUp;
             break;
         default:
             break;
         }
     }
     return data;
 }
 
 int LayerModel::rowCount(const QModelIndex& parent) const
 {
     if ( parent.isValid() ) {
         return 0;
     }
     return d->layers.count();
 }
 
 QVariant LayerModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     return QAbstractItemModel::headerData(section, orientation, role);
 }
 
 void LayerModel::setActive(int index)
 {
     if (index > -1 && index < d->layers.count()) {
         KisNodeSP newNode = d->layers.at(index);
         d->nodeManager->slotUiActivatedNode(newNode);
         currentNodeChanged(newNode);
     }
 }
 
 void LayerModel::moveUp()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!d->nodeManager->activeNode()->nextSibling()) {
         //dbgKrita << "Active node apparently has no next sibling, however that has happened...";
         if (!grandParent)
             return;
         //dbgKrita << "Node has grandparent";
         if (!grandParent->parent() && node->inherits("KisMask"))
             return;
         //dbgKrita << "Node isn't a mask";
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
     }
     else {
         //dbgKrita << "Move node directly";
         d->nodeManager->lowerNode();
     }
 }
 
 void LayerModel::moveDown()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!d->nodeManager->activeNode()->prevSibling()) {
         //dbgKrita << "Active node apparently has no previous sibling, however that has happened...";
         if (!grandParent)
             return;
         //dbgKrita << "Node has grandparent";
         if (!grandParent->parent() && node->inherits("KisMask"))
             return;
         //dbgKrita << "Node isn't a mask";
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
     } else
     {
         //dbgKrita << "Move node directly";
         d->nodeManager->raiseNode();
     }
 }
 
 void LayerModel::moveLeft()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
     quint16 nodeIndex = parent->index(node);
 
     if (!grandParent)
         return;
     if (!grandParent->parent() && node->inherits("KisMask"))
         return;
 
     if (nodeIndex <= parent->childCount() / 2) {
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
     }
     else {
         d->nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
     }
 }
 
 void LayerModel::moveRight()
 {
     KisNodeSP node = d->nodeManager->activeNode();
     KisNodeSP parent = d->nodeManager->activeNode()->parent();
     KisNodeSP newParent;
     int nodeIndex = parent->index(node);
     int indexAbove = nodeIndex + 1;
     int indexBelow = nodeIndex - 1;
 
     if (parent->at(indexBelow) && parent->at(indexBelow)->allowAsChild(node)) {
         newParent = parent->at(indexBelow);
         d->nodeManager->moveNodeAt(node, newParent, newParent->childCount());
     }
     else if (parent->at(indexAbove) && parent->at(indexAbove)->allowAsChild(node)) {
         newParent = parent->at(indexAbove);
         d->nodeManager->moveNodeAt(node, newParent, 0);
     }
     else {
         return;
     }
 }
 
 void LayerModel::clear()
 {
     d->canvas->viewManager()->selectionManager()->clear();
 }
 
 void LayerModel::clone()
 {
     d->nodeManager->duplicateActiveNode();
 }
 
 void LayerModel::setLocked(int index, bool newLocked)
 {
     if (index > -1 && index < d->layers.count()) {
         if(d->layers[index]->userLocked() == newLocked)
             return;
         d->layers[index]->setUserLocked(newLocked);
         QModelIndex idx = createIndex(index, 0);
         dataChanged(idx, idx);
     }
 }
 
 void LayerModel::setOpacity(int index, float newOpacity)
 {
     if (index > -1 && index < d->layers.count()) {
         if(qFuzzyCompare(d->layers[index]->opacity() + 1, newOpacity + 1))
             return;
         d->layers[index]->setOpacity(newOpacity);
         d->layers[index]->setDirty();
         QModelIndex idx = createIndex(index, 0);
         dataChanged(idx, idx);
     }
 }
 
 void LayerModel::setVisible(int index, bool newVisible)
 {
     if (index > -1 && index < d->layers.count()) {
         KisBaseNode::PropertyList props = d->layers[index]->sectionModelProperties();
         if(props[0].state == newVisible)
             return;
         KisBaseNode::Property prop = props[0];
         prop.state = newVisible;
         props[0] = prop;
         d->nodeModel->setData( d->nodeModel->indexFromNode(d->layers[index]), QVariant::fromValue<KisBaseNode::PropertyList>(props), KisNodeModel::PropertiesRole );
         d->layers[index]->setDirty(d->layers[index]->extent());
         QModelIndex idx = createIndex(index, 0);
         dataChanged(idx, idx);
     }
 }
 
 QImage LayerModel::layerThumbnail(QString layerID) const
 {
     // So, yeah, this is a complete cheatery hack. However, it ensures
     // we actually get updates when we want them (every time the image is supposed
     // to be changed). Had hoped we could avoid it, but apparently not.
     int index = layerID.section(QChar('/'), 0, 0).toInt();
     QImage thumb;
     if (index > -1 && index < d->layers.count()) {
         if (d->thumbProvider)
             thumb = d->layers[index]->createThumbnail(120, 120);
     }
     return thumb;
 }
 
 void LayerModel::deleteCurrentLayer()
 {
     d->activeNode.clear();
     d->nodeManager->removeNode();
 }
 
 void LayerModel::deleteLayer(int index)
 {
     if (index > -1 && index < d->layers.count()) {
         if (d->activeNode == d->layers.at(index))
             d->activeNode.clear();
         d->nodeManager->slotUiActivatedNode(d->layers.at(index));
         d->nodeManager->removeNode();
         d->rebuildLayerList();
         beginResetModel();
         endResetModel();
     }
 }
 
 void LayerModel::addLayer(int layerType)
 {
     switch(layerType) {
         case 0:
             d->nodeManager->createNode("KisPaintLayer");
             break;
         case 1:
             d->nodeManager->createNode("KisGroupLayer");
             break;
         case 2:
             d->nodeManager->createNode("KisFilterMask", true);
             break;
         default:
             break;
     }
 }
 
 void LayerModel::source_rowsAboutToBeInserted(QModelIndex /*p*/, int /*from*/, int /*to*/)
 {
     beginResetModel();
 }
 
 void LayerModel::source_rowsInserted(QModelIndex /*p*/, int, int)
 {
     d->rebuildLayerList();
     emit countChanged();
     endResetModel();
 }
 
 void LayerModel::source_rowsAboutToBeRemoved(QModelIndex /*p*/, int /*from*/, int /*to*/)
 {
     beginResetModel();
 }
 
 void LayerModel::source_rowsRemoved(QModelIndex, int, int)
 {
     d->rebuildLayerList();
     emit countChanged();
     endResetModel();
 }
 
 void LayerModel::source_dataChanged(QModelIndex /*tl*/, QModelIndex /*br*/)
 {
         QModelIndex top = createIndex(0, 0);
         QModelIndex bottom = createIndex(d->layers.count() - 1, 0);
         dataChanged(top, bottom);
 }
 
 void LayerModel::source_modelReset()
 {
     beginResetModel();
     d->rebuildLayerList();
     d->activeNode.clear();
     if (d->layers.count() > 0)
     {
         d->nodeManager->slotUiActivatedNode(d->layers.at(0));
         currentNodeChanged(d->layers.at(0));
     }
     emit countChanged();
     endResetModel();
 }
 
 void LayerModel::notifyImageDeleted()
 {
 }
 
 void LayerModel::nodeChanged(KisNodeSP node)
 {
     QModelIndex index = createIndex(d->layers.indexOf(node), 0);
     dataChanged(index, index);
 }
 
 void LayerModel::imageChanged()
 {
     d->imageChangedTimer->start();
 }
 
 void LayerModel::imageHasChanged()
 {
     QModelIndex top = createIndex(0, 0);
     QModelIndex bottom = createIndex(d->layers.count() - 1, 0);
     dataChanged(top, bottom);
 }
 
 void LayerModel::aboutToRemoveNode(KisNodeSP node)
 {
     Q_UNUSED(node)
     QTimer::singleShot(0, this, SLOT(source_modelReset()));
 }
 
 void LayerModel::emitActiveChanges()
 {
     emit activeFilterConfigChanged();
     emit activeNameChanged();
     emit activeTypeChanged();
     emit activeCompositeOpChanged();
     emit activeOpacityChanged();
     emit activeVisibleChanged();
     emit activeLockedChanged();
     emit activeRChannelActiveChanged();
     emit activeGChannelActiveChanged();
     emit activeBChannelActiveChanged();
     emit activeAChannelActiveChanged();
 }
 
 QString LayerModel::activeName() const
 {
     if (d->activeNode.isNull())
         return QString();
     return d->activeNode->name();
 }
 
 void LayerModel::setActiveName(QString newName)
 {
     if (d->activeNode.isNull())
         return;
     d->activeNode->setName(newName);
     emit activeNameChanged();
 }
 
 QString LayerModel::activeType() const
 {
     return d->activeNode->metaObject()->className();
 }
 
 int LayerModel::activeCompositeOp() const
 {
     if (d->activeNode.isNull())
         return 0;
     KoID entry(d->activeNode->compositeOp()->id());
     QModelIndex idx = KisCompositeOpListModel::sharedInstance()->indexOf(entry);
     if (idx.isValid())
         return idx.row();
     return 0;
 }
 
 void LayerModel::setActiveCompositeOp(int newOp)
 {
     if (d->activeNode.isNull())
         return;
     KoID entry;
     if (KisCompositeOpListModel::sharedInstance()->entryAt(entry, KisCompositeOpListModel::sharedInstance()->index(newOp)))
     {
         d->activeNode->setCompositeOpId(entry.id());
         d->activeNode->setDirty();
         emit activeCompositeOpChanged();
     }
 }
 
 int LayerModel::activeOpacity() const
 {
     if (d->activeNode.isNull())
         return 0;
     return d->activeNode->opacity();
 }
 
 void LayerModel::setActiveOpacity(int newOpacity)
 {
     d->activeNode->setOpacity(newOpacity);
     d->activeNode->setDirty();
     emit activeOpacityChanged();
 }
 
 bool LayerModel::activeVisible() const
 {    if (d->activeNode.isNull())
         return false;
     return d->activeNode->visible();
 }
 
 void LayerModel::setActiveVisible(bool newVisible)
 {
     if (d->activeNode.isNull())
         return;
     setVisible(d->layers.indexOf(d->activeNode), newVisible);
     emit activeVisibleChanged();
 }
 
 bool LayerModel::activeLocked() const
 {
     if (d->activeNode.isNull())
         return false;
     return d->activeNode->userLocked();
 }
 
 void LayerModel::setActiveLocked(bool newLocked)
 {
     if (d->activeNode.isNull())
         return;
     d->activeNode->setUserLocked(newLocked);
     emit activeLockedChanged();
 }
 
 bool LayerModel::activeAChannelActive() const
 {
     KisLayer* layer = qobject_cast<KisLayer*>(d->activeNode.data());
     bool state = false;
     if (layer)
         state = !layer->alphaChannelDisabled();
     return state;
 }
 
 void LayerModel::setActiveAChannelActive(bool newActive)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(d->activeNode.data());
     if (layer)
     {
         layer->disableAlphaChannel(!newActive);
         layer->setDirty();
         emit activeAChannelActiveChanged();
     }
 }
 
 
 bool getActiveChannel(KisNodeSP node, int channelIndex)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(node.data());
     bool flag = false;
     if (layer)
     {
         QBitArray flags = layer->channelFlags();
         if (channelIndex < flags.size()) {
             flag = flags[channelIndex];
         }
     }
     return flag;
 }
 
 void setChannelActive(KisNodeSP node, int channelIndex, bool newActive)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(node.data());
     if (layer) {
         QBitArray flags = layer->channelFlags();
         flags.setBit(channelIndex, newActive);
         layer->setChannelFlags(flags);
         layer->setDirty();
     }
 }
 
 bool LayerModel::activeBChannelActive() const
 {
     return getActiveChannel(d->activeNode, 2);
 }
 
 void LayerModel::setActiveBChannelActive(bool newActive)
 {
     setChannelActive(d->activeNode, 2, newActive);
     emit activeBChannelActiveChanged();
 }
 
 bool LayerModel::activeGChannelActive() const
 {
     return getActiveChannel(d->activeNode, 1);
 }
 
 void LayerModel::setActiveGChannelActive(bool newActive)
 {
     setChannelActive(d->activeNode, 1, newActive);
     emit activeGChannelActiveChanged();
 }
 
 bool LayerModel::activeRChannelActive() const
 {
     return getActiveChannel(d->activeNode, 0);
 }
 
 void LayerModel::setActiveRChannelActive(bool newActive)
 {
     setChannelActive(d->activeNode, 0, newActive);
     emit activeRChannelActiveChanged();
 }
 
 QObject* LayerModel::activeFilterConfig() const
 {
     QMap<QString, QVariant> props;
     QString filterId;
     KisFilterMask* filterMask = qobject_cast<KisFilterMask*>(d->activeNode.data());
     if (filterMask) {
         props = filterMask->filter()->getProperties();
         filterId = filterMask->filter()->name();
     }
     else {
         KisAdjustmentLayer* adjustmentLayer = qobject_cast<KisAdjustmentLayer*>(d->activeNode.data());
         if (adjustmentLayer)
         {
             props = adjustmentLayer->filter()->getProperties();
             filterId = adjustmentLayer->filter()->name();
         }
     }
     PropertyContainer* config = new PropertyContainer(filterId, 0);
     QMap<QString, QVariant>::const_iterator i;
     for(i = props.constBegin(); i != props.constEnd(); ++i) {
         config->setProperty(i.key().toLatin1(), i.value());
         //dbgKrita << "Getting active config..." << i.key() << i.value();
     }
     return config;
 }
 
 void LayerModel::setActiveFilterConfig(QObject* newConfig)
 {
     if (d->activeNode.isNull())
         return;
     PropertyContainer* config = qobject_cast<PropertyContainer*>(newConfig);
     if (!config)
         return;
 
     //dbgKrita << "Attempting to set new config" << config->name();
     KisFilterConfigurationSP realConfig = d->filters.value(config->name())->factoryConfiguration();
     QMap<QString, QVariant>::const_iterator i;
     for(i = realConfig->getProperties().constBegin(); i != realConfig->getProperties().constEnd(); ++i)
     {
         realConfig->setProperty(i.key(), config->property(i.key().toLatin1()));
         //dbgKrita << "Creating config..." << i.key() << i.value();
     }
 // The following code causes sporadic crashes, and disabling causes leaks. So, leaks it must be, for now.
 // The cause is the lack of a smart pointer interface for passing filter configs around
 // Must be remedied, but for now...
 //    if (d->newConfig)
 //        delete(d->newConfig);
     d->newConfig = realConfig;
     //d->updateActiveLayerWithNewFilterConfigTimer->start();
     updateActiveLayerWithNewFilterConfig();
 }
 
 void LayerModel::updateActiveLayerWithNewFilterConfig()
 {
     if (!d->newConfig)
         return;
     //dbgKrita << "Setting new config..." << d->newConfig->name();
     KisFilterMask* filterMask = qobject_cast<KisFilterMask*>(d->activeNode.data());
     if (filterMask)
     {
         //dbgKrita << "Filter mask";
         if (filterMask->filter() == d->newConfig)
             return;
         //dbgKrita << "Setting filter mask";
         filterMask->setFilter(d->newConfig);
     }
     else
     {
         KisAdjustmentLayer* adjustmentLayer = qobject_cast<KisAdjustmentLayer*>(d->activeNode.data());
         if (adjustmentLayer)
         {
             //dbgKrita << "Adjustment layer";
             if (adjustmentLayer->filter() == d->newConfig)
                 return;
             //dbgKrita << "Setting filter on adjustment layer";
             adjustmentLayer->setFilter(d->newConfig);
         }
         else
         {
             //dbgKrita << "UNKNOWN, BAIL OUT!";
         }
     }
     d->newConfig = 0;
     d->activeNode->setDirty(d->activeNode->extent());
     d->image->setModified();
     QTimer::singleShot(100, this, SIGNAL(activeFilterConfigChanged()));
 }
 
diff --git a/libs/ui/kis_node_filter_proxy_model.cpp b/libs/ui/kis_node_filter_proxy_model.cpp
index 1f6e14abaa..083741e1af 100644
--- a/libs/ui/kis_node_filter_proxy_model.cpp
+++ b/libs/ui/kis_node_filter_proxy_model.cpp
@@ -1,169 +1,169 @@
 /*
  *  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_node_filter_proxy_model.h"
 
 #include <QSet>
 #include "kis_node.h"
 #include "kis_node_model.h"
 #include "kis_node_manager.h"
 #include "kis_signal_compressor.h"
 
 #include "kis_image.h"
 
 
 struct KisNodeFilterProxyModel::Private
 {
     Private()
         : nodeModel(0),
           activeNodeCompressor(1000, KisSignalCompressor::FIRST_INACTIVE)
     {}
 
     KisNodeModel *nodeModel;
     KisNodeSP pendingActiveNode;
     KisNodeSP activeNode;
     QSet<int> acceptedLabels;
     KisSignalCompressor activeNodeCompressor;
     bool isUpdatingFilter = false;
 
     bool checkIndexAllowedRecursively(QModelIndex srcIndex);
 };
 
 KisNodeFilterProxyModel::KisNodeFilterProxyModel(QObject *parent)
     : QSortFilterProxyModel(parent),
       m_d(new Private)
 {
     connect(&m_d->activeNodeCompressor, SIGNAL(timeout()), SLOT(slotUpdateCurrentNodeFilter()));
 }
 
 KisNodeFilterProxyModel::~KisNodeFilterProxyModel()
 {
 }
 
 void KisNodeFilterProxyModel::setNodeModel(KisNodeModel *model)
 {
     m_d->nodeModel = model;
     setSourceModel(model);
 }
 
 bool KisNodeFilterProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (m_d->isUpdatingFilter && role == KisNodeModel::ActiveRole) {
         return false;
     }
 
     return QSortFilterProxyModel::setData(index, value, role);
 }
 
 bool KisNodeFilterProxyModel::Private::checkIndexAllowedRecursively(QModelIndex srcIndex)
 {
     if (!srcIndex.isValid()) return false;
 
     KisNodeSP node = nodeModel->nodeFromIndex(srcIndex);
     if (node == activeNode ||
         acceptedLabels.contains(node->colorLabelIndex())) {
 
         return true;
     }
 
     bool result = false;
 
     const int numChildren = srcIndex.model()->rowCount(srcIndex);
     for (int i = 0; i < numChildren; i++) {
         QModelIndex child = nodeModel->index(i, 0, srcIndex);
         if (checkIndexAllowedRecursively(child)) {
             result = true;
             break;
         }
     }
 
     return result;
 }
 
 bool KisNodeFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
 {
     KIS_ASSERT_RECOVER(m_d->nodeModel) { return true; }
 
     const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
     if (!index.isValid()) return false;
 
     KisNodeSP node = m_d->nodeModel->nodeFromIndex(index);
 
     return !node ||
         m_d->acceptedLabels.isEmpty() ||
         m_d->checkIndexAllowedRecursively(index);
 }
 
 KisNodeSP KisNodeFilterProxyModel::nodeFromIndex(const QModelIndex &index) const
 {
     KIS_ASSERT_RECOVER(m_d->nodeModel) { return 0; }
 
     QModelIndex srcIndex = mapToSource(index);
     return m_d->nodeModel->nodeFromIndex(srcIndex);
 }
 
 QModelIndex KisNodeFilterProxyModel::indexFromNode(KisNodeSP node) const
 {
     KIS_ASSERT_RECOVER(m_d->nodeModel) { return QModelIndex(); }
 
     QModelIndex srcIndex = m_d->nodeModel->indexFromNode(node);
     return mapFromSource(srcIndex);
 }
 
 void KisNodeFilterProxyModel::setAcceptedLabels(const QList<int> &value)
 {
     m_d->acceptedLabels = QSet<int>::fromList(value);
     invalidateFilter();
 }
 
 void KisNodeFilterProxyModel::setActiveNode(KisNodeSP node)
 {
     // the new node may temporary become null when the last layer
     // of the document in removed
     m_d->pendingActiveNode = node;
 
     if (node && indexFromNode(node).isValid()) {
         m_d->activeNodeCompressor.start();
     } else {
         slotUpdateCurrentNodeFilter();
     }
 }
 
 void KisNodeFilterProxyModel::slotUpdateCurrentNodeFilter()
 {
     m_d->activeNode = m_d->pendingActiveNode;
 
     /**
      * During the filter update the model might emit "current changed" signals,
      * which (in their turn) will issue setData(..., KisNodeModel::ActiveRole)
      * call, leading to a double recursion. Which, obviously, crashes Krita.
      *
      * Right now, just blocking the KisNodeModel::ActiveRole call is the
      * most obvious solution for the problem.
      */
     m_d->isUpdatingFilter = true;
     invalidateFilter();
     m_d->isUpdatingFilter = false;
 }
 
 void KisNodeFilterProxyModel::unsetDummiesFacade()
 {
-    m_d->nodeModel->setDummiesFacade(0, 0, 0, 0, 0, 0, 0);
+    m_d->nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
     m_d->pendingActiveNode = 0;
     m_d->activeNode = 0;
 }
diff --git a/libs/ui/kis_node_model.cpp b/libs/ui/kis_node_model.cpp
index 99d85d86a2..0f4cddb403 100644
--- a/libs/ui/kis_node_model.cpp
+++ b/libs/ui/kis_node_model.cpp
@@ -1,739 +1,740 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_node_model.h"
 
 #include <iostream>
 
 #include <QMimeData>
 #include <QBuffer>
 #include <QPointer>
 
 #include <KoColorSpaceConstants.h>
 
 #include <klocalizedstring.h>
 
 #include "kis_mimedata.h"
 #include <kis_debug.h>
 #include <kis_node.h>
 #include <kis_node_progress_proxy.h>
 #include <kis_image.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_undo_adapter.h>
 #include <commands/kis_node_property_list_command.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_projection_leaf.h>
 #include <kis_shape_controller.h>
 
 #include "kis_dummies_facade_base.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_model_index_converter.h"
 #include "kis_model_index_converter_show_all.h"
 #include "kis_node_selection_adapter.h"
 #include "kis_node_insertion_adapter.h"
+#include "kis_node_manager.h"
 #include <KisSelectionActionsAdapter.h>
 #include <KisNodeDisplayModeAdapter.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include <QTimer>
 #include "kis_signal_auto_connection.h"
 
 
 struct KisNodeModel::Private
 {
     KisImageWSP image;
     KisShapeController *shapeController = 0;
     KisNodeSelectionAdapter *nodeSelectionAdapter = 0;
     KisNodeInsertionAdapter *nodeInsertionAdapter = 0;
     KisSelectionActionsAdapter *selectionActionsAdapter = 0;
     KisNodeDisplayModeAdapter *nodeDisplayModeAdapter = 0;
+    KisNodeManager *nodeManager = 0;
 
     KisSignalAutoConnectionsStore nodeDisplayModeAdapterConnections;
 
     QList<KisNodeDummy*> updateQueue;
     QTimer updateTimer;
 
     KisModelIndexConverterBase *indexConverter = 0;
     QPointer<KisDummiesFacadeBase> dummiesFacade = 0;
     bool needFinishRemoveRows = false;
     bool needFinishInsertRows = false;
     bool showRootLayer = false;
     bool showGlobalSelection = false;
     QPersistentModelIndex activeNodeIndex;
 
     QPointer<KisNodeDummy> parentOfRemovedNode = 0;
 
     QSet<quintptr> dropEnabled;
 };
 
 KisNodeModel::KisNodeModel(QObject * parent)
         : QAbstractItemModel(parent)
         , m_d(new Private)
 {
     m_d->updateTimer.setSingleShot(true);
     connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
 }
 
 KisNodeModel::~KisNodeModel()
 {
     delete m_d->indexConverter;
     delete m_d;
 }
 
 KisNodeSP KisNodeModel::nodeFromIndex(const QModelIndex &index) const
 {
     Q_ASSERT(index.isValid());
 
     KisNodeDummy *dummy = m_d->indexConverter->dummyFromIndex(index);
     if (dummy) {
         return dummy->node();
     }
     return 0;
 }
 
 QModelIndex KisNodeModel::indexFromNode(KisNodeSP node) const
 {
     KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
     if(dummy)
         return m_d->indexConverter->indexFromDummy(dummy);
     return QModelIndex();
 }
 
 bool KisNodeModel::belongsToIsolatedGroup(KisImageSP image, KisNodeSP node, KisDummiesFacadeBase *dummiesFacade)
 {
     KisNodeSP isolatedRoot = image->isolatedModeRoot();
     if (!isolatedRoot) return true;
 
     KisNodeDummy *isolatedRootDummy =
         dummiesFacade->dummyForNode(isolatedRoot);
     KisNodeDummy *dummy =
         dummiesFacade->dummyForNode(node);
 
     while (dummy) {
         if (dummy == isolatedRootDummy) {
             return true;
         }
         dummy = dummy->parent();
     }
 
     return false;
 }
 
 bool KisNodeModel::belongsToIsolatedGroup(KisNodeSP node) const
 {
     return belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade);
 }
 
 void KisNodeModel::resetIndexConverter()
 {
     delete m_d->indexConverter;
     m_d->indexConverter = 0;
 
     if(m_d->dummiesFacade) {
         m_d->indexConverter = createIndexConverter();
     }
 }
 
 KisModelIndexConverterBase *KisNodeModel::createIndexConverter()
 {
     if(m_d->showRootLayer) {
         return new KisModelIndexConverterShowAll(m_d->dummiesFacade, this);
     } else {
         return new KisModelIndexConverter(m_d->dummiesFacade, this, m_d->showGlobalSelection);
     }
 }
 
 void KisNodeModel::regenerateItems(KisNodeDummy *dummy)
 {
     const QModelIndex &index = m_d->indexConverter->indexFromDummy(dummy);
     emit dataChanged(index, index);
 
     dummy = dummy->firstChild();
     while (dummy) {
         regenerateItems(dummy);
         dummy = dummy->nextSibling();
     }
 }
 
 void KisNodeModel::slotIsolatedModeChanged()
 {
     regenerateItems(m_d->dummiesFacade->rootDummy());
 }
 
 bool KisNodeModel::showGlobalSelection() const
 {
     return m_d->nodeDisplayModeAdapter ?
         m_d->nodeDisplayModeAdapter->showGlobalSelectionMask() :
         false;
 }
 
 void KisNodeModel::setShowGlobalSelection(bool value)
 {
     if (m_d->nodeDisplayModeAdapter) {
         m_d->nodeDisplayModeAdapter->setShowGlobalSelectionMask(value);
     }
 }
 
 void KisNodeModel::slotNodeDisplayModeChanged(bool showRootNode, bool showGlobalSelectionMask)
 {
     const bool oldShowRootLayer = m_d->showRootLayer;
     const bool oldShowGlobalSelection = m_d->showGlobalSelection;
     m_d->showRootLayer = showRootNode;
     m_d->showGlobalSelection = showGlobalSelectionMask;
 
     if (m_d->showRootLayer != oldShowRootLayer || m_d->showGlobalSelection != oldShowGlobalSelection) {
         resetIndexConverter();
         beginResetModel();
         endResetModel();
     }
 }
 
 void KisNodeModel::progressPercentageChanged(int, const KisNodeSP node)
 {
     if(!m_d->dummiesFacade) return;
 
     // Need to check here as the node might already be removed, but there might
     // still be some signals arriving from another thread
     if (m_d->dummiesFacade->hasDummyForNode(node)) {
         QModelIndex index = indexFromNode(node);
 
         emit dataChanged(index, index);
     }
 }
 
 KisModelIndexConverterBase * KisNodeModel::indexConverter() const
 {
     return m_d->indexConverter;
 }
 
 KisDummiesFacadeBase *KisNodeModel::dummiesFacade() const
 {
     return m_d->dummiesFacade;
 }
 
 void KisNodeModel::connectDummy(KisNodeDummy *dummy, bool needConnect)
 {
     KisNodeSP node = dummy->node();
     if (!node) {
         qWarning() << "Dummy node has no node!" << dummy << dummy->node();
         return;
     }
     KisNodeProgressProxy *progressProxy = node->nodeProgressProxy();
     if(progressProxy) {
         if(needConnect) {
             connect(progressProxy, SIGNAL(percentageChanged(int,KisNodeSP)),
                     SLOT(progressPercentageChanged(int,KisNodeSP)));
         } else {
             progressProxy->disconnect(this);
         }
     }
 }
 
 void KisNodeModel::connectDummies(KisNodeDummy *dummy, bool needConnect)
 {
     connectDummy(dummy, needConnect);
 
     dummy = dummy->firstChild();
     while(dummy) {
         connectDummies(dummy, needConnect);
         dummy = dummy->nextSibling();
     }
 }
 
 void KisNodeModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade,
                                     KisImageWSP image,
                                     KisShapeController *shapeController,
-                                    KisNodeSelectionAdapter *nodeSelectionAdapter,
-                                    KisNodeInsertionAdapter *nodeInsertionAdapter,
                                     KisSelectionActionsAdapter *selectionActionsAdapter,
-                                    KisNodeDisplayModeAdapter *nodeDisplayModeAdapter)
+                                    KisNodeManager *nodeManager)
 {
     QPointer<KisDummiesFacadeBase> oldDummiesFacade(m_d->dummiesFacade);
     KisShapeController  *oldShapeController = m_d->shapeController;
 
     m_d->shapeController = shapeController;
-    m_d->nodeSelectionAdapter = nodeSelectionAdapter;
-    m_d->nodeInsertionAdapter = nodeInsertionAdapter;
+    m_d->nodeManager = nodeManager;
+    m_d->nodeSelectionAdapter = nodeManager ? nodeManager->nodeSelectionAdapter() : nullptr;
+    m_d->nodeInsertionAdapter = nodeManager ? nodeManager->nodeInsertionAdapter() : nullptr;
     m_d->selectionActionsAdapter = selectionActionsAdapter;
 
     m_d->nodeDisplayModeAdapterConnections.clear();
-    m_d->nodeDisplayModeAdapter = nodeDisplayModeAdapter;
+    m_d->nodeDisplayModeAdapter = nodeManager ? nodeManager->nodeDisplayModeAdapter() : nullptr;
     if (m_d->nodeDisplayModeAdapter) {
         m_d->nodeDisplayModeAdapterConnections.addConnection(
             m_d->nodeDisplayModeAdapter, SIGNAL(sigNodeDisplayModeChanged(bool,bool)),
             this, SLOT(slotNodeDisplayModeChanged(bool,bool)));
 
         // cold initialization
         m_d->showGlobalSelection = m_d->nodeDisplayModeAdapter->showGlobalSelectionMask();
         m_d->showRootLayer = m_d->showRootLayer;
     }
 
     if (oldDummiesFacade && m_d->image) {
         m_d->image->disconnect(this);
         oldDummiesFacade->disconnect(this);
         connectDummies(m_d->dummiesFacade->rootDummy(), false);
     }
 
     m_d->image = image;
     m_d->dummiesFacade = dummiesFacade;
     m_d->parentOfRemovedNode = 0;
     resetIndexConverter();
 
     if (m_d->dummiesFacade) {
         KisNodeDummy *rootDummy = m_d->dummiesFacade->rootDummy();
         if (rootDummy) {
             connectDummies(rootDummy, true);
         }
 
         connect(m_d->dummiesFacade, SIGNAL(sigBeginInsertDummy(KisNodeDummy*,int,QString)),
                 SLOT(slotBeginInsertDummy(KisNodeDummy*,int,QString)));
         connect(m_d->dummiesFacade, SIGNAL(sigEndInsertDummy(KisNodeDummy*)),
                 SLOT(slotEndInsertDummy(KisNodeDummy*)));
         connect(m_d->dummiesFacade, SIGNAL(sigBeginRemoveDummy(KisNodeDummy*)),
                 SLOT(slotBeginRemoveDummy(KisNodeDummy*)));
         connect(m_d->dummiesFacade, SIGNAL(sigEndRemoveDummy()),
                 SLOT(slotEndRemoveDummy()));
 
         connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                 SLOT(slotDummyChanged(KisNodeDummy*)));
 
         if (m_d->image.isValid()) {
             connect(m_d->image, SIGNAL(sigIsolatedModeChanged()), SLOT(slotIsolatedModeChanged()));
         }
     }
 
     if (m_d->dummiesFacade != oldDummiesFacade || m_d->shapeController != oldShapeController) {
         beginResetModel();
         endResetModel();
     }
 }
 
 void KisNodeModel::slotBeginInsertDummy(KisNodeDummy *parent, int index, const QString &metaObjectType)
 {
     int row = 0;
     QModelIndex parentIndex;
 
     bool willAdd =
         m_d->indexConverter->indexFromAddedDummy(parent, index,
                                                  metaObjectType,
                                                  parentIndex, row);
 
     if(willAdd) {
         beginInsertRows(parentIndex, row, row);
         m_d->needFinishInsertRows = true;
     }
 }
 
 void KisNodeModel::slotEndInsertDummy(KisNodeDummy *dummy)
 {
     if(m_d->needFinishInsertRows) {
         connectDummy(dummy, true);
         endInsertRows();
         m_d->needFinishInsertRows = false;
     }
 }
 
 void KisNodeModel::slotBeginRemoveDummy(KisNodeDummy *dummy)
 {
     if (!dummy) return;
 
     // FIXME: is it really what we want?
     m_d->updateTimer.stop();
     m_d->updateQueue.clear();
 
     m_d->parentOfRemovedNode = dummy->parent();
 
     QModelIndex parentIndex;
     if (m_d->parentOfRemovedNode) {
         parentIndex = m_d->indexConverter->indexFromDummy(m_d->parentOfRemovedNode);
     }
 
     QModelIndex itemIndex = m_d->indexConverter->indexFromDummy(dummy);
 
     if (itemIndex.isValid()) {
         connectDummy(dummy, false);
         beginRemoveRows(parentIndex, itemIndex.row(), itemIndex.row());
         m_d->needFinishRemoveRows = true;
     }
 }
 
 void KisNodeModel::slotEndRemoveDummy()
 {
     if(m_d->needFinishRemoveRows) {
         endRemoveRows();
         m_d->needFinishRemoveRows = false;
     }
 }
 
 void KisNodeModel::slotDummyChanged(KisNodeDummy *dummy)
 {
     if (!m_d->updateQueue.contains(dummy)) {
         m_d->updateQueue.append(dummy);
     }
     m_d->updateTimer.start(1000);
 }
 
 void addChangedIndex(const QModelIndex &idx, QSet<QModelIndex> *indexes)
 {
     if (!idx.isValid() || indexes->contains(idx)) return;
 
     indexes->insert(idx);
 
     const int rowCount = idx.model()->rowCount(idx);
     for (int i = 0; i < rowCount; i++) {
         addChangedIndex(idx.model()->index(i, 0, idx), indexes);
     }
 }
 
 
 void KisNodeModel::processUpdateQueue()
 {
     QSet<QModelIndex> indexes;
 
     Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
         QModelIndex index = m_d->indexConverter->indexFromDummy(dummy);
         addChangedIndex(index, &indexes);
     }
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         emit dataChanged(index, index);
     }
 
     m_d->updateQueue.clear();
 }
 
 QModelIndex KisNodeModel::index(int row, int col, const QModelIndex &parent) const
 {
     if(!m_d->dummiesFacade || !hasIndex(row, col, parent)) return QModelIndex();
 
     QModelIndex itemIndex;
 
     KisNodeDummy *dummy = m_d->indexConverter->dummyFromRow(row, parent);
     if(dummy) {
         itemIndex = m_d->indexConverter->indexFromDummy(dummy);
     }
 
     return itemIndex;
 }
 
 int KisNodeModel::rowCount(const QModelIndex &parent) const
 {
     if(!m_d->dummiesFacade) return 0;
     return m_d->indexConverter->rowCount(parent);
 }
 
 int KisNodeModel::columnCount(const QModelIndex&) const
 {
     return 1;
 }
 
 QModelIndex KisNodeModel::parent(const QModelIndex &index) const
 {
     if(!m_d->dummiesFacade || !index.isValid()) return QModelIndex();
 
     KisNodeDummy *dummy = m_d->indexConverter->dummyFromIndex(index);
     KisNodeDummy *parentDummy = dummy->parent();
 
     QModelIndex parentIndex;
 
     if(parentDummy) {
         parentIndex = m_d->indexConverter->indexFromDummy(parentDummy);
     }
 
     return parentIndex;
 }
 
 QVariant KisNodeModel::data(const QModelIndex &index, int role) const
 {
     if (!m_d->dummiesFacade || !index.isValid() || !m_d->image.isValid()) return QVariant();
 
     KisNodeSP node = nodeFromIndex(index);
 
     switch (role) {
     case Qt::DisplayRole: return node->name();
     case Qt::DecorationRole: return node->icon();
     case Qt::EditRole: return node->name();
     case Qt::SizeHintRole: return m_d->image->size(); // FIXME
     case Qt::TextColorRole:
         return belongsToIsolatedGroup(node) &&
             !node->projectionLeaf()->isDroppedMask() ? QVariant() : QVariant(QColor(Qt::gray));
     case Qt::FontRole: {
         QFont baseFont;
         if (node->projectionLeaf()->isDroppedMask()) {
             baseFont.setStrikeOut(true);
         }
         if (m_d->activeNodeIndex == index) {
             baseFont.setBold(true);
         }
         return baseFont;
     }
     case KisNodeModel::PropertiesRole: return QVariant::fromValue(node->sectionModelProperties());
     case KisNodeModel::AspectRatioRole: return double(m_d->image->width()) / m_d->image->height();
     case KisNodeModel::ProgressRole: {
         KisNodeProgressProxy *proxy = node->nodeProgressProxy();
         return proxy ? proxy->percentage() : -1;
     }
     case KisNodeModel::ActiveRole: {
         return m_d->activeNodeIndex == index;
     }
     case KisNodeModel::ShouldGrayOutRole: {
         return !node->visible(true);
     }
     case KisNodeModel::ColorLabelIndexRole: {
         return node->colorLabelIndex();
     }
     default:
         if (role >= int(KisNodeModel::BeginThumbnailRole) && belongsToIsolatedGroup(node)) {
 
             const int maxSize = role - int(KisNodeModel::BeginThumbnailRole);
 
             QSize size = node->extent().size();
             size.scale(maxSize, maxSize, Qt::KeepAspectRatio);
             if (size.width() == 0 || size.height() == 0) {
                 // No thumbnail can be shown if there isn't width or height...
                 return QVariant();
             }
 
             return node->createThumbnail(size.width(), size.height());
         } else {
             return QVariant();
         }
     }
 
     return QVariant();
 }
 
 Qt::ItemFlags KisNodeModel::flags(const QModelIndex &index) const
 {
     if(!m_d->dummiesFacade || !index.isValid()) return Qt::ItemIsDropEnabled;
 
     Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEditable;
     if (m_d->dropEnabled.contains(index.internalId())) {
         flags |= Qt::ItemIsDropEnabled;
     }
     return flags;
 }
 
 bool KisNodeModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (role == KisNodeModel::DropEnabled) {
         const QMimeData *mimeData = static_cast<const QMimeData*>(value.value<void*>());
         setDropEnabled(mimeData);
         return true;
     }
 
     if (role == KisNodeModel::ActiveRole || role == KisNodeModel::AlternateActiveRole) {
         QModelIndex parentIndex;
         if (!index.isValid() && m_d->parentOfRemovedNode && m_d->dummiesFacade && m_d->indexConverter) {
             parentIndex = m_d->indexConverter->indexFromDummy(m_d->parentOfRemovedNode);
             m_d->parentOfRemovedNode = 0;
         }
 
         KisNodeSP activatedNode;
 
         if (index.isValid() && value.toBool()) {
             activatedNode = nodeFromIndex(index);
         }
         else if (parentIndex.isValid() && value.toBool()) {
             activatedNode = nodeFromIndex(parentIndex);
         }
         else {
             activatedNode = 0;
         }
 
         QModelIndex newActiveNode = activatedNode ? indexFromNode(activatedNode) : QModelIndex();
         if (role == KisNodeModel::ActiveRole && value.toBool() &&
             m_d->activeNodeIndex == newActiveNode) {
 
             return true;
         }
 
         m_d->activeNodeIndex = newActiveNode;
 
         if (m_d->nodeSelectionAdapter) {
             m_d->nodeSelectionAdapter->setActiveNode(activatedNode);
         }
 
         if (role == KisNodeModel::AlternateActiveRole) {
             emit toggleIsolateActiveNode();
         }
 
         emit dataChanged(index, index);
         return true;
     }
 
     if(!m_d->dummiesFacade || !index.isValid()) return false;
 
     bool result = true;
     bool shouldUpdate = true;
     bool shouldUpdateRecursively = false;
     KisNodeSP node = nodeFromIndex(index);
 
     switch (role) {
     case Qt::DisplayRole:
     case Qt::EditRole:
         node->setName(value.toString());
         break;
     case KisNodeModel::PropertiesRole:
         {
             // don't record undo/redo for visibility, locked or alpha locked changes
             KisBaseNode::PropertyList proplist = value.value<KisBaseNode::PropertyList>();
             KisNodePropertyListCommand::setNodePropertiesNoUndo(node, m_d->image, proplist);
             shouldUpdateRecursively = true;
 
             break;
         }
     case KisNodeModel::SelectOpaqueRole:
         if (node && m_d->selectionActionsAdapter) {
             SelectionAction action = SelectionAction(value.toInt());
             m_d->selectionActionsAdapter->selectOpaqueOnNode(node, action);
         }
         shouldUpdate = false;
         break;
     default:
         result = false;
     }
 
     if (result && shouldUpdate) {
         if (shouldUpdateRecursively) {
             QSet<QModelIndex> indexes;
             addChangedIndex(index, &indexes);
             Q_FOREACH (const QModelIndex &index, indexes) {
                 emit dataChanged(index, index);
             }
         } else {
             emit dataChanged(index, index);
         }
     }
 
     return result;
 }
 
 Qt::DropActions KisNodeModel::supportedDragActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions KisNodeModel::supportedDropActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 bool KisNodeModel::hasDummiesFacade()
 {
     return m_d->dummiesFacade != 0;
 }
 
 QStringList KisNodeModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-krita-node");
     types << QLatin1String("application/x-qt-image");
     return types;
 }
 
 QMimeData * KisNodeModel::mimeData(const QModelIndexList &indexes) const
 {
     KisNodeList nodes;
     Q_FOREACH (const QModelIndex &idx, indexes) {
         nodes << nodeFromIndex(idx);
     }
 
     return KisMimeData::mimeForLayers(nodes, m_d->image);
 }
 
 bool KisNodeModel::dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent)
 {
     Q_UNUSED(column);
 
     bool copyNode = (action == Qt::CopyAction);
 
     KisNodeDummy *parentDummy = 0;
     KisNodeDummy *aboveThisDummy = 0;
 
     parentDummy = parent.isValid() ?
         m_d->indexConverter->dummyFromIndex(parent) :
         m_d->dummiesFacade->rootDummy();
 
     if (row == -1) {
         aboveThisDummy = parent.isValid() ? parentDummy->lastChild() : 0;
     }
     else {
         aboveThisDummy = row < m_d->indexConverter->rowCount(parent) ? m_d->indexConverter->dummyFromRow(row, parent) : 0;
     }
 
     return KisMimeData::insertMimeLayers(data,
                                          m_d->image,
                                          m_d->shapeController,
                                          parentDummy,
                                          aboveThisDummy,
                                          copyNode,
                                          m_d->nodeInsertionAdapter);
 }
 
 bool KisNodeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const {
     if (parent.isValid()) {
         // drop occurred on an item. always return true as returning false will mess up
         // QT5's drag handling (see KisNodeModel::setDropEnabled).
         return true;
     } else {
         return QAbstractItemModel::canDropMimeData(data, action, row, column, parent);
     }
 }
 
 void KisNodeModel::setDropEnabled(const QMimeData *data) {
     // what happens here should really happen in KisNodeModel::canDropMimeData(), but QT5
     // will mess up if an item's Qt::ItemIsDropEnabled does not match what is returned by
     // canDropMimeData; specifically, if we set the flag, but decide in canDropMimeData()
     // later on that an "onto" drag is not allowed, QT will display an drop indicator for
     // insertion, but not perform any drop when the mouse is released.
 
     // the only robust implementation seems to set all flags correctly, which is done here.
 
     bool copyNode = false;
     KisNodeList nodes = KisMimeData::loadNodesFast(data, m_d->image, m_d->shapeController, copyNode);
     m_d->dropEnabled.clear();
     updateDropEnabled(nodes);
 }
 
 void KisNodeModel::updateDropEnabled(const QList<KisNodeSP> &nodes, QModelIndex parent) {
     for (int r = 0; r < rowCount(parent); r++) {
         QModelIndex idx = index(r, 0, parent);
 
         KisNodeSP target = nodeFromIndex(idx);
 
         bool dropEnabled = true;
         Q_FOREACH (const KisNodeSP &node, nodes) {
             if (!target->allowAsChild(node)) {
                 dropEnabled = false;
                 break;
             }
         }
         if (dropEnabled) {
             m_d->dropEnabled.insert(idx.internalId());
         }
         emit dataChanged(idx, idx); // indicate to QT that flags() have changed
 
         if (hasChildren(idx)) {
             updateDropEnabled(nodes, idx);
         }
     }
 }
diff --git a/libs/ui/kis_node_model.h b/libs/ui/kis_node_model.h
index ef1fe3a3ab..60dcc6dd9a 100644
--- a/libs/ui/kis_node_model.h
+++ b/libs/ui/kis_node_model.h
@@ -1,191 +1,190 @@
 /*
  *  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_MODEL
 #define KIS_NODE_MODEL
 
 #include "kritaui_export.h"
 #include <kis_types.h>
 #include <QAbstractItemModel>
 #include <QIcon>
 #include <QList>
 #include <QString>
 #include <QVariant>
 
 #include <KisSelectionTags.h>
 
 class KisDummiesFacadeBase;
 class KisNodeDummy;
 class KisShapeController;
 class KisModelIndexConverterBase;
 class KisNodeSelectionAdapter;
 class KisNodeInsertionAdapter;
 class KisSelectionActionsAdapter;
 class KisNodeDisplayModeAdapter;
+class KisNodeManager;
 
 /**
  * KisNodeModel offers a Qt model-view compatible view of the node
  * hierarchy. The KisNodeView displays a thumbnail and a row of
  * icon properties for every document section.
  *
  * Note that there's a discrepancy between the krita node tree model
  * and the model Qt wants to see: we hide the root node from Qt.
  *
  * The node model also shows an inverse view of the layer tree: we want
  * the first layer to show up at the bottom.
  * 
  * See also the Qt documentation for QAbstractItemModel. 
  * This class extends that interface to provide a name and set of toggle
  * properties (like visible, locked, selected.)
  * 
  */
 class KRITAUI_EXPORT KisNodeModel : public QAbstractItemModel
 {
 
     Q_OBJECT
 
 public:
     /// Extensions to Qt::ItemDataRole.
     enum ItemDataRole
     {
         /// Whether the section is the active one
         ActiveRole = Qt::UserRole + 1,
 
         /// A list of properties the part has.
         PropertiesRole,
 
         /// The aspect ratio of the section as a floating point value: width divided by height.
         AspectRatioRole,
 
         /// Use to communicate a progress report to the section delegate on an action (a value of -1 or a QVariant() disable the progress bar
         ProgressRole,
 
         /// Speacial activation role which is emitted when the user Atl-clicks on a section
         /// The item is first activated with ActiveRole, then a separate AlternateActiveRole comes
         AlternateActiveRole,
 
         // When a layer is not (recursively) visible, then it should be gayed out
         ShouldGrayOutRole,
 
         // An index of a color label associated with the node
         ColorLabelIndexRole,
 
         // Instruct this model to update all its items' Qt::ItemIsDropEnabled flags in order to
         // reflect if the item allows an "onto" drop of the given QMimeData*.
         DropEnabled,
 
         // Instructs the model to activate "select opaque" action,
         // the selection action (of type SelectionAction) value
         // is passed via QVariant as integer
         SelectOpaqueRole,
 
         /// This is to ensure that we can extend the data role in the future, since it's not possible to add a role after BeginThumbnailRole (due to "Hack")
         ReservedRole = Qt::UserRole + 99,
 
         /**
          * For values of BeginThumbnailRole or higher, a thumbnail of the layer of which neither dimension
          * is larger than (int) value - (int) BeginThumbnailRole.
          * This is a hack to work around the fact that Interview doesn't have a nice way to
          * request thumbnails of arbitrary size.
          */
         BeginThumbnailRole
     };
 
 public: // from QAbstractItemModel
 
     KisNodeModel(QObject * parent);
     ~KisNodeModel() override;
 
     void setDummiesFacade(KisDummiesFacadeBase *dummiesFacade,
                           KisImageWSP image,
                           KisShapeController *shapeController,
-                          KisNodeSelectionAdapter *nodeSelectionAdapter,
-                          KisNodeInsertionAdapter *nodeInsertionAdapter,
                           KisSelectionActionsAdapter *selectionActionsAdapter,
-                          KisNodeDisplayModeAdapter *nodeDisplayModeAdapter);
+                          KisNodeManager *nodeManager);
     KisNodeSP nodeFromIndex(const QModelIndex &index) const;
     QModelIndex indexFromNode(KisNodeSP node) const;
 
     bool showGlobalSelection() const;
 
 public Q_SLOTS:
     void setShowGlobalSelection(bool value);
 
 public:
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex &index) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     Qt::ItemFlags flags(const QModelIndex &index) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
     QStringList mimeTypes() const override;
     QMimeData* mimeData(const QModelIndexList & indexes) const override;
     bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) override;
     bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const override;
     Qt::DropActions supportedDragActions() const override;
     Qt::DropActions supportedDropActions() const override;
     bool hasDummiesFacade();
 
     static bool belongsToIsolatedGroup(KisImageSP image, KisNodeSP node, KisDummiesFacadeBase *dummiesFacade);
 
 Q_SIGNALS:
 
     void toggleIsolateActiveNode();
 
 protected Q_SLOTS:
     void slotBeginInsertDummy(KisNodeDummy *parent, int index, const QString &metaObjectType);
     void slotEndInsertDummy(KisNodeDummy *dummy);
     void slotBeginRemoveDummy(KisNodeDummy *dummy);
     void slotEndRemoveDummy();
     void slotDummyChanged(KisNodeDummy *dummy);
 
     void slotIsolatedModeChanged();
 
     void slotNodeDisplayModeChanged(bool showRootNode, bool showGlobalSelectionMask);
 
     void processUpdateQueue();
     void progressPercentageChanged(int, const KisNodeSP);
 
 protected:
     virtual KisModelIndexConverterBase *createIndexConverter();
     KisModelIndexConverterBase *indexConverter() const;
     KisDummiesFacadeBase *dummiesFacade() const;
 
 private:
     friend class KisModelIndexConverter;
     friend class KisModelIndexConverterShowAll;
 
     void connectDummy(KisNodeDummy *dummy, bool needConnect);
     void connectDummies(KisNodeDummy *dummy, bool needConnect);
 
     void resetIndexConverter();
 
     void regenerateItems(KisNodeDummy *dummy);
     bool belongsToIsolatedGroup(KisNodeSP node) const;
 
 	void setDropEnabled(const QMimeData *data);
 	void updateDropEnabled(const QList<KisNodeSP> &nodes, QModelIndex parent = QModelIndex());
     
 private:
 
     struct Private;
     Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/tests/kis_model_index_converter_test.cpp b/libs/ui/tests/kis_model_index_converter_test.cpp
index 8fbe00cac6..795217d45d 100644
--- a/libs/ui/tests/kis_model_index_converter_test.cpp
+++ b/libs/ui/tests/kis_model_index_converter_test.cpp
@@ -1,451 +1,451 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_model_index_converter_test.h"
 
 #include <QTest>
 
 #include "kis_node_model.h"
 #include "kis_dummies_facade.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_model_index_converter.h"
 #include "kis_model_index_converter_show_all.h"
 
 
 void KisModelIndexConverterTest::init()
 {
     m_dummiesFacade = new KisDummiesFacade(0);
     m_nodeModel = new KisNodeModel(0);
     initBase();
     constructImage();
     addSelectionMasks();
 
     m_dummiesFacade->setImage(m_image);
-    m_nodeModel->setDummiesFacade(m_dummiesFacade, m_image, 0, 0, 0, 0, 0);
+    m_nodeModel->setDummiesFacade(m_dummiesFacade, m_image, 0, 0, 0);
 }
 
 void KisModelIndexConverterTest::cleanup()
 {
-    m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0, 0, 0);
+    m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
     m_dummiesFacade->setImage(0);
 
     cleanupBase();
     delete m_indexConverter;
     delete m_nodeModel;
     delete m_dummiesFacade;
 }
 
 inline void KisModelIndexConverterTest::checkIndexFromDummy(KisNodeSP node, int row) {
     QModelIndex index;
     KisNodeDummy *dummy;
 
     dummy = m_dummiesFacade->dummyForNode(node);
     index = m_indexConverter->indexFromDummy(dummy);
 
     QVERIFY(index.isValid());
     QCOMPARE(index.column(), 0);
     QCOMPARE(index.row(), row);
     QCOMPARE(m_indexConverter->dummyFromIndex(index), dummy);
 }
 
 inline void KisModelIndexConverterTest::checkInvalidIndexFromDummy(KisNodeSP node) {
     QModelIndex index;
     KisNodeDummy *dummy;
 
     dummy = m_dummiesFacade->dummyForNode(node);
     index = m_indexConverter->indexFromDummy(dummy);
 
     QVERIFY(!index.isValid());
 }
 
 inline void KisModelIndexConverterTest::checkIndexFromAddedAllowedDummy(KisNodeSP parent, int index, int parentRow, int childRow, bool parentValid)
 {
     QString type = KisLayer::staticMetaObject.className();
     checkIndexFromAddedDummy(parent, index, type, parentRow, childRow, parentValid);
 }
 
 inline void KisModelIndexConverterTest::checkIndexFromAddedDeniedDummy(KisNodeSP parent, int index, int parentRow, int childRow, bool parentValid)
 {
     QString type = KisSelectionMask::staticMetaObject.className();
     checkIndexFromAddedDummy(parent, index, type, parentRow, childRow, parentValid);
 }
 
 inline void KisModelIndexConverterTest::checkIndexFromAddedDummy(KisNodeSP parent, int index, const QString &type, int parentRow, int childRow, bool parentValid)
 {
    QModelIndex modelIndex;
    KisNodeDummy *dummy;
 
    int row = 0;
    bool result;
 
    dummy = parent ? m_dummiesFacade->dummyForNode(parent) : 0;
    result = m_indexConverter->indexFromAddedDummy(dummy, index, type, modelIndex, row);
    if(!result) dbgKrita << "Failing parent:" << (parent ? parent->name() : "none") << "index:" << index;
    QVERIFY(result);
 
    QCOMPARE(modelIndex.isValid(), parentValid);
 
    if(modelIndex.isValid()) {
        QCOMPARE(modelIndex.row(), parentRow);
        QCOMPARE(modelIndex.column(), 0);
    }
 
    if(row != childRow) dbgKrita << "Failing parent:" << (parent ? parent->name() : "none") << "index:" << index;
    QCOMPARE(row, childRow);
 }
 
 inline void KisModelIndexConverterTest::checkInvalidIndexFromAddedAllowedDummy(KisNodeSP parent, int index)
 {
     QString type = KisLayer::staticMetaObject.className();
     checkInvalidIndexFromAddedDummy(parent, index, type);
 }
 
 inline void KisModelIndexConverterTest::checkInvalidIndexFromAddedDeniedDummy(KisNodeSP parent, int index)
 {
     QString type = KisSelectionMask::staticMetaObject.className();
     checkInvalidIndexFromAddedDummy(parent, index, type);
 }
 
 inline void KisModelIndexConverterTest::checkInvalidIndexFromAddedDummy(KisNodeSP parent, int index, const QString &type)
 {
     QModelIndex modelIndex;
     KisNodeDummy *dummy;
 
     int row = 0;
     bool result;
 
     dummy = parent ? m_dummiesFacade->dummyForNode(parent) : 0;
     result = m_indexConverter->indexFromAddedDummy(dummy, index, type, modelIndex, row);
     QVERIFY(!result);
 }
 
 inline void KisModelIndexConverterTest::checkDummyFromRow(KisNodeSP parent, int row, KisNodeSP expectedNode)
 {
     QModelIndex parentIndex;
     KisNodeDummy *parentDummy;
 
     if(parent) {
         parentDummy = m_dummiesFacade->dummyForNode(parent);
         parentIndex = m_indexConverter->indexFromDummy(parentDummy);
     }
 
     KisNodeDummy *resultDummy = m_indexConverter->dummyFromRow(row, parentIndex);
     KisNodeSP resultNode = resultDummy ? resultDummy->node() : 0;
 
     if(resultNode != expectedNode) {
         dbgKrita << "Actual node:  " << (resultNode ? resultNode->name() : "none");
         dbgKrita << "Expected node:" << (expectedNode ? expectedNode->name() : "none");
         QFAIL("Wrong node");
     }
 }
 
 inline void KisModelIndexConverterTest::checkRowCount(KisNodeSP parent, int rowCount)
 {
     QModelIndex parentIndex;
     KisNodeDummy *parentDummy;
 
     if(parent) {
         parentDummy = m_dummiesFacade->dummyForNode(parent);
         parentIndex = m_indexConverter->indexFromDummy(parentDummy);
     }
 
     int resultRowCount = m_indexConverter->rowCount(parentIndex);
 
     if(resultRowCount != rowCount) {
         dbgKrita << "Wrong row count for:" << (parent ? parent->name() : "none");
         dbgKrita << "Actual:  " << resultRowCount;
         dbgKrita << "Expected:" << rowCount;
         QFAIL("Wrong row count");
     }
 }
 
 void KisModelIndexConverterTest::testIndexFromDummy()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, false);
 
     checkIndexFromDummy(m_layer1, 3);
     checkIndexFromDummy(m_layer2, 2);
     checkIndexFromDummy(m_layer3, 1);
     checkIndexFromDummy(m_layer4, 0);
 
     checkIndexFromDummy(m_mask1, 1);
     checkIndexFromDummy(m_sel3, 0);
 
     checkInvalidIndexFromDummy(m_image->root());
     checkInvalidIndexFromDummy(m_sel1);
     checkInvalidIndexFromDummy(m_sel2);
 }
 
 void KisModelIndexConverterTest::testIndexFromAddedAllowedDummy()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, false);
 
     checkIndexFromAddedAllowedDummy(m_image->root(), 0, 0, 4, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 1, 0, 4, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 2, 0, 3, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 3, 0, 2, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 4, 0, 2, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 5, 0, 1, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 6, 0, 0, false);
 
     checkIndexFromAddedAllowedDummy(m_layer1, 0, 3, 0, true);
 
     checkIndexFromAddedAllowedDummy(m_layer3, 0, 1, 2, true);
     checkIndexFromAddedAllowedDummy(m_layer3, 1, 1, 1, true);
     checkIndexFromAddedAllowedDummy(m_layer3, 2, 1, 0, true);
 
     checkInvalidIndexFromAddedAllowedDummy(0, 0);
 }
 
 void KisModelIndexConverterTest::testIndexFromAddedDeniedDummy()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, false);
 
     checkInvalidIndexFromAddedDeniedDummy(m_image->root(), 0);
     checkInvalidIndexFromAddedDeniedDummy(m_image->root(), 1);
     checkInvalidIndexFromAddedDeniedDummy(m_image->root(), 2);
     checkInvalidIndexFromAddedDeniedDummy(m_image->root(), 3);
     checkInvalidIndexFromAddedDeniedDummy(m_image->root(), 4);
     checkInvalidIndexFromAddedDeniedDummy(m_image->root(), 5);
     checkInvalidIndexFromAddedDeniedDummy(m_image->root(), 6);
 
     checkIndexFromAddedDeniedDummy(m_layer1, 0, 3, 0, true);
 
     checkIndexFromAddedDeniedDummy(m_layer3, 0, 1, 2, true);
     checkIndexFromAddedDeniedDummy(m_layer3, 1, 1, 1, true);
     checkIndexFromAddedDeniedDummy(m_layer3, 2, 1, 0, true);
 
     checkInvalidIndexFromAddedDeniedDummy(0, 0);
 }
 
 void KisModelIndexConverterTest::testDummyFromRow()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, false);
 
     checkDummyFromRow(m_image->root(), 0, m_layer4);
     checkDummyFromRow(m_image->root(), 1, m_layer3);
     checkDummyFromRow(m_image->root(), 2, m_layer2);
     checkDummyFromRow(m_image->root(), 3, m_layer1);
 
     checkDummyFromRow(0, 0, m_layer4);
     checkDummyFromRow(0, 1, m_layer3);
     checkDummyFromRow(0, 2, m_layer2);
     checkDummyFromRow(0, 3, m_layer1);
 
     checkDummyFromRow(m_layer3, 0, m_sel3);
     checkDummyFromRow(m_layer3, 1, m_mask1);
 }
 
 void KisModelIndexConverterTest::testRowCount()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, false);
 
     checkRowCount(m_image->root(), 4);
     checkRowCount(0, 4);
 
     checkRowCount(m_layer1, 0);
     checkRowCount(m_layer2, 0);
     checkRowCount(m_layer3, 2);
     checkRowCount(m_layer4, 0);
 }
 
 void KisModelIndexConverterTest::testIndexFromDummyShowGlobalSelection()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, true);
 
     checkIndexFromDummy(m_sel1,   5);
     checkIndexFromDummy(m_layer1, 4);
     checkIndexFromDummy(m_layer2, 3);
     checkIndexFromDummy(m_sel2,   2);
     checkIndexFromDummy(m_layer3, 1);
     checkIndexFromDummy(m_layer4, 0);
 
     checkIndexFromDummy(m_mask1, 1);
     checkIndexFromDummy(m_sel3, 0);
 
     checkInvalidIndexFromDummy(m_image->root());
 }
 
 void KisModelIndexConverterTest::testIndexFromAddedAllowedDummyShowGlobalSelection()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, true);
 
     checkIndexFromAddedAllowedDummy(m_image->root(), 0, 0, 6, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 1, 0, 5, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 2, 0, 4, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 3, 0, 3, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 4, 0, 2, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 5, 0, 1, false);
     checkIndexFromAddedAllowedDummy(m_image->root(), 6, 0, 0, false);
 
     checkIndexFromAddedAllowedDummy(m_layer1, 0, 4, 0, true);
 
     checkIndexFromAddedAllowedDummy(m_layer3, 0, 1, 2, true);
     checkIndexFromAddedAllowedDummy(m_layer3, 1, 1, 1, true);
     checkIndexFromAddedAllowedDummy(m_layer3, 2, 1, 0, true);
 
     checkInvalidIndexFromAddedAllowedDummy(0, 0);
 }
 
 void KisModelIndexConverterTest::testIndexFromAddedDeniedDummyShowGlobalSelection()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, true);
 
     checkIndexFromAddedDeniedDummy(m_image->root(), 0, 0, 6, false);
     checkIndexFromAddedDeniedDummy(m_image->root(), 1, 0, 5, false);
     checkIndexFromAddedDeniedDummy(m_image->root(), 2, 0, 4, false);
     checkIndexFromAddedDeniedDummy(m_image->root(), 3, 0, 3, false);
     checkIndexFromAddedDeniedDummy(m_image->root(), 4, 0, 2, false);
     checkIndexFromAddedDeniedDummy(m_image->root(), 5, 0, 1, false);
     checkIndexFromAddedDeniedDummy(m_image->root(), 6, 0, 0, false);
 
     checkIndexFromAddedDeniedDummy(m_layer1, 0, 4, 0, true);
 
     checkIndexFromAddedDeniedDummy(m_layer3, 0, 1, 2, true);
     checkIndexFromAddedDeniedDummy(m_layer3, 1, 1, 1, true);
     checkIndexFromAddedDeniedDummy(m_layer3, 2, 1, 0, true);
 
     checkInvalidIndexFromAddedDeniedDummy(0, 0);
 }
 
 void KisModelIndexConverterTest::testDummyFromRowShowGlobalSelection()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, true);
 
     checkDummyFromRow(m_image->root(), 0, m_layer4);
     checkDummyFromRow(m_image->root(), 1, m_layer3);
     checkDummyFromRow(m_image->root(), 2, m_sel2);
     checkDummyFromRow(m_image->root(), 3, m_layer2);
     checkDummyFromRow(m_image->root(), 4, m_layer1);
     checkDummyFromRow(m_image->root(), 5, m_sel1);
 
     checkDummyFromRow(0, 0, m_layer4);
     checkDummyFromRow(0, 1, m_layer3);
     checkDummyFromRow(0, 2, m_sel2);
     checkDummyFromRow(0, 3, m_layer2);
     checkDummyFromRow(0, 4, m_layer1);
     checkDummyFromRow(0, 5, m_sel1);
 
     checkDummyFromRow(m_layer3, 0, m_sel3);
     checkDummyFromRow(m_layer3, 1, m_mask1);
 }
 
 void KisModelIndexConverterTest::testRowCountShowGlobalSelection()
 {
     m_indexConverter = new KisModelIndexConverter(m_dummiesFacade, m_nodeModel, true);
 
     checkRowCount(m_image->root(), 6);
     checkRowCount(0, 6);
 
     checkRowCount(m_layer1, 0);
     checkRowCount(m_layer2, 0);
     checkRowCount(m_layer3, 2);
     checkRowCount(m_layer4, 0);
 }
 
 void KisModelIndexConverterTest::testIndexFromDummyShowAll()
 {
     m_indexConverter = new KisModelIndexConverterShowAll(m_dummiesFacade, m_nodeModel);
 
     checkIndexFromDummy(m_sel1,   5);
     checkIndexFromDummy(m_layer1, 4);
     checkIndexFromDummy(m_layer2, 3);
     checkIndexFromDummy(m_sel2,   2);
     checkIndexFromDummy(m_layer3, 1);
     checkIndexFromDummy(m_layer4, 0);
 
     checkIndexFromDummy(m_mask1, 1);
     checkIndexFromDummy(m_sel3, 0);
 
     checkIndexFromDummy(m_image->root(), 0);
 }
 
 void KisModelIndexConverterTest::testIndexFromAddedAllowedDummyShowAll()
 {
     m_indexConverter = new KisModelIndexConverterShowAll(m_dummiesFacade, m_nodeModel);
 
     checkIndexFromAddedAllowedDummy(m_image->root(), 0, 0, 6, true);
     checkIndexFromAddedAllowedDummy(m_image->root(), 1, 0, 5, true);
     checkIndexFromAddedAllowedDummy(m_image->root(), 2, 0, 4, true);
     checkIndexFromAddedAllowedDummy(m_image->root(), 3, 0, 3, true);
     checkIndexFromAddedAllowedDummy(m_image->root(), 4, 0, 2, true);
     checkIndexFromAddedAllowedDummy(m_image->root(), 5, 0, 1, true);
     checkIndexFromAddedAllowedDummy(m_image->root(), 6, 0, 0, true);
 
     checkIndexFromAddedAllowedDummy(m_layer1, 0, 4, 0, true);
 
     checkIndexFromAddedAllowedDummy(m_layer3, 0, 1, 2, true);
     checkIndexFromAddedAllowedDummy(m_layer3, 1, 1, 1, true);
     checkIndexFromAddedAllowedDummy(m_layer3, 2, 1, 0, true);
 
     checkIndexFromAddedAllowedDummy(0, 0, 0, 0, false);
 }
 
 void KisModelIndexConverterTest::testIndexFromAddedDeniedDummyShowAll()
 {
     m_indexConverter = new KisModelIndexConverterShowAll(m_dummiesFacade, m_nodeModel);
 
     checkIndexFromAddedDeniedDummy(m_image->root(), 0, 0, 6, true);
     checkIndexFromAddedDeniedDummy(m_image->root(), 1, 0, 5, true);
     checkIndexFromAddedDeniedDummy(m_image->root(), 2, 0, 4, true);
     checkIndexFromAddedDeniedDummy(m_image->root(), 3, 0, 3, true);
     checkIndexFromAddedDeniedDummy(m_image->root(), 4, 0, 2, true);
     checkIndexFromAddedDeniedDummy(m_image->root(), 5, 0, 1, true);
     checkIndexFromAddedDeniedDummy(m_image->root(), 6, 0, 0, true);
 
     checkIndexFromAddedDeniedDummy(m_layer1, 0, 4, 0, true);
 
     checkIndexFromAddedDeniedDummy(m_layer3, 0, 1, 2, true);
     checkIndexFromAddedDeniedDummy(m_layer3, 1, 1, 1, true);
     checkIndexFromAddedDeniedDummy(m_layer3, 2, 1, 0, true);
 
     checkIndexFromAddedDeniedDummy(0, 0, 0, 0, false);
 }
 
 void KisModelIndexConverterTest::testDummyFromRowShowAll()
 {
     m_indexConverter = new KisModelIndexConverterShowAll(m_dummiesFacade, m_nodeModel);
 
     checkDummyFromRow(m_image->root(), 0, m_layer4);
     checkDummyFromRow(m_image->root(), 1, m_layer3);
     checkDummyFromRow(m_image->root(), 2, m_sel2);
     checkDummyFromRow(m_image->root(), 3, m_layer2);
     checkDummyFromRow(m_image->root(), 4, m_layer1);
     checkDummyFromRow(m_image->root(), 5, m_sel1);
 
     checkDummyFromRow(0, 0, m_image->root());
 
     checkDummyFromRow(m_layer3, 0, m_sel3);
     checkDummyFromRow(m_layer3, 1, m_mask1);
 }
 
 
 void KisModelIndexConverterTest::testRowCountShowAll()
 {
     m_indexConverter = new KisModelIndexConverterShowAll(m_dummiesFacade, m_nodeModel);
 
     checkRowCount(m_image->root(), 6);
     checkRowCount(0, 1);
 
     checkRowCount(m_layer1, 0);
     checkRowCount(m_layer2, 0);
     checkRowCount(m_layer3, 2);
     checkRowCount(m_layer4, 0);
 }
 
 QTEST_MAIN(KisModelIndexConverterTest)
diff --git a/libs/ui/tests/kis_node_model_test.cpp b/libs/ui/tests/kis_node_model_test.cpp
index 26e76df849..5e13432edc 100644
--- a/libs/ui/tests/kis_node_model_test.cpp
+++ b/libs/ui/tests/kis_node_model_test.cpp
@@ -1,113 +1,113 @@
 
 /*
  * Copyright (C) 2007 Boudewijn Rempt <boud@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_node_model_test.h"
 
 #include <QTest>
 #include <kis_debug.h>
 
 #include "KisDocument.h"
 #include "KisPart.h"
 #include "kis_node_model.h"
 #include "kis_name_server.h"
 #include "flake/kis_shape_controller.h"
 
 #include <sdk/tests/testutil.h>
 
 #include "modeltest.h"
 
 void KisNodeModelTest::init()
 {
     m_doc = KisPart::instance()->createDocument();
 
     m_nameServer = new KisNameServer();
     m_shapeController = new KisShapeController(m_doc, m_nameServer);
     m_nodeModel = new KisNodeModel(0);
 
     initBase();
 }
 
 void KisNodeModelTest::cleanup()
 {
     cleanupBase();
 
     delete m_nodeModel;
     delete m_shapeController;
     delete m_nameServer;
     delete m_doc;
 }
 
 void KisNodeModelTest::testSetImage()
 {
     constructImage();
     m_shapeController->setImage(m_image);
-    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0, 0, 0);
+    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0);
     new ModelTest(m_nodeModel, this);
 }
 
 void KisNodeModelTest::testAddNode()
 {
     m_shapeController->setImage(m_image);
-    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0, 0, 0);
+    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0);
     new ModelTest(m_nodeModel, this);
 
     constructImage();
 
 }
 
 void KisNodeModelTest::testRemoveAllNodes()
 {
     constructImage();
     m_shapeController->setImage(m_image);
-    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0, 0, 0);
+    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0);
     new ModelTest(m_nodeModel, this);
 
     m_image->removeNode(m_layer4);
     m_image->removeNode(m_layer3);
     m_image->removeNode(m_layer2);
     m_image->removeNode(m_layer1);
 }
 
 void KisNodeModelTest::testRemoveIncludingRoot()
 {
     constructImage();
     m_shapeController->setImage(m_image);
-    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0, 0, 0);
+    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0);
     new ModelTest(m_nodeModel, this);
 
     m_image->removeNode(m_layer4);
     m_image->removeNode(m_layer3);
     m_image->removeNode(m_layer2);
     m_image->removeNode(m_layer1);
     m_image->removeNode(m_image->root());
 
 
 }
 
 void KisNodeModelTest::testSubstituteRootNode()
 {
     constructImage();
     m_shapeController->setImage(m_image);
-    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0, 0, 0);
+    m_nodeModel->setDummiesFacade(m_shapeController, m_image, 0, 0, 0);
     new ModelTest(m_nodeModel, this);
 
     m_image->flatten(0);
 }
 
 KISTEST_MAIN(KisNodeModelTest)
diff --git a/plugins/dockers/layerdocker/LayerBox.cpp b/plugins/dockers/layerdocker/LayerBox.cpp
index e4c0c66c6e..48a4dfaf94 100644
--- a/plugins/dockers/layerdocker/LayerBox.cpp
+++ b/plugins/dockers/layerdocker/LayerBox.cpp
@@ -1,1081 +1,1079 @@
 /*
  *  LayerBox.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 "LayerBox.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 <QProxyStyle>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_base_node.h>
 #include <kis_composite_ops_model.h>
 #include <kis_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 #include <KoProperties.h>
 
 #include <kis_action.h>
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 
 #include "canvas/kis_canvas2.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_signals_blocker.h"
 #include "kis_color_filter_combo.h"
 #include "kis_node_filter_proxy_model.h"
 
 #include "kis_selection.h"
 #include "kis_processing_applicator.h"
 #include "commands/kis_set_global_selection_command.h"
 #include "KisSelectionActionsAdapter.h"
 
 #include "kis_layer_utils.h"
 
 #include "ui_WdgLayerBox.h"
 #include "NodeView.h"
 #include "SyncButtonAndAction.h"
 
 
 class LayerBoxStyle : public QProxyStyle
 {
 public:
     LayerBoxStyle(QStyle *baseStyle = 0) : QProxyStyle(baseStyle) {}
 
     void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                        QPainter *painter, const QWidget *widget) const
     {
         if (element == QStyle::PE_IndicatorItemViewItemDrop)
         {
             QColor color(widget->palette().color(QPalette::Highlight).lighter());
 
             if (option->rect.height() == 0) {
                 QBrush brush(color);
 
                 QRect r(option->rect);
                 r.setTop(r.top() - 2);
                 r.setBottom(r.bottom() + 2);
 
                 painter->fillRect(r, brush);
             } else {
                 color.setAlpha(200);
                 QBrush brush(color);
                 painter->fillRect(option->rect, brush);
             }
         }
         else
         {
             QProxyStyle::drawPrimitive(element, option, painter, widget);
         }
     }
 };
 
 inline void LayerBox::connectActionToButton(KisViewManager* viewManager, QAbstractButton *button, const QString &id)
 {
     if (!viewManager || !button) return;
 
     KisAction *action = viewManager->actionManager()->actionByName(id);
 
     if (!action) return;
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
     connect(viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 inline void LayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     if (m_canvas) {
         menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
     }
 }
 
 LayerBox::LayerBox()
     : QDockWidget(i18n("Layers"))
     , m_canvas(0)
     , m_wdgLayerBox(new Ui_WdgLayerBox)
     , m_thumbnailCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_colorLabelCompressor(900, KisSignalCompressor::FIRST_INACTIVE)
     , m_thumbnailSizeCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     KisConfig cfg(false);
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setStyle(new LayerBoxStyle(m_wdgLayerBox->listLayers->style()));
 
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(contextMenuRequested(QPoint,QModelIndex)),
             this, SLOT(slotContextMenuRequested(QPoint,QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(collapsed(QModelIndex)), SLOT(slotCollapsed(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(expanded(QModelIndex)), SLOT(slotExpanded(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(selectionChanged(QModelIndexList)), SLOT(selectionChanged(QModelIndexList)));
 
     slotUpdateIcons();
 
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnRaise->setEnabled(false);
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix("%");
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_newLayerMenu = new QMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
     m_filteringModel = new KisNodeFilterProxyModel(this);
     m_filteringModel->setNodeModel(m_nodeModel);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setActivationFlags(KisAction::ACTIVE_IMAGE);
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_colorSelector = new KisColorLabelSelectorWidget(this);
     connect(m_colorSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
     m_colorSelectorAction = new QWidgetAction(this);
     m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             &m_colorLabelCompressor, SLOT(start()));
 
     m_wdgLayerBox->listLayers->setModel(m_filteringModel);
     // this connection should be done *after* the setModel() call to
     // happen later than the internal selection model
     connect(m_filteringModel.data(), &KisNodeFilterProxyModel::rowsAboutToBeRemoved,
             this, &LayerBox::slotAboutToRemoveRows);
 
     connect(m_wdgLayerBox->cmbFilter, SIGNAL(selectedColorsChanged()), SLOT(updateLayerFiltering()));
 
     setEnabled(false);
 
     connect(&m_thumbnailCompressor, SIGNAL(timeout()), SLOT(updateThumbnail()));
     connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 
 
 
     // set up the configure menu for changing thumbnail size
     QMenu* configureMenu = new QMenu(this);
     configureMenu->setStyleSheet("margin: 6px");
     configureMenu->addSection(i18n("Thumbnail Size"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setMenu(configureMenu);
     m_wdgLayerBox->configureLayerDockerToolbar->setIcon(KisIconUtils::loadIcon("configure"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setPopupMode(QToolButton::InstantPopup);
 
 
     // add horizontal slider
     thumbnailSizeSlider = new QSlider(this);
     thumbnailSizeSlider->setOrientation(Qt::Horizontal);
     thumbnailSizeSlider->setRange(20, 80);
 
     thumbnailSizeSlider->setValue(cfg.layerThumbnailSize(false)); // grab this from the kritarc
 
     thumbnailSizeSlider->setMinimumHeight(20);
     thumbnailSizeSlider->setMinimumWidth(40);
     thumbnailSizeSlider->setTickInterval(5);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(thumbnailSizeSlider);
     configureMenu->addAction(sliderAction);
 
 
     connect(thumbnailSizeSlider, SIGNAL(sliderMoved(int)), &m_thumbnailSizeCompressor, SLOT(start()));
     connect(&m_thumbnailSizeCompressor, SIGNAL(timeout()), SLOT(slotUpdateThumbnailIconSize()));
 }
 
 LayerBox::~LayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeFilterProxyModel> filteringModel, NodeView *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->collapsed() && node->childCount() > 0) {
             expandNodesRecursively(node, filteringModel, nodeView);
         }
         node = node->nextSibling();
     }
     nodeView->blockSignals(false);
 }
 
 void LayerBox::slotAddLayerBnClicked()
 {
     if (m_canvas) {
         KisNodeList nodes = m_nodeManager->selectedNodes();
 
         if (nodes.size() == 1) {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("add_new_paint_layer");
             action->trigger();
         } else {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("create_quick_group");
             action->trigger();
         }
     }
 }
 
 void LayerBox::setViewManager(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
     Q_FOREACH (KisAction *action, m_actions) {
         kisview->actionManager()->
                 addAction(action->objectName(),
                           action);
     }
 
     connect(m_wdgLayerBox->bnAdd, SIGNAL(clicked()), this, SLOT(slotAddLayerBnClicked()));
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
     KisActionManager *actionManager = kisview->actionManager();
 
     KisAction *action = actionManager->createAction("RenameCurrentLayer");
     Q_ASSERT(action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
     m_propertiesAction = actionManager->createAction("layer_properties");
     Q_ASSERT(m_propertiesAction);
     new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
     m_removeAction = actionManager->createAction("remove_layer");
     Q_ASSERT(m_removeAction);
     new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
     action = actionManager->createAction("move_layer_up");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
     action = actionManager->createAction("move_layer_down");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 }
 
 void LayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if (m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
-        m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0, 0, 0);
+        m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
         m_selectionActionsAdapter.reset();
 
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
             animation->disconnect(this);
         }
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         m_nodeManager->slotSetSelectedNodes(KisNodeList());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), &m_thumbnailCompressor, SLOT(start()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade =
                 static_cast<KisDummiesFacadeBase*>(kritaShapeController);
 
 
         m_selectionActionsAdapter.reset(new KisSelectionActionsAdapter(m_canvas->viewManager()->selectionManager()));
         m_nodeModel->setDummiesFacade(kritaDummiesFacade,
                                       m_image,
                                       kritaShapeController,
-                                      m_nodeManager->nodeSelectionAdapter(),
-                                      m_nodeManager->nodeInsertionAdapter(),
                                       m_selectionActionsAdapter.data(),
-                                      m_nodeManager->nodeDisplayModeAdapter());
+                                      m_nodeManager);
 
         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 -> LayerBox
             connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                     this, SLOT(setCurrentNode(KisNodeSP)));
 
             connect(m_nodeManager,
                     SIGNAL(sigUiNeedChangeSelectedNodes(QList<KisNodeSP>)),
                     SLOT(slotNodeManagerChangedSelection(QList<KisNodeSP>)));
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection LayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                 m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         KisImageAnimationInterface *animation = m_image->animationInterface();
         connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &LayerBox::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 LayerBox::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 LayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void LayerBox::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, &LayerBox::slotKeyframeChannelAdded);
             }
         }
     }
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
     m_wdgLayerBox->cmbComposite->validate(m_image->colorSpace());
 
     if (activeNode) {
         if (activeNode->inherits("KisColorizeMask") ||
                 activeNode->inherits("KisLayer")) {
 
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             slotSetOpacity(activeNode->opacity() * 100.0 / 255);
 
             const KoCompositeOp* compositeOp = activeNode->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         } else if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         }
     }
 }
 
 
 /**
  * This method is called *only* when non-GUI code requested the
  * change of the current node
  */
 void LayerBox::setCurrentNode(KisNodeSP node)
 {
     m_filteringModel->setActiveNode(node);
 
     QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
     m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
     updateUI();
 }
 
 void LayerBox::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 LayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 // range: 0-100
 void LayerBox::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 LayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
     KisNodeSP activeNode = m_nodeManager->activeNode();
     if (nodes.isEmpty() || !activeNode) return;
 
     if (m_canvas) {
         QMenu menu;
 
         const bool singleLayer = nodes.size() == 1;
 
         if (index.isValid()) {
             menu.addAction(m_propertiesAction);
 
             if (singleLayer) {
                 addActionToMenu(&menu, "layer_style");
             }
 
             {
                 KisSignalsBlocker b(m_colorSelector);
                 m_colorSelector->setCurrentIndex(singleLayer ? activeNode->colorLabelIndex() : -1);
             }
             menu.addAction(m_colorSelectorAction);
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "cut_layer_clipboard");
             addActionToMenu(&menu, "copy_layer_clipboard");
             addActionToMenu(&menu, "paste_layer_from_clipboard");
             menu.addAction(m_removeAction);
             addActionToMenu(&menu, "duplicatelayer");
             addActionToMenu(&menu, "merge_layer");
 
             if (singleLayer) {
                 addActionToMenu(&menu, "flatten_image");
                 addActionToMenu(&menu, "flatten_layer");
             }
 
             menu.addSeparator();
             QMenu *selectMenu = menu.addMenu(i18n("&Select"));
             addActionToMenu(selectMenu, "select_all_layers");
             addActionToMenu(selectMenu, "select_visible_layers");
             addActionToMenu(selectMenu, "select_invisible_layers");
             addActionToMenu(selectMenu, "select_locked_layers");
             addActionToMenu(selectMenu, "select_unlocked_layers");
             QMenu *groupMenu = menu.addMenu(i18n("&Group"));
             addActionToMenu(groupMenu, "create_quick_group");
             addActionToMenu(groupMenu, "create_quick_clipping_group");
             addActionToMenu(groupMenu, "quick_ungroup");
             QMenu *locksMenu = menu.addMenu(i18n("&Toggle Locks && Visibility"));
             addActionToMenu(locksMenu, "toggle_layer_visibility");
             addActionToMenu(locksMenu, "toggle_layer_lock");
             addActionToMenu(locksMenu, "toggle_layer_inherit_alpha");
             addActionToMenu(locksMenu, "toggle_layer_alpha_lock");
 
             if (singleLayer) {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_transparency_mask");
                 addActionToMenu(addLayerMenu, "add_new_filter_mask");
                 addActionToMenu(addLayerMenu, "add_new_colorize_mask");
                 addActionToMenu(addLayerMenu, "add_new_transform_mask");
                 addActionToMenu(addLayerMenu, "add_new_selection_mask");
 
                 QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
                 addActionToMenu(convertToMenu, "convert_to_paint_layer");
                 addActionToMenu(convertToMenu, "convert_to_transparency_mask");
                 addActionToMenu(convertToMenu, "convert_to_filter_mask");
                 addActionToMenu(convertToMenu, "convert_to_selection_mask");
                 addActionToMenu(convertToMenu, "convert_to_file_layer");
 
                 QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
                 addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
                 addActionToMenu(splitAlphaMenu, "split_alpha_write");
                 addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
             }
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "show_in_timeline");
 
             if (singleLayer) {
                 KisNodeSP node = m_filteringModel->nodeFromIndex(index);
                 if (node && !node->inherits("KisTransformMask")) {
                     addActionToMenu(&menu, "isolate_layer");
                 }
 
                 addActionToMenu(&menu, "selectopaque");
             }
         }
         menu.exec(pos);
     }
 }
 
 void LayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::MinimalMode);
 }
 
 void LayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::DetailedMode);
 }
 
 void LayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::ThumbnailMode);
 }
 
 void LayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void LayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->raiseNode();
 }
 
 void LayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->lowerNode();
 }
 
 void LayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void LayerBox::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 LayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_blockOpacityUpdate = true;
     m_nodeManager->nodeOpacityChanged(m_newOpacity, true);
     m_blockOpacityUpdate = false;
 }
 
 void LayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void LayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void LayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void LayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void LayerBox::slotNodeCollapsedChanged()
 {
     expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP LayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (KisNodeManager::isNodeHidden(startNode, true) &&
             startNode->parent() &&
             !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && KisNodeManager::isNodeHidden(node, true)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void LayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
     KisSelectionMaskSP globalSelectionMask;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     globalSelectionMask = m_image->rootLayer()->selectionMask();
 
     // try to find deactivated, but visible masks
     if (!globalSelectionMask) {
         KoProperties properties;
         properties.setProperty("visible", true);
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     // try to find at least any selection mask
     if (!globalSelectionMask) {
         KoProperties properties;
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     if (globalSelectionMask) {
         if (showSelections) {
             activateNode = globalSelectionMask;
         }
     }
 
     if (activateNode != lastActiveNode) {
         m_nodeManager->slotNonUiActivatedNode(activateNode);
     } else if (lastActiveNode) {
         setCurrentNode(lastActiveNode);
     }
 
     if (showSelections && !globalSelectionMask) {
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Quick Selection Mask"));
 
         applicator.applyCommand(
             new KisLayerUtils::KeepNodesSelectedCommand(
                 m_nodeManager->selectedNodes(), KisNodeList(),
                 lastActiveNode, 0, m_image, false),
             KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisLayerUtils::SelectGlobalSelectionMask(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
 
         applicator.end();
     } else if (!showSelections &&
                globalSelectionMask &&
                globalSelectionMask->selection()->selectedRect().isEmpty()) {
 
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Cancel Quick Selection Mask"));
         applicator.applyCommand(new KisSetGlobalSelectionCommand(m_image, 0), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
 }
 
 void LayerBox::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 LayerBox::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 LayerBox::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 LayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::slotRenameCurrentNode()
 {
     m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::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 LayerBox::updateAvailableLabels()
 {
     if (!m_image) return;
     m_wdgLayerBox->cmbFilter->updateAvailableLabels(m_image->root());
 }
 
 void LayerBox::updateLayerFiltering()
 {
     m_filteringModel->setAcceptedLabels(m_wdgLayerBox->cmbFilter->selectedColors());
 }
 
 void LayerBox::slotKeyframeChannelAdded(KisKeyframeChannel *channel)
 {
     if (channel->id() == KisKeyframeChannel::Opacity.id()) {
         watchOpacityChannel(channel);
     }
 }
 
 void LayerBox::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 LayerBox::slotOpacityKeyframeChanged(KisKeyframeSP keyframe)
 {
     Q_UNUSED(keyframe);
     if (m_blockOpacityUpdate) return;
     updateUI();
 }
 
 void LayerBox::slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime)
 {
     Q_UNUSED(fromTime);
     slotOpacityKeyframeChanged(keyframe);
 }
 
 void LayerBox::slotImageTimeChanged(int time)
 {
     Q_UNUSED(time);
     updateUI();
 }
 
 void LayerBox::slotUpdateIcons() {
     m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowupblr"));
     m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
     m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
     m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     // call child function about needing to update icons
     m_wdgLayerBox->listLayers->slotUpdateIcons();
 }
 
 void LayerBox::slotUpdateThumbnailIconSize()
 {
     KisConfig cfg(false);
     cfg.setLayerThumbnailSize(thumbnailSizeSlider->value());
 
     // this is a hack to force the layers list to update its display and
     // re-layout all the layers with the new thumbnail size
     resize(this->width()+1, this->height()+1);
     resize(this->width()-1, this->height()-1);
 }
 
 
 #include "moc_LayerBox.cpp"