diff --git a/krita/image/kis_image.cc b/krita/image/kis_image.cc
index c99f2f9c9d..612f926115 100644
--- a/krita/image/kis_image.cc
+++ b/krita/image/kis_image.cc
@@ -1,1656 +1,1785 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image.h"
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QPainter>
 #include <QSize>
 #include <QDateTime>
 #include <QRect>
 #include <QRegion>
 
 #include <klocale.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorConversionTransformation.h"
 #include "KoColorProfile.h"
 #include <KoCompositeOpRegistry.h>
 
 #include "recorder/kis_action_recorder.h"
 #include "kis_adjustment_layer.h"
 #include "kis_annotation.h"
 #include "kis_change_profile_visitor.h"
 #include "kis_colorspace_convert_visitor.h"
 #include "kis_count_visitor.h"
 #include "kis_filter_strategy.h"
 #include "kis_group_layer.h"
 #include "commands/kis_image_commands.h"
 #include "kis_layer.h"
 #include "kis_meta_data_merge_strategy_registry.h"
 #include "kis_name_server.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_painter.h"
 #include "kis_perspective_grid.h"
 #include "kis_selection.h"
 #include "kis_transaction.h"
 #include "kis_types.h"
 #include "kis_meta_data_merge_strategy.h"
 #include "kis_memory_statistics_server.h"
 
 #include "kis_image_config.h"
 #include "kis_update_scheduler.h"
 #include "kis_image_signal_router.h"
 #include "kis_stroke_strategy.h"
+#include "kis_image_barrier_locker.h"
+
 
 #include "kis_undo_stores.h"
 #include "kis_legacy_undo_adapter.h"
 #include "kis_post_execution_undo_adapter.h"
 
 #include "kis_transform_worker.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "processing/kis_crop_selections_processing_visitor.h"
 #include "processing/kis_transform_processing_visitor.h"
 #include "commands_new/kis_image_resize_command.h"
 #include "commands_new/kis_image_set_resolution_command.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_layer_composition.h"
 #include "kis_wrapped_rect.h"
 #include "kis_crop_saved_extra_data.h"
 
 #include "kis_layer_projection_plane.h"
 
 #include "kis_update_time_monitor.h"
 
 
 // #define SANITY_CHECKS
 
 #ifdef SANITY_CHECKS
 #define SANITY_CHECK_LOCKED(name)                                       \
     if (!locked()) warnKrita() << "Locking policy failed:" << name          \
                                << "has been called without the image"       \
                                   "being locked";
 #else
 #define SANITY_CHECK_LOCKED(name)
 #endif
 
 
 class KisImage::KisImagePrivate
 {
 public:
     quint32 lockCount;
     KisPerspectiveGrid* perspectiveGrid;
 
     qint32 width;
     qint32 height;
 
     double xres;
     double yres;
 
     const KoColorSpace * colorSpace;
 
     KisSelectionSP deselectedGlobalSelection;
     KisGroupLayerSP rootLayer; // The layers are contained in here
     QList<KisLayer*> dirtyLayers; // for thumbnails
     QList<KisLayerComposition*> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted;
 
     KisNameServer *nserver;
 
     KisUndoStore *undoStore;
     KisUndoAdapter *legacyUndoAdapter;
     KisPostExecutionUndoAdapter *postExecutionUndoAdapter;
 
     KisActionRecorder *recorder;
 
     vKisAnnotationSP annotations;
 
     QAtomicInt disableUIUpdateSignals;
     QAtomicInt disableDirtyRequests;
     KisImageSignalRouter *signalRouter;
     KisUpdateScheduler *scheduler;
 
     KisCompositeProgressProxy *compositeProgressProxy;
 
     bool startProjection;
 
     bool tryCancelCurrentStrokeAsync();
 };
 
 KisImage::KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name, bool startProjection)
         : QObject(0)
         , KisShared()
         , m_d(new KisImagePrivate())
 {
     setObjectName(name);
     dbgImage << "creating" << name;
     m_d->startProjection = startProjection;
 
     if (colorSpace == 0) {
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     }
 
     m_d->lockCount = 0;
     m_d->perspectiveGrid = 0;
     m_d->scheduler = 0;
     m_d->wrapAroundModePermitted = false;
 
     m_d->signalRouter = new KisImageSignalRouter(this);
 
     if (!undoStore) {
         undoStore = new KisDumbUndoStore();
     }
 
     m_d->undoStore = undoStore;
     m_d->legacyUndoAdapter = new KisLegacyUndoAdapter(m_d->undoStore, this);
     m_d->postExecutionUndoAdapter = new KisPostExecutionUndoAdapter(m_d->undoStore, this);
 
     m_d->nserver = new KisNameServer(1);
 
     m_d->colorSpace = colorSpace;
 
     setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
 
     m_d->xres = 1.0;
     m_d->yres = 1.0;
     m_d->width = width;
     m_d->height = height;
 
     m_d->recorder = new KisActionRecorder(this);
 
     m_d->compositeProgressProxy = new KisCompositeProgressProxy();
 
     if (m_d->startProjection) {
         m_d->scheduler = new KisUpdateScheduler(this);
         m_d->scheduler->setProgressProxy(m_d->compositeProgressProxy);
     }
 
     connect(this, SIGNAL(sigImageModified()), KisMemoryStatisticsServer::instance(), SLOT(notifyImageChanged()));
 }
 
 KisImage::~KisImage()
 {
     dbgImage << "deleting kisimage" << objectName();
 
     /**
      * Request the tools to end currently running strokes
      */
     waitForDone();
 
     /**
      * First delete the nodes, while strokes
      * and undo are still alive
      */
     m_d->rootLayer = 0;
 
 
     KisUpdateScheduler *scheduler = m_d->scheduler;
     m_d->scheduler = 0;
     delete scheduler;
 
     delete m_d->postExecutionUndoAdapter;
     delete m_d->legacyUndoAdapter;
     delete m_d->undoStore;
     delete m_d->compositeProgressProxy;
 
     delete m_d->signalRouter;
     delete m_d->perspectiveGrid;
     delete m_d->nserver;
     delete m_d;
 
     disconnect(); // in case Qt gets confused
 }
 
 void KisImage::aboutToAddANode(KisNode *parent, int index)
 {
     KisNodeGraphListener::aboutToAddANode(parent, index);
     SANITY_CHECK_LOCKED("aboutToAddANode");
 }
 
 void KisImage::nodeHasBeenAdded(KisNode *parent, int index)
 {
     KisNodeGraphListener::nodeHasBeenAdded(parent, index);
 
     SANITY_CHECK_LOCKED("nodeHasBeenAdded");
     m_d->signalRouter->emitNodeHasBeenAdded(parent, index);
 
     KisNodeSP newNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(newNode.data())) {
         stopIsolatedMode();
     }
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data())) {
         stopIsolatedMode();
     }
 
     KisNodeGraphListener::aboutToRemoveANode(parent, index);
 
     SANITY_CHECK_LOCKED("aboutToRemoveANode");
     m_d->signalRouter->emitAboutToRemoveANode(parent, index);
 }
 
 void KisImage::nodeChanged(KisNode* node)
 {
     KisNodeGraphListener::nodeChanged(node);
     requestStrokeEnd();
     m_d->signalRouter->emitNodeChanged(node);
 }
 
 KisSelectionSP KisImage::globalSelection() const
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
     if (selectionMask) {
         return selectionMask->selection();
     } else {
         return 0;
     }
 }
 
 void KisImage::setGlobalSelection(KisSelectionSP globalSelection)
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
 
     if (!globalSelection) {
         if (selectionMask) {
             removeNode(selectionMask);
         }
     }
     else {
         if (!selectionMask) {
             selectionMask = new KisSelectionMask(this);
             selectionMask->initSelection(m_d->rootLayer);
             addNode(selectionMask);
             // If we do not set the selection now, the setActive call coming next
             // can be very, very expensive, depending on the size of the image.
             selectionMask->setSelection(globalSelection);
             selectionMask->setActive(true);
         }
         else {
             selectionMask->setSelection(globalSelection);
         }
 
         Q_ASSERT(m_d->rootLayer->childCount() > 0);
         Q_ASSERT(m_d->rootLayer->selectionMask());
     }
 
     m_d->deselectedGlobalSelection = 0;
     m_d->legacyUndoAdapter->emitSelectionChanged();
 }
 
 void KisImage::deselectGlobalSelection()
 {
     KisSelectionSP savedSelection = globalSelection();
     setGlobalSelection(0);
     m_d->deselectedGlobalSelection = savedSelection;
 }
 
 bool KisImage::canReselectGlobalSelection()
 {
     return m_d->deselectedGlobalSelection;
 }
 
 void KisImage::reselectGlobalSelection()
 {
     if(m_d->deselectedGlobalSelection) {
         setGlobalSelection(m_d->deselectedGlobalSelection);
     }
 }
 
 QString KisImage::nextLayerName() const
 {
     if (m_d->nserver->currentSeed() == 0) {
         m_d->nserver->number();
         return i18n("background");
     }
 
     return i18n("Layer %1", m_d->nserver->number());
 }
 
 void KisImage::rollBackLayerName()
 {
     m_d->nserver->rollback();
 }
 
 KisCompositeProgressProxy* KisImage::compositeProgressProxy()
 {
     return m_d->compositeProgressProxy;
 }
 
 bool KisImage::locked() const
 {
     return m_d->lockCount != 0;
 }
 
 void KisImage::barrierLock()
 {
     if (!locked()) {
         requestStrokeEnd();
 
         if (m_d->scheduler) {
             m_d->scheduler->barrierLock();
         }
     }
     m_d->lockCount++;
 }
 
 bool KisImage::tryBarrierLock()
 {
     bool result = true;
 
     if (!locked()) {
         if (m_d->scheduler) {
             result = m_d->scheduler->tryBarrierLock();
         }
     }
 
     if (result) {
         m_d->lockCount++;
     }
 
     return result;
 }
 
 void KisImage::lock()
 {
     if (!locked()) {
         requestStrokeEnd();
 
         if (m_d->scheduler) {
             m_d->scheduler->lock();
         }
     }
     m_d->lockCount++;
 }
 
 void KisImage::unlock()
 {
     Q_ASSERT(locked());
 
     if (locked()) {
         m_d->lockCount--;
 
         if (m_d->lockCount == 0) {
             if (m_d->scheduler) {
                 m_d->scheduler->unlock();
             }
         }
     }
 }
 
 void KisImage::blockUpdates()
 {
     m_d->scheduler->blockUpdates();
 }
 
 void KisImage::unblockUpdates()
 {
     m_d->scheduler->unblockUpdates();
 }
 
 void KisImage::setSize(const QSize& size)
 {
     m_d->width = size.width();
     m_d->height = size.height();
 }
 
 void KisImage::resizeImageImpl(const QRect& newRect, bool cropLayers)
 {
     if (newRect == bounds() && !cropLayers) return;
 
     KUndo2MagicString actionName = cropLayers ?
         kundo2_i18n("Crop Image") :
         kundo2_i18n("Resize Image");
 
     KisImageSignalVector emitSignals;
     emitSignals << ComplexSizeChangedSignal(newRect, newRect.size());
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(cropLayers ?
                                   KisCropSavedExtraData::CROP_IMAGE :
                                   KisCropSavedExtraData::RESIZE_IMAGE,
                                   newRect);
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName, extraData);
 
     if (cropLayers || !newRect.topLeft().isNull()) {
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(newRect, cropLayers, true);
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     }
     applicator.applyCommand(new KisImageResizeCommand(this, newRect.size()));
     applicator.end();
 }
 
 void KisImage::resizeImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, false);
 }
 
 void KisImage::cropImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, true);
 }
 
 
 void KisImage::cropNode(KisNodeSP node, const QRect& newRect)
 {
     bool isLayer = dynamic_cast<KisLayer*>(node.data());
     KUndo2MagicString actionName = isLayer ?
         kundo2_i18n("Crop Layer") :
         kundo2_i18n("Crop Mask");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(KisCropSavedExtraData::CROP_LAYER,
                                   newRect, node);
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName, extraData);
 
     KisProcessingVisitorSP visitor =
         new KisCropProcessingVisitor(newRect, true, false);
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     bool resolutionChanged = xres != xRes() && yres != yRes();
     bool sizeChanged = size != this->size();
 
     if (!resolutionChanged && !sizeChanged) return;
 
     KisImageSignalVector emitSignals;
     if (resolutionChanged) emitSignals << ResolutionChangedSignal;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), size);
     emitSignals << ModifiedSignal;
 
     KUndo2MagicString actionName = sizeChanged ?
         kundo2_i18n("Scale Image") :
         kundo2_i18n("Change Image Resolution");
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         (resolutionChanged || sizeChanged) ?
                 KisProcessingApplicator::NO_UI_UPDATES :
                 KisProcessingApplicator::NONE;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     qreal sx = qreal(size.width()) / this->size().width();
     qreal sy = qreal(size.height()) / this->size().height();
 
     QTransform shapesCorrection;
 
     if (resolutionChanged) {
         shapesCorrection = QTransform::fromScale(xRes() / xres, yRes() / yres);
     }
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(sx, sy,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy,
                                           shapesCorrection);
 
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resolutionChanged) {
         KUndo2Command *parent =
             new KisResetShapesCommand(m_d->rootLayer);
         new KisImageSetResolutionCommand(this, xres, yres, parent);
         applicator.applyCommand(parent);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, size));
     }
 
     applicator.end();
 }
 
 void KisImage::scaleNode(KisNodeSP node, qreal sx, qreal sy, KisFilterStrategy *filterStrategy)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(sx, sy,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy);
 
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           bool resizeImage,
                           double radians)
 {
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   0, 0, 0, 0,
                                   radians,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         if (resizeImage) {
             QRect newRect = transform.mapRect(bounds());
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(rootNode->exactBounds()).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != width() || newSize.height() != height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     // These flags determine whether updates are transferred to the UI during processing
     KisProcessingApplicator::ProcessingFlags signalFlags =
         sizeChanged ?
         KisProcessingApplicator::NO_UI_UPDATES :
         KisProcessingApplicator::NONE;
 
 
     KisProcessingApplicator applicator(this, rootNode,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bicubic");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
     applicator.end();
 }
 
 
 void KisImage::rotateImage(double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Image"), root(), true, radians);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Layer"), node, false, radians);
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          const QPointF &origin)
 {
     //angleX, angleY are in degrees
     const qreal pi = 3.1415926535897932385;
     const qreal deg2rad = pi / 180.0;
 
     qreal tanX = tan(angleX * deg2rad);
     qreal tanY = tan(angleY * deg2rad);
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   tanX, tanY, origin.x(), origin.y(),
                                   0,
                                   0, 0, 0, 0);
 
         QRect newRect = worker.transform().mapRect(bounds());
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         KisProcessingApplicator::RECURSIVE;
     if (resizeImage) signalFlags |= KisProcessingApplicator::NO_UI_UPDATES;
 
     KisProcessingApplicator applicator(this, rootNode,
                                        signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bilinear");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY)
 {
     QPointF shearOrigin = QRectF(bounds()).center();
 
     shearImpl(kundo2_i18n("Shear layer"), node, false,
               angleX, angleY, shearOrigin);
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, QPointF());
 }
 
 void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!dstColorSpace) return;
 
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Image Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
 
     KisColorSpaceConvertVisitor visitor(this, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     m_d->rootLayer->accept(visitor);
 
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     const KoColorSpace *srcCs = colorSpace();
 
     if (!dstCs) return false;
 
     m_d->colorSpace = dstCs;
 
     KisChangeProfileVisitor visitor(srcCs, dstCs);
     return m_d->rootLayer->accept(visitor);
 
 }
 
 void KisImage::convertProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     if (*m_d->colorSpace == *dstColorSpace) return;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Projection Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
     m_d->rootLayer->resetCache();
     m_d->signalRouter->emitNotification(ColorSpaceChangedSignal);
 }
 
 const KoColorSpace * KisImage::colorSpace() const
 {
     return m_d->colorSpace;
 }
 
 const KoColorProfile * KisImage::profile() const
 {
     return colorSpace()->profile();
 }
 
 double KisImage::xRes() const
 {
     return m_d->xres;
 }
 
 double KisImage::yRes() const
 {
     return m_d->yres;
 }
 
 void KisImage::setResolution(double xres, double yres)
 {
     m_d->xres = xres;
     m_d->yres = yres;
     m_d->signalRouter->emitNotification(ResolutionChangedSignal);
 }
 
 QPointF KisImage::documentToPixel(const QPointF &documentCoord) const
 {
     return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
 }
 
 QPoint KisImage::documentToIntPixel(const QPointF &documentCoord) const
 {
     QPointF pixelCoord = documentToPixel(documentCoord);
     return QPoint((int)pixelCoord.x(), (int)pixelCoord.y());
 }
 
 QRectF KisImage::documentToPixel(const QRectF &documentRect) const
 {
     return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
 }
 
 QRect KisImage::documentToIntPixel(const QRectF &documentRect) const
 {
     return documentToPixel(documentRect).toAlignedRect();
 }
 
 QPointF KisImage::pixelToDocument(const QPointF &pixelCoord) const
 {
     return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
 }
 
 QPointF KisImage::pixelToDocument(const QPoint &pixelCoord) const
 {
     return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
 }
 
 QRectF KisImage::pixelToDocument(const QRectF &pixelCoord) const
 {
     return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
 }
 
 qint32 KisImage::width() const
 {
     return m_d->width;
 }
 
 qint32 KisImage::height() const
 {
     return m_d->height;
 }
 
 KisGroupLayerSP KisImage::rootLayer() const
 {
     Q_ASSERT(m_d->rootLayer);
     return m_d->rootLayer;
 }
 
 KisPaintDeviceSP KisImage::projection() const
 {
     if (m_d->isolatedRootNode) {
         return m_d->isolatedRootNode->projection();
     }
 
 
     Q_ASSERT(m_d->rootLayer);
     KisPaintDeviceSP projection = m_d->rootLayer->projection();
     Q_ASSERT(projection);
     return projection;
 }
 
 qint32 KisImage::nlayers() const
 {
     QStringList list;
     list << "KisLayer";
 
     KisCountVisitor visitor(list, KoProperties());
     m_d->rootLayer->accept(visitor);
     return visitor.count();
 }
 
 qint32 KisImage::nHiddenLayers() const
 {
     QStringList list;
     list << "KisLayer";
     KoProperties properties;
     properties.setProperty("visible", false);
     KisCountVisitor visitor(list, properties);
     m_d->rootLayer->accept(visitor);
 
     return visitor.count();
 }
 
 QRect realNodeExactBounds(KisNodeSP rootNode, QRect currentRect = QRect())
 {
     KisNodeSP node = rootNode->firstChild();
 
     while(node) {
         currentRect |= realNodeExactBounds(node, currentRect);
         node = node->nextSibling();
     }
 
     // TODO: it would be better to count up changeRect inside
     // node's extent() method
     currentRect |= rootNode->projectionPlane()->changeRect(rootNode->exactBounds());
 
     return currentRect;
 }
 
 void KisImage::refreshHiddenArea(KisNodeSP rootNode, const QRect &preparedArea)
 {
     QRect realNodeRect = realNodeExactBounds(rootNode);
     if (!preparedArea.contains(realNodeRect)) {
 
         QRegion dirtyRegion = realNodeRect;
         dirtyRegion -= preparedArea;
 
         foreach(const QRect &rc, dirtyRegion.rects()) {
             refreshGraph(rootNode, rc, realNodeRect);
         }
     }
 }
 
 void KisImage::flatten()
 {
     KisGroupLayerSP oldRootLayer = m_d->rootLayer;
     KisGroupLayerSP newRootLayer =
         new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8);
 
     refreshHiddenArea(oldRootLayer, bounds());
 
     lock();
     KisPaintDeviceSP projectionCopy = new KisPaintDevice(oldRootLayer->projection()->colorSpace());
     projectionCopy->makeCloneFrom(oldRootLayer->projection(), oldRootLayer->exactBounds());
     unlock();
 
     KisPaintLayerSP flattenLayer =
         new KisPaintLayer(this, nextLayerName(), OPACITY_OPAQUE_U8, projectionCopy);
     Q_CHECK_PTR(flattenLayer);
 
     addNode(flattenLayer, newRootLayer, 0);
 
     undoAdapter()->beginMacro(kundo2_i18n("Flatten Image"));
     // NOTE: KisImageChangeLayersCommand performs all the locking for us
     undoAdapter()->addCommand(new KisImageChangeLayersCommand(KisImageWSP(this), oldRootLayer, newRootLayer));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
+bool checkIsSourceForClone(KisNodeSP src, const QList<KisNodeSP> &nodes)
+{
+    foreach (KisNodeSP node, nodes) {
+        if (node == src) continue;
+
+        KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
+
+        if (clone && KisNodeSP(clone->copyFrom()) == src) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void KisImage::safeRemoveMultipleNodes(QList<KisNodeSP> nodes)
+{
+    while (!nodes.isEmpty()) {
+        QList<KisNodeSP>::iterator it = nodes.begin();
+
+        while (it != nodes.end()) {
+            if (!checkIsSourceForClone(*it, nodes)) {
+                KisNodeSP node = *it;
+                undoAdapter()->addCommand(new KisImageLayerRemoveCommand(this, node));
+                it = nodes.erase(it);
+            } else {
+                ++it;
+            }
+        }
+
+    }
+}
+
+bool checkIsChildOf(KisNodeSP node, const QList<KisNodeSP> &parents)
+{
+    QList<KisNodeSP> nodeParents;
+
+    KisNodeSP parent = node->parent();
+    while (parent) {
+        nodeParents << parent;
+        parent = parent->parent();
+    }
+
+    foreach(KisNodeSP perspectiveParent, parents) {
+        if (nodeParents.contains(perspectiveParent)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void filterMergableNodes(QList<KisNodeSP> &nodes)
+{
+    QList<KisNodeSP>::iterator it = nodes.begin();
+
+    while (it != nodes.end()) {
+        if (!dynamic_cast<KisLayer*>(it->data()) ||
+            checkIsChildOf(*it, nodes)) {
+
+            qDebug() << "Skipping node" << ppVar((*it)->name());
+            it = nodes.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+KisNodeSP KisImage::mergeMultipleLayers(QList<KisNodeSP> mergedNodes, KisNodeSP putAfter)
+{
+    filterMergableNodes(mergedNodes);
+
+    if (mergedNodes.size() <= 1) return KisNodeSP();
+
+    foreach (KisNodeSP layer, mergedNodes) {
+        refreshHiddenArea(layer, bounds());
+    }
+
+    KisPaintDeviceSP mergedDevice = new KisPaintDevice(colorSpace());
+    KisPainter gc(mergedDevice);
+
+    {
+        KisImageBarrierLocker l(this);
+
+        foreach (KisNodeSP layer, mergedNodes) {
+            QRect rc = layer->exactBounds() | bounds();
+            layer->projectionPlane()->apply(&gc, rc);
+        }
+    }
+
+    const QString mergedLayerSuffix = i18n("Merged");
+    QString mergedLayerName = mergedNodes.first()->name();
+
+    if (!mergedLayerName.endsWith(mergedLayerSuffix)) {
+        mergedLayerName = QString("%1 %2")
+            .arg(mergedLayerName).arg(mergedLayerSuffix);
+    }
+
+    KisNodeSP newLayer = new KisPaintLayer(this, mergedLayerName, OPACITY_OPAQUE_U8, mergedDevice);
+
+
+    undoAdapter()->beginMacro(kundo2_i18n("Merge Selected Nodes"));
+
+    if (!putAfter) {
+        putAfter = mergedNodes.last();
+    }
+
+    // Add the new merged node on top of the active node -- checking
+    // whether the parent is going to be deleted
+    KisNodeSP parent = putAfter->parent();
+    while (mergedNodes.contains(parent)) {
+        parent = parent->parent();
+    }
+
+    if (parent == putAfter->parent()) {
+        undoAdapter()->addCommand(new KisImageLayerAddCommand(this, newLayer, parent, putAfter));
+    } else {
+        undoAdapter()->addCommand(new KisImageLayerAddCommand(this, newLayer, parent, parent->lastChild()));
+    }
+
+    safeRemoveMultipleNodes(mergedNodes);
+
+    undoAdapter()->endMacro();
+
+    return newLayer;
+}
+
 KisLayerSP KisImage::mergeDown(KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
 {
     if (!layer->prevSibling()) return 0;
 
     // XXX: this breaks if we allow free mixing of masks and layers
     KisLayerSP prevLayer = dynamic_cast<KisLayer*>(layer->prevSibling().data());
     if (!prevLayer) return 0;
 
     refreshHiddenArea(layer, bounds());
     refreshHiddenArea(prevLayer, bounds());
 
     QRect layerProjectionExtent = this->projection()->extent();
     QRect prevLayerProjectionExtent = prevLayer->projection()->extent();
 
     // actual merging done by KisLayer::createMergedLayer (or specialized decendant)
     KisLayerSP mergedLayer = layer->createMergedLayer(prevLayer);
     Q_CHECK_PTR(mergedLayer);
 
     // Merge meta data
     QList<const KisMetaData::Store*> srcs;
     srcs.append(prevLayer->metaData());
     srcs.append(layer->metaData());
     QList<double> scores;
     int prevLayerArea = prevLayerProjectionExtent.width() * prevLayerProjectionExtent.height();
     int layerArea = layerProjectionExtent.width() * layerProjectionExtent.height();
     double norm = qMax(prevLayerArea, layerArea);
     scores.append(prevLayerArea / norm);
     scores.append(layerArea / norm);
     strategy->merge(mergedLayer->metaData(), srcs, scores);
 
     KisNodeSP parent = layer->parent(); // parent is set to null when the layer is removed from the node
     dbgImage << ppVar(parent);
 
     // FIXME: "Merge Down"?
     undoAdapter()->beginMacro(kundo2_i18n("Merge with Layer Below"));
 
     undoAdapter()->addCommand(new KisImageLayerAddCommand(this, mergedLayer, parent, layer));
     safeRemoveTwoNodes(layer, prevLayer);
 
     undoAdapter()->endMacro();
 
     return mergedLayer;
 }
 
 /**
  * The removal of two nodes in one go may be a bit tricky, because one
  * of them may be the clone of another. If we remove the source of a
  * clone layer, it will reincarnate into a paint layer. In this case
  * the pointer to the second layer will be lost.
  *
  * That's why we need to care about the order of the nodes removal:
  * the clone --- first, the source --- last.
  */
 void KisImage::safeRemoveTwoNodes(KisNodeSP node1, KisNodeSP node2)
 {
     KisCloneLayer *clone1 = dynamic_cast<KisCloneLayer*>(node1.data());
 
     if (clone1 && KisNodeSP(clone1->copyFrom()) == node2) {
         undoAdapter()->addCommand(new KisImageLayerRemoveCommand(this, node1));
         undoAdapter()->addCommand(new KisImageLayerRemoveCommand(this, node2));
     } else {
         undoAdapter()->addCommand(new KisImageLayerRemoveCommand(this, node2));
         undoAdapter()->addCommand(new KisImageLayerRemoveCommand(this, node1));
     }
 }
 
 KisLayerSP KisImage::flattenLayer(KisLayerSP layer)
 {
     if (!layer->firstChild()) return layer;
 
     refreshHiddenArea(layer, bounds());
 
     bool resetComposition = false;
 
     KisPaintDeviceSP mergedDevice;
 
     lock();
     if (layer->layerStyle()) {
         mergedDevice = new KisPaintDevice(layer->colorSpace());
         mergedDevice->prepareClone(layer->projection());
 
         QRect updateRect = layer->projection()->extent() | bounds();
 
         KisPainter gc(mergedDevice);
         layer->projectionPlane()->apply(&gc, updateRect);
 
         resetComposition = true;
 
     } else {
         mergedDevice = new KisPaintDevice(*layer->projection());
     }
     unlock();
 
     KisPaintLayerSP newLayer = new KisPaintLayer(this, layer->name(), layer->opacity(), mergedDevice);
 
     if (!resetComposition) {
         newLayer->setCompositeOp(layer->compositeOp()->id());
         newLayer->setChannelFlags(layer->channelFlags());
     }
 
     undoAdapter()->beginMacro(kundo2_i18n("Flatten Layer"));
     undoAdapter()->addCommand(new KisImageLayerAddCommand(this, newLayer, layer->parent(), layer));
     undoAdapter()->addCommand(new KisImageLayerRemoveCommand(this, layer));
 
     QList<const KisMetaData::Store*> srcs;
     srcs.append(layer->metaData());
 
     const KisMetaData::MergeStrategy* strategy = KisMetaData::MergeStrategyRegistry::instance()->get("Smart");
     QList<double> scores;
     scores.append(1.0); //Just give some score, there only is one layer
     strategy->merge(newLayer->metaData(), srcs, scores);
 
     undoAdapter()->endMacro();
 
     return newLayer;
 }
 
 
 void KisImage::setModified()
 {
     m_d->signalRouter->emitNotification(ModifiedSignal);
 }
 
 QImage KisImage::convertToQImage(QRect imageRect,
                                  const KoColorProfile * profile)
 {
     qint32 x;
     qint32 y;
     qint32 w;
     qint32 h;
     imageRect.getRect(&x, &y, &w, &h);
     return convertToQImage(x, y, w, h, profile);
 }
 
 QImage KisImage::convertToQImage(qint32 x,
                                  qint32 y,
                                  qint32 w,
                                  qint32 h,
                                  const KoColorProfile * profile)
 {
     KisPaintDeviceSP dev = projection();
     if (!dev) return QImage();
     QImage image = dev->convertToQImage(const_cast<KoColorProfile*>(profile), x, y, w, h,
                                         KoColorConversionTransformation::InternalRenderingIntent,
                                         KoColorConversionTransformation::InternalConversionFlags);
 
     return image;
 }
 
 
 
 QImage KisImage::convertToQImage(const QRect& scaledRect, const QSize& scaledImageSize, const KoColorProfile *profile)
 {
 
     if (scaledRect.isEmpty() || scaledImageSize.isEmpty()) {
         return QImage();
     }
 
     try {
         qint32 imageWidth = width();
         qint32 imageHeight = height();
         quint32 pixelSize = colorSpace()->pixelSize();
 
         double xScale = static_cast<double>(imageWidth) / scaledImageSize.width();
         double yScale = static_cast<double>(imageHeight) / scaledImageSize.height();
 
         QRect srcRect;
 
         srcRect.setLeft(static_cast<int>(scaledRect.left() * xScale));
         srcRect.setRight(static_cast<int>(ceil((scaledRect.right() + 1) * xScale)) - 1);
         srcRect.setTop(static_cast<int>(scaledRect.top() * yScale));
         srcRect.setBottom(static_cast<int>(ceil((scaledRect.bottom() + 1) * yScale)) - 1);
 
         KisPaintDeviceSP mergedImage = projection();
         quint8 *scaledImageData = new quint8[scaledRect.width() * scaledRect.height() * pixelSize];
 
         quint8 *imageRow = new quint8[srcRect.width() * pixelSize];
         const qint32 imageRowX = srcRect.x();
 
         for (qint32 y = 0; y < scaledRect.height(); ++y) {
 
             qint32 dstY = scaledRect.y() + y;
             qint32 dstX = scaledRect.x();
             qint32 srcY = (dstY * imageHeight) / scaledImageSize.height();
 
             mergedImage->readBytes(imageRow, imageRowX, srcY, srcRect.width(), 1);
 
             quint8 *dstPixel = scaledImageData + (y * scaledRect.width() * pixelSize);
             quint32 columnsRemaining = scaledRect.width();
 
             while (columnsRemaining > 0) {
 
                 qint32 srcX = (dstX * imageWidth) / scaledImageSize.width();
 
                 memcpy(dstPixel, imageRow + ((srcX - imageRowX) * pixelSize), pixelSize);
 
                 ++dstX;
                 dstPixel += pixelSize;
                 --columnsRemaining;
             }
         }
         delete [] imageRow;
 
         QImage image = colorSpace()->convertToQImage(scaledImageData, scaledRect.width(), scaledRect.height(), const_cast<KoColorProfile*>(profile),
                                                      KoColorConversionTransformation::InternalRenderingIntent,
                                                      KoColorConversionTransformation::InternalConversionFlags);
 
         delete [] scaledImageData;
 
         return image;
     }
     catch (std::bad_alloc) {
         warnKrita << "KisImage::convertToQImage ran out of memory";
         return QImage();
     }
 }
 
 void KisImage::notifyLayersChanged()
 {
     m_d->signalRouter->emitNotification(LayersChangedSignal);
 }
 
 QRect KisImage::bounds() const
 {
     return QRect(0, 0, width(), height());
 }
 
 KisPostExecutionUndoAdapter* KisImage::postExecutionUndoAdapter() const
 {
     return m_d->postExecutionUndoAdapter;
 }
 
 void KisImage::setUndoStore(KisUndoStore *undoStore)
 {
 
     m_d->legacyUndoAdapter->setUndoStore(undoStore);
     m_d->postExecutionUndoAdapter->setUndoStore(undoStore);
     delete m_d->undoStore;
     m_d->undoStore = undoStore;
 }
 
 KisUndoStore* KisImage::undoStore()
 {
     return m_d->undoStore;
 }
 
 KisUndoAdapter* KisImage::undoAdapter() const
 {
     return m_d->legacyUndoAdapter;
 }
 
 KisActionRecorder* KisImage::actionRecorder() const
 {
     return m_d->recorder;
 }
 
 void KisImage::setDefaultProjectionColor(const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->rootLayer);
     m_d->rootLayer->setDefaultProjectionColor(color);
 }
 
 KoColor KisImage::defaultProjectionColor() const
 {
     KIS_ASSERT_RECOVER(m_d->rootLayer) {
         return KoColor(Qt::transparent, m_d->colorSpace);
     }
 
     return m_d->rootLayer->defaultProjectionColor();
 }
 
 void KisImage::setRootLayer(KisGroupLayerSP rootLayer)
 {
     stopIsolatedMode();
 
     KoColor defaultProjectionColor(Qt::transparent, m_d->colorSpace);
 
     if (m_d->rootLayer) {
         m_d->rootLayer->setGraphListener(0);
         m_d->rootLayer->disconnect();
 
         KisPaintDeviceSP original = m_d->rootLayer->original();
         defaultProjectionColor.setColor(original->defaultPixel(), original->colorSpace());
     }
 
     m_d->rootLayer = rootLayer;
     m_d->rootLayer->disconnect();
     m_d->rootLayer->setGraphListener(this);
 
     KisPaintDeviceSP newOriginal = m_d->rootLayer->original();
     defaultProjectionColor.convertTo(newOriginal->colorSpace());
     newOriginal->setDefaultPixel(defaultProjectionColor.data());
 
     setRoot(m_d->rootLayer.data());
 }
 
 void KisImage::addAnnotation(KisAnnotationSP annotation)
 {
     // Find the icc annotation, if there is one
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == annotation->type()) {
             *it = annotation;
             return;
         }
         ++it;
     }
     m_d->annotations.push_back(annotation);
 }
 
 KisAnnotationSP KisImage::annotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             return *it;
         }
         ++it;
     }
     return KisAnnotationSP(0);
 }
 
 void KisImage::removeAnnotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             m_d->annotations.erase(it);
             return;
         }
         ++it;
     }
 }
 
 vKisAnnotationSP_it KisImage::beginAnnotations()
 {
     return m_d->annotations.begin();
 }
 
 vKisAnnotationSP_it KisImage::endAnnotations()
 {
     return m_d->annotations.end();
 }
 
 void KisImage::notifyAboutToBeDeleted()
 {
     emit sigAboutToBeDeleted();
 }
 
 KisPerspectiveGrid* KisImage::perspectiveGrid()
 {
     if (m_d->perspectiveGrid == 0)
         m_d->perspectiveGrid = new KisPerspectiveGrid();
     return m_d->perspectiveGrid;
 }
 
 KisImageSignalRouter* KisImage::signalRouter()
 {
     return m_d->signalRouter;
 }
 
 void KisImage::waitForDone()
 {
     requestStrokeEnd();
 
     if (m_d->scheduler) {
         m_d->scheduler->waitForDone();
     }
 }
 
 KisStrokeId KisImage::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     /**
      * Ask open strokes to end gracefully. All the strokes clients
      * (including the one calling this method right now) will get
      * a notification that they should probably end their strokes.
      * However this is purely their choice whether to end a stroke
      * or not.
      */
     requestStrokeEnd();
 
     /**
      * Some of the strokes can cancel their work with undoing all the
      * changes they did to the paint devices. The problem is that undo
      * stack will know nothing about it. Therefore, just notify it
      * explicitly
      */
     if (strokeStrategy->clearsRedoOnStart()) {
         m_d->undoStore->purgeRedoState();
     }
 
     KisStrokeId id;
 
     if (m_d->scheduler) {
         id = m_d->scheduler->startStroke(strokeStrategy);
     }
 
     return id;
 }
 
 void KisImage::startIsolatedMode(KisNodeSP node)
 {
     barrierLock();
     unlock();
 
     m_d->isolatedRootNode = node;
     emit sigIsolatedModeChanged();
 
     notifyProjectionUpdated(bounds());
 }
 
 void KisImage::stopIsolatedMode()
 {
     if (!m_d->isolatedRootNode)  return;
 
     KisNodeSP oldRootNode = m_d->isolatedRootNode;
     m_d->isolatedRootNode = 0;
 
     emit sigIsolatedModeChanged();
 
     notifyProjectionUpdated(bounds());
 
     // TODO: Substitute notifyProjectionUpdated() with this code
     // when update optimization is implemented
     // 
     // QRect updateRect = bounds() | oldRootNode->extent();
     // oldRootNode->setDirty(updateRect);
 }
 
 KisNodeSP KisImage::isolatedModeRoot() const
 {
     return m_d->isolatedRootNode;
 }
 
 void KisImage::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     KisUpdateTimeMonitor::instance()->reportJobStarted(data);
 
     if (m_d->scheduler) {
         m_d->scheduler->addJob(id, data);
     }
 }
 
 void KisImage::endStroke(KisStrokeId id)
 {
     if (m_d->scheduler) {
         m_d->scheduler->endStroke(id);
     }
 }
 
 bool KisImage::cancelStroke(KisStrokeId id)
 {
     bool result = false;
     if (m_d->scheduler) {
         result = m_d->scheduler->cancelStroke(id);
     }
     return result;
 }
 
 bool KisImage::KisImagePrivate::tryCancelCurrentStrokeAsync()
 {
     bool result = false;
     if (scheduler) {
         result = scheduler->tryCancelCurrentStrokeAsync();
     }
     return result;
 }
 
 void KisImage::requestUndoDuringStroke()
 {
     emit sigUndoDuringStrokeRequested();
 }
 
 void KisImage::requestStrokeCancellation()
 {
     if (!m_d->tryCancelCurrentStrokeAsync()) {
         emit sigStrokeCancellationRequested();
     }
 }
 
 void KisImage::requestStrokeEnd()
 {
     emit sigStrokeEndRequested();
 }
 
 void KisImage::refreshGraph(KisNodeSP root)
 {
     refreshGraph(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraph(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     if (m_d->scheduler) {
         m_d->scheduler->fullRefresh(root, rc, cropRect);
     }
 }
 
 void KisImage::initialRefreshGraph()
 {
     /**
      * NOTE: Tricky part. We set crop rect to null, so the clones
      * will not rely on precalculated projections of their sources
      */
 
     refreshGraphAsync(0, bounds(), QRect());
     waitForDone();
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root)
 {
     refreshGraphAsync(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc)
 {
     refreshGraphAsync(root, rc, bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     if (m_d->scheduler) {
         m_d->scheduler->fullRefreshAsync(root, rc, cropRect);
     }
 }
 
 void KisImage::requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect)
 {
     KIS_ASSERT_RECOVER_RETURN(pseudoFilthy);
 
     if (m_d->scheduler) {
         m_d->scheduler->updateProjectionNoFilthy(pseudoFilthy, rc, cropRect);
     }
 }
 
 void KisImage::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     if (m_d->scheduler) {
         m_d->scheduler->addSpontaneousJob(spontaneousJob);
     }
 }
 
 void KisImage::disableDirtyRequests()
 {
     m_d->disableDirtyRequests.ref();
 }
 
 void KisImage::enableDirtyRequests()
 {
     m_d->disableDirtyRequests.deref();
 }
 
 void KisImage::disableUIUpdates()
 {
     m_d->disableUIUpdateSignals.ref();
 }
 
 void KisImage::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
 }
 
 void KisImage::notifyProjectionUpdated(const QRect &rc)
 {
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(rc);
 
     if (!m_d->disableUIUpdateSignals) {
         emit sigImageUpdated(rc);
     }
 }
 
 void KisImage::notifySelectionChanged()
 {
     /**
      * The selection is calculated asynchromously, so it is not
      * handled by disableUIUpdates() and other special signals of
      * KisImageSignalRouter
      */
     m_d->legacyUndoAdapter->emitSelectionChanged();
 
     /**
      * Editing of selection masks doesn't necessary produce a
      * setDirty() call, so in the end of the stroke we need to request
      * direct update of the UI's cache.
      */
     if (m_d->isolatedRootNode &&
         dynamic_cast<KisSelectionMask*>(m_d->isolatedRootNode.data())) {
 
         notifyProjectionUpdated(bounds());
     }
 }
 
 void KisImage::requestProjectionUpdateImpl(KisNode *node,
                                            const QRect &rect,
                                            const QRect &cropRect)
 {
     KisNodeGraphListener::requestProjectionUpdate(node, rect);
 
     if (m_d->scheduler) {
         m_d->scheduler->updateProjection(node, rect, cropRect);
     }
 }
 
 void KisImage::requestProjectionUpdate(KisNode *node, const QRect& rect)
 {
     if (m_d->disableDirtyRequests) return;
 
     /**
      * Here we use 'permitted' instead of 'active' intentively,
      * because the updates may come after the actual stroke has been
      * finished. And having some more updates for the stroke not
      * supporting the wrap-around mode will not make much harm.
      */
     if (m_d->wrapAroundModePermitted) {
         QRect boundRect = bounds();
         KisWrappedRect splitRect(rect, boundRect);
 
         foreach (const QRect &rc, splitRect) {
             requestProjectionUpdateImpl(node, rc, boundRect);
         }
     } else {
         requestProjectionUpdateImpl(node, rect, bounds());
     }
 }
 
 QList<KisLayerComposition*> KisImage::compositions()
 {
     return m_d->compositions;
 }
 
 void KisImage::addComposition(KisLayerComposition* composition)
 {
     m_d->compositions.append(composition);
 }
 
 void KisImage::removeComposition(KisLayerComposition* composition)
 {
     m_d->compositions.removeAll(composition);
     delete composition;
 }
 
 bool checkMasksNeedConversion(KisNodeSP root, const QRect &bounds)
 {
     KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(root.data());
     if (mask &&
         (!bounds.contains(mask->paintDevice()->exactBounds()) ||
          mask->selection()->hasShapeSelection())) {
 
         return true;
     }
 
     KisNodeSP node = root->firstChild();
 
     while (node) {
         if (checkMasksNeedConversion(node, bounds)) {
             return true;
         }
 
         node = node->nextSibling();
     }
 
     return false;
 }
 
 void KisImage::setWrapAroundModePermitted(bool value)
 {
     m_d->wrapAroundModePermitted = value;
 
     if (m_d->wrapAroundModePermitted &&
         checkMasksNeedConversion(root(), bounds())) {
 
         KisProcessingApplicator applicator(this, root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Crop Selections"));
 
         KisProcessingVisitorSP visitor =
             new KisCropSelectionsProcessingVisitor(bounds());
 
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
         applicator.end();
     }
 }
 
 bool KisImage::wrapAroundModePermitted() const
 {
     return m_d->wrapAroundModePermitted;
 }
 
 bool KisImage::wrapAroundModeActive() const
 {
     return m_d->wrapAroundModePermitted && m_d->scheduler &&
         m_d->scheduler->wrapAroundModeSupported();
 }
 
 void KisImage::notifyNodeCollpasedChanged()
 {
     emit sigNodeCollapsedChanged();
 }
 
 
 #include "kis_image.moc"
 
diff --git a/krita/image/kis_image.h b/krita/image/kis_image.h
index 8dedd03ae7..d35aa7d2b8 100644
--- a/krita/image/kis_image.h
+++ b/krita/image/kis_image.h
@@ -1,822 +1,833 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_IMAGE_H_
 #define KIS_IMAGE_H_
 
 #include <QObject>
 #include <QString>
 #include <QPainter>
 #include <QRect>
 #include <QRegion>
 #include <QBitArray>
 
 #include <KoColorConversionTransformation.h>
 
 #include "kis_paint_device.h" // msvc cannot handle forward declarations, so include kis_paint_device here
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kis_node_graph_listener.h"
 #include "kis_node_facade.h"
 #include "kis_default_bounds.h"
 #include "kis_image_interfaces.h"
 
 #include <krita_export.h>
 
 class KisDocument;
 class KoColorSpace;
 class KoColor;
 
 class KisCompositeProgressProxy;
 class KisActionRecorder;
 class KisUndoStore;
 class KisUndoAdapter;
 class KisImageSignalRouter;
 class KisPostExecutionUndoAdapter;
 class KisFilterStrategy;
 class KoColorProfile;
 class KisPerspectiveGrid;
 class KisLayerComposition;
 class KisSpontaneousJob;
 
 namespace KisMetaData
 {
 class MergeStrategy;
 }
 
 /**
  * This is the image class, it contains a tree of KisLayer stack and
  * meta information about the image. And it also provides some
  * functions to manipulate the whole image.
  */
 class KRITAIMAGE_EXPORT KisImage : public QObject,
         public KisStrokesFacade,
         public KisUpdatesFacade,
         public KisProjectionUpdateListener,
         public KisNodeFacade,
         public KisNodeGraphListener,
         public KisShared
 {
 
     Q_OBJECT
 
 public:
 
     /// @param colorSpace can be null. in that case it will be initialised to a default color space.
     KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name, bool startProjection = true);
     virtual ~KisImage();
 
 public: // KisNodeGraphListener implementation
 
     void aboutToAddANode(KisNode *parent, int index);
     void nodeHasBeenAdded(KisNode *parent, int index);
     void aboutToRemoveANode(KisNode *parent, int index);
     void nodeChanged(KisNode * node);
     void notifySelectionChanged();
     void requestProjectionUpdate(KisNode *node, const QRect& rect);
 
 public: // KisProjectionUpdateListener implementation
     void notifyProjectionUpdated(const QRect &rc);
 
 public:
 
     /**
      * Render the projection onto a QImage.
      */
     QImage convertToQImage(qint32 x1,
                            qint32 y1,
                            qint32 width,
                            qint32 height,
                            const KoColorProfile * profile);
 
     /**
      * Render the projection onto a QImage.
      * (this is an overloaded function)
      */
     QImage convertToQImage(QRect imageRect,
                            const KoColorProfile * profile);
 
 
     /**
      * XXX: docs!
      */
     QImage convertToQImage(const QRect& scaledRect, const QSize& scaledImageSize, const KoColorProfile *profile);
 
     /**
      * Calls KisUpdateScheduler::lock
      */
     void lock();
 
     /**
      * Calls KisUpdateScheduler::unlock
      */
     void unlock();
 
     /**
      * Returns true if lock() has been called more often than unlock().
      */
     bool locked() const;
 
     /**
      * @return the global selection object or 0 if there is none. The
      * global selection is always read-write.
      */
     KisSelectionSP globalSelection() const;
 
     /**
      * Retrieve the next automatic layername (XXX: fix to add option to return Mask X)
      */
     QString nextLayerName() const;
 
     /**
      * Set the automatic layer name counter one back.
      */
     void rollBackLayerName();
 
     /**
      * @return the perspective grid associated to this image
      */
     KisPerspectiveGrid* perspectiveGrid();
 
     /**
      * Resize the image to the specified rect. The resize
      * method handles the creating on an undo step itself.
      *
      * @param newRect the rect describing the new width, height and offset
      *        of the image
      */
     void resizeImage(const QRect& newRect);
 
     /**
      * Crop the image to the specified rect. The crop
      * method handles the creating on an undo step itself.
      *
      * @param newRect the rect describing the new width, height and offset
      *        of the image
      */
     void cropImage(const QRect& newRect);
 
 
     /**
      * Crop a node to @newRect. The node will *not* be moved anywhere,
      * it just drops some content
      */
     void cropNode(KisNodeSP node, const QRect& newRect);
 
     void scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy);
     void scaleNode(KisNodeSP node, qreal sx, qreal sy, KisFilterStrategy *filterStrategy);
 
     /**
      * Execute a rotate transform on all layers in this image.
      * Image is resized to fit rotated image.
      */
     void rotateImage(double radians);
 
     /**
      * Execute a rotate transform on on a subtree of this image.
      * Image is not resized.
      */
     void rotateNode(KisNodeSP node, double radians);
 
     /**
      * Execute a shear transform on all layers in this image.
      */
     void shear(double angleX, double angleY);
 
     /**
      * Shear a node and all its children.
      * @param angleX, @param angleY are given in degrees.
      */
     void shearNode(KisNodeSP node, double angleX, double angleY);
 
     /**
      * Convert the image and all its layers to the dstColorSpace
      */
     void convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                 KoColorConversionTransformation::Intent renderingIntent,
                                 KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Set the color space of  the projection (and the root layer)
      * to dstColorSpace. No conversion is done for other layers,
      * their colorspace can differ.
      * NOTE: Note conversion is done, only regeneration, so no rendering
      * intent needed
      */
     void convertProjectionColorSpace(const KoColorSpace *dstColorSpace);
 
     // Get the profile associated with this image
     const KoColorProfile *  profile() const;
 
     /**
      * Set the profile of the image to the new profile and do the same for
      * all layers that have the same colorspace and profile of the image.
      * It doesn't do any pixel conversion.
      *
      * This is essential if you have loaded an image that didn't
      * have an embedded profile to which you want to attach the right profile.
      *
      * This does not create an undo action; only call it when creating or
      * loading an image.
      *
      * @returns false if the profile could not be assigned
      */
     bool assignImageProfile(const KoColorProfile *profile);
 
     /**
      * Returns the current undo adapter. You can add new commands to the
      * undo stack using the adapter. This adapter is used for a backward
      * compatibility for old commands created before strokes. It blocks
      * all the porcessing at the scheduler, waits until it's finished
      * adn executes commands exclusively.
      */
     KisUndoAdapter* undoAdapter() const;
 
     /**
      * This adapter is used by the strokes system. The commands are added
      * to it *after* redo() is done (in the scheduler context). They are
      * wrapped into a special command and added to the undo stack. redo()
      * in not called.
      */
     KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const;
 
     /**
      * Replace current undo store with the new one. The old store
      * will be deleted.
      * This method is used by KisDocument for dropping all the commands
      * during file loading.
      */
     void setUndoStore(KisUndoStore *undoStore);
 
     /**
      * Return current undo store of the image
      */
     KisUndoStore* undoStore();
 
     /**
      * @return the action recorder associated with this image
      */
     KisActionRecorder* actionRecorder() const;
 
     /**
      * Tell the image it's modified; this emits the sigImageModified
      * signal. This happens when the image needs to be saved
      */
     void setModified();
 
     /**
      * The default colorspace of this image: new layers will have this
      * colorspace and the projection will have this colorspace.
      */
     const KoColorSpace * colorSpace() const;
 
     /**
      * X resolution in pixels per pt
      */
     double xRes() const;
 
     /**
      * Y resolution in pixels per pt
      */
     double yRes() const;
 
     /**
      * Set the resolution in pixels per pt.
      */
     void setResolution(double xres, double yres);
 
     /**
      * Convert a document coordinate to a pixel coordinate.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPointF documentToPixel(const QPointF &documentCoord) const;
 
     /**
      * Convert a document coordinate to an integer pixel coordinate.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPoint documentToIntPixel(const QPointF &documentCoord) const;
 
     /**
      * Convert a document rectangle to a pixel rectangle.
      *
      * @param documentRect PostScript Pt rectangle to convert.
      */
     QRectF documentToPixel(const QRectF &documentRect) const;
 
     /**
      * Convert a document rectangle to an integer pixel rectangle.
      *
      * @param documentRect PostScript Pt rectangle to convert.
      */
     QRect documentToIntPixel(const QRectF &documentRect) const;
 
     /**
      * Convert a pixel coordinate to a document coordinate.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPointF &pixelCoord) const;
 
     /**
      * Convert an integer pixel coordinate to a document coordinate.
      * The document coordinate is at the centre of the pixel.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPoint &pixelCoord) const;
 
     /**
      * Convert a document rectangle to an integer pixel rectangle.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QRectF pixelToDocument(const QRectF &pixelCoord) const;
 
     /**
      * Return the width of the image
      */
     qint32 width() const;
 
     /**
      * Return the height of the image
      */
     qint32 height() const;
 
     /**
      * Return the size of the image
      */
     QSize size() const {
         return QSize(width(), height());
     }
 
     /**
      * @return the root node of the image node graph
      */
     KisGroupLayerSP rootLayer() const;
 
     /**
      * Return the projection; that is, the complete, composited
      * representation of this image.
      */
     KisPaintDeviceSP projection() const;
 
     /**
      * Return the number of layers (not other nodes) that are in this
      * image.
      */
     qint32 nlayers() const;
 
     /**
      * Return the number of layers (not other node types) that are in
      * this image and that are hidden.
      */
     qint32 nHiddenLayers() const;
 
     /**
      * Merge all visible layers and discard hidden ones.
      */
     void flatten();
 
     /**
      * Merge the specified layer with the layer
      * below this layer, remove the specified layer.
      */
     KisLayerSP mergeDown(KisLayerSP l, const KisMetaData::MergeStrategy* strategy);
 
     /**
      * flatten the layer: that is, the projection becomes the layer
      * and all subnodes are removed. If this is not a paint layer, it will morph
      * into a paint layer.
      */
     KisLayerSP flattenLayer(KisLayerSP layer);
 
+    /**
+     * Removes \p nodes in a safe way, that is handling clone layers
+     * reincarnation correctly
+     */
+    void safeRemoveMultipleNodes(QList<KisNodeSP> nodes);
+
+    /**
+     * Merges layers in \p mergedLayers and creates a new layer above
+     * \p putAfter
+     */
+    KisNodeSP mergeMultipleLayers(QList<KisNodeSP> mergedLayers, KisNodeSP putAfter);
 
     /// This overrides interface for KisDefaultBounds
     /// @return the exact bounds of the image in pixel coordinates.
     QRect bounds() const;
 
     /// use if the layers have changed _completely_ (eg. when flattening)
     void notifyLayersChanged();
 
     /**
      * Sets the default color of the root layer projection. All the layers
      * will be merged on top of this very color
      */
     void setDefaultProjectionColor(const KoColor &color);
 
     /**
      * \see setDefaultProjectionColor()
      */
     KoColor defaultProjectionColor() const;
 
     void setRootLayer(KisGroupLayerSP rootLayer);
 
     /**
      * Add an annotation for this image. This can be anything: Gamma, EXIF, etc.
      * Note that the "icc" annotation is reserved for the color strategies.
      * If the annotation already exists, overwrite it with this one.
      */
     void addAnnotation(KisAnnotationSP annotation);
 
     /** get the annotation with the given type, can return 0 */
     KisAnnotationSP annotation(const QString& type);
 
     /** delete the annotation, if the image contains it */
     void removeAnnotation(const QString& type);
 
     /**
      * Start of an iteration over the annotations of this image (including the ICC Profile)
      */
     vKisAnnotationSP_it beginAnnotations();
 
     /** end of an iteration over the annotations of this image */
     vKisAnnotationSP_it endAnnotations();
 
     /**
      * Called before the image is delted and sends the sigAboutToBeDeleted signal
      */
     void notifyAboutToBeDeleted();
 
     KisImageSignalRouter* signalRouter();
 
     /**
      * Returns whether we can reselect current global selection
      *
      * \see reselectGlobalSelection()
      */
     bool canReselectGlobalSelection();
 
     /**
      * Returns the layer compositions for the image
      */
     QList<KisLayerComposition*> compositions();
 
     /**
      * Adds a new layer composition, will be saved with the image
      */
     void addComposition(KisLayerComposition* composition);
 
     /**
      * Remove the layer compostion
      */
     void removeComposition(KisLayerComposition* composition);
 
     /**
      * Permit or deny the wrap-around mode for all the paint devices
      * of the image. Note that permitting the wraparound mode will not
      * necessarily activate it right now. To be activated the wrap
      * around mode should be 1) permitted; 2) supported by the
      * currently running stroke.
      */
     void setWrapAroundModePermitted(bool value);
 
     /**
      * \return whether the wrap-around mode is permitted for this
      *         image. If the wrap around mode is permitted and the
      *         currently running stroke supports it, the mode will be
      *         activated for all paint devices of the image.
      *
      * \see setWrapAroundMode
      */
     bool wrapAroundModePermitted() const;
 
 
     /**
      * \return whether the wraparound mode is activated for all the
      *         devices of the image. The mode is activated when both
      *         factors are true: the user permitted it and the stroke
      *         supports it
      */
     bool wrapAroundModeActive() const;
 
     /**
      * Notifies that the node collapsed state has changed
      */
     void notifyNodeCollpasedChanged();
 
 public:
     void startIsolatedMode(KisNodeSP node);
     void stopIsolatedMode();
     KisNodeSP isolatedModeRoot() const;
 
 Q_SIGNALS:
 
     /**
      *  Emitted whenever an action has caused the image to be
      *  recomposited.
      *
      * @param rc The rect that has been recomposited.
      */
     void sigImageUpdated(const QRect &);
 
     /**
        Emitted whenever the image has been modified, so that it
        doesn't match with the version saved on disk.
      */
     void sigImageModified();
 
     /**
      * The signal is emitted when the size of the image is changed.
      * \p oldStillPoint and \p newStillPoint give the receiver the
      * hint about how the new and old rect of the image correspond to
      * each other. They specify the point of the image around which
      * the conversion was done. This point will stay still on the
      * user's screen. That is the \p newStillPoint of the new image
      * will be painted at the same screen position, where \p
      * oldStillPoint of the old image was painted.
      *
      * \param oldStillPoint is a still point represented in *old*
      *                      image coordinates
      *
      * \param newStillPoint is a still point represented in *new*
      *                      image coordinates
      */
     void sigSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
 
     void sigProfileChanged(const KoColorProfile *  profile);
     void sigColorSpaceChanged(const KoColorSpace*  cs);
     void sigResolutionChanged(double xRes, double yRes);
 
     /**
      * Inform the model that a node was changed
      */
     void sigNodeChanged(KisNodeSP node);
 
     /**
      * Inform that the image is going to be deleted
      */
     void sigAboutToBeDeleted();
 
     /**
      * The signal is emitted right after a node has been connected
      * to the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread. If you need
      * information about the parent/siblings of the node connect
      * with Qt::DirectConnection, get needed information and then
      * emit another Qt::AutoConnection signal to pass this information
      * to your thread. See details of the implementation
      * in KisDummiesfacadeBase.
      */
     void sigNodeAddedAsync(KisNodeSP node);
 
     /**
      * This signal is emitted right before a node is going to removed
      * from the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread.
      *
      * \see comment in sigNodeAddedAsync()
      */
     void sigRemoveNodeAsync(KisNodeSP node);
 
     /**
      * Emitted when the root node of the image has changed.
      * It happens, e.g. when we flatten the image. When
      * this happens the receiver should reload information
      * about the image
      */
     void sigLayersChangedAsync();
 
     /**
      * Emitted when the UI has requested the undo of the last stroke's
      * operation. The point is, we cannot deal with the internals of
      * the stroke without its creator knowing about it (which most
      * probably cause a crash), so we just forward this request from
      * the UI to the creator of the stroke.
      *
      * If your tool supports undoing part of its work, just listen to
      * this signal and undo when it comes
      */
     void sigUndoDuringStrokeRequested();
 
     /**
      * Emitted when the UI has requested the cancellation of
      * the stroke. The point is, we cannot cancel the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports cancelling of its work in the middle
      * of operation, just listen to this signal and cancel
      * the stroke when it comes
      */
     void sigStrokeCancellationRequested();
 
     /**
      * Emitted when the image decides that the stroke should better
      * be ended. The point is, we cannot just end the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports long  strokes that may involve multiple
      * mouse actions in one stroke, just listen to this signal and
      * end the stroke when it comes.
      */
     void sigStrokeEndRequested();
 
     /**
      * Emitted when the isolated mode status has changed.
      *
      * Can be used by the receivers to catch a fact of forcefully
      * stopping the isolated mode by the image when some complex
      * action was requested
      */
     void sigIsolatedModeChanged();
 
     /**
      * Emitted when one or more nodes changed the collapsed state
      *
      */
     void sigNodeCollapsedChanged();
 
 public Q_SLOTS:
     KisCompositeProgressProxy* compositeProgressProxy();
 
     void barrierLock();
     bool tryBarrierLock();
     void waitForDone();
 
     KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy);
     void addJob(KisStrokeId id, KisStrokeJobData *data);
     void endStroke(KisStrokeId id);
     bool cancelStroke(KisStrokeId id);
 
     void blockUpdates();
     void unblockUpdates();
 
     /**
      * Disables notification of the UI about the changes in the image.
      * This feature is used by KisProcessingApplicator. It is needed
      * when we change the size of the image. In this case, the whole
      * image will be reloaded into UI by sigSizeChanged(), so there is
      * no need to inform the UI about individual dirty rects.
      */
     void disableUIUpdates();
 
     /**
      * \see disableUIUpdates
      */
     void enableUIUpdates();
 
     /**
      * Disables the processing of all the setDirty() requests that
      * come to the image. The incoming requests are effectively
      * *dropped*.
      *
      * This feature is used by KisProcessingApplicator. For many cases
      * it provides its own updates interface, which recalculates the
      * whole subtree of nodes. But while we change any particular
      * node, it can ask for an update itself. This method is a way of
      * blocking such intermediate (and excessive) requests.
      */
     void disableDirtyRequests();
 
     /**
      * \see disableDirtyRequests()
      */
     void enableDirtyRequests();
 
     void refreshGraphAsync(KisNodeSP root = 0);
     void refreshGraphAsync(KisNodeSP root, const QRect &rc);
     void refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect);
 
     /**
      * Triggers synchronous recomposition of the projection
      */
     void refreshGraph(KisNodeSP root = 0);
     void refreshGraph(KisNodeSP root, const QRect& rc, const QRect &cropRect);
     void initialRefreshGraph();
 
     /**
      * Initiate a stack regeneration skipping the recalculation of the
      * filthy node's projection.
      *
      * Works exactly as pseudoFilthy->setDirty() with the only
      * exception that pseudoFilthy::updateProjection() will not be
      * called. That is used by KisRecalculateTransformMaskJob to avoid
      * cyclic dependencies.
      */
     void requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect);
 
     /**
      * Adds a spontaneous job to the updates queue.
      *
      * A spontaneous job may do some trivial tasks in the background,
      * like updating the outline of selection or purging unused tiles
      * from the existing paint devices.
      */
     void addSpontaneousJob(KisSpontaneousJob *spontaneousJob);
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks the current stroke should undo its last
      * action, for example, when the user presses Ctrl+Z while some
      * stroke is active.
      *
      * If the creator of the stroke supports undoing of intermediate
      * actions, it will be notified about this request and can undo
      * its last action.
      */
     void requestUndoDuringStroke();
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks current stroke should be cancelled. If
      * there is a running stroke that has already been detached from
      * its creator (ended or cancelled), it will be forcefully
      * cancelled and reverted. If there is an open stroke present, and
      * if its creator supports cancelling, it will be notified about
      * the request and the stroke will be cancelled
      */
     void requestStrokeCancellation();
 
     /**
      * This method is called when image or some other part of Krita
      * (*not* the creator of the stroke) decides that the stroke
      * should be ended. If the creator of the stroke supports it, it
      * will be notified and the stroke will be cancelled
      */
     void requestStrokeEnd();
 
 private:
 
     KisImage(const KisImage& rhs);
     KisImage& operator=(const KisImage& rhs);
 
     void emitSizeChanged();
 
     void resizeImageImpl(const QRect& newRect, bool cropLayers);
     void rotateImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode,
                     bool resizeImage, double radians);
     void shearImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode,
                    bool resizeImage, double angleX, double angleY,
                    const QPointF &origin);
 
     void safeRemoveTwoNodes(KisNodeSP node1, KisNodeSP node2);
 
     void refreshHiddenArea(KisNodeSP rootNode, const QRect &preparedArea);
 
     void requestProjectionUpdateImpl(KisNode *node,
                                      const QRect& rect,
                                      const QRect &cropRect);
 
     friend class KisImageResizeCommand;
     void setSize(const QSize& size);
 
     friend class KisImageSetProjectionColorSpaceCommand;
     void setProjectionColorSpace(const KoColorSpace * colorSpace);
 
 
     friend class KisDeselectGlobalSelectionCommand;
     friend class KisReselectGlobalSelectionCommand;
     friend class KisSetGlobalSelectionCommand;
     friend class KisImageTest;
 
     /**
      * Replaces the current global selection with globalSelection. If
      * \p globalSelection is empty, removes the selection object, so that
      * \ref globalSelection() will return 0 after that.
      */
     void setGlobalSelection(KisSelectionSP globalSelection);
 
     /**
      * Deselects current global selection.
      * \ref globalSelection() will return 0 after that.
      */
     void deselectGlobalSelection();
 
     /**
      * Reselects current deselected selection
      *
      * \see deselectGlobalSelection()
      */
     void reselectGlobalSelection();
 
 private:
     class KisImagePrivate;
     KisImagePrivate * const m_d;
 };
 
 #endif // KIS_IMAGE_H_
diff --git a/krita/image/tests/kis_image_test.cpp b/krita/image/tests/kis_image_test.cpp
index 7ea3d409f3..8ed12e9713 100644
--- a/krita/image/tests/kis_image_test.cpp
+++ b/krita/image/tests/kis_image_test.cpp
@@ -1,503 +1,528 @@
 /*
  *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image_test.h"
 #include <QApplication>
 
 #include <qtest_kde.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 
 #include "kis_image.h"
 #include "kis_paint_layer.h"
 #include "kis_group_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_selection.h"
 #include <kis_debug.h>
 #include <kis_layer_composition.h>
 
 #define IMAGE_WIDTH 128
 #define IMAGE_HEIGHT 128
 
 void KisImageTest::layerTests()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
 
     QVERIFY(image->rootLayer()->firstChild()->objectName() == layer->objectName());
 }
 
 void KisImageTest::testConvertImageColorSpace()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     KisPaintDeviceSP device1 = new KisPaintDevice(cs8);
     KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
 
     KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
     Q_ASSERT(filter);
     KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
     Q_ASSERT(configuration);
 
     KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
 
     image->addNode(paint1, image->root());
     image->addNode(blur1, image->root());
 
     image->refreshGraph();
 
     const KoColorSpace *cs16 = KoColorSpaceRegistry::instance()->rgb16();
     image->lock();
     image->convertImageColorSpace(cs16,
                                   KoColorConversionTransformation::InternalRenderingIntent,
                                   KoColorConversionTransformation::InternalConversionFlags);
     image->unlock();
 
     QVERIFY(*cs16 == *image->colorSpace());
     QVERIFY(*cs16 == *image->root()->colorSpace());
     QVERIFY(*cs16 == *paint1->colorSpace());
     QVERIFY(*cs16 == *blur1->colorSpace());
 
     QVERIFY(!image->root()->compositeOp());
     QVERIFY(*cs16 == *paint1->compositeOp()->colorSpace());
     QVERIFY(*cs16 == *blur1->compositeOp()->colorSpace());
 
     image->refreshGraph();
 }
 
 void KisImageTest::testGlobalSelection()
 {
     const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
 
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 0U);
 
     KisSelectionSP selection1 = new KisSelection(new KisDefaultBounds(image));
     KisSelectionSP selection2 = new KisSelection(new KisDefaultBounds(image));
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->setGlobalSelection(selection2);
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->reselectGlobalSelection();
     QCOMPARE(image->globalSelection(), selection2);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 
     // mixed deselecting/setting/reselecting
 
     image->deselectGlobalSelection();
     QCOMPARE(image->globalSelection(), KisSelectionSP(0));
     QCOMPARE(image->canReselectGlobalSelection(), true);
     QCOMPARE(image->root()->childCount(), 0U);
 
     image->setGlobalSelection(selection1);
     QCOMPARE(image->globalSelection(), selection1);
     QCOMPARE(image->canReselectGlobalSelection(), false);
     QCOMPARE(image->root()->childCount(), 1U);
 }
 
 void KisImageTest::testLayerComposition()
 {
     KisImageSP image = new KisImage(0, IMAGE_WIDTH, IMAGE_WIDTH, 0, "layer tests");
     QVERIFY(image->rootLayer() != 0);
     QVERIFY(image->rootLayer()->firstChild() == 0);
 
     KisLayerSP layer = new KisPaintLayer(image, "layer 1", OPACITY_OPAQUE_U8);
     image->addNode(layer);
     KisLayerSP layer2 = new KisPaintLayer(image, "layer 2", OPACITY_OPAQUE_U8);
     image->addNode(layer2);
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     KisLayerComposition comp(image, "comp 1");
     comp.store();
 
     layer2->setVisible(false);
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 
     KisLayerComposition comp2(image, "comp 2");
     comp2.store();
 
     comp.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(layer2->visible());
 
     comp2.apply();
 
     QVERIFY(layer->visible());
     QVERIFY(!layer2->visible());
 }
 
 #include "testutil.h"
 #include "kis_group_layer.h"
 #include "kis_transparency_mask.h"
 #include "kis_psd_layer_style.h"
 
 struct FlattenTestImage
 {
     FlattenTestImage()
         : refRect(0,0,512,512)
         , p(refRect)
     {
 
         image = p.image;
 
         layer1 = p.layer;
 
         layer5 = new KisPaintLayer(p.image, "paint5", 0.4 * OPACITY_OPAQUE_U8);
         layer5->disableAlphaChannel(true);
 
         layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
         tmask = new KisTransparencyMask();
 
         // check channel flags
         // make addition composite op
         group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
         layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
         layer4 = new KisPaintLayer(p.image, "paint4", OPACITY_OPAQUE_U8);
 
         layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
 
         layer7 = new KisPaintLayer(p.image, "paint7", OPACITY_OPAQUE_U8);
         layer8 = new KisPaintLayer(p.image, "paint8", OPACITY_OPAQUE_U8);
         layer7->setCompositeOp(COMPOSITE_ADD);
         layer8->setCompositeOp(COMPOSITE_ADD);
 
         QRect rect1(100, 100, 100, 100);
         QRect rect2(150, 150, 150, 150);
         QRect tmaskRect(200,200,100,100);
 
         QRect rect3(400, 100, 100, 100);
         QRect rect4(500, 100, 100, 100);
 
         QRect rect5(50, 50, 100, 100);
 
         QRect rect6(50, 250, 100, 100);
 
         QRect rect7(50, 350, 50, 50);
         QRect rect8(50, 400, 50, 50);
 
         layer1->paintDevice()->fill(rect1, KoColor(Qt::red, p.image->colorSpace()));
 
         layer2->paintDevice()->fill(rect2, KoColor(Qt::green, p.image->colorSpace()));
         tmask->testingInitSelection(tmaskRect);
 
         layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, p.image->colorSpace()));
         layer4->paintDevice()->fill(rect4, KoColor(Qt::yellow, p.image->colorSpace()));
         layer5->paintDevice()->fill(rect5, KoColor(Qt::green, p.image->colorSpace()));
 
         layer6->paintDevice()->fill(rect6, KoColor(Qt::cyan, p.image->colorSpace()));
 
         layer7->paintDevice()->fill(rect7, KoColor(Qt::red, p.image->colorSpace()));
         layer8->paintDevice()->fill(rect8, KoColor(Qt::green, p.image->colorSpace()));
 
         KisPSDLayerStyleSP style(new KisPSDLayerStyle());
         style->dropShadow()->setEffectEnabled(true);
         style->dropShadow()->setDistance(10.0);
         style->dropShadow()->setSpread(80.0);
         style->dropShadow()->setSize(10);
         style->dropShadow()->setNoise(0);
         style->dropShadow()->setKnocksOut(false);
         style->dropShadow()->setOpacity(80.0);
         layer2->setLayerStyle(style);
 
         layer2->setCompositeOp(COMPOSITE_ADD);
         group1->setCompositeOp(COMPOSITE_ADD);
 
         p.image->addNode(layer5);
 
         p.image->addNode(layer2);
         p.image->addNode(tmask, layer2);
 
         p.image->addNode(group1);
         p.image->addNode(layer3, group1);
         p.image->addNode(layer4, group1);
 
         p.image->addNode(layer6);
 
         p.image->addNode(layer7);
         p.image->addNode(layer8);
 
         p.image->initialRefreshGraph();
 
         // qDebug() << ppVar(layer1->exactBounds());
         // qDebug() << ppVar(layer5->exactBounds());
         // qDebug() << ppVar(layer2->exactBounds());
         // qDebug() << ppVar(group1->exactBounds());
         // qDebug() << ppVar(layer3->exactBounds());
         // qDebug() << ppVar(layer4->exactBounds());
 
         TestUtil::ExternalImageChecker chk("flatten", "imagetest");
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
     }
 
     QRect refRect;
     TestUtil::MaskParent p;
 
     KisImageSP image;
     KisPaintLayerSP layer1;
 
     KisPaintLayerSP layer2;
     KisTransparencyMaskSP tmask;
 
     KisGroupLayerSP group1;
     KisPaintLayerSP layer3;
     KisPaintLayerSP layer4;
 
     KisPaintLayerSP layer5;
 
     KisPaintLayerSP layer6;
 
     KisPaintLayerSP layer7;
     KisPaintLayerSP layer8;
 };
 
 void KisImageTest::testFlattenLayer()
 {
     FlattenTestImage p;
 
     TestUtil::ExternalImageChecker chk("flatten", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = p.image->flattenLayer(p.layer2);
         p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
 
         KisLayerSP newLayer = p.image->flattenLayer(p.group1);
         p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(400, 100, 200, 100));
     }
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = p.image->flattenLayer(p.layer5);
         p.image->waitForDone();
 
         QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 50, 100, 100));
 
         QCOMPARE(newLayer->alphaChannelDisabled(), true);
     }
 }
 
 #include <metadata/kis_meta_data_merge_strategy_registry.h>
 
 void KisImageTest::testMergeDown()
 {
     FlattenTestImage p;
 
     TestUtil::ExternalImageChecker img("flatten", "imagetest");
     TestUtil::ExternalImageChecker chk("mergedown_simple", "imagetest");
 
 
     {
         QCOMPARE(p.layer5->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer5->alphaChannelDisabled(), true);
 
         KisLayerSP newLayer = p.image->mergeDown(p.layer5, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer5_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = p.image->mergeDown(p.layer2, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "02_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 213, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = p.image->mergeDown(p.group1, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "03_group1_mergedown_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(100, 100, 500, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationInheritsAlpha()
 {
     FlattenTestImage p;
 
     TestUtil::ExternalImageChecker img("flatten", "imagetest");
     TestUtil::ExternalImageChecker chk("mergedown_dst_inheritsalpha", "imagetest");
 
     {
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = p.image->mergeDown(p.layer2, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer2_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50,50, 263, 267));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationCustomCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ExternalImageChecker img("flatten", "imagetest");
     TestUtil::ExternalImageChecker chk("mergedown_dst_customop", "imagetest");
 
     {
         QCOMPARE(p.layer6->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(p.layer6->alphaChannelDisabled(), false);
 
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = p.image->mergeDown(p.layer6, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer6_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOpLayerStyle()
 {
     FlattenTestImage p;
 
     TestUtil::ExternalImageChecker img("flatten", "imagetest");
     TestUtil::ExternalImageChecker chk("mergedown_sameop_ls", "imagetest");
 
     {
         QCOMPARE(p.group1->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.group1->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer2->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer2->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = p.image->mergeDown(p.group1, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_group1_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
         QCOMPARE(newLayer->exactBounds(), QRect(197, 100, 403, 217));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
 void KisImageTest::testMergeDownDestinationSameCompositeOp()
 {
     FlattenTestImage p;
 
     TestUtil::ExternalImageChecker img("flatten", "imagetest");
     TestUtil::ExternalImageChecker chk("mergedown_sameop_fastpath", "imagetest");
 
     {
         QCOMPARE(p.layer8->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer8->alphaChannelDisabled(), false);
 
         QCOMPARE(p.layer7->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(p.layer7->alphaChannelDisabled(), false);
 
         KisLayerSP newLayer = p.image->mergeDown(p.layer8, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         p.image->waitForDone();
 
         QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
         QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
 
         QCOMPARE(newLayer->compositeOpId(), COMPOSITE_ADD);
         QCOMPARE(newLayer->exactBounds(), QRect(50, 350, 50, 100));
         QCOMPARE(newLayer->alphaChannelDisabled(), false);
     }
 }
 
+void KisImageTest::testMergeMultiple()
+{
+    FlattenTestImage p;
+
+    TestUtil::ExternalImageChecker img("flatten", "imagetest");
+    TestUtil::ExternalImageChecker chk("mergemultiple", "imagetest");
+
+    QList<KisNodeSP> selectedNodes;
+
+    selectedNodes << p.layer2
+                  << p.group1
+                  << p.layer6;
+
+    {
+        KisNodeSP newLayer = p.image->mergeMultipleLayers(selectedNodes, 0);
+        p.image->waitForDone();
+
+        QVERIFY(img.checkDevice(p.image->projection(), p.image, "00_initial"));
+        QVERIFY(chk.checkDevice(newLayer->projection(), p.image, "01_layer8_layerproj"));
+
+        QCOMPARE(newLayer->compositeOpId(), COMPOSITE_OVER);
+        QCOMPARE(newLayer->exactBounds(), QRect(50, 100, 550, 250));
+    }
+}
+
 QTEST_KDEMAIN(KisImageTest, NoGUI)
 #include "kis_image_test.moc"
diff --git a/krita/image/tests/kis_image_test.h b/krita/image/tests/kis_image_test.h
index 9238b02464..66fcfef74f 100644
--- a/krita/image/tests/kis_image_test.h
+++ b/krita/image/tests/kis_image_test.h
@@ -1,45 +1,47 @@
 /*
  *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.com>
  *  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.
  */
 
 #ifndef KIS_IMAGE_TESTER_H
 #define KIS_IMAGE_TESTER_H
 
 #include <QtTest>
 
 class KisImageTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
 
     void layerTests();
     void testConvertImageColorSpace();
     void testGlobalSelection();
     void testLayerComposition();
 
     void testFlattenLayer();
     void testMergeDown();
     void testMergeDownDestinationInheritsAlpha();
     void testMergeDownDestinationCustomCompositeOp();
     void testMergeDownDestinationSameCompositeOpLayerStyle();
     void testMergeDownDestinationSameCompositeOp();
+
+    void testMergeMultiple();
 };
 
 #endif
 
diff --git a/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp b/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp
index f3049f41b1..e5c430c829 100644
--- a/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp
+++ b/krita/plugins/extensions/dockers/defaultdockers/kis_layer_box.cpp
@@ -1,815 +1,815 @@
 /*
  *  kis_layer_box.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer_box.h"
 
 
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 
 #include <kis_debug.h>
 #include <kmenu.h>
 #include <klocale.h>
 
 #include <KoIcon.h>
 #include <KisDocumentSectionView.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_composite_ops_model.h>
 
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 #include "canvas/kis_canvas2.h"
 #include "KisDocument.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 
 #include "ui_wdglayerbox.h"
 
 class ButtonAction : public KisAction
 {
 public:
     ButtonAction(QAbstractButton* button, const KIcon& icon, const QString& text, QObject* parent)
         : KisAction(icon, text, parent)
         , m_button(button)
     {
         connect(m_button, SIGNAL(clicked()), this, SLOT(trigger()));
     }
 
     ButtonAction(QAbstractButton* button, QObject* parent) : KisAction(parent) , m_button(button)
     {
         connect(m_button, SIGNAL(clicked()), this, SLOT(trigger()));
     }
 
     virtual void setActionEnabled(bool enabled) {
         KisAction::setActionEnabled(enabled);
         m_button->setEnabled(enabled);
     }
 private:
     QAbstractButton* m_button;
 };
 
 inline void KisLayerBox::connectActionToButton(KisViewManager* view, QAbstractButton *button, const QString &id)
 {
     Q_ASSERT(view);
     KisAction *action = view->actionManager()->actionByName(id);
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
 }
 
 inline void KisLayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     Q_ASSERT(m_canvas);
     menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
 }
 
 KisLayerBox::KisLayerBox()
         : QDockWidget(i18n("Layers"))
         , m_canvas(0)
         , m_wdgLayerBox(new Ui_WdgLayerBox)
 {
     KisConfig cfg;
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setDefaultDropAction(Qt::MoveAction);
     m_wdgLayerBox->listLayers->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_wdgLayerBox->listLayers->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
     m_wdgLayerBox->listLayers->setSelectionBehavior(QAbstractItemView::SelectRows);
 
     connect(m_wdgLayerBox->listLayers, SIGNAL(contextMenuRequested(const QPoint&, const QModelIndex&)),
             this, SLOT(slotContextMenuRequested(const QPoint&, const QModelIndex&)));
     connect(m_wdgLayerBox->listLayers, SIGNAL(collapsed(const QModelIndex&)), SLOT(slotCollapsed(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers, SIGNAL(expanded(const QModelIndex&)), SLOT(slotExpanded(const QModelIndex &)));
     connect(m_wdgLayerBox->listLayers, SIGNAL(selectionChanged(const QModelIndexList&)), SLOT(selectionChanged(const QModelIndexList&)));
 
     m_viewModeMenu = new KMenu(this);
     QActionGroup *group = new QActionGroup(this);
     QList<QAction*> actions;
 
     actions << m_viewModeMenu->addAction(koIcon("view-list-text"),
                                          i18n("Minimal View"), this, SLOT(slotMinimalView()));
     actions << m_viewModeMenu->addAction(koIcon("view-list-details"),
                                          i18n("Detailed View"), this, SLOT(slotDetailedView()));
     actions << m_viewModeMenu->addAction(koIcon("view-preview"),
                                          i18n("Thumbnail View"), this, SLOT(slotThumbnailView()));
 
     for (int i = 0, n = actions.count(); i < n; ++i) {
         actions[i]->setCheckable(true);
         actions[i]->setActionGroup(group);
     }
 
     m_wdgLayerBox->bnAdd->setIcon(themedIcon("addlayer"));
 
     m_wdgLayerBox->bnViewMode->setMenu(m_viewModeMenu);
     m_wdgLayerBox->bnViewMode->setPopupMode(QToolButton::InstantPopup);
     m_wdgLayerBox->bnViewMode->setIcon(koIcon("view-choose"));
     m_wdgLayerBox->bnViewMode->setText(i18n("View mode"));
 
     m_wdgLayerBox->bnDelete->setIcon(themedIcon("deletelayer"));
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnRaise->setEnabled(false);
     m_wdgLayerBox->bnRaise->setIcon(themedIcon("arrowupblr"));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnLower->setIcon(themedIcon("arrowdown"));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLeft->setEnabled(true);
     m_wdgLayerBox->bnLeft->setIcon(themedIcon("removefromfolder"));
     m_wdgLayerBox->bnLeft->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnRight->setEnabled(true);
     m_wdgLayerBox->bnRight->setIcon(themedIcon("addtofolder"));
     m_wdgLayerBox->bnRight->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnProperties->setIcon(themedIcon("properties"));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnDuplicate->setIcon(themedIcon("duplicatelayer"));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_removeAction  = new ButtonAction(m_wdgLayerBox->bnDelete, themedIcon("deletelayer"), i18n("&Remove Layer"), this);
     m_removeAction->setActivationFlags(KisAction::ACTIVE_NODE);
     m_removeAction->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     m_removeAction->setObjectName("remove_layer");
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
     m_actions.append(m_removeAction);
 
     KisAction* action  = new ButtonAction(m_wdgLayerBox->bnLeft, this);
     action->setText(i18n("Move Layer Left"));
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     action->setObjectName("move_layer_left");
     connect(action, SIGNAL(triggered()), this, SLOT(slotLeftClicked()));
     m_actions.append(action);
 
     action  = new ButtonAction(m_wdgLayerBox->bnRight, this);
     action->setText(i18n("Move Layer Right"));
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     action->setObjectName("move_layer_right");
     connect(action, SIGNAL(triggered()), this, SLOT(slotRightClicked()));
     m_actions.append(action);
 
     m_propertiesAction  = new ButtonAction(m_wdgLayerBox->bnProperties, themedIcon("properties"), i18n("&Properties..."),this);
     m_propertiesAction->setActivationFlags(KisAction::ACTIVE_NODE);
     m_propertiesAction->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     m_propertiesAction->setObjectName("layer_properties");
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
     m_actions.append(m_propertiesAction);
 
     // NOTE: this is _not_ a mistake. The layerbox shows the layers in the reverse order
     connect(m_wdgLayerBox->bnRaise, SIGNAL(clicked()), SLOT(slotLowerClicked()));
     connect(m_wdgLayerBox->bnLower, SIGNAL(clicked()), SLOT(slotRaiseClicked()));
     // END NOTE
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix("%");
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_selectOpaque = new KisAction(i18n("&Select Opaque"), this);
     m_selectOpaque->setActivationFlags(KisAction::ACTIVE_DEVICE);
     m_selectOpaque->setActivationConditions(KisAction::SELECTION_EDITABLE);
     m_selectOpaque->setObjectName("select_opaque");
     connect(m_selectOpaque, SIGNAL(triggered(bool)), this, SLOT(slotSelectOpaque()));
     m_actions.append(m_selectOpaque);
 
     m_newLayerMenu = new KMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <interface>Layers</interface> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_wdgLayerBox->listLayers->setModel(m_nodeModel);
 }
 
 KisLayerBox::~KisLayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeModel> nodeModel, KisDocumentSectionView *sectionView)
 {
     if (!root) return;
     if (nodeModel.isNull()) return;
     if (!sectionView) return;
 
     sectionView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = nodeModel->indexFromNode(node);
         if (idx.isValid()) {
             if (node->collapsed()) {
                 sectionView->collapse(idx);
             }
         }
         if (node->childCount() > 0) {
             expandNodesRecursively(node, nodeModel, sectionView);
         }
         node = node->nextSibling();
     }
     sectionView->blockSignals(false);
 }
 
 void KisLayerBox::setMainWindow(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
 
     foreach(KisAction *action, m_actions) {
         kisview->actionManager()->
             addAction(action->objectName(),
                       action);
     }
 
     connectActionToButton(kisview, m_wdgLayerBox->bnAdd, "add_new_paint_layer");
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 }
 
 void KisLayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if(m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0);
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         disconnect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), this, SLOT(updateUI()));
         m_nodeManager->setSelectedNodes(QList<KisNodeSP>());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
 
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), SLOT(updateThumbnail()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController = dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade = static_cast<KisDummiesFacadeBase*>(kritaShapeController);
         m_nodeModel->setDummiesFacade(kritaDummiesFacade, m_image, kritaShapeController);
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection KisNodeManager -> KisLayerBox
         connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)), this, SLOT(setCurrentNode(KisNodeSP)));
 
         // Connection KisLayerBox -> KisNodeManager
         // The order of these connections is important! See comment in the ctor
         connect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), m_nodeManager, SLOT(slotUiActivatedNode(KisNodeSP)));
         connect(m_nodeModel, SIGNAL(nodeActivated(KisNodeSP)), SLOT(updateUI()));
 
         // Connection KisLayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()), m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         // Node manipulation methods are forwarded to the node manager
         connect(m_nodeModel, SIGNAL(requestAddNode(KisNodeSP, KisNodeSP, KisNodeSP)),
                 m_nodeManager, SLOT(addNodeDirect(KisNodeSP, KisNodeSP, KisNodeSP)));
         connect(m_nodeModel, SIGNAL(requestMoveNode(KisNodeSP, KisNodeSP, KisNodeSP)),
                 m_nodeManager, SLOT(moveNodeDirect(KisNodeSP, KisNodeSP, KisNodeSP)));
 
         m_wdgLayerBox->listLayers->expandAll();
         expandNodesRecursively(m_image->rootLayer(), m_nodeModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
 
         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_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void KisLayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
     setCanvas(0);
 }
 
 void KisLayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void KisLayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
 
     if (activeNode) {
         if (m_nodeManager->activePaintDevice()) {
             slotFillCompositeOps(m_nodeManager->activeColorSpace());
         } else {
             slotFillCompositeOps(m_image->colorSpace());
         }
 
         if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         } else if (activeNode->inherits("KisLayer")) {
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             KisLayerSP l = qobject_cast<KisLayer*>(activeNode.data());
             slotSetOpacity(l->opacity() * 100.0 / 255);
 
             const KoCompositeOp* compositeOp = l->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);
         }
     }
 }
 
 
 /**
  * This method is callen *only* when non-GUI code requested the
  * change of the current node
  */
 void KisLayerBox::setCurrentNode(KisNodeSP node)
 {
     QModelIndex index = node ? m_nodeModel->indexFromNode(node) : QModelIndex();
 
     m_wdgLayerBox->listLayers->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
     updateUI();
 }
 
 void KisLayerBox::slotModelReset()
 {
     if(m_nodeModel->hasDummiesFacade()) {
         QItemSelection selection;
         foreach(const KisNodeSP node, m_nodeManager->selectedNodes()) {
             const QModelIndex &idx = m_nodeModel->indexFromNode(node);
             if(idx.isValid()){
                 QItemSelectionRange selectionRange(idx);
                 selection << selectionRange;
             }
         }
 
         m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
     }
 
     updateUI();
 }
 
 void KisLayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 void KisLayerBox::slotFillCompositeOps(const KoColorSpace* colorSpace)
 {
     m_wdgLayerBox->cmbComposite->validate(colorSpace);
 }
 
 // range: 0-100
 void KisLayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void KisLayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     QMenu menu;
 
     if (index.isValid()) {
         menu.addAction(m_propertiesAction);
         addActionToMenu(&menu, "layer_style");
 
         menu.addSeparator();
         menu.addAction(m_removeAction);
 
         addActionToMenu(&menu, "duplicatelayer");
         addActionToMenu(&menu, "flatten_image");
         addActionToMenu(&menu, "flatten_layer");
 
         // TODO: missing icon "edit-merge"
         QAction* mergeLayerDown = menu.addAction(i18n("&Merge with Layer Below"), this, SLOT(slotMergeLayer()));
         if (!index.sibling(index.row() + 1, 0).isValid()) mergeLayerDown->setEnabled(false);
         menu.addSeparator();
 
         QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
         addActionToMenu(convertToMenu, "convert_to_paint_layer");
         addActionToMenu(convertToMenu, "convert_to_transparency_mask");
         addActionToMenu(convertToMenu, "convert_to_filter_mask");
         addActionToMenu(convertToMenu, "convert_to_selection_mask");
 
         QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
         addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
         addActionToMenu(splitAlphaMenu, "split_alpha_write");
         addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
 
         KisNodeSP node = m_nodeModel->nodeFromIndex(index);
         if (node && !node->inherits("KisTransformMask")) {
             addActionToMenu(&menu, "isolate_layer");
         }
     }
     menu.addSeparator();
     addActionToMenu(&menu, "add_new_transparency_mask");
     addActionToMenu(&menu, "add_new_filter_mask");
     addActionToMenu(&menu, "add_new_transform_mask");
     addActionToMenu(&menu, "add_new_selection_mask");
     menu.addSeparator();
     menu.addAction(m_selectOpaque);
     menu.exec(pos);
 }
 
 void KisLayerBox::slotMergeLayer()
 {
     if (!m_canvas) return;
-    m_nodeManager->mergeLayerDown();
+    m_nodeManager->mergeLayer();
 }
 
 void KisLayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisDocumentSectionView::MinimalMode);
 }
 
 void KisLayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisDocumentSectionView::DetailedMode);
 }
 
 void KisLayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(KisDocumentSectionView::ThumbnailMode);
 }
 
 void KisLayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void KisLayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     KisNodeSP node = m_nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!m_nodeManager->activeNode()->prevSibling()) {
         if (!grandParent) return;
         if (!grandParent->parent() && node->inherits("KisMask")) return;
         m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
     } else {
         m_nodeManager->raiseNode();
     }
 }
 
 void KisLayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     KisNodeSP node = m_nodeManager->activeNode();
     KisNodeSP parent = node->parent();
     KisNodeSP grandParent = parent->parent();
 
     if (!m_nodeManager->activeNode()->nextSibling()) {
         if (!grandParent) return;
         if (!grandParent->parent() && node->inherits("KisMask")) return;
         m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
     }
     else {
         m_nodeManager->lowerNode();
     }
 }
 
 void KisLayerBox::slotLeftClicked()
 {
     if (!m_canvas) return;
     foreach(KisNodeSP node, m_nodeManager->selectedNodes()) {
         KisNodeSP parent = node->parent();
         KisNodeSP grandParent = parent->parent();
         quint16 nodeIndex = parent->index(node);
 
         if (!grandParent) continue;
         if (!grandParent->parent() && node->inherits("KisMask")) continue;
 
         if (nodeIndex <= parent->childCount() / 2) {
             m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent));
         }
         else {
             m_nodeManager->moveNodeAt(node, grandParent, grandParent->index(parent) + 1);
         }
     }
 }
 
 void KisLayerBox::slotRightClicked()
 {
     if (!m_canvas) return;
 
     foreach(KisNodeSP node, m_nodeManager->selectedNodes()) {
         KisNodeSP parent = m_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);
             m_nodeManager->moveNodeAt(node, newParent, newParent->childCount());
         }
         else if (parent->at(indexAbove) && parent->at(indexAbove)->allowAsChild(node)) {
             newParent = parent->at(indexAbove);
             m_nodeManager->moveNodeAt(node, newParent, 0);
         }
     }
 }
 
 void KisLayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void KisLayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void KisLayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_nodeManager->nodeOpacityChanged(m_newOpacity, true);
 }
 
 void KisLayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void KisLayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_nodeModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void KisLayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_nodeModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void KisLayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void KisLayerBox::slotNodeCollapsedChanged()
 {
     m_wdgLayerBox->listLayers->expandAll();
     expandNodesRecursively(m_image->rootLayer(), m_nodeModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP KisLayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (isSelectionMask(startNode) &&
         startNode->parent() &&
         !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && isSelectionMask(node)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && isSelectionMask(node)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && isSelectionMask(node)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void KisLayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     if (showSelections) {
         KisNodeSP newMask = m_image->rootLayer()->selectionMask();
         if (newMask) {
             activateNode = newMask;
         }
     }
 
     if (activateNode) {
         if (lastActiveNode != activateNode) {
             m_nodeManager->slotNonUiActivatedNode(activateNode);
         } else {
             setCurrentNode(lastActiveNode);
         }
     }
 }
 
 void KisLayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         m_wdgLayerBox->listLayers->selectionModel()->
             setCurrentIndex(
                 m_nodeModel->indexFromNode(m_nodeManager->activeNode()),
                 QItemSelectionModel::ClearAndSelect);
         return;
     }
 
 
     QList<KisNodeSP> selectedNodes;
     foreach(const QModelIndex &idx, selection) {
         selectedNodes << m_nodeModel->nodeFromIndex(idx);
     }
 
 
     m_nodeManager->setSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void KisLayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 #include "kis_layer_box.moc"
diff --git a/krita/ui/kis_layer_manager.cc b/krita/ui/kis_layer_manager.cc
index d55bc20a3b..02626ba9e1 100644
--- a/krita/ui/kis_layer_manager.cc
+++ b/krita/ui/kis_layer_manager.cc
@@ -1,961 +1,966 @@
 /*
  *  Copyright (C) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer_manager.h"
 
 #include <QRect>
 #include <QApplication>
 #include <QCursor>
 #include <QString>
 #include <QDialog>
 #include <QVBoxLayout>
 #include <QFileInfo>
 #include <QDesktopServices>
 #include <QScopedPointer>
 
 #include <kactioncollection.h>
 #include <klocale.h>
 #include <QMessageBox>
 #include <kfilewidget.h>
 #include <kurl.h>
 #include <kdiroperator.h>
 #include <kurlcombobox.h>
 
 #include <KoIcon.h>
 #include <KisImportExportManager.h>
 #include <KisDocument.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoPointerEvent.h>
 #include <KoColorProfile.h>
 #include <KoSelection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <filter/kis_filter.h>
 #include <kis_filter_strategy.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_selection.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_undo_adapter.h>
 #include <kis_painter.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_merge_strategy_registry.h>
 #include <kis_psd_layer_style.h>
 
 #include "KisView.h"
 #include "kis_config.h"
 #include "kis_cursor.h"
 #include "dialogs/kis_dlg_adj_layer_props.h"
 #include "dialogs/kis_dlg_adjustment_layer.h"
 #include "dialogs/kis_dlg_layer_properties.h"
 #include "dialogs/kis_dlg_generator_layer.h"
 #include "dialogs/kis_dlg_file_layer.h"
 #include "dialogs/kis_dlg_layer_style.h"
 #include "KisDocument.h"
 #include "kis_filter_manager.h"
 #include "kis_node_visitor.h"
 #include "kis_paint_layer.h"
 #include "commands/kis_image_commands.h"
 #include "commands/kis_layer_commands.h"
 #include "commands/kis_node_commands.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_selection_manager.h"
 #include "kis_statusbar.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "widgets/kis_meta_data_merge_strategy_chooser_widget.h"
 #include "widgets/kis_wdg_generator.h"
 #include "kis_progress_widget.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisPart.h"
 
 #include "kis_signal_compressor_with_param.h"
 #include "kis_abstract_projection_plane.h"
 #include "commands_new/kis_set_layer_style_command.h"
 #include "kis_post_execution_undo_adapter.h"
 
 
 
 class KisSaveGroupVisitor : public KisNodeVisitor
 {
 public:
     KisSaveGroupVisitor(KisImageWSP image,
                         bool saveInvisible,
                         bool saveTopLevelOnly,
                         const KUrl &url,
                         const QString &baseName,
                         const QString &extension,
                         const QString &mimeFilter)
         : m_image(image)
         , m_saveInvisible(saveInvisible)
         , m_saveTopLevelOnly(saveTopLevelOnly)
         , m_url(url)
         , m_baseName(baseName)
         , m_extension(extension)
         , m_mimeFilter(mimeFilter)
     {
     }
 
     virtual ~KisSaveGroupVisitor()
     {
     }
 
 public:
 
     bool visit(KisNode* ) {
         return true;
     }
 
     bool visit(KisPaintLayer *) {
         return true;
     }
 
     bool visit(KisAdjustmentLayer *) {
         return true;
     }
 
 
     bool visit(KisExternalLayer *) {
         return true;
     }
 
 
     bool visit(KisCloneLayer *) {
         return true;
     }
 
 
     bool visit(KisFilterMask *) {
         return true;
     }
 
     bool visit(KisTransformMask *) {
         return true;
     }
 
     bool visit(KisTransparencyMask *) {
         return true;
     }
 
     bool visit(KisGeneratorLayer * ) {
         return true;
     }
 
     bool visit(KisSelectionMask* ) {
         return true;
     }
 
     bool visit(KisGroupLayer *layer)
     {
         if (layer == m_image->rootLayer()) {
             KisLayerSP child = dynamic_cast<KisLayer*>(layer->firstChild().data());
             while (child) {
                 child->accept(*this);
                 child = dynamic_cast<KisLayer*>(child->nextSibling().data());
             }
 
         }
         else if (layer->visible() || m_saveInvisible) {
 
             QRect r = m_image->bounds();
 
             KisDocument *d = KisPart::instance()->createDocument();
 
             d->prepareForImport();
 
             KisImageWSP dst = new KisImage(d->createUndoStore(), r.width(), r.height(), m_image->colorSpace(), layer->name());
             dst->setResolution(m_image->xRes(), m_image->yRes());
             d->setCurrentImage(dst);
             KisPaintLayer* paintLayer = new KisPaintLayer(dst, "projection", layer->opacity());
             KisPainter gc(paintLayer->paintDevice());
             gc.bitBlt(QPoint(0, 0), layer->projection(), r);
             dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
             dst->refreshGraph();
 
             d->setOutputMimeType(m_mimeFilter.toLatin1());
             d->setSaveInBatchMode(true);
 
 
             KUrl url = m_url;
             url.adjustPath(KUrl::AddTrailingSlash);
 
             url.setFileName(m_baseName + '_' + layer->name().replace(' ', '_') + '.' + m_extension);
 
             d->exportDocument(url);
 
             if (!m_saveTopLevelOnly) {
                 KisGroupLayerSP child = dynamic_cast<KisGroupLayer*>(layer->firstChild().data());
                 while (child) {
                     child->accept(*this);
                     child = dynamic_cast<KisGroupLayer*>(child->nextSibling().data());
                 }
             }
             delete d;
         }
 
         return true;
     }
 
 private:
 
     KisImageWSP m_image;
     bool m_saveInvisible;
     bool m_saveTopLevelOnly;
     KUrl m_url;
     QString m_baseName;
     QString m_extension;
     QString m_mimeFilter;
 };
 
 KisLayerManager::KisLayerManager(KisViewManager * view)
     : m_view(view)
     , m_imageView(0)
     , m_imageFlatten(0)
     , m_imageMergeLayer(0)
     , m_groupLayersSave(0)
     , m_imageResizeToLayer(0)
     , m_flattenLayer(0)
     , m_rasterizeLayer(0)
     , m_commandsAdapter(new KisNodeCommandsAdapter(m_view))
     , m_layerStyle(0)
 {
 }
 
 KisLayerManager::~KisLayerManager()
 {
     delete m_commandsAdapter;
 }
 
 void KisLayerManager::setView(QPointer<KisView>view)
 {
     m_imageView = view;
 }
 
 KisLayerSP KisLayerManager::activeLayer()
 {
     if (m_imageView) {
         return m_imageView->currentLayer();
     }
     return 0;
 }
 
 KisPaintDeviceSP KisLayerManager::activeDevice()
 {
     if (activeLayer()) {
         return activeLayer()->paintDevice();
     }
     return 0;
 }
 
 void KisLayerManager::activateLayer(KisLayerSP layer)
 {
     if (m_imageView) {
         emit sigLayerActivated(layer);
         layersUpdated();
         if (layer) {
             m_view->resourceProvider()->slotNodeActivated(layer.data());
         }
     }
 }
 
 
 void KisLayerManager::setup(KisActionManager* actionManager)
 {
     m_imageFlatten = new KisAction(i18n("&Flatten image"), this);
     m_imageFlatten->setActivationFlags(KisAction::ACTIVE_LAYER);
     actionManager->addAction("flatten_image", m_imageFlatten);
     m_imageFlatten->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_E));
     connect(m_imageFlatten, SIGNAL(triggered()), this, SLOT(flattenImage()));
 
     m_imageMergeLayer = new KisAction(i18n("&Merge with Layer Below"), this);
     m_imageMergeLayer->setActivationFlags(KisAction::ACTIVE_LAYER);
     actionManager->addAction("merge_layer", m_imageMergeLayer);
     m_imageMergeLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_E));
     connect(m_imageMergeLayer, SIGNAL(triggered()), this, SLOT(mergeLayer()));
 
     m_flattenLayer = new KisAction(i18n("&Flatten Layer"), this);
     m_flattenLayer->setActivationFlags(KisAction::ACTIVE_LAYER);
     actionManager->addAction("flatten_layer", m_flattenLayer);
     connect(m_flattenLayer, SIGNAL(triggered()), this, SLOT(flattenLayer()));
 
     KisAction * action = new KisAction(i18n("Rename current layer"), this);
     action->setActivationFlags(KisAction::ACTIVE_LAYER);
     actionManager->addAction("RenameCurrentLayer", action);
     action->setShortcut(KShortcut(Qt::Key_F2));
     connect(action, SIGNAL(triggered()), this, SLOT(layerProperties()));
 
     m_rasterizeLayer = new KisAction(i18n("Rasterize Layer"), this);
     m_rasterizeLayer->setActivationFlags(KisAction::ACTIVE_SHAPE_LAYER);
     m_rasterizeLayer->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     actionManager->addAction("rasterize_layer", m_rasterizeLayer);
     connect(m_rasterizeLayer, SIGNAL(triggered()), this, SLOT(rasterizeLayer()));
 
     m_groupLayersSave = new KisAction(koIcon("document-save"), i18n("Save Group Layers..."), this);
     m_groupLayersSave->setActivationFlags(KisAction::ACTIVE_LAYER);
     actionManager->addAction("save_groups_as_images", m_groupLayersSave);
     connect(m_groupLayersSave, SIGNAL(triggered()), this, SLOT(saveGroupLayers()));
 
     m_imageResizeToLayer = new KisAction(i18n("Trim to Current Layer"), this);
     m_imageResizeToLayer->setActivationFlags(KisAction::ACTIVE_LAYER);
     actionManager->addAction("resizeimagetolayer", m_imageResizeToLayer);
     connect(m_imageResizeToLayer, SIGNAL(triggered()), this, SLOT(imageResizeToActiveLayer()));
 
     m_layerStyle  = new KisAction(i18n("Layer Style..."), this);
     m_layerStyle->setActivationFlags(KisAction::ACTIVE_LAYER);
     m_layerStyle->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     actionManager->addAction("layer_style", m_layerStyle);
     connect(m_layerStyle, SIGNAL(triggered()), this, SLOT(layerStyle()));
 
 }
 
 void KisLayerManager::updateGUI()
 {
     KisImageWSP image = m_view->image();
 
     KisLayerSP layer;
     qint32 nlayers = 0;
 
     if (image) {
         layer = activeLayer();
         nlayers = image->nlayers();
     }
 
     // XXX these should be named layer instead of image
     m_imageFlatten->setEnabled(nlayers > 1);
     m_imageMergeLayer->setEnabled(nlayers > 1 && layer && layer->prevSibling());
     m_flattenLayer->setEnabled(nlayers > 1 && layer && layer->firstChild());
 
     if (m_view->statusBar())
         m_view->statusBar()->setProfile(image);
 }
 
 void KisLayerManager::imageResizeToActiveLayer()
 {
     KisLayerSP layer;
     KisImageWSP image = m_view->image();
 
     if (image && (layer = activeLayer())) {
         QRect cropRect = layer->projection()->nonDefaultPixelArea();
         if (!cropRect.isEmpty()) {
             image->cropImage(cropRect);
         } else {
             m_view->showFloatingMessage(
                 i18nc("floating message in layer manager",
                       "Layer is empty "),
                 QIcon(), 2000, KisFloatingMessage::Low);
         }
     }
 }
 
 void KisLayerManager::layerProperties()
 {
     if (!m_view) return;
     if (!m_view->document()) return;
 
     KisLayerSP layer = activeLayer();
 
     if (!layer) return;
 
 
     if (KisAdjustmentLayerSP alayer = KisAdjustmentLayerSP(dynamic_cast<KisAdjustmentLayer*>(layer.data()))) {
         KisPaintDeviceSP dev = alayer->projection();
 
         KisDlgAdjLayerProps dlg(alayer, alayer.data(), dev, m_view, alayer->filter().data(), alayer->name(), i18n("Filter Layer Properties"), m_view->mainWindow(), "dlgadjlayerprops");
         dlg.resize(dlg.minimumSizeHint());
 
 
         KisSafeFilterConfigurationSP configBefore(alayer->filter());
         KIS_ASSERT_RECOVER_RETURN(configBefore);
         QString xmlBefore = configBefore->toXML();
 
 
         if (dlg.exec() == QDialog::Accepted) {
 
             alayer->setName(dlg.layerName());
 
             KisSafeFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                    = new KisChangeFilterCmd(alayer,
                                              configBefore->name(),
                                              xmlBefore,
                                              configAfter->name(),
                                              xmlAfter,
                                              false);
                 // FIXME: check whether is needed
                 cmd->redo();
                 m_view->undoAdapter()->addCommand(cmd);
                 m_view->document()->setModified(true);
             }
         }
         else {
             KisSafeFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 alayer->setFilter(KisFilterRegistry::instance()->cloneConfiguration(configBefore.data()));
                 alayer->setDirty();
             }
         }
     }
     else if (KisGeneratorLayerSP alayer = KisGeneratorLayerSP(dynamic_cast<KisGeneratorLayer*>(layer.data()))) {
 
         KisDlgGeneratorLayer dlg(alayer->name(), m_view, m_view->mainWindow());
         dlg.setCaption(i18n("Fill Layer Properties"));
 
         KisSafeFilterConfigurationSP configBefore(alayer->filter());
         Q_ASSERT(configBefore);
         QString xmlBefore = configBefore->toXML();
 
         dlg.setConfiguration(configBefore.data());
         dlg.resize(dlg.minimumSizeHint());
 
         if (dlg.exec() == QDialog::Accepted) {
 
             alayer->setName(dlg.layerName());
 
             KisSafeFilterConfigurationSP configAfter(dlg.configuration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                         = new KisChangeFilterCmd(alayer,
                                                  configBefore->name(),
                                                  xmlBefore,
                                                  configAfter->name(),
                                                  xmlAfter,
                                                  true);
                 // FIXME: check whether is needed
                 cmd->redo();
                 m_view->undoAdapter()->addCommand(cmd);
                 m_view->document()->setModified(true);
             }
 
         }
     } else { // If layer == normal painting layer, vector layer, or group layer
         KisDlgLayerProperties *dialog = new KisDlgLayerProperties(layer, m_view, m_view->document());
         dialog->resize(dialog->minimumSizeHint());
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         Qt::WindowFlags flags = dialog->windowFlags();
         dialog->setWindowFlags(flags | Qt::WindowStaysOnTopHint | Qt::Dialog);
         dialog->show();
 
     }
 }
 
 void KisLayerManager::convertNodeToPaintLayer(KisNodeSP source)
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisPaintDeviceSP srcDevice =
         source->paintDevice() ? source->projection() : source->original();
 
     if (!srcDevice) return;
 
     KisPaintDeviceSP clone;
 
     if (!(*srcDevice->colorSpace() ==
           *srcDevice->compositionSourceColorSpace())) {
 
         clone = new KisPaintDevice(srcDevice->compositionSourceColorSpace());
 
         QRect rc(srcDevice->extent());
         KisPainter::copyAreaOptimized(rc.topLeft(), srcDevice, clone, rc);
 
     } else {
         clone = new KisPaintDevice(*srcDevice);
     }
 
     KisLayerSP layer = new KisPaintLayer(image,
                                          source->name(),
                                          source->opacity(),
                                          clone);
     layer->setCompositeOp(source->compositeOpId());
 
     KisNodeSP parent = source->parent();
     KisNodeSP above = source;
 
     while (parent && !parent->allowAsChild(layer)) {
         above = above->parent();
         parent = above ? above->parent() : 0;
     }
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a Paint Layer"));
     m_commandsAdapter->addNode(layer, parent, above);
     m_commandsAdapter->removeNode(source);
     m_commandsAdapter->endMacro();
 
 }
 
 void KisLayerManager::adjustLayerPosition(KisNodeSP node, KisNodeSP activeNode, KisNodeSP &parent, KisNodeSP &above)
 {
     Q_ASSERT(activeNode);
 
     parent = activeNode;
     above = parent->lastChild();
 
     while (parent && !parent->allowAsChild(node)) {
         above = parent;
         parent = parent->parent();
     }
 
     if (!parent) {
         qWarning() << "KisLayerManager::adjustLayerPosition:"
                    << "No node accepted newly created node";
 
         parent = m_view->image()->root();
         above = parent->lastChild();
     }
 }
 
 void KisLayerManager::addLayerCommon(KisNodeSP activeNode, KisLayerSP layer)
 {
     KisNodeSP parent;
     KisNodeSP above;
     adjustLayerPosition(layer, activeNode, parent, above);
 
     m_commandsAdapter->addNode(layer, parent, above);
 }
 
 void KisLayerManager::addLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     addLayerCommon(activeNode,
                    new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace()));
 }
 
 void KisLayerManager::addGroupLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     addLayerCommon(activeNode,
                    new KisGroupLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8));
 }
 
 void KisLayerManager::addCloneLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     addLayerCommon(activeNode,
                    new KisCloneLayer(activeLayer(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8));
 }
 
 void KisLayerManager::addShapeLayer(KisNodeSP activeNode)
 {
     if (!m_view) return;
     if (!m_view->document()) return;
 
     KisImageWSP image = m_view->image();
     KisShapeLayerSP layer = new KisShapeLayer(m_view->document()->shapeController(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8);
 
     addLayerCommon(activeNode, layer);
 }
 
 void KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
 
     KisSelectionSP selection = m_view->selection();
     KisAdjustmentLayerSP adjl = addAdjustmentLayer(activeNode, QString(), 0, selection);
     image->refreshGraph();
 
     KisPaintDeviceSP previewDevice = new KisPaintDevice(*adjl->original());
 
     KisDlgAdjustmentLayer dlg(adjl, adjl.data(), previewDevice, image->nextLayerName(), i18n("New Filter Layer"), m_view);
     dlg.resize(dlg.minimumSizeHint());
 
     // ensure that the device may be free'd by the dialog
     // when it is not needed anymore
     previewDevice = 0;
 
     if (dlg.exec() != QDialog::Accepted || adjl->filter().isNull()) {
         // XXX: add messagebox warning if there's no filter set!
         m_commandsAdapter->undoLastCommand();
     } else {
         adjl->setName(dlg.layerName());
     }
 
 }
 
 KisAdjustmentLayerSP KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode, const QString & name,
                                                          KisFilterConfiguration * filter, KisSelectionSP selection)
 {
     KisImageWSP image = m_view->image();
     KisAdjustmentLayerSP layer = new KisAdjustmentLayer(image, name, filter, selection);
     addLayerCommon(activeNode, layer);
 
     return layer;
 }
 
 void KisLayerManager::addGeneratorLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
 
     KisDlgGeneratorLayer dlg(image->nextLayerName(), m_view, m_view->mainWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     if (dlg.exec() == QDialog::Accepted) {
         KisSelectionSP selection = m_view->selection();
         KisFilterConfiguration * generator = dlg.configuration();
         QString name = dlg.layerName();
 
         addLayerCommon(activeNode,
             new KisGeneratorLayer(image, name, generator, selection));
     }
 
 }
 
 void KisLayerManager::layerDuplicate()
 {
     KisImageWSP image = m_view->image();
 
     if (!image)
         return;
 
     KisLayerSP active = activeLayer();
 
     if (!active)
         return;
 
     KisLayerSP dup = dynamic_cast<KisLayer*>(active->clone().data());
     m_commandsAdapter->addNode(dup.data(), active->parent(), active.data());
     if (dup) {
         activateLayer(dup);
     } else {
         QMessageBox::critical(m_view->mainWindow(),
                               i18nc("@title:window", "Krita"),
                               i18n("Could not add layer to image."));
     }
 }
 
 void KisLayerManager::layerRaise()
 {
     KisImageWSP image = m_view->image();
     KisLayerSP layer;
 
     if (!image)
         return;
 
     layer = activeLayer();
 
     m_commandsAdapter->raise(layer);
     layer->parent()->setDirty();
 }
 
 void KisLayerManager::layerLower()
 {
     KisImageWSP image = m_view->image();
     KisLayerSP layer;
 
     if (!image)
         return;
 
     layer = activeLayer();
 
     m_commandsAdapter->lower(layer);
     layer->parent()->setDirty();
 }
 
 void KisLayerManager::layerFront()
 {
     KisImageWSP image = m_view->image();
     KisLayerSP layer;
 
     if (!image)
         return;
 
     layer = activeLayer();
     m_commandsAdapter->toTop(layer);
     layer->parent()->setDirty();
 }
 
 void KisLayerManager::layerBack()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer;
 
     layer = activeLayer();
     m_commandsAdapter->toBottom(layer);
     layer->parent()->setDirty();
 }
 
 void KisLayerManager::rotateLayer(double radians)
 {
     if (!m_view->image()) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     m_view->image()->rotateNode(layer, radians);
 }
 
 void KisLayerManager::shearLayer(double angleX, double angleY)
 {
     if (!m_view->image()) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     m_view->image()->shearNode(layer, angleX, angleY);
 }
 
 void KisLayerManager::flattenImage()
 {
     KisImageWSP image = m_view->image();
 
     if (image) {
         bool doIt = true;
 
         if (image->nHiddenLayers() > 0) {
             int answer = QMessageBox::warning(m_view->mainWindow(),
                                               i18nc("@title:window", "Flatten Image"),
                                               i18n("The image contains hidden layers that will be lost. Do you want to flatten the image?"),
                                               QMessageBox::Yes | QMessageBox::No,
                                               QMessageBox::No);
 
             if (answer != QMessageBox::Yes) {
                 doIt = false;
             }
         }
 
         if (doIt) {
             image->flatten();
         }
     }
 }
 
 void KisLayerManager::mergeLayer()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
-    if (!layer->prevSibling()) return;
-    KisLayer *prevLayer = dynamic_cast<KisLayer*>(layer->prevSibling().data());
-    if (!prevLayer) return;
+    QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
+    if (selectedNodes.size() > 1) {
+        image->mergeMultipleLayers(selectedNodes, layer);
+    } else {
+        if (!layer->prevSibling()) return;
+        KisLayer *prevLayer = dynamic_cast<KisLayer*>(layer->prevSibling().data());
+        if (!prevLayer) return;
 
-    if (layer->metaData()->isEmpty() && prevLayer->metaData()->isEmpty()) {
-        image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
+        if (layer->metaData()->isEmpty() && prevLayer->metaData()->isEmpty()) {
+            image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
+        }
+        else {
+            const KisMetaData::MergeStrategy* strategy = KisMetaDataMergeStrategyChooserWidget::showDialog(m_view->mainWindow());
+            if (!strategy) return;
+            image->mergeDown(layer, strategy);
+        }
     }
-    else {
-        const KisMetaData::MergeStrategy* strategy = KisMetaDataMergeStrategyChooserWidget::showDialog(m_view->mainWindow());
-        if (!strategy) return;
-        image->mergeDown(layer, strategy);
 
-    }
     m_view->updateGUI();
 }
 
 void KisLayerManager::flattenLayer()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     KisLayerSP newLayer = image->flattenLayer(layer);
     if (newLayer) {
         newLayer->setDirty();
     }
     m_view->updateGUI();
 }
 
 void KisLayerManager::rasterizeLayer()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, layer->name(), layer->opacity());
     KisPainter gc(paintLayer->paintDevice());
     QRect rc = layer->projection()->exactBounds();
     gc.bitBlt(rc.topLeft(), layer->projection(), rc);
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Rasterize Layer"));
     m_commandsAdapter->addNode(paintLayer.data(), layer->parent().data(), layer.data());
 
     int childCount = layer->childCount();
     for (int i = 0; i < childCount; i++) {
         m_commandsAdapter->moveNode(layer->firstChild(), paintLayer, paintLayer->lastChild());
     }
     m_commandsAdapter->removeNode(layer);
     m_commandsAdapter->endMacro();
     updateGUI();
 }
 
 
 void KisLayerManager::layersUpdated()
 {
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     m_view->updateGUI();
 }
 
 void KisLayerManager::saveGroupLayers()
 {
     QStringList listMimeFilter = KisImportExportManager::mimeFilter("application/x-krita", KisImportExportManager::Export);
 
     KDialog dlg;
     QWidget *page = new QWidget(&dlg);
     dlg.setMainWidget(page);
     QBoxLayout *layout = new QVBoxLayout(page);
 
     KFileWidget *fd = new KFileWidget(m_view->document()->url().path(), page);
     fd->setUrl(m_view->document()->url());
     fd->setMimeFilter(listMimeFilter);
     fd->setOperationMode(KAbstractFileWidget::Saving);
     layout->addWidget(fd);
 
     QCheckBox *chkInvisible = new QCheckBox(i18n("Convert Invisible Groups"), page);
     chkInvisible->setChecked(false);
     layout->addWidget(chkInvisible);
     QCheckBox *chkDepth = new QCheckBox(i18n("Export Only Toplevel Groups"), page);
     chkDepth->setChecked(true);
     layout->addWidget(chkDepth);
 
     if (!dlg.exec()) return;
 
     // selectedUrl()( does not return the expected result. So, build up the KUrl the more complicated way
     //return m_fileWidget->selectedUrl();
     KUrl url = fd->dirOperator()->url();
     url.adjustPath(KUrl::AddTrailingSlash);
     QString path = fd->locationEdit()->currentText();
     QFileInfo f(path);
     QString extension = f.completeSuffix();
     QString basename = f.baseName();
 
     QString mimefilter = fd->currentMimeFilter();
 
     if (mimefilter.isEmpty()) {
         KMimeType::Ptr mime = KMimeType::findByUrl(url);
         mimefilter = mime->name();
         extension = mime->extractKnownExtension(path);
     }
 
     if (url.isEmpty())
         return;
 
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisSaveGroupVisitor v(image, chkInvisible->isChecked(), chkDepth->isChecked(), url, basename, extension, mimefilter);
     image->rootLayer()->accept(v);
 
 }
 
 bool KisLayerManager::activeLayerHasSelection()
 {
     return (activeLayer()->selection() != 0);
 }
 
 void KisLayerManager::addFileLayer(KisNodeSP activeNode)
 {
 
     QString basePath;
     KUrl url = m_view->document()->url();
     if (url.isLocalFile()) {
         basePath = QFileInfo(url.toLocalFile()).absolutePath();
     }
     KisImageWSP image = m_view->image();
 
     KisDlgFileLayer dlg(basePath, image->nextLayerName(), m_view->mainWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     if (dlg.exec() == QDialog::Accepted) {
         QString name = dlg.layerName();
         QString fileName = dlg.fileName();
 
         if(fileName.isEmpty()){
             QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
             return;
         }
 
         KisFileLayer::ScalingMethod scalingMethod = dlg.scaleToImageResolution();
 
         addLayerCommon(activeNode,
                        new KisFileLayer(image, basePath, fileName, scalingMethod, name, OPACITY_OPAQUE_U8));
     }
 
 }
 
 void updateLayerStyles(KisLayerSP layer, KisDlgLayerStyle *dlg)
 {
     KisSetLayerStyleCommand::updateLayerStyle(layer, dlg->style()->clone());
 }
 
 void KisLayerManager::layerStyle()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     KisPSDLayerStyleSP oldStyle;
     if (layer->layerStyle()) {
         oldStyle = layer->layerStyle()->clone();
     }
     else {
         oldStyle = toQShared(new KisPSDLayerStyle());
     }
 
     KisDlgLayerStyle dlg(oldStyle->clone(), m_view->resourceProvider());
 
     boost::function<void ()> updateCall(boost::bind(updateLayerStyles, layer, &dlg));
     SignalToFunctionProxy proxy(updateCall);
     connect(&dlg, SIGNAL(configChanged()), &proxy, SLOT(start()));
 
     if (dlg.exec() == QDialog::Accepted) {
         KisPSDLayerStyleSP newStyle = dlg.style();
 
         KUndo2CommandSP command = toQShared(
             new KisSetLayerStyleCommand(layer, oldStyle, newStyle));
 
         image->postExecutionUndoAdapter()->addCommand(command);
     }
 }
 
 #include "kis_layer_manager.moc"
 
diff --git a/krita/ui/kis_node_manager.cpp b/krita/ui/kis_node_manager.cpp
index 014ec9755c..d967c1f7f2 100644
--- a/krita/ui/kis_node_manager.cpp
+++ b/krita/ui/kis_node_manager.cpp
@@ -1,1240 +1,1149 @@
 /*
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_node_manager.h"
 
 #include <QDesktopServices>
 #include <QMessageBox>
 
 #include <kactioncollection.h>
 #include <kmimetype.h>
 
 #include <KoIcon.h>
 #include <KoProperties.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoShape.h>
 #include <KoShapeLayer.h>
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KoToolManager.h>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_image.h>
 #include <kis_painter.h>
 #include <kis_paint_layer.h>
 
 #include "KisPart.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_shape_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_mask_manager.h"
 #include "kis_group_layer.h"
 #include "kis_layer_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_processing_applicator.h"
 #include "kis_sequential_iterator.h"
 #include "kis_transaction.h"
 
 #include "processing/kis_mirror_processing_visitor.h"
 #include "KisView.h"
 
 struct KisNodeManager::Private {
 
     Private(KisNodeManager *_q)
         : q(_q)
         , view(0)
         , imageView(0)
         , layerManager(0)
         , maskManager(0)
         , self(0)
         , commandsAdapter(0)
     {
     }
 
     ~Private() {
         delete layerManager;
         delete maskManager;
     }
 
     KisNodeManager *q;
     KisViewManager * view;
     QPointer<KisView>imageView;
     KisLayerManager * layerManager;
     KisMaskManager * maskManager;
     KisNodeManager* self;
     KisNodeCommandsAdapter* commandsAdapter;
-    KisAction *mergeSelectedLayers;
 
     QList<KisNodeSP> selectedNodes;
 
     bool activateNodeImpl(KisNodeSP node);
 
     QSignalMapper nodeCreationSignalMapper;
     QSignalMapper nodeConversionSignalMapper;
 
     void saveDeviceAsImage(KisPaintDeviceSP device,
                            const QString &defaultName,
                            const QRect &bounds,
                            qreal xRes,
                            qreal yRes,
                            quint8 opacity);
 
     void mergeTransparencyMaskAsAlpha(bool writeToLayers);
 };
 
 bool KisNodeManager::Private::activateNodeImpl(KisNodeSP node)
 {
     Q_ASSERT(view);
     Q_ASSERT(view->canvasBase());
     Q_ASSERT(view->canvasBase()->globalShapeManager());
     Q_ASSERT(imageView);
     if (node && node == self->activeNode()) {
         return false;
     }
 
     // Set the selection on the shape manager to the active layer
     // and set call KoSelection::setActiveLayer( KoShapeLayer* layer )
     // with the parent of the active layer.
     KoSelection *selection = view->canvasBase()->globalShapeManager()->selection();
     Q_ASSERT(selection);
     selection->deselectAll();
 
     if (!node) {
         selection->setActiveLayer(0);
         imageView->setCurrentNode(0);
         maskManager->activateMask(0);
         layerManager->activateLayer(0);
     } else {
 
         KoShape * shape = view->document()->shapeForNode(node);
         Q_ASSERT(shape);
 
         selection->select(shape);
         KoShapeLayer * shapeLayer = dynamic_cast<KoShapeLayer*>(shape);
 
         Q_ASSERT(shapeLayer);
 //         shapeLayer->setGeometryProtected(node->userLocked());
 //         shapeLayer->setVisible(node->visible());
         selection->setActiveLayer(shapeLayer);
 
         imageView->setCurrentNode(node);
         if (KisLayerSP layer = dynamic_cast<KisLayer*>(node.data())) {
             maskManager->activateMask(0);
             layerManager->activateLayer(layer);
         } else if (KisMaskSP mask = dynamic_cast<KisMask*>(node.data())) {
             maskManager->activateMask(mask);
             // XXX_NODE: for now, masks cannot be nested.
             layerManager->activateLayer(static_cast<KisLayer*>(node->parent().data()));
         }
 
     }
     return true;
 }
 
 KisNodeManager::KisNodeManager(KisViewManager *view)
     : m_d(new Private(this))
 {
     m_d->view = view;
     m_d->layerManager = new KisLayerManager(view);
     m_d->maskManager = new KisMaskManager(view);
     m_d->self = this;
     m_d->commandsAdapter = new KisNodeCommandsAdapter(view);
 
     connect(m_d->layerManager, SIGNAL(sigLayerActivated(KisLayerSP)), SIGNAL(sigLayerActivated(KisLayerSP)));
-
-    m_d->mergeSelectedLayers = new KisAction(i18n("&Merge Selected Layers"), this);
-    m_d->mergeSelectedLayers->setActivationFlags(KisAction::ACTIVE_LAYER);
-    view->actionManager()->addAction("merge_selected_layers", m_d->mergeSelectedLayers);
-    m_d->mergeSelectedLayers->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_E));
-    connect(m_d->mergeSelectedLayers, SIGNAL(triggered()), this, SLOT(mergeLayerDown()));
-
 }
 
 KisNodeManager::~KisNodeManager()
 {
     delete m_d->commandsAdapter;
     delete m_d;
 }
 
 void KisNodeManager::setView(QPointer<KisView>imageView)
 {
     m_d->maskManager->setView(imageView);
     m_d->layerManager->setView(imageView);
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         shapeController->disconnect(SIGNAL(sigActivateNode(KisNodeSP)), this);
         m_d->imageView->image()->disconnect(this);
     }
 
     m_d->imageView = imageView;
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         connect(shapeController, SIGNAL(sigActivateNode(KisNodeSP)), SLOT(slotNonUiActivatedNode(KisNodeSP)));
         connect(m_d->imageView->image(), SIGNAL(sigIsolatedModeChanged()),this, SLOT(slotUpdateIsolateModeAction()));
         m_d->imageView->resourceProvider()->slotNodeActivated(m_d->imageView->currentNode());
     }
 
 }
 
 #define NEW_LAYER_ACTION(id, text, layerType, icon)                     \
     {                                                                   \
         action = new KisAction(icon, text, this);                       \
         action->setActivationFlags(KisAction::ACTIVE_NODE);             \
         actionManager->addAction(id, action);                           \
         m_d->nodeCreationSignalMapper.setMapping(action, layerType);    \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeCreationSignalMapper, SLOT(map()));           \
     }
 
 #define NEW_LAYER_ACTION_KEY(id, text, layerType, icon, shortcut)       \
     {                                                                   \
         NEW_LAYER_ACTION(id, text, layerType, icon);                    \
         action->setShortcut(KShortcut(shortcut));                       \
     }
 
 #define NEW_MASK_ACTION(id, text, layerType, icon)                      \
     {                                                                   \
         NEW_LAYER_ACTION(id, text, layerType, icon);                    \
         action->setActivationFlags(KisAction::ACTIVE_LAYER);            \
     }
 
 #define CONVERT_NODE_ACTION(id, text, layerType, icon)                  \
     {                                                                   \
         action = new KisAction(icon, text, this);                       \
         action->setActivationFlags(KisAction::ACTIVE_NODE);             \
         action->setExcludedNodeTypes(QStringList(layerType));           \
         actionManager->addAction(id, action);         \
         m_d->nodeConversionSignalMapper.setMapping(action, layerType);  \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeConversionSignalMapper, SLOT(map()));         \
     }
 
 void KisNodeManager::setup(KActionCollection * actionCollection, KisActionManager* actionManager)
 {
     m_d->layerManager->setup(actionManager);
     m_d->maskManager->setup(actionCollection, actionManager);
 
     KisAction * action  = new KisAction(koIcon("object-flip-horizontal"), i18n("Mirror Layer Horizontally"), this);
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     actionManager->addAction("mirrorNodeX", action);
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeX()));
 
     action  = new KisAction(koIcon("object-flip-vertical"), i18n("Mirror Layer Vertically"), this);
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     actionManager->addAction("mirrorNodeY", action);
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeY()));
 
     action = new KisAction(i18n("Activate next layer"), this);
     action->setActivationFlags(KisAction::ACTIVE_LAYER);
     action->setShortcut(KShortcut(Qt::Key_PageUp));
     actionManager->addAction("activateNextLayer", action);
     connect(action, SIGNAL(triggered()), this, SLOT(activateNextNode()));
 
     action = new KisAction(i18n("Activate previous layer"), this);
     action->setActivationFlags(KisAction::ACTIVE_LAYER);
     action->setShortcut(KShortcut(Qt::Key_PageDown));
     actionManager->addAction("activatePreviousLayer", action);
     connect(action, SIGNAL(triggered()), this, SLOT(activatePreviousNode()));
 
     action  = new KisAction(koIcon("document-save"), i18n("Save Layer/Mask..."), this);
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     actionManager->addAction("save_node_as_image", action);
     connect(action, SIGNAL(triggered()), this, SLOT(saveNodeAsImage()));
 
     action = new KisAction(koIcon("edit-copy"), i18n("&Duplicate Layer or Mask"), this);
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     action->setShortcut(KShortcut(Qt::ControlModifier + Qt::Key_J));
     actionManager->addAction("duplicatelayer", action);
     connect(action, SIGNAL(triggered()), this, SLOT(duplicateActiveNode()));
 
 
     NEW_LAYER_ACTION_KEY("add_new_paint_layer", i18n("&Paint Layer"),
                          "KisPaintLayer", koIcon("document-new"),
                          Qt::Key_Insert);
 
     NEW_LAYER_ACTION_KEY("add_new_group_layer", i18n("&Group Layer"),
                      "KisGroupLayer", koIcon("folder-new"),
                      Qt::ControlModifier + Qt::Key_G);
 
     NEW_LAYER_ACTION("add_new_clone_layer", i18n("&Clone Layer"),
                      "KisCloneLayer", koIcon("edit-copy"));
 
     NEW_LAYER_ACTION("add_new_shape_layer", i18n("&Vector Layer"),
                      "KisShapeLayer", koIcon("bookmark-new"));
 
     NEW_LAYER_ACTION("add_new_adjustment_layer", i18n("&Filter Layer..."),
                      "KisAdjustmentLayer", koIcon("view-filter"));
 
     NEW_LAYER_ACTION("add_new_fill_layer", i18n("&Fill Layer..."),
                      "KisGeneratorLayer", koIcon("krita_tool_color_fill"));
 
     NEW_LAYER_ACTION("add_new_file_layer", i18n("&File Layer..."),
                      "KisFileLayer", koIcon("document-open"));
 
     NEW_MASK_ACTION("add_new_transparency_mask", i18n("&Transparency Mask"),
                     "KisTransparencyMask", koIcon("edit-copy"));
 
     NEW_MASK_ACTION("add_new_filter_mask", i18n("&Filter Mask..."),
                     "KisFilterMask", koIcon("bookmarks"));
 
     NEW_MASK_ACTION("add_new_transform_mask", i18n("&Transform Mask..."),
                     "KisTransformMask", koIcon("bookmarks"));
 
     NEW_MASK_ACTION("add_new_selection_mask", i18n("&Local Selection"),
                     "KisSelectionMask", koIcon("edit-paste"));
 
     connect(&m_d->nodeCreationSignalMapper, SIGNAL(mapped(const QString &)),
             this, SLOT(createNode(const QString &)));
 
     CONVERT_NODE_ACTION("convert_to_paint_layer", i18n("to &Paint Layer"),
                         "KisPaintLayer", koIcon("document-new"));
 
     CONVERT_NODE_ACTION("convert_to_selection_mask", i18n("to &Selection Mask"),
                         "KisSelectionMask", koIcon("edit-paste"));
 
     CONVERT_NODE_ACTION("convert_to_filter_mask", i18n("to &Filter Mask..."),
                         "KisFilterMask", koIcon("bookmarks"));
 
     CONVERT_NODE_ACTION("convert_to_transparency_mask", i18n("to &Transparency Mask"),
                         "KisTransparencyMask", koIcon("edit-copy"));
 
     connect(&m_d->nodeConversionSignalMapper, SIGNAL(mapped(const QString &)),
             this, SLOT(convertNode(const QString &)));
 
     action = new KisAction(koIcon("view-filter"), i18n("&Isolate Layer"), this);
     action->setCheckable(true);
     action->setActivationFlags(KisAction::ACTIVE_NODE);
     actionManager->addAction("isolate_layer", action);
     connect(action, SIGNAL(triggered(bool)), this, SLOT(toggleIsolateMode(bool)));
 
     action  = new KisAction(koIcon("edit-copy"), i18n("Alpha into Mask"), this);
     action->setActivationFlags(KisAction::ACTIVE_LAYER);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE_PAINT_DEVICE);
     actionManager->addAction("split_alpha_into_mask", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaIntoMask()));
 
     action  = new KisAction(koIcon("transparency-enabled"), i18n("Write as Alpha"), this);
     action->setActivationFlags(KisAction::ACTIVE_TRANSPARENCY_MASK);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     actionManager->addAction("split_alpha_write", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaWrite()));
 
     action  = new KisAction(koIcon("document-save"), i18n("Save Merged..."), this);
     action->setActivationFlags(KisAction::ACTIVE_TRANSPARENCY_MASK);
     // HINT: we can save even when the nodes are not editable
     actionManager->addAction("split_alpha_save_merged", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaSaveMerged()));
 
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotUpdateIsolateModeAction()));
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotTryFinishIsolatedMode()));
 }
 
 void KisNodeManager::updateGUI()
 {
     // enable/disable all relevant actions
     m_d->layerManager->updateGUI();
     m_d->maskManager->updateGUI();
 
 }
 
 
 KisNodeSP KisNodeManager::activeNode()
 {
     if (m_d->imageView) {
         return m_d->imageView->currentNode();
     }
     return 0;
 }
 
 KisLayerSP KisNodeManager::activeLayer()
 {
     return m_d->layerManager->activeLayer();
 }
 
 const KoColorSpace* KisNodeManager::activeColorSpace()
 {
     Q_ASSERT(m_d->maskManager);
 
     if (m_d->maskManager->activeDevice()) {
 //        Q_ASSERT(m_d->maskManager->activeDevice());
         return m_d->maskManager->activeDevice()->colorSpace();
     } else {
         Q_ASSERT(m_d->layerManager);
         Q_ASSERT(m_d->layerManager->activeLayer());
         if (m_d->layerManager->activeLayer()->parentLayer())
             return m_d->layerManager->activeLayer()->parentLayer()->colorSpace();
         else
             return m_d->view->image()->colorSpace();
     }
 }
 
 void KisNodeManager::moveNodeAt(KisNodeSP node, KisNodeSP parent, int index)
 {
     if (parent->allowAsChild(node)) {
         if (node->inherits("KisSelectionMask") && parent->inherits("KisLayer")) {
             KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data());
             KisLayer *l = dynamic_cast<KisLayer*>(parent.data());
             KisSelectionMaskSP selMask = l->selectionMask();
             if (m && m->active() && l && l->selectionMask())
                 selMask->setActive(false);
         }
         m_d->commandsAdapter->moveNode(node, parent, index);
     }
 }
 
 void KisNodeManager::addNodeDirect(KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis)
 {
     Q_ASSERT(parent->allowAsChild(node));
     m_d->commandsAdapter->addNode(node, parent, aboveThis);
 }
 
 void KisNodeManager::moveNodeDirect(KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis)
 {
     Q_ASSERT(parent->allowAsChild(node));
     m_d->commandsAdapter->moveNode(node, parent, aboveThis);
 }
 
 void KisNodeManager::toggleIsolateActiveNode()
 {
     KisImageWSP image = m_d->view->image();
     KisNodeSP activeNode = this->activeNode();
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     if (activeNode == image->isolatedModeRoot()) {
         toggleIsolateMode(false);
     } else {
         toggleIsolateMode(true);
     }
 }
 
 void KisNodeManager::toggleIsolateMode(bool checked)
 {
     KisImageWSP image = m_d->view->image();
 
     if (checked) {
         KisNodeSP activeNode = this->activeNode();
         // Transform masks don't have pixel data...
         if (activeNode->inherits("KisTransformMask")) return;
         KIS_ASSERT_RECOVER_RETURN(activeNode);
 
         image->startIsolatedMode(activeNode);
     } else {
         image->stopIsolatedMode();
     }
 }
 
 void KisNodeManager::slotUpdateIsolateModeAction()
 {
     KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
     Q_ASSERT(action);
 
     KisNodeSP activeNode = this->activeNode();
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
 
     action->setChecked(isolatedRootNode && isolatedRootNode == activeNode);
 }
 
 void KisNodeManager::slotTryFinishIsolatedMode()
 {
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (!isolatedRootNode) return;
 
     bool belongsToIsolatedGroup = false;
 
     KisNodeSP node = this->activeNode();
     while(node) {
         if (node == isolatedRootNode) {
             belongsToIsolatedGroup = true;
             break;
         }
         node = node->parent();
     }
 
     if (!belongsToIsolatedGroup) {
         m_d->view->image()->stopIsolatedMode();
     }
 }
 
 void KisNodeManager::createNode(const QString & nodeType, bool quiet, KisPaintDeviceSP copyFrom)
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     KIS_ASSERT_RECOVER_RETURN(activeNode);
     if (activeNode->systemLocked()) {
         return;
     }
 
     // XXX: make factories for this kind of stuff,
     //      with a registry
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager->addLayer(activeNode);
     } else if (nodeType == "KisGroupLayer") {
         m_d->layerManager->addGroupLayer(activeNode);
     } else if (nodeType == "KisAdjustmentLayer") {
         m_d->layerManager->addAdjustmentLayer(activeNode);
     } else if (nodeType == "KisGeneratorLayer") {
         m_d->layerManager->addGeneratorLayer(activeNode);
     } else if (nodeType == "KisShapeLayer") {
         m_d->layerManager->addShapeLayer(activeNode);
     } else if (nodeType == "KisCloneLayer") {
         m_d->layerManager->addCloneLayer(activeNode);
     } else if (nodeType == "KisTransparencyMask") {
         m_d->maskManager->createTransparencyMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFilterMask") {
         m_d->maskManager->createFilterMask(activeNode, copyFrom, quiet, false);
     } else if (nodeType == "KisTransformMask") {
         m_d->maskManager->createTransformMask(activeNode);
     } else if (nodeType == "KisSelectionMask") {
         m_d->maskManager->createSelectionMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFileLayer") {
         m_d->layerManager->addFileLayer(activeNode);
     }
 
 }
 
 void KisNodeManager::convertNode(const QString &nodeType)
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager->convertNodeToPaintLayer(activeNode);
     } else if (nodeType == "KisSelectionMask" ||
                nodeType == "KisFilterMask" ||
                nodeType == "KisTransparencyMask") {
 
         KisPaintDeviceSP copyFrom = activeNode->paintDevice() ?
             activeNode->paintDevice() : activeNode->projection();
 
         m_d->commandsAdapter->beginMacro(kundo2_i18n("Convert to a Selection Mask"));
 
         if (nodeType == "KisSelectionMask") {
             m_d->maskManager->createSelectionMask(activeNode, copyFrom, true);
         } else if (nodeType == "KisFilterMask") {
             m_d->maskManager->createFilterMask(activeNode, copyFrom, false, true);
         } else if (nodeType == "KisTransparencyMask") {
             m_d->maskManager->createTransparencyMask(activeNode, copyFrom, true);
         }
 
         m_d->commandsAdapter->removeNode(activeNode);
         m_d->commandsAdapter->endMacro();
 
     } else {
         qWarning() << "Unsupported node conversion type:" << nodeType;
     }
 }
 
 void KisNodeManager::slotNonUiActivatedNode(KisNodeSP node)
 {
     if (m_d->activateNodeImpl(node)) {
         emit sigUiNeedChangeActiveNode(node);
         emit sigNodeActivated(node);
         nodesUpdated();
         if (node) {
             bool toggled =  m_d->view->actionCollection()->action("view_show_just_the_canvas")->isChecked();
             if (toggled) {
                 m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
             }
         }
     }
 }
 
 void KisNodeManager::slotUiActivatedNode(KisNodeSP node)
 {
     if (m_d->activateNodeImpl(node)) {
         emit sigNodeActivated(node);
         nodesUpdated();
     }
 
     if (node) {
         QStringList vectorTools = QStringList()
                 << "InteractionTool"
                 << "KarbonPatternTool"
                 << "KarbonGradientTool"
                 << "KarbonCalligraphyTool"
                 << "CreateShapesTool"
                 << "PathToolFactoryId";
 
         QStringList pixelTools = QStringList()
                 << "KritaShape/KisToolBrush"
                 << "KritaShape/KisToolDyna"
                 << "KritaShape/KisToolMultiBrush"
                 << "KritaFill/KisToolFill"
                 << "KritaFill/KisToolGradient";
 
         if (node->inherits("KisShapeLayer")) {
             if (pixelTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("InteractionTool");
             }
         }
         else {
             if (vectorTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
             }
         }
     }
 }
 
 void KisNodeManager::nodesUpdated()
 {
     KisNodeSP node = activeNode();
     if (!node) return;
 
     m_d->layerManager->layersUpdated();
     m_d->maskManager->masksUpdated();
 
     m_d->view->updateGUI();
     m_d->view->selectionManager()->selectionChanged();
 
 }
 
 KisPaintDeviceSP KisNodeManager::activePaintDevice()
 {
     return m_d->maskManager->activeMask() ?
         m_d->maskManager->activeDevice() :
         m_d->layerManager->activeDevice();
 }
 
 void KisNodeManager::nodeProperties(KisNodeSP node)
 {
     if (node->inherits("KisLayer")) {
         m_d->layerManager->layerProperties();
     } else if (node->inherits("KisMask")) {
         m_d->maskManager->maskProperties();
     }
 }
 
 qint32 KisNodeManager::convertOpacityToInt(qreal opacity)
 {
     /**
      * Scales opacity from the range 0...100
      * to the integer range 0...255
      */
 
     return qMin(255, int(opacity * 2.55 + 0.5));
 }
 
 void KisNodeManager::setNodeOpacity(KisNodeSP node, qint32 opacity,
                                     bool finalChange)
 {
     if (!node) return;
     if (node->opacity() == opacity) return;
 
     if (!finalChange) {
         node->setOpacity(opacity);
         node->setDirty();
     } else {
         m_d->commandsAdapter->setOpacity(node, opacity);
     }
 }
 
 void KisNodeManager::setNodeCompositeOp(KisNodeSP node,
                                         const KoCompositeOp* compositeOp)
 {
     if (!node) return;
     if (node->compositeOp() == compositeOp) return;
 
     m_d->commandsAdapter->setCompositeOp(node, compositeOp);
 }
 
 void KisNodeManager::setSelectedNodes(QList<KisNodeSP> nodes)
 {
     m_d->selectedNodes = nodes;
 }
 
 QList<KisNodeSP> KisNodeManager::selectedNodes()
 {
     return m_d->selectedNodes;
 }
 
 void KisNodeManager::nodeOpacityChanged(qreal opacity, bool finalChange)
 {
     KisNodeSP node = activeNode();
 
     setNodeOpacity(node, convertOpacityToInt(opacity), finalChange);
 }
 
 void KisNodeManager::nodeCompositeOpChanged(const KoCompositeOp* op)
 {
     KisNodeSP node = activeNode();
 
     setNodeCompositeOp(node, op);
 }
 
 void KisNodeManager::duplicateActiveNode()
 {
     KisNodeSP node = activeNode();
 
     // FIXME: can't imagine how it may happen
     Q_ASSERT(node);
 
     if (node->inherits("KisLayer")) {
         m_d->layerManager->layerDuplicate();
     } else if (node->inherits("KisMask")) {
         m_d->maskManager->duplicateMask();
     }
 }
 
 void KisNodeManager::raiseNode()
 {
     // The user sees the layer stack topsy-turvy, as a tree with the
     // root at the bottom instead of on top.
     KisNodeSP node = activeNode();
     if (node->inherits("KisLayer")) {
         m_d->layerManager->layerLower();
     } else if (node->inherits("KisMask")) {
         m_d->maskManager->lowerMask();
     }
 }
 
 void KisNodeManager::lowerNode()
 {
     // The user sees the layer stack topsy-turvy, as a tree with the
     // root at the bottom instead of on top.
     KisNodeSP node = activeNode();
 
     if (node->inherits("KisLayer")) {
         m_d->layerManager->layerRaise();
     } else if (node->inherits("KisMask")) {
         m_d->maskManager->raiseMask();
     }
 }
 
 void KisNodeManager::nodeToTop()
 {
     KisNodeSP node = activeNode();
     if (node->inherits("KisLayer")) {
         m_d->layerManager->layerBack();
     } else if (node->inherits("KisMask")) {
         m_d->maskManager->maskToBottom();
     }
 
 }
 
 void KisNodeManager::nodeToBottom()
 {
     KisNodeSP node = activeNode();
     if (node->inherits("KisLayer")) {
         m_d->layerManager->layerLower();
     } else if (node->inherits("KisMask")) {
         m_d->maskManager->maskToTop();
     }
 }
 
 bool scanForLastLayer(KisImageWSP image, KisNodeSP nodeToRemove)
 {
     if (!dynamic_cast<KisLayer*>(nodeToRemove.data())) {
         return false;
     }
 
     bool lastLayer = true;
     KisNodeSP node = image->root()->firstChild();
     while (node) {
         if (node != nodeToRemove && dynamic_cast<KisLayer*>(node.data())) {
             lastLayer = false;
             break;
         }
         node = node->nextSibling();
     }
 
     return lastLayer;
 }
 
 /// Scan whether the node has a parent in the list of nodes
 bool scanForParent(QList<KisNodeSP> nodeList, KisNodeSP node)
 {
     KisNodeSP parent = node->parent();
 
     while (parent) {
         if (nodeList.contains(parent)) {
             return true;
         }
         parent = parent->parent();
     }
     return false;
 }
 
 void KisNodeManager::removeSingleNode(KisNodeSP node)
 {
     if (!node || !node->parent()) {
         return;
     }
 
     if (scanForLastLayer(m_d->view->image(), node)) {
         m_d->commandsAdapter->beginMacro(kundo2_i18n("Remove Last Layer"));
         m_d->commandsAdapter->removeNode(node);
         // An oddity, but this is required as for some reason, we can end up in a situation
         // where our active node is still set to one of the layers removed above.
         activeNode().clear();
         createNode("KisPaintLayer");
         m_d->commandsAdapter->endMacro();
     } else {
         m_d->commandsAdapter->removeNode(node);
     }
 }
 
 void KisNodeManager::removeSelectedNodes(QList<KisNodeSP> selectedNodes)
 {
     m_d->commandsAdapter->beginMacro(kundo2_i18n("Remove Multiple Layers and Masks"));
     foreach(KisNodeSP node, selectedNodes) {
         if (!scanForParent(selectedNodes, node)) {
             removeSingleNode(node);
         }
     }
     m_d->commandsAdapter->endMacro();
 }
 
 void KisNodeManager::removeNode()
 {
     //do not delete root layer
     if (m_d->selectedNodes.count() > 1) {
         removeSelectedNodes(m_d->selectedNodes);
     }
     else {
         removeSingleNode(activeNode());
     }
 
 
 }
 
 void KisNodeManager::mirrorNodeX()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer X");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask X");
     }
     mirrorNode(node, commandName, Qt::Horizontal);
 }
 
 void KisNodeManager::mirrorNodeY()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer Y");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask Y");
     }
     mirrorNode(node, commandName, Qt::Vertical);
 }
 
 inline bool checkForGlobalSelection(KisNodeSP node) {
     return dynamic_cast<KisSelectionMask*>(node.data()) && node->parent() && !node->parent()->parent();
 }
 
 void KisNodeManager::activateNextNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node = activeNode->nextSibling();
 
     if (!node && activeNode->parent() && activeNode->parent()->parent()) {
         node = activeNode->parent();
     }
 
     while(node && checkForGlobalSelection(node)) {
         node = node->nextSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::activatePreviousNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node = activeNode->prevSibling();
 
     if (!node && activeNode->parent()) {
         node = activeNode->parent()->prevSibling();
     }
 
     while(node && checkForGlobalSelection(node)) {
         node = node->prevSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
-QList<KisNodeSP> hideLayers(KisNodeSP root, QList<KisNodeSP> selectedNodes)
+void KisNodeManager::mergeLayer()
 {
-    QList<KisNodeSP> alreadyHidden;
-
-    foreach(KisNodeSP node, root->childNodes(QStringList(), KoProperties())) {
-        if (!selectedNodes.contains(node)) {
-            if (node->visible()) {
-                node->setVisible(false);
-            }
-            else {
-                alreadyHidden << node;
-            }
-        }
-        if (node->childCount() > 0) {
-            hideLayers(node, selectedNodes);
-        }
-    }
-
-    return alreadyHidden;
-}
-
-void showNodes(KisNodeSP root, QList<KisNodeSP> keepHiddenNodes)
-{
-    foreach(KisNodeSP node, root->childNodes(QStringList(), KoProperties())) {
-        if (!keepHiddenNodes.contains(node)) {
-            node->setVisible(true);
-        }
-        if (node->childCount() > 0) {
-            showNodes(node, keepHiddenNodes);
-        }
-    }
-}
-
-void KisNodeManager::mergeLayerDown()
-{
-    if (m_d->selectedNodes.size() > 1) {
-
-        QList<KisNodeSP> selectedNodes = m_d->selectedNodes;
-        KisLayerSP l = activeLayer();
-
-        // hide every layer that's not in the list of selected nodes
-        QList<KisNodeSP> alreadyHiddenNodes = hideLayers(m_d->imageView->image()->root(), selectedNodes);
-
-        // render and copy the projection
-        m_d->imageView->image()->refreshGraph();
-        m_d->imageView->image()->waitForDone();
-
-        // Copy the projections
-        KisPaintDeviceSP dev = new KisPaintDevice(*m_d->imageView->image()->projection().data());
-        // place the projection in a layer
-        KisPaintLayerSP flattenLayer = new KisPaintLayer(m_d->imageView->image(), i18n("Merged"), OPACITY_OPAQUE_U8, dev);
-
-        // start a big macro
-        m_d->commandsAdapter->beginMacro(kundo2_i18n("Merge Selected Nodes"));
-
-        // Add the new merged node on top of the active node -- checking whether the parent is in the selection
-        KisNodeSP parent = l->parent();
-        while (selectedNodes.contains(parent)) {
-            parent = parent->parent();
-        }
-        if (parent == l->parent()) {
-            m_d->commandsAdapter->addNode(flattenLayer, parent, l);
-        }
-        else {
-            m_d->commandsAdapter->addNode(flattenLayer, parent, parent->lastChild());
-        }
-
-        // remove all nodes in the selection but the active node
-        removeSelectedNodes(selectedNodes);
-
-        m_d->commandsAdapter->endMacro();
-
-        // And unhide
-        showNodes(m_d->imageView->image()->root(), alreadyHiddenNodes);
-
-        m_d->imageView->image()->refreshGraph();
-        m_d->imageView->image()->waitForDone();
-        m_d->imageView->image()->notifyLayersChanged();
-        m_d->imageView->image()->setModified();
-
-        slotNonUiActivatedNode(flattenLayer);
-
-    }
-    else {
-        m_d->layerManager->mergeLayer();
-    }
+    m_d->layerManager->mergeLayer();
 }
 
 void KisNodeManager::rotate(double radians)
 {
     // XXX: implement rotation for masks as well
     m_d->layerManager->rotateLayer(radians);
 
 }
 
 
 void KisNodeManager::rotate180()
 {
     rotate(M_PI);
 }
 
 void KisNodeManager::rotateLeft90()
 {
    rotate(-M_PI / 2);
 }
 
 void KisNodeManager::rotateRight90()
 {
     rotate(M_PI / 2);
 }
 
 void KisNodeManager::shear(double angleX, double angleY)
 {
     // XXX: implement shear for masks as well
     m_d->layerManager->shearLayer(angleX, angleY);
 }
 
 void KisNodeManager::scale(double sx, double sy, KisFilterStrategy *filterStrategy)
 {
     KisNodeSP node = activeNode();
     KIS_ASSERT_RECOVER_RETURN(node);
 
     m_d->view->image()->scaleNode(node, sx, sy, filterStrategy);
 
     nodesUpdated();
 }
 
 void KisNodeManager::mirrorNode(KisNodeSP node, const KUndo2MagicString& actionName, Qt::Orientation orientation)
 {
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(m_d->view->image(), node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisMirrorProcessingVisitor(m_d->view->image()->bounds(), orientation);
 
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 
     nodesUpdated();
 }
 
 void KisNodeManager::Private::saveDeviceAsImage(KisPaintDeviceSP device,
                                                 const QString &defaultName,
                                                 const QRect &bounds,
                                                 qreal xRes,
                                                 qreal yRes,
                                                 quint8 opacity)
 {
     KoFileDialog dialog(view->mainWindow(), KoFileDialog::SaveFile, "krita/savenodeasimage");
     dialog.setCaption(i18n("Export \"%1\"", defaultName));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter("application/x-krita", KisImportExportManager::Export));
     QString filename = dialog.url();
 
     if (filename.isEmpty()) return;
 
     KUrl url = KUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     KMimeType::Ptr mime = KMimeType::findByUrl(url);
     QString mimefilter = mime->name();
 
     QScopedPointer<KisDocument> d(KisPart::instance()->createDocument());
     d->prepareForImport();
 
     KisImageSP dst = new KisImage(d->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   device->compositionSourceColorSpace(),
                                   defaultName);
     dst->setResolution(xRes, yRes);
     d->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", opacity);
     paintLayer->paintDevice()->makeCloneFrom(device, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
     dst->initialRefreshGraph();
 
     d->setOutputMimeType(mimefilter.toLatin1());
     d->exportDocument(url);
 }
 
 void KisNodeManager::saveNodeAsImage()
 {
     KisNodeSP node = activeNode();
 
     if (!node) {
         qWarning() << "BUG: Save Node As Image was called without any node selected";
         return;
     }
 
     KisImageWSP image = m_d->view->image();
     QRect saveRect = image->bounds() | node->exactBounds();
 
     KisPaintDeviceSP device = node->paintDevice();
     if (!device) {
         device = node->projection();
     }
 
     m_d->saveDeviceAsImage(device, node->name(),
                            saveRect,
                            image->xRes(), image->yRes(),
                            node->opacity());
 }
 
 void KisNodeManager::slotSplitAlphaIntoMask()
 {
     KisNodeSP node = activeNode();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->hasEditablePaintDevice());
 
     KisPaintDeviceSP srcDevice = node->paintDevice();
     const KoColorSpace *srcCS = srcDevice->colorSpace();
     const QRect processRect =
         srcDevice->exactBounds() |
         srcDevice->defaultBounds()->bounds();
 
     KisPaintDeviceSP selectionDevice =
         new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
     m_d->commandsAdapter->beginMacro(kundo2_i18n("Split Alpha into a Mask"));
     KisTransaction transaction(kundo2_noi18n("__split_alpha_channel__"), srcDevice);
 
     KisSequentialIterator srcIt(srcDevice, processRect);
     KisSequentialIterator dstIt(selectionDevice, processRect);
 
     do {
         quint8 *srcPtr = srcIt.rawData();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->opacityU8(srcPtr);
         srcCS->setOpacity(srcPtr, OPACITY_OPAQUE_U8, 1);
     } while (srcIt.nextPixel() && dstIt.nextPixel());
 
     m_d->commandsAdapter->addExtraCommand(transaction.endAndTake());
 
     createNode("KisTransparencyMask", false, selectionDevice);
     m_d->commandsAdapter->endMacro();
 }
 
 void KisNodeManager::Private::mergeTransparencyMaskAsAlpha(bool writeToLayers)
 {
     KisNodeSP node = q->activeNode();
     KisNodeSP parentNode = node->parent();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->inherits("KisTransparencyMask"));
 
     if (writeToLayers && !parentNode->hasEditablePaintDevice()) {
         QMessageBox::information(view->mainWindow(),
                                  i18nc("@title:window", "Layer %1 is not editable").arg(parentNode->name()),
                                  i18n("Cannot write alpha channel of "
                                       "the parent layer \"%1\".\n"
                                       "The operation will be cancelled.").arg(parentNode->name()));
         return;
     }
 
     KisPaintDeviceSP dstDevice;
     if (writeToLayers) {
         KIS_ASSERT_RECOVER_RETURN(parentNode->paintDevice());
         dstDevice = parentNode->paintDevice();
     } else {
         KisPaintDeviceSP copyDevice = parentNode->paintDevice();
         if (!copyDevice) {
             copyDevice = parentNode->original();
         }
         dstDevice = new KisPaintDevice(*copyDevice);
     }
 
     const KoColorSpace *dstCS = dstDevice->colorSpace();
 
     KisPaintDeviceSP selectionDevice = node->paintDevice();
     KIS_ASSERT_RECOVER_RETURN(selectionDevice->colorSpace()->pixelSize() == 1);
 
     const QRect processRect =
         selectionDevice->exactBounds() |
         dstDevice->exactBounds() |
         selectionDevice->defaultBounds()->bounds();
 
     QScopedPointer<KisTransaction> transaction;
 
     if (writeToLayers) {
         commandsAdapter->beginMacro(kundo2_i18n("Write Alpha into a Layer"));
         transaction.reset(new KisTransaction(kundo2_noi18n("__write_alpha_channel__"), dstDevice));
     }
 
     KisSequentialIterator srcIt(selectionDevice, processRect);
     KisSequentialIterator dstIt(dstDevice, processRect);
 
     do {
         quint8 *alpha8Ptr = srcIt.rawData();
         quint8 *dstPtr = dstIt.rawData();
 
         dstCS->setOpacity(dstPtr, *alpha8Ptr, 1);
     } while (srcIt.nextPixel() && dstIt.nextPixel());
 
     if (writeToLayers) {
         commandsAdapter->addExtraCommand(transaction->endAndTake());
         commandsAdapter->removeNode(node);
         commandsAdapter->endMacro();
     } else {
         KisImageWSP image = view->image();
         QRect saveRect = image->bounds();
 
         saveDeviceAsImage(dstDevice, parentNode->name(),
                           saveRect,
                           image->xRes(), image->yRes(),
                           OPACITY_OPAQUE_U8);
     }
 }
 
 
 void KisNodeManager::slotSplitAlphaWrite()
 {
     m_d->mergeTransparencyMaskAsAlpha(true);
 }
 
 void KisNodeManager::slotSplitAlphaSaveMerged()
 {
     m_d->mergeTransparencyMaskAsAlpha(false);
 }
 
 
 #include "kis_node_manager.moc"
 
diff --git a/krita/ui/kis_node_manager.h b/krita/ui/kis_node_manager.h
index 196223c06d..cf345661d9 100644
--- a/krita/ui/kis_node_manager.h
+++ b/krita/ui/kis_node_manager.h
@@ -1,224 +1,224 @@
 /*
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_NODE_MANAGER
 #define KIS_NODE_MANAGER
 
 #include <QObject>
 #include <QList>
 
 #include "kis_types.h"
 #include <krita_export.h>
 
 class KActionCollection;
 
 class KoCompositeOp;
 class KoColorSpace;
 class KUndo2MagicString;
 
 class KisFilterStrategy;
 class KisViewManager;
 class KisActionManager;
 class KisView;
 
 /**
  * The node manager passes requests for new layers or masks on to the mask and layer
  * managers.
  */
 class KRITAUI_EXPORT KisNodeManager : public QObject
 {
 
     Q_OBJECT
 
 public:
 
     KisNodeManager(KisViewManager * view);
     ~KisNodeManager();
     
     void setView(QPointer<KisView>imageView);
 
 Q_SIGNALS:
 
     /// emitted whenever a node is selected.
     void sigNodeActivated(KisNodeSP node);
     
     /// emitted whenever a different layer is selected.
     void sigLayerActivated(KisLayerSP layer);
     
     /// for the layer box: this sets the current node in the layerbox
     /// without telling the node manager that the node is activated,
     /// preventing loops (I think...)
     void sigUiNeedChangeActiveNode(KisNodeSP node);
     
 public:
     
     void setup(KActionCollection * collection, KisActionManager* actionManager);
     void updateGUI();
 
     /// Convenience function to get the active layer or mask
     KisNodeSP activeNode();
 
     /// convenience function to get the active layer. If a mask is
     /// active, it's parent layer is the active layer.
     KisLayerSP activeLayer();
     
     /// Get the paint device the user wants to paint on now
     KisPaintDeviceSP activePaintDevice();
 
     /**
      * @return the active color space used for composition, meaning the color space
      * of the active mask, or the color space of the parent of the active layer
      */
     const KoColorSpace* activeColorSpace();
 
     /**
      * Sets opacity for the node in a universal way (masks/layers)
      */
     void setNodeOpacity(KisNodeSP node, qint32 opacity, bool finalChange);
 
     /**
      * Sets compositeOp for the node in a universal way (masks/layers)
      */
     void setNodeCompositeOp(KisNodeSP node, const KoCompositeOp* compositeOp);
 
     /**
      * @brief setSelectedNodes set the list of nodes selected in the layerbox. Selected nodes are not necessarily active nodes.
      * @param nodes the selected nodes
      */
     void setSelectedNodes(QList<KisNodeSP> nodes);
     QList<KisNodeSP> selectedNodes();
 
 public Q_SLOTS:
 
     /**
      * Explicitly activates \p node
      * The UI will be noticed that active node has been changed.
      * Both sigNodeActivated and sigUiNeedChangeActiveNode are emitted.
      *
      * WARNING: normally you needn't call this method manually. It is
      * automatically called when a node is added to the graph. If you
      * have some special cases when you need to activate a node, consider
      * adding them to KisDummiesFacadeBase instead. Calling this method
      * directly  should be the last resort.
      *
      * \see slotUiActivatedNode for comparison
      */
     void slotNonUiActivatedNode(KisNodeSP node);
 
     /**
      * Activates \p node.
      * All non-ui listeners are notified with sigNodeActivated,
      * sigUiNeedChangeActiveNode is *not* emitted.
      *
      * \see activateNode
      */
     void slotUiActivatedNode(KisNodeSP node);
 
     /**
      * Adds a node without searching appropriate position for it.
      * You *must* ensure that the node is allowed to be added to
      * the parent, otherwise you'll get an assert.
      */
     void addNodeDirect(KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis);
 
     /**
      * Moves a node without searching appropriate position for it.
      * You *must* ensure that the node is allowed to be added to
      * the parent, otherwise you'll get an assert.
      */
     void moveNodeDirect(KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis);
 
 
     void toggleIsolateActiveNode();
     void toggleIsolateMode(bool checked);
     void slotUpdateIsolateModeAction();
     void slotTryFinishIsolatedMode();
 
     void moveNodeAt(KisNodeSP node, KisNodeSP parent, int index);
     void createNode(const QString& nodeType, bool quiet = false, KisPaintDeviceSP copyFrom = 0);
     void convertNode(const QString &nodeType);
     void nodesUpdated();
     void nodeProperties(KisNodeSP node);
     void nodeOpacityChanged(qreal opacity, bool finalChange);
     void nodeCompositeOpChanged(const KoCompositeOp* op);
     void duplicateActiveNode();
     void removeNode();
     void mirrorNodeX();
     void mirrorNodeY();
     void mirrorNode(KisNodeSP node, const KUndo2MagicString& commandName, Qt::Orientation orientation);
     void activateNextNode();
     void activatePreviousNode();
 
     /**
      * move the active node up the nodestack.
      */
     void raiseNode();
 
     /**
      * move the active node down the nodestack
      */
     void lowerNode();
 
     /**
      * move the activenode to the top-most position of the nodestack
      * If the node is a mask, the stack is limited to the set of masks
      * belonging to the current layer.
      */
     void nodeToTop();
 
     /**
      * move the activenode to the bottom-most position of the nodestack
      * If the node is a mask, the stack is limited to the set of masks
      * belonging to the current layer.
      */
     void nodeToBottom();
     
     void rotate(double radians);
     void rotate180();
     void rotateLeft90();
     void rotateRight90();
 
     void saveNodeAsImage();
 
     // merges the active layer with the layer below it.
-    void mergeLayerDown();
+    void mergeLayer();
 
     void slotSplitAlphaIntoMask();
     void slotSplitAlphaWrite();
     void slotSplitAlphaSaveMerged();
 
 public:
 
     
     void shear(double angleX, double angleY);
 
     void scale(double sx, double sy, KisFilterStrategy *filterStrategy);
     
 private:
     /**
      * Scales opacity from the range 0...1
      * to the integer range 0...255
      */
     qint32 convertOpacityToInt(qreal opacity);
     void removeSelectedNodes(QList<KisNodeSP> selectedNodes);
     void removeSingleNode(KisNodeSP node);
 
     struct Private;
     Private * const m_d;
 };
 
 #endif