diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
index cd96946f37..fee2b41ce3 100644
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -1,2250 +1,2265 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 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_paint_device.h"
 
 #include <QRect>
 #include <QTransform>
 #include <QImage>
 #include <QList>
 #include <QHash>
 #include <QIODevice>
 #include <qmath.h>
 #include <KisRegion.h>
 
 #include <klocalizedstring.h>
 
 #include <KoChannelInfo.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoIntegerMaths.h>
 #include <KoMixColorsOp.h>
 #include <KoUpdater.h>
 
 #include "kis_image.h"
 #include "kis_random_sub_accessor.h"
 #include "kis_selection.h"
 #include "kis_node.h"
 #include "kis_datamanager.h"
 #include "kis_paint_device_writer.h"
 #include "kis_selection_component.h"
 #include "kis_pixel_selection.h"
 #include "kis_repeat_iterators_pixel.h"
 #include "kis_fixed_paint_device.h"
 
 #include "tiles3/kis_hline_iterator.h"
 #include "tiles3/kis_vline_iterator.h"
 #include "tiles3/kis_random_accessor.h"
 
 #include "kis_default_bounds.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_paint_device_cache.h"
 #include "kis_paint_device_data.h"
 #include "kis_paint_device_frames_interface.h"
 
 #include "kis_transform_worker.h"
 #include "kis_filter_strategy.h"
 #include "krita_utils.h"
 
 
 struct KisPaintDeviceSPStaticRegistrar {
     KisPaintDeviceSPStaticRegistrar() {
         qRegisterMetaType<KisPaintDeviceSP>("KisPaintDeviceSP");
     }
 };
 static KisPaintDeviceSPStaticRegistrar __registrar;
 
 
 
 struct KisPaintDevice::Private
 {
     /**
      * Used when the paint device is loading to ensure no lod/animation
      * interferes the process.
      */
     static const KisDefaultBoundsSP transitionalDefaultBounds;
 
 public:
 
     class KisPaintDeviceStrategy;
     class KisPaintDeviceWrappedStrategy;
 
     class DeviceChangeProfileCommand;
     class DeviceChangeColorSpaceCommand;
 
     Private(KisPaintDevice *paintDevice);
     ~Private();
 
     KisPaintDevice *q;
     KisNodeWSP parent;
     QScopedPointer<KisRasterKeyframeChannel> contentChannel;
     KisDefaultBoundsBaseSP defaultBounds;
     QScopedPointer<KisPaintDeviceStrategy> basicStrategy;
     QScopedPointer<KisPaintDeviceWrappedStrategy> wrappedStrategy;
     QMutex m_wrappedStrategyMutex;
 
     QScopedPointer<KisPaintDeviceFramesInterface> framesInterface;
     bool isProjectionDevice;
 
     KisPaintDeviceStrategy* currentStrategy();
 
     void init(const KoColorSpace *cs, const quint8 *defaultPixel);
     void convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand);
     bool assignProfile(const KoColorProfile * profile, KUndo2Command *parentCommand);
 
+    KUndo2Command* reincarnateWithDetachedHistory(bool copyContent);
+
+
     inline const KoColorSpace* colorSpace() const
     {
         return currentData()->colorSpace();
     }
     inline KisDataManagerSP dataManager() const
     {
         return currentData()->dataManager();
     }
 
     inline qint32 x() const
     {
         return currentData()->x();
     }
     inline qint32 y() const
     {
         return currentData()->y();
     }
     inline void setX(qint32 x)
     {
         currentData()->setX(x);
     }
     inline void setY(qint32 y)
     {
         currentData()->setY(y);
     }
 
     inline KisPaintDeviceCache* cache()
     {
         return currentData()->cache();
     }
 
     inline KisIteratorCompleteListener* cacheInvalidator() {
         return currentData()->cacheInvalidator();
     }
 
 
     void cloneAllDataObjects(Private *rhs, bool copyFrames)
     {
 
         m_lodData.reset();
         m_externalFrameData.reset();
 
         if (!m_frames.isEmpty()) {
             m_frames.clear();
         }
 
         if (!copyFrames) {
             if (m_data) {
                 m_data->prepareClone(rhs->currentNonLodData(), true);
             } else {
                 m_data = toQShared(new KisPaintDeviceData(q, rhs->currentNonLodData(), true));
             }
         } else {
             if (m_data && !rhs->m_data) {
                 m_data.clear();
             } else if (!m_data && rhs->m_data) {
                 m_data = toQShared(new KisPaintDeviceData(q, rhs->m_data.data(), true));
             } else if (m_data && rhs->m_data) {
                 m_data->prepareClone(rhs->m_data.data(), true);
             }
 
             if (!rhs->m_frames.isEmpty()) {
                 FramesHash::const_iterator it = rhs->m_frames.constBegin();
                 FramesHash::const_iterator end = rhs->m_frames.constEnd();
 
                 for (; it != end; ++it) {
                     DataSP data = toQShared(new KisPaintDeviceData(q, it.value().data(), true));
                     m_frames.insert(it.key(), data);
                 }
             }
             m_nextFreeFrameId = rhs->m_nextFreeFrameId;
         }
 
         if (rhs->m_lodData) {
             m_lodData.reset(new KisPaintDeviceData(q, rhs->m_lodData.data(), true));
         }
     }
 
     void prepareClone(KisPaintDeviceSP src)
     {
         prepareCloneImpl(src, src->m_d->currentData());
         KIS_SAFE_ASSERT_RECOVER_NOOP(fastBitBltPossible(src));
     }
 
     bool fastBitBltPossible(KisPaintDeviceSP src)
     {
         return fastBitBltPossibleImpl(src->m_d->currentData());
     }
 
     int currentFrameId() const
     {
         KIS_ASSERT_RECOVER(contentChannel) {
             return -1;
         }
         return !defaultBounds->currentLevelOfDetail() ?
                contentChannel->frameIdAt(defaultBounds->currentTime()) :
                -1;
     }
 
     KisDataManagerSP frameDataManager(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return data->dataManager();
     }
 
     void invalidateFrameCache(int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->cache()->invalidate();
     }
 
 private:
     typedef KisPaintDeviceData Data;
     typedef QSharedPointer<Data> DataSP;
     typedef QHash<int, DataSP> FramesHash;
 
     class FrameInsertionCommand : public KUndo2Command
     {
     public:
 
         FrameInsertionCommand(FramesHash *hash, DataSP data, int frameId, bool insert, KUndo2Command *parentCommand)
             : KUndo2Command(parentCommand),
               m_hash(hash),
               m_data(data),
               m_frameId(frameId),
               m_insert(insert)
         {
         }
 
         void redo() override
         {
             doSwap(m_insert);
         }
 
         void undo() override
         {
             doSwap(!m_insert);
         }
 
     private:
         void doSwap(bool insert)
         {
             if (insert) {
                 m_hash->insert(m_frameId, m_data);
             } else {
                 DataSP deletedData = m_hash->take(m_frameId);
             }
         }
 
     private:
         FramesHash *m_hash;
         DataSP m_data;
         int m_frameId;
         bool m_insert;
     };
 
 public:
 
     int getNextFrameId() {
         int frameId = 0;
         while (m_frames.contains(frameId = m_nextFreeFrameId++));
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_frames.contains(frameId));
 
         return frameId;
     }
 
     int createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER(parentCommand) {
             return -1;
         }
 
         DataSP data;
         bool initialFrame = false;
 
         if (m_frames.isEmpty()) {
             /**
              * Here we move the contents of the paint device to the
              * new frame and clear m_data to make the "background" for
              * the areas where there is no frame at all.
              */
             data = toQShared(new Data(q, m_data.data(), true));
             m_data->dataManager()->clear();
             m_data->cache()->invalidate();
             initialFrame = true;
 
         } else if (copy) {
             DataSP srcData = m_frames[copySrc];
             data = toQShared(new Data(q, srcData.data(), true));
         } else {
             DataSP srcData = m_frames.begin().value();
             data = toQShared(new Data(q, srcData.data(), false));
         }
 
         if (!initialFrame && !copy) {
             data->setX(offset.x());
             data->setY(offset.y());
         }
 
         int frameId = getNextFrameId();
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       data,
                                       frameId, true,
                                       parentCommand);
 
         cmd->redo();
 
         return frameId;
     }
 
     void deleteFrame(int frame, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER_RETURN(m_frames.contains(frame));
         KIS_ASSERT_RECOVER_RETURN(parentCommand);
 
         DataSP deletedData = m_frames[frame];
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       deletedData,
                                       frame, false,
                                       parentCommand);
         cmd->redo();
     }
 
     QRect frameBounds(int frameId)
     {
         DataSP data = m_frames[frameId];
 
         QRect extent = data->dataManager()->extent();
         extent.translate(data->x(), data->y());
 
         return extent;
     }
 
     QPoint frameOffset(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return QPoint(data->x(), data->y());
     }
 
     void setFrameOffset(int frameId, const QPoint &offset)
     {
         DataSP data = m_frames[frameId];
         data->setX(offset.x());
         data->setY(offset.y());
     }
 
     const QList<int> frameIds() const
     {
         return m_frames.keys();
     }
 
     bool readFrame(QIODevice *stream, int frameId)
     {
         bool retval = false;
         DataSP data = m_frames[frameId];
         retval = data->dataManager()->read(stream);
         data->cache()->invalidate();
         return retval;
     }
 
     bool writeFrame(KisPaintDeviceWriter &store, int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->dataManager()->write(store);
     }
 
     void setFrameDefaultPixel(const KoColor &defPixel, int frameId)
     {
         DataSP data = m_frames[frameId];
         KoColor color(defPixel);
         color.convertTo(data->colorSpace());
         data->dataManager()->setDefaultPixel(color.data());
     }
 
     KoColor frameDefaultPixel(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return KoColor(data->dataManager()->defaultPixel(),
                        data->colorSpace());
     }
 
     void fetchFrame(int frameId, KisPaintDeviceSP targetDevice);
     void uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrameData(DataSP srcData, DataSP dstData);
 
     struct LodDataStructImpl;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
     KisRegion regionForLodSyncing() const;
 
     void updateLodDataManager(KisDataManager *srcDataManager,
                               KisDataManager *dstDataManager, const QPoint &srcOffset, const QPoint &dstOffset,
                               const QRect &originalRect, int lod);
 
     void generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod);
 
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 
 private:
     qint64 estimateDataSize(Data *data) const {
         const QRect &rc = data->dataManager()->extent();
         return rc.width() * rc.height() * data->colorSpace()->pixelSize();
     }
 
 public:
 
     void estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const {
         imageData = 0;
         temporaryData = 0;
         lodData = 0;
 
         if (m_data) {
             imageData += estimateDataSize(m_data.data());
         }
 
         if (m_lodData) {
             lodData += estimateDataSize(m_lodData.data());
         }
 
         if (m_externalFrameData) {
             temporaryData += estimateDataSize(m_externalFrameData.data());
         }
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             imageData += estimateDataSize(value.data());
         }
     }
 
 
 private:
 
     inline DataSP currentFrameData() const
     {
         DataSP data;
 
         const int numberOfFrames = contentChannel->keyframeCount();
 
         if (numberOfFrames > 1) {
             int frameId = contentChannel->frameIdAt(defaultBounds->currentTime());
 
             if (frameId == -1) {
                 data = m_data;
             } else {
                 KIS_ASSERT_RECOVER(m_frames.contains(frameId)) {
                     return m_frames.begin().value();
                 }
                 data = m_frames[frameId];
             }
         } else if (numberOfFrames == 1) {
             data = m_frames.begin().value();
         } else {
             data = m_data;
         }
 
         return data;
     }
 
     inline Data* currentNonLodData() const
     {
         Data *data = m_data.data();
 
         if (contentChannel) {
             data = currentFrameData().data();
         } else if (isProjectionDevice && defaultBounds->externalFrameActive()) {
             if (!m_externalFrameData) {
                 QMutexLocker l(&m_dataSwitchLock);
                 if (!m_externalFrameData) {
                     m_externalFrameData.reset(new Data(q, m_data.data(), false));
                 }
             }
             data = m_externalFrameData.data();
         }
 
         return data;
     }
 
     inline void ensureLodDataPresent() const
     {
         if (!m_lodData) {
             Data *srcData = currentNonLodData();
 
             QMutexLocker l(&m_dataSwitchLock);
             if (!m_lodData) {
                 m_lodData.reset(new Data(q, srcData, false));
             }
         }
     }
 
     inline Data* currentData() const
     {
         Data *data;
 
         if (defaultBounds->currentLevelOfDetail()) {
             ensureLodDataPresent();
             data = m_lodData.data();
         } else {
             data = currentNonLodData();
         }
 
         return data;
     }
 
     void prepareCloneImpl(KisPaintDeviceSP src, Data *srcData)
     {
         /**
          * The result of currentData() depends on the current
          * level of detail and animation frame index. So we
          * should first connect the device to the new
          * default bounds object, and only after that ask
          * currentData() to start cloning.
          */
         q->setDefaultPixel(KoColor(srcData->dataManager()->defaultPixel(), colorSpace()));
         q->setDefaultBounds(src->defaultBounds());
 
         currentData()->prepareClone(srcData);
     }
 
     bool fastBitBltPossibleImpl(Data *srcData)
     {
         return x() == srcData->x() && y() == srcData->y() &&
                *colorSpace() == *srcData->colorSpace();
     }
 
     QList<Data*> allDataObjects() const
     {
         QList<Data*> dataObjects;
 
         if (m_frames.isEmpty()) {
             dataObjects << m_data.data();
         }
         dataObjects << m_lodData.data();
         dataObjects << m_externalFrameData.data();
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             dataObjects << value.data();
         }
 
         return dataObjects;
     }
 
     void transferFromData(Data *data, KisPaintDeviceSP targetDevice);
 
     struct Q_DECL_HIDDEN StrategyPolicy;
     typedef KisSequentialIteratorBase<ReadOnlyIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialConstIterator;
     typedef KisSequentialIteratorBase<WritableIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialIterator;
 
 private:
     friend class KisPaintDeviceFramesInterface;
 
 private:
     DataSP m_data;
     mutable QScopedPointer<Data> m_lodData;
     mutable QScopedPointer<Data> m_externalFrameData;
     mutable QMutex m_dataSwitchLock;
 
     FramesHash m_frames;
     int m_nextFreeFrameId;
 };
 
 const KisDefaultBoundsSP KisPaintDevice::Private::transitionalDefaultBounds = new KisDefaultBounds();
 
 #include "kis_paint_device_strategies.h"
 
 KisPaintDevice::Private::Private(KisPaintDevice *paintDevice)
     : q(paintDevice),
       basicStrategy(new KisPaintDeviceStrategy(paintDevice, this)),
       isProjectionDevice(false),
       m_data(new Data(paintDevice)),
       m_nextFreeFrameId(0)
 {
 }
 
 KisPaintDevice::Private::~Private()
 {
     m_frames.clear();
 }
 
 KisPaintDevice::Private::KisPaintDeviceStrategy* KisPaintDevice::Private::currentStrategy()
 {
     if (!defaultBounds->wrapAroundMode()) {
         return basicStrategy.data();
     }
 
     const QRect wrapRect = defaultBounds->bounds();
 
     if (!wrappedStrategy || wrappedStrategy->wrapRect() != wrapRect) {
         QMutexLocker locker(&m_wrappedStrategyMutex);
 
         if (!wrappedStrategy) {
             wrappedStrategy.reset(new KisPaintDeviceWrappedStrategy(wrapRect, q, this));
         }  else if (wrappedStrategy->wrapRect() != wrapRect) {
             wrappedStrategy->setWrapRect(wrapRect);
         }
     }
 
     return wrappedStrategy.data();
 }
 
 struct KisPaintDevice::Private::StrategyPolicy {
     StrategyPolicy(KisPaintDevice::Private::KisPaintDeviceStrategy *strategy,
                    KisDataManager *dataManager, qint32 offsetX, qint32 offsetY)
         : m_strategy(strategy),
           m_dataManager(dataManager),
           m_offsetX(offsetX),
           m_offsetY(offsetY)
     {
     }
 
     KisHLineConstIteratorSP createConstIterator(const QRect &rect)
     {
         return m_strategy->createHLineConstIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     KisHLineIteratorSP createIterator(const QRect &rect)
     {
         return m_strategy->createHLineIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     int pixelSize() const
     {
         return m_dataManager->pixelSize();
     }
 
 
     KisPaintDeviceStrategy *m_strategy;
     KisDataManager *m_dataManager;
     int m_offsetX;
     int m_offsetY;
 };
 
 struct KisPaintDevice::Private::LodDataStructImpl : public KisPaintDevice::LodDataStruct {
     LodDataStructImpl(Data *_lodData) : lodData(_lodData) {}
     QScopedPointer<Data> lodData;
 };
 
 KisRegion KisPaintDevice::Private::regionForLodSyncing() const
 {
     Data *srcData = currentNonLodData();
     return srcData->dataManager()->region().translated(srcData->x(), srcData->y());
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::Private::createLodDataStruct(int newLod)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(newLod > 0);
 
     Data *srcData = currentNonLodData();
 
     Data *lodData = new Data(q, srcData, false);
     LodDataStruct *lodStruct = new LodDataStructImpl(lodData);
 
     int expectedX = KisLodTransform::coordToLodCoord(srcData->x(), newLod);
     int expectedY = KisLodTransform::coordToLodCoord(srcData->y(), newLod);
 
     /**
      * We compare color spaces as pure pointers, because they must be
      * exactly the same, since they come from the common source.
      */
     if (lodData->levelOfDetail() != newLod ||
         lodData->colorSpace() != srcData->colorSpace() ||
         lodData->x() != expectedX ||
         lodData->y() != expectedY) {
 
 
         lodData->prepareClone(srcData);
 
         lodData->setLevelOfDetail(newLod);
         lodData->setX(expectedX);
         lodData->setY(expectedY);
 
         // FIXME: different kind of synchronization
     }
 
     lodData->cache()->invalidate();
 
     return lodStruct;
 }
 
 void KisPaintDevice::Private::updateLodDataManager(KisDataManager *srcDataManager,
                                                    KisDataManager *dstDataManager,
                                                    const QPoint &srcOffset,
                                                    const QPoint &dstOffset,
                                                    const QRect &originalRect,
                                                    int lod)
 {
     if (originalRect.isEmpty()) return;
 
     const int srcStepSize = 1 << lod;
 
     KIS_ASSERT_RECOVER_RETURN(lod > 0);
 
     const QRect srcRect = KisLodTransform::alignedRect(originalRect, lod);
     const QRect dstRect = KisLodTransform::scaledRect(srcRect, lod);
     if (!srcRect.isValid() || !dstRect.isValid()) return;
 
     KIS_ASSERT_RECOVER_NOOP(srcRect.width() / srcStepSize == dstRect.width());
 
     const int pixelSize = srcDataManager->pixelSize();
 
     int rowsAccumulated = 0;
     int columnsAccumulated = 0;
 
     KoMixColorsOp *mixOp = colorSpace()->mixColorsOp();
 
     QScopedArrayPointer<quint8> blendData(new quint8[srcStepSize * srcRect.width() * pixelSize]);
     quint8 *blendDataPtr = blendData.data();
     int blendDataOffset = 0;
 
     const int srcCellSize = srcStepSize * srcStepSize;
     const int srcCellStride = srcCellSize * pixelSize;
     const int srcStepStride = srcStepSize * pixelSize;
     const int srcColumnStride = (srcStepSize - 1) * srcStepStride;
 
     QScopedArrayPointer<qint16> weights(new qint16[srcCellSize]);
 
     {
         const qint16 averageWeight = qCeil(255.0 / srcCellSize);
         const qint16 extraWeight = averageWeight * srcCellSize - 255;
         KIS_ASSERT_RECOVER_NOOP(extraWeight == 1);
 
         for (int i = 0; i < srcCellSize - 1; i++) {
             weights[i] = averageWeight;
         }
         weights[srcCellSize - 1] = averageWeight - extraWeight;
     }
 
     InternalSequentialConstIterator srcIntIt(StrategyPolicy(currentStrategy(), srcDataManager, srcOffset.x(), srcOffset.y()), srcRect);
     InternalSequentialIterator dstIntIt(StrategyPolicy(currentStrategy(), dstDataManager, dstOffset.x(), dstOffset.y()), dstRect);
 
     int rowsRemaining = srcRect.height();
     while (rowsRemaining > 0) {
 
         int colsRemaining = srcRect.width();
         while (colsRemaining > 0 && srcIntIt.nextPixel()) {
 
             memcpy(blendDataPtr, srcIntIt.rawDataConst(), pixelSize);
             blendDataPtr += pixelSize;
             columnsAccumulated++;
 
             if (columnsAccumulated >= srcStepSize) {
                 blendDataPtr += srcColumnStride;
                 columnsAccumulated = 0;
             }
 
             colsRemaining--;
         }
 
         rowsAccumulated++;
 
         if (rowsAccumulated >= srcStepSize) {
 
             // blend and write the final data
             blendDataPtr = blendData.data();
 
             int colsRemaining = dstRect.width();
             while (colsRemaining > 0 && dstIntIt.nextPixel()) {
                 mixOp->mixColors(blendDataPtr, weights.data(), srcCellSize, dstIntIt.rawData());
                 blendDataPtr += srcCellStride;
 
                 colsRemaining--;
             }
 
             // reset counters
             rowsAccumulated = 0;
             blendDataPtr = blendData.data();
             blendDataOffset = 0;
         } else {
             blendDataOffset += srcStepStride;
             blendDataPtr = blendData.data() + blendDataOffset;
         }
 
         rowsRemaining--;
     }
 }
 
 void KisPaintDevice::Private::updateLodDataStruct(LodDataStruct *_dst, const QRect &originalRect)
 {
     LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
     KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
     Data *lodData = dst->lodData.data();
     Data *srcData = currentNonLodData();
 
     const int lod = lodData->levelOfDetail();
 
     updateLodDataManager(srcData->dataManager().data(), lodData->dataManager().data(),
                          QPoint(srcData->x(), srcData->y()),
                          QPoint(lodData->x(), lodData->y()),
                          originalRect, lod);
 }
 
 void KisPaintDevice::Private::generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(fastBitBltPossible(dst));
 
     Data *srcData = currentNonLodData();
     updateLodDataManager(srcData->dataManager().data(), dst->dataManager().data(),
                          QPoint(srcData->x(), srcData->y()),
                          QPoint(dst->x(), dst->y()),
                          originalRect, lod);
 }
 
 void KisPaintDevice::Private::uploadLodDataStruct(LodDataStruct *_dst)
 {
     LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
     KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(
         dst->lodData->levelOfDetail() == defaultBounds->currentLevelOfDetail());
 
     ensureLodDataPresent();
 
     m_lodData->prepareClone(dst->lodData.data());
     m_lodData->dataManager()->bitBltRough(dst->lodData->dataManager(), dst->lodData->dataManager()->extent());
 }
 
 void KisPaintDevice::Private::transferFromData(Data *data, KisPaintDeviceSP targetDevice)
 {
     QRect extent = data->dataManager()->extent();
     extent.translate(data->x(), data->y());
 
     targetDevice->m_d->prepareCloneImpl(q, data);
     targetDevice->m_d->currentStrategy()->fastBitBltRough(data->dataManager(), extent);
 }
 
 void KisPaintDevice::Private::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     DataSP data = m_frames[frameId];
     transferFromData(data.data(), targetDevice);
 }
 
 void KisPaintDevice::Private::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_frames[srcFrameId];
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_data;
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrameData(DataSP srcData, DataSP dstData)
 {
     if (srcData->colorSpace() != dstData->colorSpace() &&
         *srcData->colorSpace() != *dstData->colorSpace()) {
 
         KUndo2Command tempCommand;
 
         srcData = toQShared(new Data(q, srcData.data(), true));
         srcData->convertDataColorSpace(dstData->colorSpace(),
                                        KoColorConversionTransformation::internalRenderingIntent(),
                                        KoColorConversionTransformation::internalConversionFlags(),
                                        &tempCommand);
     }
 
     dstData->dataManager()->clear();
     dstData->cache()->invalidate();
 
     const QRect rect = srcData->dataManager()->extent();
     dstData->dataManager()->bitBltRough(srcData->dataManager(), rect);
     dstData->setX(srcData->x());
     dstData->setY(srcData->y());
 }
 
 void KisPaintDevice::Private::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     Data *data = m_lodData.data();
     Q_ASSERT(data);
 
     transferFromData(data, targetDevice);
 }
 
 class KisPaintDevice::Private::DeviceChangeProfileCommand : public KUndo2Command
 {
 public:
     DeviceChangeProfileCommand(KisPaintDeviceSP device, KUndo2Command *parent = 0)
         : KUndo2Command(parent),
           m_device(device)
     {
     }
 
     virtual void emitNotifications()
     {
         m_device->emitProfileChanged();
     }
 
     void redo() override
     {
         if (m_firstRun) {
             m_firstRun = false;
             return;
         }
 
         KUndo2Command::redo();
         emitNotifications();
     }
 
     void undo() override
     {
         KUndo2Command::undo();
         emitNotifications();
     }
 
 protected:
     KisPaintDeviceSP m_device;
 
 private:
     bool m_firstRun {true};
 };
 
 class KisPaintDevice::Private::DeviceChangeColorSpaceCommand : public DeviceChangeProfileCommand
 {
 public:
     DeviceChangeColorSpaceCommand(KisPaintDeviceSP device, KUndo2Command *parent = 0)
         : DeviceChangeProfileCommand(device, parent)
     {
     }
 
     void emitNotifications() override
     {
         m_device->emitColorSpaceChanged();
     }
 };
 
 void KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand)
 {
     QList<Data*> dataObjects = allDataObjects();
     if (dataObjects.isEmpty()) return;
 
     KUndo2Command *mainCommand =
         parentCommand ? new DeviceChangeColorSpaceCommand(q, parentCommand) : 0;
 
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         data->convertDataColorSpace(dstColorSpace, renderingIntent, conversionFlags, mainCommand);
     }
 
     q->emitColorSpaceChanged();
 }
 
 bool KisPaintDevice::Private::assignProfile(const KoColorProfile * profile, KUndo2Command *parentCommand)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstColorSpace =
         KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     KUndo2Command *mainCommand =
         parentCommand ? new DeviceChangeColorSpaceCommand(q, parentCommand) : 0;
 
 
     QList<Data*> dataObjects = allDataObjects();
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
         data->assignColorSpace(dstColorSpace, mainCommand);
     }
     q->emitProfileChanged();
 
     // no undo information is provided here
     return true;
 }
 
+KUndo2Command *KisPaintDevice::Private::reincarnateWithDetachedHistory(bool copyContent)
+{
+    KUndo2Command *mainCommand = new KUndo2Command();
+    currentData()->reincarnateWithDetachedHistory(copyContent, mainCommand);
+    return mainCommand;
+}
+
 void KisPaintDevice::Private::init(const KoColorSpace *cs, const quint8 *defaultPixel)
 {
     QList<Data*> dataObjects = allDataObjects();
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         KisDataManagerSP dataManager = new KisDataManager(cs->pixelSize(), defaultPixel);
         data->init(cs, dataManager);
     }
 }
 
 KisPaintDevice::KisPaintDevice(const KoColorSpace * colorSpace, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, new KisDefaultBounds(), 0, name);
 }
 
 KisPaintDevice::KisPaintDevice(KisNodeWSP parent, const KoColorSpace * colorSpace, KisDefaultBoundsBaseSP defaultBounds, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, defaultBounds, parent, name);
 }
 
 void KisPaintDevice::init(const KoColorSpace *colorSpace,
                           KisDefaultBoundsBaseSP defaultBounds,
                           KisNodeWSP parent, const QString& name)
 {
     Q_ASSERT(colorSpace);
     setObjectName(name);
 
     // temporary def. bounds object for the initialization phase only
     m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
     if (!defaultBounds) {
         // Reuse transitionalDefaultBounds here. Change if you change
         // semantics of transitionalDefaultBounds
         defaultBounds = m_d->transitionalDefaultBounds;
     }
 
     QScopedArrayPointer<quint8> defaultPixel(new quint8[colorSpace->pixelSize()]);
     colorSpace->fromQColor(Qt::transparent, defaultPixel.data());
     m_d->init(colorSpace, defaultPixel.data());
 
     Q_ASSERT(m_d->colorSpace());
 
     setDefaultBounds(defaultBounds);
     setParentNode(parent);
 }
 
 KisPaintDevice::KisPaintDevice(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode, KisNode *newParentNode)
     : QObject()
     , KisShared()
     , m_d(new Private(this))
 {
     if (this != &rhs) {
         makeFullCopyFrom(rhs, copyMode, newParentNode);
     }
 }
 
 void KisPaintDevice::makeFullCopyFrom(const KisPaintDevice &rhs, KritaUtils::DeviceCopyMode copyMode, KisNode *newParentNode)
 {
     // temporary def. bounds object for the initialization phase only
     m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
     // copy data objects with or without frames
     m_d->cloneAllDataObjects(rhs.m_d, copyMode == KritaUtils::CopyAllFrames);
 
     if (copyMode == KritaUtils::CopyAllFrames && rhs.m_d->framesInterface) {
         KIS_ASSERT_RECOVER_RETURN(rhs.m_d->framesInterface);
         KIS_ASSERT_RECOVER_RETURN(rhs.m_d->contentChannel);
         m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
         m_d->contentChannel.reset(new KisRasterKeyframeChannel(*rhs.m_d->contentChannel.data(), newParentNode, this));
     }
 
     setDefaultBounds(rhs.m_d->defaultBounds);
     setParentNode(newParentNode);
 }
 
 KisPaintDevice::~KisPaintDevice()
 {
     delete m_d;
 }
 
 void KisPaintDevice::setProjectionDevice(bool value)
 {
     m_d->isProjectionDevice = value;
 }
 
 void KisPaintDevice::prepareClone(KisPaintDeviceSP src)
 {
     m_d->prepareClone(src);
 }
 
 void KisPaintDevice::makeCloneFrom(KisPaintDeviceSP src, const QRect &rect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = rect & src->extent();
 
     fastBitBlt(src, optimizedRect);
 }
 
 void KisPaintDevice::makeCloneFromRough(KisPaintDeviceSP src, const QRect &minimalRect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = minimalRect & src->extent();
 
     fastBitBltRough(src, optimizedRect);
 }
 
 void KisPaintDevice::setDirty()
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty();
 }
 
 void KisPaintDevice::setDirty(const QRect & rc)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rc);
 }
 
 void KisPaintDevice::setDirty(const KisRegion &region)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(region);
 }
 
 void KisPaintDevice::setDirty(const QVector<QRect> &rects)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rects);
 }
 
 void KisPaintDevice::requestTimeSwitch(int time)
 {
     if (m_d->parent.isValid()) {
         m_d->parent->requestTimeSwitch(time);
     }
 }
 
 int KisPaintDevice::sequenceNumber() const
 {
     return m_d->cache()->sequenceNumber();
 }
 
 void KisPaintDevice::estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const
 {
     m_d->estimateMemoryStats(imageData, temporaryData, lodData);
 }
 
 void KisPaintDevice::setParentNode(KisNodeWSP parent)
 {
     m_d->parent = parent;
 }
 
 // for testing purposes only
 KisNodeWSP KisPaintDevice::parentNode() const
 {
     return m_d->parent;
 }
 
 void KisPaintDevice::setDefaultBounds(KisDefaultBoundsBaseSP defaultBounds)
 {
     m_d->defaultBounds = defaultBounds;
     m_d->cache()->invalidate();
 }
 
 KisDefaultBoundsBaseSP KisPaintDevice::defaultBounds() const
 {
     return m_d->defaultBounds;
 }
 
 void KisPaintDevice::moveTo(const QPoint &pt)
 {
     m_d->currentStrategy()->move(pt);
     m_d->cache()->invalidate();
 }
 
 QPoint KisPaintDevice::offset() const
 {
     return QPoint(x(), y());
 }
 
 void KisPaintDevice::moveTo(qint32 x, qint32 y)
 {
     moveTo(QPoint(x, y));
 }
 
 void KisPaintDevice::setX(qint32 x)
 {
     moveTo(QPoint(x, m_d->y()));
 }
 
 void KisPaintDevice::setY(qint32 y)
 {
     moveTo(QPoint(m_d->x(), y));
 }
 
 qint32 KisPaintDevice::x() const
 {
     return m_d->x();
 }
 
 qint32 KisPaintDevice::y() const
 {
     return m_d->y();
 }
 
 void KisPaintDevice::extent(qint32 &x, qint32 &y, qint32 &w, qint32 &h) const
 {
     QRect rc = extent();
     x = rc.x();
     y = rc.y();
     w = rc.width();
     h = rc.height();
 }
 
 QRect KisPaintDevice::extent() const
 {
     return m_d->currentStrategy()->extent();
 }
 
 KisRegion KisPaintDevice::region() const
 {
     return m_d->currentStrategy()->region();
 }
 
 QRect KisPaintDevice::nonDefaultPixelArea() const
 {
     return m_d->cache()->nonDefaultPixelArea();
 }
 
 QRect KisPaintDevice::exactBounds() const
 {
     return m_d->cache()->exactBounds();
 }
 
 QRect KisPaintDevice::exactBoundsAmortized() const
 {
     return m_d->cache()->exactBoundsAmortized();
 }
 
 namespace Impl
 {
 
 struct CheckFullyTransparent {
     CheckFullyTransparent(const KoColorSpace *colorSpace)
         : m_colorSpace(colorSpace)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return m_colorSpace->opacityU8(pixelData) == OPACITY_TRANSPARENT_U8;
     }
 
 private:
     const KoColorSpace *m_colorSpace;
 };
 
 struct CheckNonDefault {
     CheckNonDefault(int pixelSize, const quint8 *defaultPixel)
         : m_pixelSize(pixelSize),
           m_defaultPixel(defaultPixel)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return memcmp(m_defaultPixel, pixelData, m_pixelSize) == 0;
     }
 
 private:
     int m_pixelSize;
     const quint8 *m_defaultPixel;
 };
 
 template <class ComparePixelOp>
 QRect calculateExactBoundsImpl(const KisPaintDevice *device, const QRect &startRect, const QRect &endRect, ComparePixelOp compareOp)
 {
     if (startRect == endRect) return startRect;
 
     // the passed extent might have weird invalid structure that
     // can overflow integer precision when calling startRect.right()
     if (!startRect.isValid()) return QRect();
 
     // Solution n°2
     int  x, y, w, h;
     int boundLeft, boundTop, boundRight, boundBottom;
     int endDirN, endDirE, endDirS, endDirW;
 
     startRect.getRect(&x, &y, &w, &h);
 
     if (endRect.isEmpty()) {
         endDirS = startRect.bottom();
         endDirN = startRect.top();
         endDirE = startRect.right();
         endDirW = startRect.left();
         startRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     } else {
         endDirS = endRect.top() - 1;
         endDirN = endRect.bottom() + 1;
         endDirE = endRect.left() - 1;
         endDirW = endRect.right() + 1;
         endRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     }
 
     // XXX: a small optimization is possible by using H/V line iterators in the first
     //      and third cases, at the cost of making the code a bit more complex
 
     KisRandomConstAccessorSP accessor = device->createRandomConstAccessorNG();
 
     bool found = false;
     {
         for (qint32 y2 = y; y2 <= endDirS; ++y2) {
             for (qint32 x2 = x; x2 < x + w || found; ++ x2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundTop = y2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     /**
      * If the first pass hasn't found any opaque pixel, there is no
      * reason to check that 3 more times. They will not appear in the
      * meantime. Just return an empty bounding rect.
      */
     if (!found && endRect.isEmpty()) {
         return QRect();
     }
 
     found = false;
 
     for (qint32 y2 = y + h - 1; y2 >= endDirN ; --y2) {
         for (qint32 x2 = x + w - 1; x2 >= x || found; --x2) {
             accessor->moveTo(x2, y2);
             if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                 boundBottom = y2;
                 found = true;
                 break;
             }
         }
         if (found) break;
     }
     found = false;
 
     {
         for (qint32 x2 = x; x2 <= endDirE ; ++x2) {
             for (qint32 y2 = y; y2 < y + h || found; ++y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundLeft = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     found = false;
 
     // Look for right edge )
     {
 
         for (qint32 x2 = x + w - 1; x2 >= endDirW; --x2) {
             for (qint32 y2 = y + h - 1; y2 >= y || found; --y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundRight = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     return QRect(boundLeft, boundTop,
                  boundRight - boundLeft + 1,
                  boundBottom - boundTop + 1);
 }
 
 }
 
 QRect KisPaintDevice::calculateExactBounds(bool nonDefaultOnly) const
 {
     QRect startRect = extent();
     QRect endRect;
 
     quint8 defaultOpacity = defaultPixel().opacityU8();
     if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
         if (!nonDefaultOnly) {
             /**
              * We will calculate exact bounds only outside of the
              * image bounds, and that'll be nondefault area only.
              */
 
             endRect = defaultBounds()->bounds();
             nonDefaultOnly = true;
 
         } else {
             startRect = region().boundingRect();
         }
     }
 
     if (nonDefaultOnly) {
         const KoColor defaultPixel = this->defaultPixel();
         Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     } else {
         Impl::CheckFullyTransparent compareOp(m_d->colorSpace());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     }
 
     return endRect;
 }
 
 KisRegion KisPaintDevice::regionExact() const
 {
     QVector<QRect> sourceRects = region().rects();
     QVector<QRect> resultRects;
 
     const KoColor defaultPixel = this->defaultPixel();
     Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
 
     Q_FOREACH (const QRect &rc1, sourceRects) {
         const int patchSize = 64;
         QVector<QRect> smallerRects = KritaUtils::splitRectIntoPatches(rc1, QSize(patchSize, patchSize));
         Q_FOREACH (const QRect &rc2, smallerRects) {
 
             const QRect result =
                 Impl::calculateExactBoundsImpl(this, rc2, QRect(), compareOp);
 
             if (!result.isEmpty()) {
                 resultRects << result;
             }
         }
     }
     return KisRegion(std::move(resultRects));
 }
 
 void KisPaintDevice::crop(qint32 x, qint32 y, qint32 w, qint32 h)
 {
     crop(QRect(x, y, w, h));
 }
 
 
 void KisPaintDevice::crop(const QRect &rect)
 {
     m_d->currentStrategy()->crop(rect);
 }
 
 void KisPaintDevice::purgeDefaultPixels()
 {
     KisDataManagerSP dm = m_d->dataManager();
     dm->purge(dm->extent());
 }
 
 void KisPaintDevice::setDefaultPixel(const KoColor &defPixel)
 {
     KoColor color(defPixel);
     color.convertTo(colorSpace());
 
     m_d->dataManager()->setDefaultPixel(color.data());
     m_d->cache()->invalidate();
 }
 
 KoColor KisPaintDevice::defaultPixel() const
 {
     return KoColor(m_d->dataManager()->defaultPixel(), colorSpace());
 }
 
 void KisPaintDevice::clear()
 {
     m_d->dataManager()->clear();
     m_d->cache()->invalidate();
 }
 
 void KisPaintDevice::clear(const QRect & rc)
 {
     m_d->currentStrategy()->clear(rc);
 }
 
 void KisPaintDevice::fill(const QRect & rc, const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(*color.colorSpace() == *colorSpace());
     m_d->currentStrategy()->fill(rc, color.data());
 }
 
 void KisPaintDevice::fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel)
 {
     m_d->currentStrategy()->fill(QRect(x, y, w, h), fillPixel);
 }
 
 
 bool KisPaintDevice::write(KisPaintDeviceWriter &store)
 {
     return m_d->dataManager()->write(store);
 }
 
 bool KisPaintDevice::read(QIODevice *stream)
 {
     bool retval;
 
     retval = m_d->dataManager()->read(stream);
     m_d->cache()->invalidate();
 
     return retval;
 }
 
 void KisPaintDevice::emitColorSpaceChanged()
 {
     emit colorSpaceChanged(m_d->colorSpace());
 }
 
 void KisPaintDevice::emitProfileChanged()
 {
     emit profileChanged(m_d->colorSpace()->profile());
 }
 
 void KisPaintDevice::convertTo(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand)
 {
     m_d->convertColorSpace(dstColorSpace, renderingIntent, conversionFlags, parentCommand);
 }
 
 bool KisPaintDevice::setProfile(const KoColorProfile * profile, KUndo2Command *parentCommand)
 {
     return m_d->assignProfile(profile, parentCommand);
 }
 
+KUndo2Command *KisPaintDevice::reincarnateWithDetachedHistory(bool copyContent)
+{
+    return m_d->reincarnateWithDetachedHistory(copyContent);
+}
+
 KisDataManagerSP KisPaintDevice::dataManager() const
 {
     return m_d->dataManager();
 }
 
 void KisPaintDevice::convertFromQImage(const QImage& _image, const KoColorProfile *profile,
                                        qint32 offsetX, qint32 offsetY)
 {
     QImage image = _image;
 
     if (image.format() != QImage::Format_ARGB32) {
         image = image.convertToFormat(QImage::Format_ARGB32);
     }
     // Don't convert if not no profile is given and both paint dev and qimage are rgba.
     if (!profile && colorSpace()->id() == "RGBA") {
         writeBytes(image.constBits(), offsetX, offsetY, image.width(), image.height());
     } else {
         try {
             quint8 * dstData = new quint8[image.width() * image.height() * pixelSize()];
             KoColorSpaceRegistry::instance()
             ->colorSpace(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), profile)
             ->convertPixelsTo(image.constBits(), dstData, colorSpace(), image.width() * image.height(),
                               KoColorConversionTransformation::internalRenderingIntent(),
                               KoColorConversionTransformation::internalConversionFlags());
 
             writeBytes(dstData, offsetX, offsetY, image.width(), image.height());
             delete[] dstData;
         } catch (const std::bad_alloc&) {
             warnKrita << "KisPaintDevice::convertFromQImage: Could not allocate" << image.width() * image.height() * pixelSize() << "bytes";
             return;
         }
     }
     m_d->cache()->invalidate();
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     qint32 x1;
     qint32 y1;
     qint32 w;
     qint32 h;
 
     QRect rc = exactBounds();
     x1 = rc.x();
     y1 = rc.y();
     w = rc.width();
     h = rc.height();
 
     return convertToQImage(dstProfile, x1, y1, w, h, renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile,
                                        const QRect &rc,
                                        KoColorConversionTransformation::Intent renderingIntent,
                                        KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     return convertToQImage(dstProfile,
                            rc.x(), rc.y(), rc.width(), rc.height(),
                            renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, qint32 x1, qint32 y1, qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
 
     if (w < 0)
         return QImage();
 
     if (h < 0)
         return QImage();
 
     quint8 *data = 0;
     try {
         data = new quint8 [w * h * pixelSize()];
     } catch (const std::bad_alloc&) {
         warnKrita << "KisPaintDevice::convertToQImage std::bad_alloc for " << w << " * " << h << " * " << pixelSize();
         //delete[] data; // data is not allocated, so don't free it
         return QImage();
     }
     Q_CHECK_PTR(data);
 
     // XXX: Is this really faster than converting line by line and building the QImage directly?
     //      This copies potentially a lot of data.
     readBytes(data, x1, y1, w, h);
     QImage image = colorSpace()->convertToQImage(data, w, h, dstProfile, renderingIntent, conversionFlags);
     delete[] data;
 
     return image;
 }
 
 inline bool moveBy(KisSequentialConstIterator& iter, int numPixels)
 {
     int pos = 0;
     while (pos < numPixels) {
         int step = std::min(iter.nConseqPixels(), numPixels - pos);
         if (!iter.nextPixels(step))
             return false;
         pos += step;
     }
     return true;
 }
 
 static KisPaintDeviceSP createThumbnailDeviceInternal(const KisPaintDevice* srcDev, qint32 srcX0, qint32 srcY0, qint32 srcWidth, qint32 srcHeight, qint32 w, qint32 h, QRect outputRect)
 {
     KisPaintDeviceSP thumbnail = new KisPaintDevice(srcDev->colorSpace());
     qint32 pixelSize = srcDev->pixelSize();
 
     KisRandomConstAccessorSP srcIter = srcDev->createRandomConstAccessorNG();
     KisRandomAccessorSP dstIter = thumbnail->createRandomAccessorNG();
 
     for (qint32 y = outputRect.y(); y < outputRect.y() + outputRect.height(); ++y) {
         qint32 iY = srcY0 + (y * srcHeight) / h;
         for (qint32 x = outputRect.x(); x < outputRect.x() + outputRect.width(); ++x) {
             qint32 iX = srcX0 + (x * srcWidth) / w;
             srcIter->moveTo(iX, iY);
             dstIter->moveTo(x,  y);
             memcpy(dstIter->rawData(), srcIter->rawDataConst(), pixelSize);
         }
     }
     return thumbnail;
 }
 
 QSize fixThumbnailSize(QSize size)
 {
     if (!size.width() && size.height()) {
         size.setWidth(1);
     }
 
     if (size.width() && !size.height()) {
         size.setHeight(1);
     }
 
     return size;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(qint32 w, qint32 h, QRect rect, QRect outputRect) const
 {
     QSize thumbnailSize(w, h);
 
     QRect imageRect = rect.isValid() ? rect : extent();
 
     if ((thumbnailSize.width() > imageRect.width()) || (thumbnailSize.height() > imageRect.height())) {
         thumbnailSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailSize = fixThumbnailSize(thumbnailSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     int srcWidth, srcHeight;
     int srcX0, srcY0;
     imageRect.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight);
 
     if (!outputRect.isValid()) {
         outputRect = QRect(0, 0, w, h);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailSize.width(), thumbnailSize.height(), outputRect);
 
     return thumbnail;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect,  QRect outputTileRect) const
 {
     QSize thumbnailSize(w, h);
     qreal oversampleAdjusted = qMax(oversample, 1.);
     QSize thumbnailOversampledSize = oversampleAdjusted * thumbnailSize;
 
     QRect outputRect;
     QRect imageRect = rect.isValid() ? rect : extent();
 
     qint32 hstart = thumbnailOversampledSize.height();
 
     if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
         thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailOversampledSize = fixThumbnailSize(thumbnailOversampledSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty() || thumbnailOversampledSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     oversampleAdjusted *= (hstart > 0) ? ((qreal)thumbnailOversampledSize.height() / hstart) : 1.; //readjusting oversample ratio, given that we had to adjust thumbnail size
 
     outputRect = QRect(0, 0, thumbnailOversampledSize.width(), thumbnailOversampledSize.height());
 
     if (outputTileRect.isValid()) {
         //compensating output rectangle for oversampling
         outputTileRect = QRect(oversampleAdjusted * outputTileRect.topLeft(), oversampleAdjusted * outputTileRect.bottomRight());
         outputRect = outputRect.intersected(outputTileRect);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailOversampledSize.width(), thumbnailOversampledSize.height(), outputRect);
 
     if (oversample != 1. && oversampleAdjusted != 1.) {
         KoDummyUpdater updater;
         KisTransformWorker worker(thumbnail, 1 / oversampleAdjusted, 1 / oversampleAdjusted, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                                   &updater, KisFilterStrategyRegistry::instance()->value("Bilinear"));
         worker.run();
     }
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, QRect rect, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     KisPaintDeviceSP dev = createThumbnailDeviceOversampled(size.width(), size.height(), oversample, rect);
     QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags);
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     return m_d->cache()->createThumbnail(size.width(), size.height(), oversample, renderingIntent, conversionFlags);
 }
 
 KisHLineIteratorSP KisPaintDevice::createHLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createHLineIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisHLineConstIteratorSP KisPaintDevice::createHLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisVLineIteratorSP KisPaintDevice::createVLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createVLineIteratorNG(x, y, w);
 }
 
 KisVLineConstIteratorSP KisPaintDevice::createVLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createVLineConstIteratorNG(x, y, w);
 }
 
 KisRepeatHLineConstIteratorSP KisPaintDevice::createRepeatHLineConstIterator(qint32 x, qint32 y, qint32 w, const QRect& _dataWidth) const
 {
     return new KisRepeatHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRepeatVLineConstIteratorSP KisPaintDevice::createRepeatVLineConstIterator(qint32 x, qint32 y, qint32 h, const QRect& _dataWidth) const
 {
     return new KisRepeatVLineConstIteratorNG(m_d->dataManager().data(), x, y, h, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRandomAccessorSP KisPaintDevice::createRandomAccessorNG()
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createRandomAccessorNG();
 }
 
 KisRandomConstAccessorSP KisPaintDevice::createRandomConstAccessorNG() const
 {
     return m_d->currentStrategy()->createRandomConstAccessorNG();
 }
 
 KisRandomSubAccessorSP KisPaintDevice::createRandomSubAccessor() const
 {
     KisPaintDevice* pd = const_cast<KisPaintDevice*>(this);
     return new KisRandomSubAccessor(pd);
 }
 
 void KisPaintDevice::clearSelection(KisSelectionSP selection)
 {
     const KoColorSpace *colorSpace = m_d->colorSpace();
     const QRect r = selection->selectedExactRect();
 
     if (r.isValid()) {
 
         {
             KisHLineIteratorSP devIt = createHLineIteratorNG(r.x(), r.y(), r.width());
             KisHLineConstIteratorSP selectionIt = selection->projection()->createHLineConstIteratorNG(r.x(), r.y(), r.width());
 
             const KoColor defaultPixel = this->defaultPixel();
             bool transparentDefault = (defaultPixel.opacityU8() == OPACITY_TRANSPARENT_U8);
             for (qint32 y = 0; y < r.height(); y++) {
 
                 do {
                     // XXX: Optimize by using stretches
                     colorSpace->applyInverseAlphaU8Mask(devIt->rawData(), selectionIt->rawDataConst(), 1);
                     if (transparentDefault && colorSpace->opacityU8(devIt->rawData()) == OPACITY_TRANSPARENT_U8) {
                         memcpy(devIt->rawData(), defaultPixel.data(), colorSpace->pixelSize());
                     }
                 } while (devIt->nextPixel() && selectionIt->nextPixel());
                 devIt->nextRow();
                 selectionIt->nextRow();
             }
         }
 
         // purge() must be executed **after** all iterators have been destroyed!
         m_d->dataManager()->purge(r.translated(-m_d->x(), -m_d->y()));
 
         setDirty(r);
     }
 }
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, QColor *c) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     colorSpace()->toQColor(pix, c);
 
     return true;
 }
 
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, KoColor * kc) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     kc->setColor(pix, m_d->colorSpace());
 
     return true;
 }
 
 KoColor KisPaintDevice::pixel(const QPoint &pos) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(pos.x(), pos.y(), 1);
     return KoColor(iter->rawDataConst(), m_d->colorSpace());
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const QColor& c)
 {
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
 
     colorSpace()->fromQColor(c, iter->rawData());
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const KoColor& kc)
 {
     const quint8 * pix;
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
     if (kc.colorSpace() != m_d->colorSpace()) {
         KoColor kc2(kc, m_d->colorSpace());
         pix = kc2.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     } else {
         pix = kc.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     }
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::fastBitBltPossible(KisPaintDeviceSP src)
 {
     return m_d->fastBitBltPossible(src);
 }
 
 void KisPaintDevice::fastBitBlt(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBlt(src, rect);
 }
 
 void KisPaintDevice::fastBitBltOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltOldData(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRough(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRough(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRoughOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRoughOldData(src, rect);
 }
 
 void KisPaintDevice::readBytes(quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     readBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::readBytes(quint8 *data, const QRect &rect) const
 {
     m_d->currentStrategy()->readBytes(data, rect);
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     writeBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, const QRect &rect)
 {
     m_d->currentStrategy()->writeBytes(data, rect);
 }
 
 QVector<quint8*> KisPaintDevice::readPlanarBytes(qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     return m_d->currentStrategy()->readPlanarBytes(x, y, w, h);
 }
 
 void KisPaintDevice::writePlanarBytes(QVector<quint8*> planes, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     m_d->currentStrategy()->writePlanarBytes(planes, x, y, w, h);
 }
 
 
 quint32 KisPaintDevice::pixelSize() const
 {
     quint32 _pixelSize = m_d->colorSpace()->pixelSize();
     Q_ASSERT(_pixelSize > 0);
     return _pixelSize;
 }
 
 quint32 KisPaintDevice::channelCount() const
 {
     quint32 _channelCount = m_d->colorSpace()->channelCount();
     Q_ASSERT(_channelCount > 0);
     return _channelCount;
 }
 
 KisRasterKeyframeChannel *KisPaintDevice::createKeyframeChannel(const KoID &id)
 {
     Q_ASSERT(!m_d->framesInterface);
     m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
 
     Q_ASSERT(!m_d->contentChannel);
     if (m_d->parent.isValid()) {
         m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, this, m_d->parent));
     } else {
         //fallback when paint device is isolated / does not belong to a node.
         ENTER_FUNCTION() << ppVar(this) << ppVar(m_d->defaultBounds);
         m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, this, m_d->defaultBounds));
     }
 
     // Raster channels always have at least one frame (representing a static image)
     KUndo2Command tempParentCommand;
     m_d->contentChannel->addKeyframe(0, &tempParentCommand);
 
     return m_d->contentChannel.data();
 }
 
 KisRasterKeyframeChannel* KisPaintDevice::keyframeChannel() const
 {
     if (m_d->contentChannel) {
         return m_d->contentChannel.data();
     }
     return 0;
 }
 
 const KoColorSpace* KisPaintDevice::colorSpace() const
 {
     Q_ASSERT(m_d->colorSpace() != 0);
     return m_d->colorSpace();
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice() const
 {
     KisPaintDeviceSP device = new KisPaintDevice(compositionSourceColorSpace());
     device->setDefaultBounds(defaultBounds());
     return device;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(*cloneSource);
     clone->setDefaultBounds(defaultBounds());
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource, const QRect roughRect) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(colorSpace());
     clone->setDefaultBounds(defaultBounds());
     clone->makeCloneFromRough(cloneSource, roughRect);
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisFixedPaintDeviceSP KisPaintDevice::createCompositionSourceDeviceFixed() const
 {
     return new KisFixedPaintDevice(compositionSourceColorSpace());
 }
 
 const KoColorSpace* KisPaintDevice::compositionSourceColorSpace() const
 {
     return colorSpace();
 }
 
 QVector<qint32> KisPaintDevice::channelSizes() const
 {
     QVector<qint32> sizes;
     QList<KoChannelInfo*> channels = colorSpace()->channels();
     std::sort(channels.begin(), channels.end());
 
     Q_FOREACH (KoChannelInfo * channelInfo, channels) {
         sizes.append(channelInfo->size());
     }
     return sizes;
 }
 
 KisPaintDevice::MemoryReleaseObject::~MemoryReleaseObject()
 {
     KisDataManager::releaseInternalPools();
 }
 
 KisPaintDevice::MemoryReleaseObject* KisPaintDevice::createMemoryReleaseObject()
 {
     return new MemoryReleaseObject();
 }
 
 KisPaintDevice::LodDataStruct::~LodDataStruct()
 {
 }
 
 KisRegion KisPaintDevice::regionForLodSyncing() const
 {
     return m_d->regionForLodSyncing();
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::createLodDataStruct(int lod)
 {
     return m_d->createLodDataStruct(lod);
 }
 
 void KisPaintDevice::updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect)
 {
     m_d->updateLodDataStruct(dst, srcRect);
 }
 
 void KisPaintDevice::uploadLodDataStruct(LodDataStruct *dst)
 {
     m_d->uploadLodDataStruct(dst);
 }
 
 void KisPaintDevice::generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod)
 {
     m_d->generateLodCloneDevice(dst, originalRect, lod);
 }
 
 
 KisPaintDeviceFramesInterface* KisPaintDevice::framesInterface()
 {
     return m_d->framesInterface.data();
 }
 
 /******************************************************************/
 /*               KisPaintDeviceFramesInterface                    */
 /******************************************************************/
 
 KisPaintDeviceFramesInterface::KisPaintDeviceFramesInterface(KisPaintDevice *parentDevice)
     : q(parentDevice)
 {
 }
 
 QList<int> KisPaintDeviceFramesInterface::frames()
 {
     return q->m_d->frameIds();
 }
 
 int KisPaintDeviceFramesInterface::createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
 {
     return q->m_d->createFrame(copy, copySrc, offset, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::deleteFrame(int frame, KUndo2Command *parentCommand)
 {
     return q->m_d->deleteFrame(frame, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     q->m_d->fetchFrame(frameId, targetDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(srcFrameId, dstFrameId, srcDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(dstFrameId, srcDevice);
 }
 
 QRect KisPaintDeviceFramesInterface::frameBounds(int frameId)
 {
     return q->m_d->frameBounds(frameId);
 }
 
 QPoint KisPaintDeviceFramesInterface::frameOffset(int frameId) const
 {
     return q->m_d->frameOffset(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameDefaultPixel(const KoColor &defPixel, int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     q->m_d->setFrameDefaultPixel(defPixel, frameId);
 }
 
 KoColor KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return KoColor(Qt::red, q->m_d->colorSpace());
     }
     return q->m_d->frameDefaultPixel(frameId);
 }
 
 bool KisPaintDeviceFramesInterface::writeFrame(KisPaintDeviceWriter &store, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->writeFrame(store, frameId);
 }
 
 bool KisPaintDeviceFramesInterface::readFrame(QIODevice *stream, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->readFrame(stream, frameId);
 }
 
 int KisPaintDeviceFramesInterface::currentFrameId() const
 {
     return q->m_d->currentFrameId();
 }
 
 KisDataManagerSP KisPaintDeviceFramesInterface::frameDataManager(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return q->m_d->dataManager();
     }
     return q->m_d->frameDataManager(frameId);
 }
 
 void KisPaintDeviceFramesInterface::invalidateFrameCache(int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
 
     return q->m_d->invalidateFrameCache(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameOffset(int frameId, const QPoint &offset)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     return q->m_d->setFrameOffset(frameId, offset);
 }
 
 KisPaintDeviceFramesInterface::TestingDataObjects
 KisPaintDeviceFramesInterface::testingGetDataObjects() const
 {
     TestingDataObjects objects;
 
     objects.m_data = q->m_d->m_data.data();
     objects.m_lodData = q->m_d->m_lodData.data();
     objects.m_externalFrameData = q->m_d->m_externalFrameData.data();
 
     typedef KisPaintDevice::Private::FramesHash FramesHash;
 
     FramesHash::const_iterator it = q->m_d->m_frames.constBegin();
     FramesHash::const_iterator end = q->m_d->m_frames.constEnd();
 
     for (; it != end; ++it) {
         objects.m_frames.insert(it.key(), it.value().data());
     }
 
     objects.m_currentData = q->m_d->currentData();
 
     return objects;
 }
 
 QList<KisPaintDeviceData*> KisPaintDeviceFramesInterface::testingGetDataObjectsList() const
 {
     return q->m_d->allDataObjects();
 }
 
 void KisPaintDevice::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     m_d->tesingFetchLodDevice(targetDevice);
 }
diff --git a/libs/image/kis_paint_device.h b/libs/image/kis_paint_device.h
index f2ea29725b..25565ec026 100644
--- a/libs/image/kis_paint_device.h
+++ b/libs/image/kis_paint_device.h
@@ -1,898 +1,917 @@
 /*
  *  Copyright (c) 2002 patrick julien <freak@codepimps.org>
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_PAINT_DEVICE_IMPL_H_
 #define KIS_PAINT_DEVICE_IMPL_H_
 
 #include <QObject>
 #include <QRect>
 #include <QVector>
 
 #include "kis_debug.h"
 
 #include <KoColorConversionTransformation.h>
 
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kis_default_bounds_base.h"
 
 #include <kritaimage_export.h>
 
 class KUndo2Command;
 class QRect;
 class QImage;
 class QPoint;
 class QString;
 class QColor;
 class QIODevice;
 
 class KoColor;
 class KoColorSpace;
 class KoColorProfile;
 
 class KisRegion;
 class KisDataManager;
 class KisPaintDeviceWriter;
 class KisKeyframe;
 class KisRasterKeyframeChannel;
 
 class KisPaintDeviceFramesInterface;
 
 typedef KisSharedPtr<KisDataManager> KisDataManagerSP;
 
 namespace KritaUtils {
 enum DeviceCopyMode {
     CopySnapshot = 0,
     CopyAllFrames
 };
 }
 
 
 /**
  * A paint device contains the actual pixel data and offers methods
  * to read and write pixels. A paint device has an integer x, y position
  * (it is not positioned on the image with sub-pixel accuracy).
  * A KisPaintDevice doesn't have any fixed size, the size changes dynamically
  * when pixels are accessed by an iterator.
  */
 class KRITAIMAGE_EXPORT KisPaintDevice
     : public QObject
     , public KisShared
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * Create a new paint device with the specified colorspace.
      *
      * @param colorSpace the colorspace of this paint device
      * @param name for debugging purposes
      */
     explicit KisPaintDevice(const KoColorSpace * colorSpace, const QString& name = QString());
 
     /**
      * Create a new paint device with the specified colorspace. The
      * parent node will be notified of changes to this paint device.
      *
      * @param parent the node that contains this paint device
      * @param colorSpace the colorspace of this paint device
      * @param defaultBounds boundaries of the device in case it is empty
      * @param name for debugging purposes
      */
     KisPaintDevice(KisNodeWSP parent, const KoColorSpace * colorSpace, KisDefaultBoundsBaseSP defaultBounds = KisDefaultBoundsBaseSP(), const QString& name = QString());
 
     /**
      * Creates a copy of this device.
      *
      * If \p copyMode is CopySnapshot, the newly created device clones the
      * current frame of \p rhs only (default and efficient
      * behavior). If \p copyFrames is CopyAllFrames, the new device is a deep
      * copy of the source with all the frames included.
      */
     KisPaintDevice(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode = KritaUtils::CopySnapshot, KisNode *newParentNode = 0);
     ~KisPaintDevice() override;
 
     void makeFullCopyFrom(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode = KritaUtils::CopySnapshot, KisNode *newParentNode = 0);
 
 protected:
     /**
      * A special constructor for usage in KisPixelSelection. It allows
      * two paint devices to share a data manager.
      *
      * @param explicitDataManager data manager to use inside paint device
      * @param src source paint device to copy parameters from
      * @param name for debugging purposes
      */
     KisPaintDevice(KisDataManagerSP explicitDataManager,
                    KisPaintDeviceSP src, const QString& name = QString());
 
 public:
 
     /**
      * Write the pixels of this paint device into the specified file store.
      */
     bool write(KisPaintDeviceWriter &store);
 
     /**
      * Fill this paint device with the pixels from the specified file store.
      */
     bool read(QIODevice *stream);
 
 public:
 
     /**
      * set the parent node of the paint device
      */
     void setParentNode(KisNodeWSP parent);
 
     /**
      * set the default bounds for the paint device when
      * the default pixel is not completely transparent
      */
     void setDefaultBounds(KisDefaultBoundsBaseSP bounds);
 
     /**
      * the default bounds rect of the paint device
      */
     KisDefaultBoundsBaseSP defaultBounds() const;
 
     /**
      * Moves the device to these new coordinates (no incremental move)
      */
     void moveTo(qint32 x, qint32 y);
 
     /**
      * Convenience method for the above.
      */
     virtual void moveTo(const QPoint& pt);
 
     /**
      * Return an X,Y offset of the device in a convenient form
      */
     QPoint offset() const;
 
     /**
      * The X offset of the paint device
      */
     qint32 x() const;
 
     /**
      * The Y offset of the paint device
      */
     qint32 y() const;
 
     /**
      * set the X offset of the paint device
      */
     void setX(qint32 x);
 
     /**
      * set the Y offset of the paint device
      */
     void setY(qint32 y);
 
     /**
      * Retrieve the bounds of the paint device. The size is not exact,
      * but may be larger if the underlying datamanager works that way.
      * For instance, the tiled datamanager keeps the extent to the nearest
      * multiple of 64.
      *
      * If default pixel is not transparent, then the actual extent
      * rect is united with the defaultBounds()->bounds() value
      * (the size of the image, usually).
      */
     QRect extent() const;
 
     /// Convenience method for the above
     void extent(qint32 &x, qint32 &y, qint32 &w, qint32 &h) const;
 
     /**
      * Get the exact bounds of this paint device. The real solution is
      * very slow because it does a linear scanline search, but it
      * uses caching, so calling to this function without changing
      * the device is quite cheap.
      *
      * Exactbounds follows these rules:
      *
      * <ul>
      * <li>if default pixel is transparent, then exact bounds
      *     of actual pixel data are returned
      * <li>if default pixel is not transparent, then the union
      *     (defaultBounds()->bounds() | nonDefaultPixelArea()) is
      *     returned
      * </ul>
      * \see calculateExactBounds()
      */
     QRect exactBounds() const;
 
     /**
      * Relaxed version of the exactBounds() that can be used in tight
      * loops.  If the exact bounds value is present in the paint
      * device cache, returns this value.  If the cache is invalidated,
      * returns extent() and tries to recalculate the exact bounds not
      * faster than once in 1000 ms.
      */
     QRect exactBoundsAmortized() const;
 
     /**
      * Returns exact rectangle of the paint device that contains
      * non-default pixels. For paint devices with fully transparent
      * default pixel is equivalent to exactBounds().
      *
      * nonDefaultPixelArea() follows these rules:
      *
      * <ul>
      * <li>if default pixel is transparent, then exact bounds
      *     of actual pixel data are returned. The same as exactBounds()
      * <li>if default pixel is not transparent, then calculates the
      *     rectangle of non-default pixels. May be smaller or greater
      *     than image bounds
      * </ul>
      * \see calculateExactBounds()
      */
     QRect nonDefaultPixelArea() const;
 
 
     /**
      * Returns a rough approximation of region covered by device.
      * For tiled data manager, it region will consist of a number
      * of rects each corresponding to a tile.
      */
     KisRegion region() const;
 
     /**
      * The slow version of region() that searches for exact bounds of
      * each rectangle in the region
      */
     KisRegion regionExact() const;
 
     /**
      * Cut the paint device down to the specified rect. If the crop
      * area is bigger than the paint device, nothing will happen.
      */
     void crop(qint32 x, qint32 y, qint32 w, qint32 h);
 
     /// Convenience method for the above
     void crop(const QRect & r);
 
     /**
      * Complete erase the current paint device. Its size will become 0. This
      * does not take the selection into account.
      */
     virtual void clear();
 
     /**
      * Clear the given rectangle to transparent black. The paint device will expand to
      * contain the given rect.
      */
     void clear(const QRect & rc);
 
     /**
      * Frees the memory occupied by the pixels containing default
      * values. The extents() and exactBounds() of the paint device will
      * probably also shrink
      */
     void purgeDefaultPixels();
 
     /**
      * Sets the default pixel. New data will be initialised with this pixel. The pixel is copied: the
      * caller still owns the pointer and needs to delete it to avoid memory leaks.
      * If frame ID is given, set default pixel for that frame. Otherwise use active frame.
      */
     void setDefaultPixel(const KoColor &defPixel);
 
     /**
      * Get a pointer to the default pixel.
      * If the frame parameter is given, get the default pixel of
      * specified frame. Otherwise use currently active frame.
      */
     KoColor defaultPixel() const;
 
     /**
      * Fill the given rectangle with the given pixel. The paint device will expand to
      * contain the given rect.
      */
     void fill(const QRect & rc, const KoColor &color);
 
     /**
      * Overloaded function. For legacy purposes only.
      * Please use fill(const QRect & rc, const KoColor &color) instead
      */
     void fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel);
 
 public:
 
     /**
      * Prepares the device for fastBitBlt operation. It clears
      * the device, switches x,y shifts and colorspace if needed.
      * After this call fastBitBltPossible will return true.
      * May be used for initialization of temporary devices.
      */
     void prepareClone(KisPaintDeviceSP src);
 
     /**
      * Make this device to become a clone of \a src. It will have the same
      * x,y shifts, colorspace and will share pixels inside \a rect.
      * After calling this function:
      * (this->extent() >= this->exactBounds() == rect).
      *
      * Rule of thumb:
      *
      * "Use makeCloneFrom() or makeCloneFromRough() if and only if you
      * are the only owner of the destination paint device and you are
      * 100% sure no other thread has access to it"
      */
     void makeCloneFrom(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * Make this device to become a clone of \a src. It will have the same
      * x,y shifts, colorspace and will share pixels inside \a rect.
      * Be careful, this function will copy *at least* \a rect
      * of pixels. Actual copy area will be a bigger - it will
      * be aligned by tiles borders. So after calling this function:
      * (this->extent() == this->exactBounds() >= rect).
      *
      * Rule of thumb:
      *
      * "Use makeCloneFrom() or makeCloneFromRough() if and only if you
      * are the only owner of the destination paint device and you are
      * 100% sure no other thread has access to it"
      */
     void makeCloneFromRough(KisPaintDeviceSP src, const QRect &minimalRect);
 
 
 protected:
     friend class KisPaintDeviceTest;
     friend class DataReaderThread;
 
     /**
      * Checks whether a src paint device can be used as source
      * of fast bitBlt operation. The result of the check may
      * depend on whether color spaces coincide, whether there is
      * any shift of tiles between the devices and etc.
      *
      * WARNING: This check must be done <i>before</i> performing any
      * fast bitBlt operation!
      *
      * \see fastBitBlt
      * \see fastBitBltRough
      */
     bool fastBitBltPossible(KisPaintDeviceSP src);
 
     /**
      * Clones rect from another paint device. The cloned area will be
      * shared between both paint devices as much as possible using
      * copy-on-write. Parts of the rect that cannot be shared
      * (cross tiles) are deep-copied,
      *
      * \see fastBitBltPossible
      * \see fastBitBltRough
      */
     void fastBitBlt(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * The same as \ref fastBitBlt() but reads old data
      */
     void fastBitBltOldData(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * Clones rect from another paint device in a rough and fast way.
      * All the tiles touched by rect will be shared, between both
      * devices, that means it will copy a bigger area than was
      * requested. This method is supposed to be used for bitBlt'ing
      * into temporary paint devices.
      *
      * \see fastBitBltPossible
      * \see fastBitBlt
      */
     void fastBitBltRough(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * The same as \ref fastBitBltRough() but reads old data
      */
     void fastBitBltRoughOldData(KisPaintDeviceSP src, const QRect &rect);
 
 public:
     /**
      * Read the bytes representing the rectangle described by x, y, w, h into
      * data. If data is not big enough, Krita will gladly overwrite the rest
      * of your precious memory.
      *
      * Since this is a copy, you need to make sure you have enough memory.
      *
      * Reading from areas not previously initialized will read the default
      * pixel value into data but not initialize that region.
      */
     void readBytes(quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h) const;
 
     /**
      * Read the bytes representing the rectangle rect into
      * data. If data is not big enough, Krita will gladly overwrite the rest
      * of your precious memory.
      *
      * Since this is a copy, you need to make sure you have enough memory.
      *
      * Reading from areas not previously initialized will read the default
      * pixel value into data but not initialize that region.
      * @param data The address of the memory to receive the bytes read
      * @param rect The rectangle in the paint device to read from
      */
     void readBytes(quint8 * data, const QRect &rect) const;
 
     /**
      * Copy the bytes in data into the rect specified by x, y, w, h. If the
      * data is too small or uninitialized, Krita will happily read parts of
      * memory you never wanted to be read.
      *
      * If the data is written to areas of the paint device not previously initialized,
      * the paint device will grow.
      */
     void writeBytes(const quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h);
 
     /**
      * Copy the bytes in data into the rectangle rect. If the
      * data is too small or uninitialized, Krita will happily read parts of
      * memory you never wanted to be read.
      *
      * If the data is written to areas of the paint device not previously initialized,
      * the paint device will grow.
      * @param data The address of the memory to write bytes from
      * @param rect The rectangle in the paint device to write to
      */
     void writeBytes(const quint8 * data, const QRect &rect);
 
     /**
      * Copy the bytes in the paint device into a vector of arrays of bytes,
      * where the number of arrays is the number of channels in the
      * paint device. If the specified area is larger than the paint
      * device's extent, the default pixel will be read.
      */
     QVector<quint8*> readPlanarBytes(qint32 x, qint32 y, qint32 w, qint32 h) const;
 
     /**
      * Write the data in the separate arrays to the channes. If there
      * are less vectors than channels, the remaining channels will not
      * be copied. If any of the arrays points to 0, the channel in
      * that location will not be touched. If the specified area is
      * larger than the paint device, the paint device will be
      * extended. There are no guards: if the area covers more pixels
      * than there are bytes in the arrays, krita will happily fill
      * your paint device with areas of memory you never wanted to be
      * read. Krita may also crash.
      *
      * XXX: what about undo?
      */
     void writePlanarBytes(QVector<quint8*> planes, qint32 x, qint32 y, qint32 w, qint32 h);
 
     /**
      * Converts the paint device to a different colorspace
      */
     void convertTo(const KoColorSpace * dstColorSpace,
                    KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                    KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags(),
                    KUndo2Command *parentCommand = 0);
 
     /**
      * Changes the profile of the colorspace of this paint device to the given
      * profile. If the given profile is 0, nothing happens.
      */
     bool setProfile(const KoColorProfile * profile, KUndo2Command *parentCommand);
 
     /**
      * Fill this paint device with the data from image; starting at (offsetX, offsetY)
      * @param image the image
      * @param profile name of the RGB profile to interpret the image as. 0 is interpreted as sRGB
      * @param offsetX x offset
      * @param offsetY y offset
      */
     void convertFromQImage(const QImage& image, const KoColorProfile *profile, qint32 offsetX = 0, qint32 offsetY = 0);
 
     /**
      * Create an RGBA QImage from a rectangle in the paint device.
      *
      * @param dstProfile RGB profile to use in conversion. May be 0, in which
      * case it's up to the color strategy to choose a profile (most
      * like sRGB).
      * @param x Left coordinate of the rectangle
      * @param y Top coordinate of the rectangle
      * @param w Width of the rectangle in pixels
      * @param h Height of the rectangle in pixels
      * @param renderingIntent Rendering intent
      * @param conversionFlags Conversion flags
      */
     QImage convertToQImage(const KoColorProfile *dstProfile, qint32 x, qint32 y, qint32 w, qint32 h,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Overridden method for convenience
      */
     QImage convertToQImage(const KoColorProfile *dstProfile,
                            const QRect &rc,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Create an RGBA QImage from a rectangle in the paint device. The
      * rectangle is defined by the parent image's bounds.
      *
      * @param dstProfile RGB profile to use in conversion. May be 0, in which
      * case it's up to the color strategy to choose a profile (most
      * like sRGB).
      * @param renderingIntent Rendering intent
      * @param conversionFlags Conversion flags
      */
     QImage convertToQImage(const KoColorProfile *  dstProfile,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Creates a paint device thumbnail of the paint device, retaining
      * the aspect ratio. The width and height of the returned device
      * won't exceed \p maxw and \p maxw, but they may be smaller.
      *
      * @param w maximum width
      * @param h maximum height
      * @param rect only this rect will be used for the thumbnail
      * @param outputRect output rectangle
      *
      */
     KisPaintDeviceSP createThumbnailDevice(qint32 w, qint32 h, QRect rect = QRect(), QRect outputRect = QRect()) const;
     KisPaintDeviceSP createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect = QRect(),  QRect outputRect = QRect()) const;
 
     /**
      * Creates a thumbnail of the paint device, retaining the aspect ratio.
      * The width and height of the returned QImage won't exceed \p maxw and \p maxw, but they may be smaller.
      * The colors are not corrected for display!
      *
      * @param maxw: maximum width
      * @param maxh: maximum height
      * @param rect: only this rect will be used for the thumbnail
      * @param oversample: ratio used for antialiasing
      * @param renderingIntent Rendering intent
      * @param conversionFlags Conversion flags
      */
     QImage createThumbnail(qint32 maxw, qint32 maxh, QRect rect, qreal oversample = 1,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     /**
      * Cached version of createThumbnail(qint32 maxw, qint32 maxh, const KisSelection *selection, QRect rect)
      */
     QImage createThumbnail(qint32 maxw, qint32 maxh, qreal oversample = 1,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     /**
      * Fill c and opacity with the values found at x and y.
      *
      * The color values will be transformed from the profile of
      * this paint device to the display profile.
      *
      * @return true if the operation was successful.
      */
     bool pixel(qint32 x, qint32 y, QColor *c) const;
 
     /**
      * Fill kc with the values found at x and y. This method differs
      * from the above in using KoColor, which can be of any colorspace
      *
      * The color values will be transformed from the profile of
      * this paint device to the display profile.
      *
      * @return true if the operation was successful.
      */
     bool pixel(qint32 x, qint32 y, KoColor * kc) const;
 
     /**
      * Return pixel value in a form of KoColor. Please don't use this method
      * for iteration, it is highly inefficient. Use iterators instead.
      */
     KoColor pixel(const QPoint &pos) const;
 
     /**
      * Set the specified pixel to the specified color. Note that this
      * bypasses KisPainter. the PaintDevice is here used as an equivalent
      * to QImage, not QPixmap. This means that this is not undoable; also,
      * there is no compositing with an existing value at this location.
      *
      * The color values will be transformed from the display profile to
      * the paint device profile.
      *
      * Note that this will use 8-bit values and may cause a significant
      * degradation when used on 16-bit or hdr quality images.
      *
      * @return true if the operation was successful
      */
     bool setPixel(qint32 x, qint32 y, const QColor& c);
 
     /// Convenience method for the above
     bool setPixel(qint32 x, qint32 y, const KoColor& kc);
 
     /**
      * @return the colorspace of the pixels in this paint device
      */
     const KoColorSpace* colorSpace() const;
 
     /**
      * There is quite a common technique in Krita. It is used in
      * cases, when we want to paint something over a paint device
      * using the composition, opacity or selection. E.g. painting a
      * dab in a paint op, filling the selection in the Fill Tool.
      * Such work is usually done in the following way:
      *
      * 1) Create a paint device
      *
      * 2) Fill it with the desired color or data
      *
      * 3) Create a KisPainter and set all the properties of the
      *    transaction: selection, compositeOp, opacity and etc.
      *
      * 4) Paint a newly created paint device over the destination
      *    device.
      *
      * The following two methods (createCompositionSourceDevice() or
      * createCompositionSourceDeviceFixed())should be used for the
      * accomplishing the step 1). The point is that the desired color
      * space of the temporary device may not coincide with the color
      * space of the destination. That is the case, for example, for
      * the alpha8() colorspace used in the selections. So for such
      * devices the temporary target would have a different (grayscale)
      * color space.
      *
      * So there are two rules of thumb:
      *
      * 1) If you need a temporary device which you are going to fill
      *    with some data and then paint over the paint device, create
      *    it with either createCompositionSourceDevice() or
      *    createCompositionSourceDeviceFixed().
      *
      * 2) Do *not* expect that the color spaces of the destination and
      *    the temporary device would coincide. If you need to copy a
      *    single pixel from one device to another, you can use
      *    KisCrossDeviceColorPicker class, that will handle all the
      *    necessary conversions for you.
      *
      * \see createCompositionSourceDeviceFixed()
      * \see compositionSourceColorSpace()
      * \see KisCrossDeviceColorPicker
      * \see KisCrossDeviceColorPickerInt
      */
     KisPaintDeviceSP createCompositionSourceDevice() const;
 
     /**
      * The same as createCompositionSourceDevice(), but initializes the
      * newly created device with the content of \p cloneSource
      *
      * \see createCompositionSourceDevice()
      */
     KisPaintDeviceSP createCompositionSourceDevice(KisPaintDeviceSP cloneSource) const;
 
     /**
      * The same as createCompositionSourceDevice(), but initializes
      * the newly created device with the *rough* \p roughRect of
      * \p cloneSource.
      *
      * "Rough rect" means that it may copy a bit more than
      * requested. It is expected that the caller will not use the area
      * outside \p roughRect.
      *
      * \see createCompositionSourceDevice()
      */
     KisPaintDeviceSP createCompositionSourceDevice(KisPaintDeviceSP cloneSource, const QRect roughRect) const;
 
     /**
      * This is a convenience method for createCompositionSourceDevice()
      *
      * \see createCompositionSourceDevice()
      */
     KisFixedPaintDeviceSP createCompositionSourceDeviceFixed() const;
 
     /**
      * This is a lowlevel method for the principle used in
      * createCompositionSourceDevice(). In most of the cases the paint
      * device creation methods should be used instead of this function.
      *
      * \see createCompositionSourceDevice()
      * \see createCompositionSourceDeviceFixed()
      */
     virtual const KoColorSpace* compositionSourceColorSpace() const;
 
     /**
      * @return the internal datamanager that keeps the pixels.
      */
     KisDataManagerSP dataManager() const;
 
     /**
      * Replace the pixel data, color strategy, and profile.
      */
     void setDataManager(KisDataManagerSP data, const KoColorSpace * colorSpace = 0);
 
     /**
      * Return the number of bytes a pixel takes.
      */
     quint32 pixelSize() const;
 
     /**
      * Return the number of channels a pixel takes
      */
     quint32 channelCount() const;
 
     /**
      * Create a keyframe channel for the content on this device.
      * @param id identifier for the channel
      * @return keyframe channel or 0 if there is not one
      */
     KisRasterKeyframeChannel *createKeyframeChannel(const KoID &id);
 
     KisRasterKeyframeChannel* keyframeChannel() const;
 
     /**
      * An interface to modify/load/save frames stored inside this device
      */
     KisPaintDeviceFramesInterface* framesInterface();
 
 public:
 
     /**
      * Add the specified rect to the parent layer's set of dirty rects
      * (if there is a parent layer)
      */
     void setDirty(const QRect & rc);
 
     void setDirty(const KisRegion &region);
 
     /**
      *  Set the parent layer completely dirty, if this paint device has
      *  as parent layer.
      */
     void setDirty();
 
     void setDirty(const QVector<QRect> &rects);
 
     /**
      * Called by KisTransactionData when it thinks current time should
      * be changed. And the requests is forwarded to the image if
      * needed.
      */
     void requestTimeSwitch(int time);
 
     /**
      * \return a sequence number corresponding to the current paint
      *         device state. Every time the paint device is changed,
      *         the sequence number is increased
      */
     int sequenceNumber() const;
 
 
     void estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const;
 
 public:
 
     KisHLineIteratorSP createHLineIteratorNG(qint32 x, qint32 y, qint32 w);
     KisHLineConstIteratorSP createHLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const;
 
     KisVLineIteratorSP createVLineIteratorNG(qint32 x, qint32 y, qint32 h);
     KisVLineConstIteratorSP createVLineConstIteratorNG(qint32 x, qint32 y, qint32 h) const;
 
     KisRandomAccessorSP createRandomAccessorNG();
     KisRandomConstAccessorSP createRandomConstAccessorNG() const;
 
     /**
      * Create an iterator that will "artificially" extend the paint device with the
      * value of the border when trying to access values outside the range of data.
      *
      * @param x x of top left corner
      * @param y y of top left corner
      * @param w width of the border
      * @param _dataWidth indicates the rectangle that truly contains data
      */
     KisRepeatHLineConstIteratorSP createRepeatHLineConstIterator(qint32 x, qint32 y, qint32 w, const QRect& _dataWidth) const;
     /**
      * Create an iterator that will "artificially" extend the paint device with the
      * value of the border when trying to access values outside the range of data.
      *
      * @param x x of top left corner
      * @param y y of top left corner
      * @param h height of the border
      * @param _dataWidth indicates the rectangle that truly contains data
      */
     KisRepeatVLineConstIteratorSP createRepeatVLineConstIterator(qint32 x, qint32 y, qint32 h, const QRect& _dataWidth) const;
 
     /**
      * This function create a random accessor which can easily access to sub pixel values.
      */
     KisRandomSubAccessorSP createRandomSubAccessor() const;
 
 
     /** Clear the selected pixels from the paint device */
     void clearSelection(KisSelectionSP selection);
 
+    /**
+     * Converts a paint device into a "new" paint device, that has
+     * unconnected history. That is, after reincarnation, the device's
+     * life starts a new page. No history. No memories.
+     *
+     * When the device is fed up with the new life, it can reincarnate
+     * back to its previous life by undoing the command returned by
+     * reincarnateWithDetachedHistory(). The old undo will continue
+     * working as if nothing has happened.
+     *
+     * NOTE: reincarnation affects only the current lod plane and/or
+     *       current frame. All other frames are kept unaffected.
+     *
+     * @param copyContent decides if the device should take its current
+     *                    content to the new life
+     * @return undo command for execution and undoing of the reincarnation
+     */
+    KUndo2Command* reincarnateWithDetachedHistory(bool copyContent);
+
 Q_SIGNALS:
 
     void profileChanged(const KoColorProfile *  profile);
     void colorSpaceChanged(const KoColorSpace *colorspace);
 
 public:
     friend class PaintDeviceCache;
 
     /**
      * Caclculates exact bounds of the device. Used internally
      * by a transparent caching system. The solution is very slow
      * because it does a linear scanline search. So the complexity
      * is n*n at worst.
      *
      * \see exactBounds(), nonDefaultPixelArea()
      */
     QRect calculateExactBounds(bool nonDefaultOnly) const;
 
 public:
     struct MemoryReleaseObject : public QObject {
         ~MemoryReleaseObject() override;
     };
 
     static MemoryReleaseObject* createMemoryReleaseObject();
 
 public:
     struct LodDataStruct {
         virtual ~LodDataStruct();
     };
 
     KisRegion regionForLodSyncing() const;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
 
     void generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod);
 
     void setProjectionDevice(bool value);
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 private:
     KisPaintDevice& operator=(const KisPaintDevice&);
     void init(const KoColorSpace *colorSpace,
               KisDefaultBoundsBaseSP defaultBounds,
               KisNodeWSP parent, const QString& name);
 
     // Only KisPainter is allowed to have access to these low-level methods
     friend class KisPainter;
 
     /**
      * Return a vector with in order the size in bytes of the channels
      * in the colorspace of this paint device.
      */
     QVector<qint32> channelSizes() const;
 
     void emitColorSpaceChanged();
     void emitProfileChanged();
 
 private:
     friend class KisPaintDeviceFramesInterface;
 
 protected:
     friend class KisSelectionTest;
     KisNodeWSP parentNode() const;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif // KIS_PAINT_DEVICE_IMPL_H_
diff --git a/libs/image/kis_paint_device_data.h b/libs/image/kis_paint_device_data.h
index 836b972d63..aa6624dc31 100644
--- a/libs/image/kis_paint_device_data.h
+++ b/libs/image/kis_paint_device_data.h
@@ -1,317 +1,357 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_PAINT_DEVICE_DATA_H
 #define __KIS_PAINT_DEVICE_DATA_H
 
 #include "KoAlwaysInline.h"
 #include "kundo2command.h"
+#include "kis_command_utils.h"
 
 
 struct DirectDataAccessPolicy {
     DirectDataAccessPolicy(KisDataManager *dataManager, KisIteratorCompleteListener *completionListener)
         : m_dataManager(dataManager),
           m_completionListener(completionListener){}
 
 
     KisHLineConstIteratorSP createConstIterator(const QRect &rect) {
         const int xOffset = 0;
         const int yOffset = 0;
         return new KisHLineIterator2(m_dataManager, rect.x(), rect.y(), rect.width(), xOffset, yOffset, false, m_completionListener);
     }
 
     KisHLineIteratorSP createIterator(const QRect &rect) {
         const int xOffset = 0;
         const int yOffset = 0;
         return new KisHLineIterator2(m_dataManager, rect.x(), rect.y(), rect.width(), xOffset, yOffset, true, m_completionListener);
     }
 
     int pixelSize() const {
         return m_dataManager->pixelSize();
     }
 
     KisDataManager *m_dataManager;
     KisIteratorCompleteListener *m_completionListener;
 };
 
 class KisPaintDeviceData
 {
 public:
     KisPaintDeviceData(KisPaintDevice *paintDevice)
         : m_cache(paintDevice),
           m_x(0), m_y(0),
           m_colorSpace(0),
           m_levelOfDetail(0),
           m_cacheInvalidator(this)
         {
         }
 
     KisPaintDeviceData(KisPaintDevice *paintDevice, const KisPaintDeviceData *rhs, bool cloneContent)
         : m_dataManager(cloneContent ?
                         new KisDataManager(*rhs->m_dataManager) :
                         new KisDataManager(rhs->m_dataManager->pixelSize(), rhs->m_dataManager->defaultPixel())),
           m_cache(paintDevice),
           m_x(rhs->m_x),
           m_y(rhs->m_y),
           m_colorSpace(rhs->m_colorSpace),
           m_levelOfDetail(rhs->m_levelOfDetail),
           m_cacheInvalidator(this)
         {
             m_cache.setupCache();
         }
 
     void init(const KoColorSpace *cs, KisDataManagerSP dataManager) {
         m_colorSpace = cs;
         m_dataManager = dataManager;
         m_cache.setupCache();
     }
 
     class ChangeProfileCommand : public KUndo2Command {
     public:
         ChangeProfileCommand(KisPaintDeviceData *data,
                              const KoColorSpace *oldCs, const KoColorSpace *newCs,
                              KUndo2Command *parent)
             : KUndo2Command(parent),
               m_data(data),
               m_oldCs(oldCs),
               m_newCs(newCs)
         {
         }
 
         virtual void forcedRedo() {
             m_data->m_colorSpace = m_newCs;
             m_data->m_cache.setupCache();
         }
 
         void redo() override {
             if (m_firstRun) {
                 m_firstRun = false;
                 return;
             }
 
             KUndo2Command::redo();
             forcedRedo();
         }
 
         void undo() override {
             m_data->m_colorSpace = m_oldCs;
             m_data->m_cache.setupCache();
 
             KUndo2Command::undo();
         }
 
     protected:
         KisPaintDeviceData *m_data;
 
     private:
         bool m_firstRun {true};
         const KoColorSpace *m_oldCs;
         const KoColorSpace *m_newCs;
     };
 
 
     class ChangeColorSpaceCommand : public ChangeProfileCommand {
     public:
         ChangeColorSpaceCommand(KisPaintDeviceData *data,
                              KisDataManagerSP oldDm, KisDataManagerSP newDm,
                              const KoColorSpace *oldCs, const KoColorSpace *newCs,
                              KUndo2Command *parent)
             : ChangeProfileCommand(data, oldCs, newCs, parent),
               m_oldDm(oldDm),
               m_newDm(newDm)
         {
         }
 
         void forcedRedo() override {
             m_data->m_dataManager = m_newDm;
             ChangeProfileCommand::forcedRedo();
         }
 
         void undo() override {
             m_data->m_dataManager = m_oldDm;
             ChangeProfileCommand::undo();
         }
 
     private:
         KisDataManagerSP m_oldDm;
         KisDataManagerSP m_newDm;
     };
 
     void assignColorSpace(const KoColorSpace *dstColorSpace, KUndo2Command *parentCommand) {
         if (*m_colorSpace->profile() == *dstColorSpace->profile()) return;
 
         KIS_ASSERT_RECOVER_RETURN(m_colorSpace->pixelSize() == dstColorSpace->pixelSize());
 
         ChangeProfileCommand *cmd =
             new ChangeProfileCommand(this,
                                      m_colorSpace, dstColorSpace,
                                      parentCommand);
         cmd->forcedRedo();
         if (!parentCommand) {
             delete cmd;
         }
     }
 
     void convertDataColorSpace(const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand) {
         typedef KisSequentialIteratorBase<ReadOnlyIteratorPolicy<DirectDataAccessPolicy>, DirectDataAccessPolicy> InternalSequentialConstIterator;
         typedef KisSequentialIteratorBase<WritableIteratorPolicy<DirectDataAccessPolicy>, DirectDataAccessPolicy> InternalSequentialIterator;
 
         if (m_colorSpace == dstColorSpace || *m_colorSpace == *dstColorSpace) {
             return;
         }
 
         QRect rc = m_dataManager->region().boundingRect();
 
         const int dstPixelSize = dstColorSpace->pixelSize();
         QScopedArrayPointer<quint8> dstDefaultPixel(new quint8[dstPixelSize]);
         memset(dstDefaultPixel.data(), 0, dstPixelSize);
         m_colorSpace->convertPixelsTo(m_dataManager->defaultPixel(), dstDefaultPixel.data(), dstColorSpace, 1, renderingIntent, conversionFlags);
 
         KisDataManagerSP dstDataManager = new KisDataManager(dstPixelSize, dstDefaultPixel.data());
 
 
         if (!rc.isEmpty()) {
             InternalSequentialConstIterator srcIt(DirectDataAccessPolicy(m_dataManager.data(), cacheInvalidator()), rc);
             InternalSequentialIterator dstIt(DirectDataAccessPolicy(dstDataManager.data(), cacheInvalidator()), rc);
 
             int nConseqPixels = srcIt.nConseqPixels();
 
             // since we are accessing data managers directly, the columns are always aligned
             KIS_SAFE_ASSERT_RECOVER_NOOP(srcIt.nConseqPixels() == dstIt.nConseqPixels());
 
             while(srcIt.nextPixels(nConseqPixels) &&
                   dstIt.nextPixels(nConseqPixels)) {
 
                 nConseqPixels = srcIt.nConseqPixels();
 
                 const quint8 *srcData = srcIt.rawDataConst();
                 quint8 *dstData = dstIt.rawData();
 
                 m_colorSpace->convertPixelsTo(srcData, dstData,
                                               dstColorSpace,
                                               nConseqPixels,
                                               renderingIntent, conversionFlags);
             }
         }
 
         // becomes owned by the parent
         ChangeColorSpaceCommand *cmd =
             new ChangeColorSpaceCommand(this,
                                         m_dataManager, dstDataManager,
                                         m_colorSpace, dstColorSpace,
                                         parentCommand);
         cmd->forcedRedo();
         if (!parentCommand) {
             delete cmd;
         }
     }
 
+    void reincarnateWithDetachedHistory(bool copyContent, KUndo2Command *parentCommand) {
+        struct SwitchDataManager : public KUndo2Command
+        {
+            SwitchDataManager(KisPaintDeviceData *data,
+                              KisDataManagerSP oldDm, KisDataManagerSP newDm,
+                              KUndo2Command *parent = 0)
+                : KUndo2Command(parent),
+                  m_data(data),
+                  m_oldDm(oldDm),
+                  m_newDm(newDm)
+            {
+            }
+
+            void redo() override {
+                m_data->m_dataManager = m_newDm;
+                m_data->cache()->invalidate();
+            }
+
+            void undo() override {
+                m_data->m_dataManager = m_oldDm;
+                m_data->cache()->invalidate();
+            }
+
+        private:
+            KisPaintDeviceData *m_data;
+            KisDataManagerSP m_oldDm;
+            KisDataManagerSP m_newDm;
+        };
+
+        new KisCommandUtils::LambdaCommand(parentCommand,
+            [this, copyContent] () {
+                KisDataManagerSP newDm =
+                    copyContent ?
+                    new KisDataManager(*this->dataManager()) :
+                    new KisDataManager(this->dataManager()->pixelSize(), this->dataManager()->defaultPixel());
+                return new SwitchDataManager(this, this->dataManager(), newDm);
+            });
+    }
+
     void prepareClone(const KisPaintDeviceData *srcData, bool copyContent = false) {
         m_x = srcData->x();
         m_y = srcData->y();
 
         if (copyContent) {
             m_dataManager = new KisDataManager(*srcData->dataManager());
         } else if (m_dataManager->pixelSize() !=
                    srcData->dataManager()->pixelSize()) {
             // NOTE: we don't check default pixel value! it is the task of
             //       the higher level!
 
             m_dataManager = new KisDataManager(srcData->dataManager()->pixelSize(), srcData->dataManager()->defaultPixel());
             m_cache.setupCache();
         } else {
             m_dataManager->clear();
             const quint8 *srcDefPixel = srcData->dataManager()->defaultPixel();
 
             const int cmp =
                 memcmp(srcDefPixel,
                        m_dataManager->defaultPixel(),
                        m_dataManager->pixelSize());
 
             if (cmp != 0) {
                 m_dataManager->setDefaultPixel(srcDefPixel);
             }
         }
 
         m_levelOfDetail = srcData->levelOfDetail();
         m_colorSpace = srcData->colorSpace();
         m_cache.invalidate();
     }
 
     ALWAYS_INLINE KisDataManagerSP dataManager() const {
         return m_dataManager;
     }
 
     ALWAYS_INLINE KisPaintDeviceCache* cache() {
         return &m_cache;
     }
 
     ALWAYS_INLINE qint32 x() const {
         return m_x;
     }
     ALWAYS_INLINE void setX(qint32 value) {
         m_x = value;
     }
 
     ALWAYS_INLINE qint32 y() const {
         return m_y;
     }
     ALWAYS_INLINE void setY(qint32 value) {
         m_y = value;
     }
 
     ALWAYS_INLINE const KoColorSpace* colorSpace() const {
         return m_colorSpace;
     }
 
     ALWAYS_INLINE qint32 levelOfDetail() const {
         return m_levelOfDetail;
     }
     ALWAYS_INLINE void setLevelOfDetail(qint32 value) {
         m_levelOfDetail = value;
     }
 
     ALWAYS_INLINE KisIteratorCompleteListener* cacheInvalidator() {
         return &m_cacheInvalidator;
     }
 
 
 private:
     struct CacheInvalidator : public KisIteratorCompleteListener {
         CacheInvalidator(KisPaintDeviceData *_q) : q(_q) {}
 
         void notifyWritableIteratorCompleted() override {
             q->cache()->invalidate();
         }
     private:
         KisPaintDeviceData *q;
     };
 
 
 private:
 
     KisDataManagerSP m_dataManager;
     KisPaintDeviceCache m_cache;
     qint32 m_x;
     qint32 m_y;
     const KoColorSpace* m_colorSpace;
     qint32 m_levelOfDetail;
     CacheInvalidator m_cacheInvalidator;
 };
 
 #endif /* __KIS_PAINT_DEVICE_DATA_H */
diff --git a/libs/image/kis_selection.cc b/libs/image/kis_selection.cc
index 59dc9c3bd8..5594822c3b 100644
--- a/libs/image/kis_selection.cc
+++ b/libs/image/kis_selection.cc
@@ -1,361 +1,485 @@
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection.h"
 
 #include "kundo2command.h"
 
 #include "kis_selection_component.h"
 #include "kis_pixel_selection.h"
 #include "kis_node_graph_listener.h"
 #include "kis_node.h"
 #include "kis_image.h"
 
 #include "kis_default_bounds.h"
 #include "kis_iterator_ng.h"
 #include "KisLazyStorage.h"
 #include "KisSelectionUpdateCompressor.h"
+#include "kis_simple_stroke_strategy.h"
+#include "KisDeleteLaterWrapper.h"
+#include "kis_command_utils.h"
 
 struct Q_DECL_HIDDEN KisSelection::Private {
     Private(KisSelection *q)
         : isVisible(true),
           shapeSelection(0),
           updateCompressor(q)
 
     {
     }
 
+    static void safeDeleteShapeSelection(KisSelectionComponent *shapeSelection, KisSelection *selection);
+
     // used for forwarding setDirty signals only
     KisNodeWSP parentNode;
 
     bool isVisible; //false is the selection decoration should not be displayed
     KisDefaultBoundsBaseSP defaultBounds;
     KisPixelSelectionSP pixelSelection;
     KisSelectionComponent *shapeSelection;
     KisLazyStorage<KisSelectionUpdateCompressor> updateCompressor;
 };
 
+void KisSelection::Private::safeDeleteShapeSelection(KisSelectionComponent *shapeSelection, KisSelection *selection)
+{
+    struct ShapeSelectionReleaseStroke : public KisSimpleStrokeStrategy {
+        ShapeSelectionReleaseStroke(KisSelectionComponent *shapeSelection)
+            : KisSimpleStrokeStrategy(QLatin1String("ShapeSelectionReleaseStroke")),
+              m_shapeSelection(shapeSelection)
+        {
+            setRequestsOtherStrokesToEnd(false);
+            setClearsRedoOnStart(false);
+            setNeedsExplicitCancel(true);
+
+            this->enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
+            this->enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
+        }
+
+        void finishStrokeCallback() {
+            makeKisDeleteLaterWrapper(m_shapeSelection)->deleteLater();
+        }
+
+        void cancelStrokeCallback() {
+            finishStrokeCallback();
+        }
+
+    private:
+        KisSelectionComponent *m_shapeSelection = 0;
+    };
+
+
+
+    KisImageSP image = 0;
+
+    KisNodeSP parentNode = selection->parentNode();
+    if (parentNode) {
+        image = parentNode->image();
+    }
+
+    if (image) {
+        KisStrokeId strokeId = image->startStroke(new ShapeSelectionReleaseStroke(shapeSelection));
+        image->endStroke(strokeId);
+    } else {
+        makeKisDeleteLaterWrapper(shapeSelection)->deleteLater();
+    }
+}
+
+struct KisSelection::ChangeShapeSelectionCommand : public KUndo2Command
+{
+    ChangeShapeSelectionCommand(KisSelection *selection, KisSelectionComponent *shapeSelection)
+        : m_selection(selection),
+          m_shapeSelection(shapeSelection)
+    {
+        m_isFlatten = !shapeSelection;
+    }
+
+    ~ChangeShapeSelectionCommand() {
+        if (m_shapeSelection) {
+            Private::safeDeleteShapeSelection(m_shapeSelection, m_selection);
+        }
+    }
+
+    void undo() override
+    {
+        if (m_reincarnationCommand) {
+            m_reincarnationCommand->undo();
+        }
+
+        std::swap(m_selection->m_d->shapeSelection, m_shapeSelection);
+
+        if (!m_isFlatten) {
+            m_selection->requestCompressedProjectionUpdate(QRect());
+        }
+    }
+
+    void redo() override
+    {
+        if (m_firstRedo) {
+            if (bool(m_selection->m_d->shapeSelection) != bool(m_shapeSelection)) {
+                m_reincarnationCommand.reset(
+                    m_selection->m_d->pixelSelection->reincarnateWithDetachedHistory(m_isFlatten));
+            }
+            m_firstRedo = false;
+
+        }
+
+        if (m_reincarnationCommand) {
+            m_reincarnationCommand->redo();
+        }
+
+        std::swap(m_selection->m_d->shapeSelection, m_shapeSelection);
+
+        if (!m_isFlatten) {
+            m_selection->requestCompressedProjectionUpdate(QRect());
+        }
+    }
+
+private:
+    KisSelection *m_selection = 0;
+    KisSelectionComponent *m_shapeSelection = 0;
+    QScopedPointer<KUndo2Command> m_reincarnationCommand;
+    bool m_firstRedo = true;
+    bool m_isFlatten = false;
+};
+
 KisSelection::KisSelection(KisDefaultBoundsBaseSP defaultBounds)
     : m_d(new Private(this))
 {
     if (!defaultBounds) {
         defaultBounds = new KisSelectionEmptyBounds(0);
     }
     m_d->defaultBounds = defaultBounds;
 
     m_d->pixelSelection = new KisPixelSelection(m_d->defaultBounds, this);
     m_d->pixelSelection->setParentNode(m_d->parentNode);
 }
 
 KisSelection::KisSelection(const KisSelection& rhs)
     : KisShared(),
       m_d(new Private(this))
 {
     copyFrom(rhs);
 }
 
 KisSelection::KisSelection(const KisPaintDeviceSP source, KritaUtils::DeviceCopyMode copyMode, KisDefaultBoundsBaseSP defaultBounds)
     : m_d(new Private(this))
 {
     if (!defaultBounds) {
         defaultBounds = new KisSelectionEmptyBounds(0);
     }
 
     m_d->defaultBounds = defaultBounds;
     m_d->pixelSelection = new KisPixelSelection(source, copyMode);
     m_d->pixelSelection->setParentSelection(this);
     m_d->pixelSelection->setParentNode(m_d->parentNode);
     m_d->pixelSelection->setDefaultBounds(m_d->defaultBounds);
 }
 
 KisSelection &KisSelection::operator=(const KisSelection &rhs)
 {
     if (&rhs != this) {
         copyFrom(rhs);
     }
     return *this;
 }
 
 void KisSelection::copyFrom(const KisSelection &rhs)
 {
     m_d->isVisible = rhs.m_d->isVisible;
     m_d->defaultBounds = rhs.m_d->defaultBounds;
     m_d->parentNode = 0; // not supposed to be shared
 
     Q_ASSERT(rhs.m_d->pixelSelection);
     m_d->pixelSelection = new KisPixelSelection(*rhs.m_d->pixelSelection, KritaUtils::CopyAllFrames);
     m_d->pixelSelection->setParentSelection(this);
 
-
-    if (rhs.m_d->shapeSelection) {
+    if (rhs.m_d->shapeSelection && !rhs.m_d->shapeSelection->isEmpty()) {
         m_d->shapeSelection = rhs.m_d->shapeSelection->clone(this);
-        Q_ASSERT(m_d->shapeSelection);
-        Q_ASSERT(m_d->shapeSelection != rhs.m_d->shapeSelection);
+        KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->shapeSelection);
+        KIS_SAFE_ASSERT_RECOVER(m_d->shapeSelection &&
+                                m_d->shapeSelection != rhs.m_d->shapeSelection) {
+            m_d->shapeSelection = 0;
+        }
     }
     else {
-        m_d->shapeSelection = 0;
+        if (m_d->shapeSelection) {
+            Private::safeDeleteShapeSelection(m_d->shapeSelection, this);
+            m_d->shapeSelection = 0;
+        }
     }
 }
 
 KisSelection::~KisSelection()
 {
     delete m_d->shapeSelection;
     delete m_d;
 }
 
 void KisSelection::setParentNode(KisNodeWSP node)
 {
     m_d->parentNode = node;
     m_d->pixelSelection->setParentNode(node);
 
     // the updates come through the parent image, so all the updates
     // that happened in the meantime are considered "stalled"
     if (node) {
         m_d->updateCompressor->tryProcessStalledUpdate();
     }
 }
 
 // for testing purposes only
 KisNodeWSP KisSelection::parentNode() const
 {
     return m_d->parentNode;
 }
 
 bool KisSelection::outlineCacheValid() const
 {
-    return hasShapeSelection() ||
+    return m_d->shapeSelection ||
         m_d->pixelSelection->outlineCacheValid();
 }
 
 QPainterPath KisSelection::outlineCache() const
 {
     QPainterPath outline;
 
-    if (hasShapeSelection()) {
+    if (m_d->shapeSelection) {
         outline += m_d->shapeSelection->outlineCache();
     } else if (m_d->pixelSelection->outlineCacheValid()) {
         outline += m_d->pixelSelection->outlineCache();
     }
 
     return outline;
 }
 
 void KisSelection::recalculateOutlineCache()
 {
     Q_ASSERT(m_d->pixelSelection);
 
-    if (hasShapeSelection()) {
+    if (m_d->shapeSelection) {
         m_d->shapeSelection->recalculateOutlineCache();
     } else if (!m_d->pixelSelection->outlineCacheValid()) {
         m_d->pixelSelection->recalculateOutlineCache();
     }
 }
 
 bool KisSelection::thumbnailImageValid() const
 {
     return m_d->pixelSelection->thumbnailImageValid();
 }
 
 void KisSelection::recalculateThumbnailImage(const QColor &maskColor)
 {
     m_d->pixelSelection->recalculateThumbnailImage(maskColor);
 }
 
 QImage KisSelection::thumbnailImage() const
 {
     return m_d->pixelSelection->thumbnailImage();
 }
 
 QTransform KisSelection::thumbnailImageTransform() const
 {
     return m_d->pixelSelection->thumbnailImageTransform();
 }
 
-bool KisSelection::hasPixelSelection() const
+bool KisSelection::hasNonEmptyPixelSelection() const
 {
     return m_d->pixelSelection && !m_d->pixelSelection->isEmpty();
 }
 
-bool KisSelection::hasShapeSelection() const
+bool KisSelection::hasNonEmptyShapeSelection() const
 {
     return m_d->shapeSelection && !m_d->shapeSelection->isEmpty();
 }
 
+bool KisSelection::hasShapeSelection() const
+{
+    return m_d->shapeSelection;
+}
+
 KisPixelSelectionSP KisSelection::pixelSelection() const
 {
     return m_d->pixelSelection;
 }
 
 KisSelectionComponent* KisSelection::shapeSelection() const
 {
     return m_d->shapeSelection;
 }
 
-void KisSelection::setShapeSelection(KisSelectionComponent* shapeSelection)
+void KisSelection::convertToVectorSelectionNoUndo(KisSelectionComponent* shapeSelection)
 {
-    const bool needsNotification = shapeSelection != m_d->shapeSelection;
-
-    m_d->shapeSelection = shapeSelection;
+    QScopedPointer<KUndo2Command> cmd(new ChangeShapeSelectionCommand(this, shapeSelection));
+    cmd->redo();
+}
 
-    if (needsNotification) {
-        requestCompressedProjectionUpdate(QRect());
-    }
+KUndo2Command *KisSelection::convertToVectorSelection(KisSelectionComponent *shapeSelection)
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_d->shapeSelection, nullptr);
+    return new ChangeShapeSelectionCommand(this, shapeSelection);
 }
 
 KisPixelSelectionSP KisSelection::projection() const
 {
     return m_d->pixelSelection;
 }
 
 void KisSelection::updateProjection(const QRect &rc)
 {
-    if(hasShapeSelection()) {
+    if(m_d->shapeSelection) {
         m_d->shapeSelection->renderToProjection(m_d->pixelSelection, rc);
         m_d->pixelSelection->setOutlineCache(m_d->shapeSelection->outlineCache());
     }
 }
 
 void KisSelection::updateProjection()
 {
-    if(hasShapeSelection()) {
+    if(m_d->shapeSelection) {
         m_d->pixelSelection->clear();
         m_d->shapeSelection->renderToProjection(m_d->pixelSelection);
         m_d->pixelSelection->setOutlineCache(m_d->shapeSelection->outlineCache());
     }
 }
 
 void KisSelection::setVisible(bool visible)
 {
     bool needsNotification = visible != m_d->isVisible;
 
     m_d->isVisible = visible;
 
     if (needsNotification) {
         notifySelectionChanged();
     }
 }
 
 bool KisSelection::isVisible()
 {
     return m_d->isVisible;
 }
 
 bool KisSelection::isTotallyUnselected(const QRect & r) const
 {
     return m_d->pixelSelection->isTotallyUnselected(r);
 }
 
 QRect KisSelection::selectedRect() const
 {
     return m_d->pixelSelection->selectedRect();
 }
 
 QRect KisSelection::selectedExactRect() const
 {
     return m_d->pixelSelection->selectedExactRect();
 }
 
 qint32 KisSelection::x() const
 {
     return m_d->pixelSelection->x();
 }
 
 qint32 KisSelection::y() const
 {
     return m_d->pixelSelection->y();
 }
 
 void KisSelection::setX(qint32 x)
 {
     Q_ASSERT(m_d->pixelSelection);
 
     qint32 delta = x - m_d->pixelSelection->x();
     m_d->pixelSelection->setX(x);
     if (m_d->shapeSelection) {
         m_d->shapeSelection->moveX(delta);
     }
 }
 
 void KisSelection::setY(qint32 y)
 {
     Q_ASSERT(m_d->pixelSelection);
 
     qint32 delta = y - m_d->pixelSelection->y();
     m_d->pixelSelection->setY(y);
     if (m_d->shapeSelection) {
         m_d->shapeSelection->moveY(delta);
     }
 }
 
 void KisSelection::setDefaultBounds(KisDefaultBoundsBaseSP bounds)
 {
     m_d->defaultBounds = bounds;
     m_d->pixelSelection->setDefaultBounds(bounds);
 }
 
 void KisSelection::clear()
 {
-    // FIXME: check whether this is safe
-    delete m_d->shapeSelection;
-    m_d->shapeSelection = 0;
+    if (m_d->shapeSelection) {
+        Private::safeDeleteShapeSelection(m_d->shapeSelection, this);
+        m_d->shapeSelection = 0;
+    }
 
     m_d->pixelSelection->clear();
 }
 
 KUndo2Command* KisSelection::flatten()
 {
     KUndo2Command *command = 0;
 
-    if (hasShapeSelection()) {
+    if (m_d->shapeSelection) {
         command = m_d->shapeSelection->resetToEmpty();
+
+        if (command) {
+            KisCommandUtils::CompositeCommand *cmd = new KisCommandUtils::CompositeCommand();
+            cmd->addCommand(command);
+            cmd->addCommand(new ChangeShapeSelectionCommand(this, nullptr));
+            command = cmd;
+        } else {
+            command = new ChangeShapeSelectionCommand(this, nullptr);
+        }
     }
 
     return command;
 }
 
 void KisSelection::notifySelectionChanged()
 {
     KisNodeWSP parentNode;
     if (!(parentNode = this->parentNode())) return;
 
     KisNodeGraphListener *listener;
     if (!(listener = parentNode->graphListener())) return;
 
     listener->notifySelectionChanged();
 }
 
 void KisSelection::requestCompressedProjectionUpdate(const QRect &rc)
 {
     m_d->updateCompressor->requestUpdate(rc);
 }
 
-void KisSelection::notifyShapeSelectionBecameEmpty()
-{
-    m_d->pixelSelection->clear();
-}
-
 quint8 KisSelection::selected(qint32 x, qint32 y) const
 {
     KisHLineConstIteratorSP iter = m_d->pixelSelection->createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->oldRawData();
 
     return *pix;
 }
+
diff --git a/libs/image/kis_selection.h b/libs/image/kis_selection.h
index d8908185a1..8d455d3856 100644
--- a/libs/image/kis_selection.h
+++ b/libs/image/kis_selection.h
@@ -1,227 +1,242 @@
 /*
  *  Copyright (c) 2004 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_SELECTION_H_
 #define KIS_SELECTION_H_
 
 #include <QRect>
 
 #include "kis_types.h"
 #include "kritaimage_export.h"
 #include "kis_default_bounds.h"
 #include "kis_image.h"
 
 #include "KisSelectionTags.h"
 
 #include "kis_pixel_selection.h"
 
 
 class KisSelectionComponent;
 class QPainterPath;
 
 /**
  * KisSelection is a composite object. It may contain an instance
  * of KisPixelSelection and a KisShapeSelection object. Both these
  * selections are merged into a projection of the KisSelection.
  *
  * Every pixel in the paint device can indicate a degree of selectedness, varying
  * between MIN_SELECTED and MAX_SELECTED.
  *
  * The projection() paint device itself is only a projection: you can
  * read from it, but not write to it. You need to keep track of
  * the need for updating the projection yourself: there is no
  * automatic updating after changing the contents of one or more
  * of the selection components.
  */
 class KRITAIMAGE_EXPORT KisSelection : public KisShared
 {
+private:
+    struct ChangeShapeSelectionCommand;
 
 public:
     /**
      * Create a new KisSelection.
      *
      * @param defaultBounds defines the bounds of the selection when
      * Select All is initiated.
      */
     KisSelection(KisDefaultBoundsBaseSP defaultBounds = KisDefaultBoundsBaseSP());
 
     /**
      * Copy the selection. The selection components are copied, too.
      */
     KisSelection(const KisSelection& rhs);
     KisSelection& operator=(const KisSelection &rhs);
 
     /**
      * Delete the selection. The shape selection component is deleted, the
      * pixel selection component is contained in a shared pointer, so that
      * may still be valid.
      */
     virtual ~KisSelection();
 
     /**
      * Create a new selection using the content of copySource as the mask.
      */
     KisSelection(const KisPaintDeviceSP copySource, KritaUtils::DeviceCopyMode copyMode, KisDefaultBoundsBaseSP defaultBounds);
 
     /**
      * The paint device of the pixel selection should report
      * about it's setDirty events to its parent. The creator
      * should set the parent manually if it wants to get the
      * signals
      */
     void setParentNode(KisNodeWSP node);
 
-    bool hasPixelSelection() const;
+    bool hasNonEmptyPixelSelection() const;
+    bool hasNonEmptyShapeSelection() const;
     bool hasShapeSelection() const;
 
     bool outlineCacheValid() const;
     QPainterPath outlineCache() const;
     void recalculateOutlineCache();
 
 
     /**
      * Tells whether the cached thumbnail of the selection is still valid
      */
     bool thumbnailImageValid() const;
 
     /**
      * Recalculates the thumbnail of the selection
      */
     void recalculateThumbnailImage(const QColor &maskColor);
 
     /**
      * Returns the thumbnail of the selection.
      */
     QImage thumbnailImage() const;
 
     /**
      * Returns the transformation which should be applied to the thumbnail before
      * being painted over the image
      */
     QTransform thumbnailImageTransform() const;
 
 
     /**
      * return the pixel selection component of this selection. Pixel
      * selection component is always present in the selection. In case
      * the user wants a vector selection, pixel selection will store
      * the pixelated version of it.
      *
      * NOTE: use pixelSelection() for changing the selection only. For
      * reading the selection and passing the data to bitBlt function use
      * projection(). Although projection() and pixelSelection() currently
      * point ot the same paint device, this behavior may change in the
      * future.
      */
     KisPixelSelectionSP pixelSelection() const;
 
     /**
      * return the vector selection component of this selection or zero
      * if hasShapeSelection() returns false.
      */
     KisSelectionComponent* shapeSelection() const;
 
-    void setShapeSelection(KisSelectionComponent* shapeSelection);
+    /**
+     * @brief converts shape selection into the vector state
+     *
+     * The selection must not have any shape selection active. It should
+     * be checked by calling hasShapeSelection() in advance.
+     *
+     * @param shapeSelection new shape selection object that should be
+     *                       attached to the selection
+     * @return undo command that exectes and undos the conversion
+     */
+    KUndo2Command* convertToVectorSelection(KisSelectionComponent* shapeSelection);
+
+    /**
+     * @see convertToVectorSelection()
+     */
+    void convertToVectorSelectionNoUndo(KisSelectionComponent* shapeSelection);
 
     /**
      * Returns the projection of the selection. It may be the same
      * as pixel selection. You must read selection data from this
      * paint device only
      */
     KisPixelSelectionSP projection() const;
 
     /**
      * Updates the projection of the selection. You should call this
      * method after the every change of the selection components.
      * There is no automatic updates framework present
      */
     void updateProjection(const QRect& rect);
     void updateProjection();
 
     void setVisible(bool visible);
     bool isVisible();
 
     /**
      * Convenience functions. Just call the corresponding methods
      * of the underlying projection
      */
     bool isTotallyUnselected(const QRect & r) const;
 
     QRect selectedRect() const;
 
     /**
      * @brief Slow, but exact way of determining the rectangle
      * that encloses the selection.
      *
      * Default pixel of the selection device may vary and you would get wrong bounds.
      * selectedExactRect() handles all these cases.
      *
      */
     QRect selectedExactRect() const;
 
     void setX(qint32 x);
     void setY(qint32 y);
 
     qint32 x() const;
     qint32 y() const;
 
     void setDefaultBounds(KisDefaultBoundsBaseSP bounds);
 
     void clear();
 
     /**
      * @brief flatten creates a new pixel selection component from the shape selection
      * and throws away the shape selection. This has no effect if there is no
      * shape selection.
      */
     KUndo2Command* flatten();
 
     void notifySelectionChanged();
 
     /**
      * Request rerendering of the shape selection component in a
      * compressed way. Usually, you don't need to call it manually,
      * because all the work is done by KisShapeSelectionModel.
      */
     void requestCompressedProjectionUpdate(const QRect &rc);
 
-    void notifyShapeSelectionBecameEmpty();
-
     /// XXX: This method was marked KDE_DEPRECATED but without information on what to
     /// replace it with. Undeprecate, therefore.
     quint8 selected(qint32 x, qint32 y) const;
 
     KisNodeWSP parentNode() const;
 
 private:
     friend class KisSelectionTest;
     friend class KisMaskTest;
     friend class KisAdjustmentLayerTest;
     friend class KisUpdateSelectionJob;
     friend class KisSelectionUpdateCompressor;
     friend class KisDeselectActiveSelectionCommand;
 
-
     void copyFrom(const KisSelection &rhs);
 
 private:
 
     struct Private;
     Private * const m_d;
 };
 
 #endif // KIS_SELECTION_H_
diff --git a/libs/image/kis_transaction_data.cpp b/libs/image/kis_transaction_data.cpp
index d40648f44e..0e0db683df 100644
--- a/libs/image/kis_transaction_data.cpp
+++ b/libs/image/kis_transaction_data.cpp
@@ -1,324 +1,343 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.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_transaction_data.h"
 
 #include "kis_pixel_selection.h"
 #include "kis_paint_device.h"
 #include "kis_paint_device_frames_interface.h"
 #include "kis_datamanager.h"
 #include "kis_image.h"
 #include "KoColor.h"
 
 //#define DEBUG_TRANSACTIONS
 
 #ifdef DEBUG_TRANSACTIONS
 #    define DEBUG_ACTION(action) dbgKrita << action << "for" << m_d->device->dataManager()
 #else
 #    define DEBUG_ACTION(action)
 #endif
 
 
 class Q_DECL_HIDDEN KisTransactionData::Private
 {
 public:
     KisPaintDeviceSP device;
     KisMementoSP memento;
     bool firstRedo;
     bool transactionFinished;
     QPoint oldOffset;
     QPoint newOffset;
 
     KoColor oldDefaultPixel;
     bool defaultPixelChanged = false;
 
     bool savedOutlineCacheValid;
     QPainterPath savedOutlineCache;
-    KUndo2Command *flattenUndoCommand;
+    QScopedPointer<KUndo2Command> flattenUndoCommand;
     bool resetSelectionOutlineCache;
 
     int transactionTime;
     int transactionFrameId;
     KisDataManagerSP savedDataManager;
 
     KUndo2Command newFrameCommand;
 
     void possiblySwitchCurrentTime();
     KisDataManagerSP dataManager();
     void moveDevice(const QPoint newOffset);
 
     void tryCreateNewFrame(KisPaintDeviceSP device, int time);
 };
 
 
 KisTransactionData::KisTransactionData(const KUndo2MagicString& name, KisPaintDeviceSP device, bool resetSelectionOutlineCache, KUndo2Command* parent)
     : KUndo2Command(name, parent)
 
     , m_d(new Private())
 {
     m_d->resetSelectionOutlineCache = resetSelectionOutlineCache;
     setTimedID(-1);
+
+    possiblyFlattenSelection(device);
     init(device);
     saveSelectionOutlineCache();
 }
 
 #include "kis_raster_keyframe_channel.h"
 #include "kis_image_config.h"
 
 void KisTransactionData::Private::tryCreateNewFrame(KisPaintDeviceSP device, int time)
 {
     if (!device->framesInterface()) return;
 
     KisImageConfig cfg(true);
     if (!cfg.lazyFrameCreationEnabled()) return;
 
     KisRasterKeyframeChannel *channel = device->keyframeChannel();
     KIS_ASSERT_RECOVER(channel) { return; }
 
     KisKeyframeSP keyframe = channel->keyframeAt(time);
 
     if (!keyframe) {
         keyframe = channel->activeKeyframeAt(time);
         KisKeyframeSP newKeyframe = channel->copyKeyframe(keyframe, time, &newFrameCommand);
         newKeyframe->setColorLabel(KisImageConfig(true).defaultFrameColorLabel());
     }
 }
 
 void KisTransactionData::init(KisPaintDeviceSP device)
 {
     m_d->device = device;
     DEBUG_ACTION("Transaction started");
 
     m_d->oldOffset = QPoint(device->x(), device->y());
     m_d->oldDefaultPixel = device->defaultPixel();
     m_d->firstRedo = true;
     m_d->transactionFinished = false;
-    m_d->flattenUndoCommand = 0;
 
     m_d->transactionTime = device->defaultBounds()->currentTime();
 
     m_d->tryCreateNewFrame(m_d->device, m_d->transactionTime);
 
     m_d->transactionFrameId = device->framesInterface() ? device->framesInterface()->currentFrameId() : -1;
     m_d->savedDataManager = m_d->transactionFrameId >= 0 ?
         m_d->device->framesInterface()->frameDataManager(m_d->transactionFrameId) :
         m_d->device->dataManager();
     m_d->memento = m_d->savedDataManager->getMemento();
 }
 
 KisTransactionData::~KisTransactionData()
 {
     Q_ASSERT(m_d->memento);
     m_d->savedDataManager->purgeHistory(m_d->memento);
 
     delete m_d;
 }
 
 void KisTransactionData::Private::moveDevice(const QPoint newOffset)
 {
     if (transactionFrameId >= 0) {
         device->framesInterface()->setFrameOffset(transactionFrameId, newOffset);
     } else {
         device->moveTo(newOffset);
     }
 }
 
 void KisTransactionData::endTransaction()
 {
     if(!m_d->transactionFinished) {
         // make sure the time didn't change during the transaction
         KIS_ASSERT_RECOVER_RETURN(
             m_d->transactionTime == m_d->device->defaultBounds()->currentTime());
 
         DEBUG_ACTION("Transaction ended");
         m_d->transactionFinished = true;
         m_d->savedDataManager->commit();
         m_d->newOffset = QPoint(m_d->device->x(), m_d->device->y());
         m_d->defaultPixelChanged = m_d->oldDefaultPixel != m_d->device->defaultPixel();
     }
 }
 
 void KisTransactionData::startUpdates()
 {
     if (m_d->transactionFrameId == -1 ||
         m_d->transactionFrameId ==
         m_d->device->framesInterface()->currentFrameId()) {
 
         QRect rc;
         QRect mementoExtent = m_d->memento->extent();
 
         if (m_d->newOffset == m_d->oldOffset) {
             rc = mementoExtent.translated(m_d->device->x(), m_d->device->y());
         } else {
             QRect totalExtent =
                 m_d->savedDataManager->extent() | mementoExtent;
 
             rc = totalExtent.translated(m_d->oldOffset) |
                 totalExtent.translated(m_d->newOffset);
         }
 
         if (m_d->defaultPixelChanged) {
             rc |= m_d->device->defaultBounds()->bounds();
         }
 
         m_d->device->setDirty(rc);
     } else {
         m_d->device->framesInterface()->invalidateFrameCache(m_d->transactionFrameId);
     }
 }
 
 void KisTransactionData::possiblyNotifySelectionChanged()
 {
     KisPixelSelectionSP pixelSelection =
         dynamic_cast<KisPixelSelection*>(m_d->device.data());
 
     KisSelectionSP selection;
     if (pixelSelection && (selection = pixelSelection->parentSelection())) {
         selection->notifySelectionChanged();
     }
 }
 
 void KisTransactionData::possiblyResetOutlineCache()
 {
     KisPixelSelectionSP pixelSelection;
 
     if (m_d->resetSelectionOutlineCache &&
         (pixelSelection =
          dynamic_cast<KisPixelSelection*>(m_d->device.data()))) {
 
         pixelSelection->invalidateOutlineCache();
     }
 }
 
+void KisTransactionData::possiblyFlattenSelection(KisPaintDeviceSP device)
+{
+    KisPixelSelectionSP pixelSelection =
+        dynamic_cast<KisPixelSelection*>(device.data());
+
+    if (pixelSelection) {
+        KisSelection *selection = pixelSelection->parentSelection().data();
+        if (selection) {
+            m_d->flattenUndoCommand.reset(selection->flatten());
+
+            if (m_d->flattenUndoCommand) {
+                m_d->flattenUndoCommand->redo();
+            }
+        }
+    }
+}
+
+void KisTransactionData::doFlattenUndoRedo(bool undo)
+{
+    KisPixelSelectionSP pixelSelection =
+        dynamic_cast<KisPixelSelection*>(m_d->device.data());
+
+    if (pixelSelection) {
+        if (m_d->flattenUndoCommand) {
+            if (undo) {
+                m_d->flattenUndoCommand->undo();
+            } else {
+                m_d->flattenUndoCommand->redo();
+            }
+        }
+    }
+}
+
 void KisTransactionData::Private::possiblySwitchCurrentTime()
 {
     if (device->defaultBounds()->currentTime() == transactionTime) return;
 
     qWarning() << "WARNING: undo command has been executed, when another frame has been active. That shouldn't have happened.";
     device->requestTimeSwitch(transactionTime);
 }
 
 void KisTransactionData::redo()
 {
     //KUndo2QStack calls redo(), so the first call needs to be blocked
     if (m_d->firstRedo) {
         m_d->firstRedo = false;
 
 
         possiblyResetOutlineCache();
         possiblyNotifySelectionChanged();
         return;
     }
 
-
+    doFlattenUndoRedo(false);
     restoreSelectionOutlineCache(false);
 
     m_d->newFrameCommand.redo();
 
     DEBUG_ACTION("Redo()");
 
     Q_ASSERT(m_d->memento);
     m_d->savedDataManager->rollforward(m_d->memento);
 
     if (m_d->newOffset != m_d->oldOffset) {
         m_d->moveDevice(m_d->newOffset);
     }
 
     m_d->possiblySwitchCurrentTime();
     startUpdates();
     possiblyNotifySelectionChanged();
 }
 
 void KisTransactionData::undo()
 {
     DEBUG_ACTION("Undo()");
     Q_ASSERT(m_d->memento);
     m_d->savedDataManager->rollback(m_d->memento);
 
     if (m_d->newOffset != m_d->oldOffset) {
         m_d->moveDevice(m_d->oldOffset);
     }
 
     restoreSelectionOutlineCache(true);
+    doFlattenUndoRedo(true);
 
     m_d->possiblySwitchCurrentTime();
     startUpdates();
     possiblyNotifySelectionChanged();
 
     m_d->newFrameCommand.undo();
 }
 
 void KisTransactionData::saveSelectionOutlineCache()
 {
     m_d->savedOutlineCacheValid = false;
 
     KisPixelSelectionSP pixelSelection =
         dynamic_cast<KisPixelSelection*>(m_d->device.data());
 
     if (pixelSelection) {
         m_d->savedOutlineCacheValid = pixelSelection->outlineCacheValid();
         if (m_d->savedOutlineCacheValid) {
             m_d->savedOutlineCache = pixelSelection->outlineCache();
 
             possiblyResetOutlineCache();
         }
-
-        KisSelectionSP selection = pixelSelection->parentSelection();
-        if (selection) {
-            m_d->flattenUndoCommand = selection->flatten();
-            if (m_d->flattenUndoCommand) {
-                m_d->flattenUndoCommand->redo();
-            }
-        }
     }
 }
 
 void KisTransactionData::restoreSelectionOutlineCache(bool undo)
 {
     KisPixelSelectionSP pixelSelection =
         dynamic_cast<KisPixelSelection*>(m_d->device.data());
 
     if (pixelSelection) {
         bool savedOutlineCacheValid;
         QPainterPath savedOutlineCache;
 
         savedOutlineCacheValid = pixelSelection->outlineCacheValid();
         if (savedOutlineCacheValid) {
             savedOutlineCache = pixelSelection->outlineCache();
         }
 
         if (m_d->savedOutlineCacheValid) {
             pixelSelection->setOutlineCache(m_d->savedOutlineCache);
         } else {
             pixelSelection->invalidateOutlineCache();
         }
 
         m_d->savedOutlineCacheValid = savedOutlineCacheValid;
         if (m_d->savedOutlineCacheValid) {
             m_d->savedOutlineCache = savedOutlineCache;
         }
-
-        if (m_d->flattenUndoCommand) {
-            if (undo) {
-                m_d->flattenUndoCommand->undo();
-            } else {
-                m_d->flattenUndoCommand->redo();
-            }
-        }
     }
 }
diff --git a/libs/image/kis_transaction_data.h b/libs/image/kis_transaction_data.h
index 74a82b6861..9af33ec17b 100644
--- a/libs/image/kis_transaction_data.h
+++ b/libs/image/kis_transaction_data.h
@@ -1,64 +1,66 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.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_TRANSACTION_DATA_H_
 #define KIS_TRANSACTION_DATA_H_
 
 #include <kundo2command.h>
 #include "kis_types.h"
 #include <kritaimage_export.h>
 
 
 /**
  * A tile based undo command.
  *
  * Ordinary KUndo2Command subclasses store parameters and apply the action in
  * the redo() command, however, Krita doesn't work like this. Undo replaces
  * the current tiles in a paint device with the old tiles, redo replaces them
  * again with the new tiles without actually executing the command that changed
  * the image data again.
  */
 class KRITAIMAGE_EXPORT KisTransactionData : public KUndo2Command
 {
 public:
     KisTransactionData(const KUndo2MagicString& name, KisPaintDeviceSP device, bool resetSelectionOutlineCache, KUndo2Command* parent);
     ~KisTransactionData() override;
 
 public:
     void redo() override;
     void undo() override;
 
     virtual void endTransaction();
 
 protected:
     virtual void saveSelectionOutlineCache();
     virtual void restoreSelectionOutlineCache(bool undo);
 
 private:
     void init(KisPaintDeviceSP device);
     void startUpdates();
     void possiblyNotifySelectionChanged();
     void possiblyResetOutlineCache();
+    void possiblyFlattenSelection(KisPaintDeviceSP device);
+    void doFlattenUndoRedo(bool undo);
 
 private:
     class Private;
     Private * const m_d;
 };
 
 #endif /* KIS_TRANSACTION_DATA_H_ */
 
diff --git a/libs/image/tests/CMakeLists.txt b/libs/image/tests/CMakeLists.txt
index fddafbc361..351b7b374c 100644
--- a/libs/image/tests/CMakeLists.txt
+++ b/libs/image/tests/CMakeLists.txt
@@ -1,192 +1,187 @@
 # cmake in some versions for some not yet known reasons fails to run automoc
 # on random targets (changing target names already has an effect)
 # As temporary workaround skipping build of tests on these versions for now
 # See https://mail.kde.org/pipermail/kde-buildsystem/2015-June/010819.html
 # extend range of affected cmake versions as needed
 if(NOT ${CMAKE_VERSION} VERSION_LESS 3.1.3 AND
    NOT ${CMAKE_VERSION} VERSION_GREATER 3.2.3)
     message(WARNING "Skipping krita/image/tests, CMake in at least versions 3.1.3 - 3.2.3 seems to have a problem with automoc.  \n(FRIENDLY REMINDER: PLEASE DON'T BREAK THE TESTS!)")
     set (HAVE_FAILING_CMAKE TRUE)
 else()
     set (HAVE_FAILING_CMAKE FALSE)
 endif()
 
 include_directories(
     ${CMAKE_BINARY_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/brushengine
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3/swap
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include_Directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 if(HAVE_VC)
   include_directories(${Vc_INCLUDE_DIR})
 endif()
 
 include(ECMAddTests)
 
 macro_add_unittest_definitions()
 
 set(KisRandomGeneratorDemoSources kis_random_generator_demo.cpp kimageframe.cpp)
 ki18n_wrap_ui(KisRandomGeneratorDemoSources kis_random_generator_demo.ui)
 add_executable(KisRandomGeneratorDemo ${KisRandomGeneratorDemoSources})
 target_link_libraries(KisRandomGeneratorDemo kritaimage)
 ecm_mark_as_test(KisRandomGeneratorDemo)
 
 ecm_add_tests(
     kis_base_node_test.cpp
     kis_fast_math_test.cpp
     kis_node_test.cpp
     kis_node_facade_test.cpp
     kis_fixed_paint_device_test.cpp
     kis_layer_test.cpp
     kis_effect_mask_test.cpp
     kis_iterator_test.cpp
     kis_painter_test.cpp
     kis_count_visitor_test.cpp
     kis_projection_test.cpp
     kis_properties_configuration_test.cpp
     kis_transaction_test.cpp
     kis_pixel_selection_test.cpp
     kis_group_layer_test.cpp
     kis_paint_layer_test.cpp
     kis_adjustment_layer_test.cpp
     kis_annotation_test.cpp
     kis_clone_layer_test.cpp
     kis_convolution_painter_test.cpp
     kis_crop_processing_visitor_test.cpp
     kis_processing_applicator_test.cpp
     kis_datamanager_test.cpp
     kis_fill_painter_test.cpp
     kis_filter_configuration_test.cpp
     kis_filter_test.cpp
     kis_filter_processing_information_test.cpp
     kis_filter_registry_test.cpp
     kis_filter_strategy_test.cpp
     kis_gradient_painter_test.cpp
     kis_image_commands_test.cpp
     kis_image_test.cpp
     kis_image_signal_router_test.cpp
     kis_iterators_ng_test.cpp
     kis_iterator_benchmark.cpp
     kis_updater_context_test.cpp
     kis_simple_update_queue_test.cpp
     kis_stroke_test.cpp
     kis_simple_stroke_strategy_test.cpp
     kis_stroke_strategy_undo_command_based_test.cpp
     kis_strokes_queue_test.cpp
     kis_mask_test.cpp
     kis_math_toolbox_test.cpp
     kis_name_server_test.cpp
     kis_node_commands_test.cpp
     kis_node_graph_listener_test.cpp
     kis_node_visitor_test.cpp
     kis_paint_information_test.cpp
     kis_distance_information_test.cpp
     kis_paintop_test.cpp
     kis_pattern_test.cpp
     kis_selection_mask_test.cpp
     kis_shared_ptr_test.cpp
     kis_bsplines_test.cpp
     kis_warp_transform_worker_test.cpp
     kis_liquify_transform_worker_test.cpp
     kis_transparency_mask_test.cpp
     kis_types_test.cpp
     kis_vec_test.cpp
     kis_filter_config_widget_test.cpp
     kis_mask_generator_test.cpp
     kis_cubic_curve_test.cpp
     kis_fixed_point_maths_test.cpp
     kis_node_query_path_test.cpp
     kis_filter_weights_buffer_test.cpp
     kis_filter_weights_applicator_test.cpp
     kis_fill_interval_test.cpp
     kis_fill_interval_map_test.cpp
     kis_scanline_fill_test.cpp
     kis_psd_layer_style_test.cpp
     kis_layer_style_projection_plane_test.cpp
     kis_lod_capable_layer_offset_test.cpp
     kis_algebra_2d_test.cpp
     kis_marker_painter_test.cpp
     kis_lazy_brush_test.cpp
     kis_mask_similarity_test.cpp
     KisMaskGeneratorTest.cpp
     kis_layer_style_filter_environment_test.cpp
     kis_asl_parser_test.cpp
     KisPerStrokeRandomSourceTest.cpp
     KisWatershedWorkerTest.cpp
     kis_dom_utils_test.cpp
     kis_transform_worker_test.cpp
     kis_cs_conversion_test.cpp
     kis_projection_leaf_test.cpp
     kis_histogram_test.cpp
     kis_onion_skin_compositor_test.cpp
     kis_queues_progress_updater_test.cpp
     kis_image_animation_interface_test.cpp
     kis_walkers_test.cpp
     kis_cage_transform_worker_test.cpp
     kis_random_generator_test.cpp
     kis_keyframing_test.cpp
     kis_filter_mask_test.cpp
     kis_asl_layer_style_serializer_test.cpp
     TestAslStorage.cpp
     kis_async_merger_test.cpp
+    kis_selection_test.cpp
 
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
 include(KritaAddBrokenUnitTest)
 
 krita_add_broken_unit_test( kis_transform_mask_test.cpp
     TEST_NAME     kis_transform_mask_test
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
 krita_add_broken_unit_test( kis_layer_styles_test.cpp
     TEST_NAME kis_layer_styles_test
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
 krita_add_broken_unit_test( kis_update_scheduler_test.cpp
     TEST_NAME kis_update_scheduler_test
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
 krita_add_broken_unit_test( kis_paint_device_test.cpp
     TEST_NAME kis_paint_device_test
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
 krita_add_broken_unit_test( kis_colorize_mask_test.cpp
     TEST_NAME kis_colorize_mask_test
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
-krita_add_broken_unit_test( kis_selection_test.cpp
-    TEST_NAME kis_selection_test
-    LINK_LIBRARIES kritaimage Qt5::Test
-    NAME_PREFIX "libs-image-"
-)
-
 krita_add_broken_unit_test( kis_processings_test.cpp
     TEST_NAME kis_processings_test
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
 
 krita_add_broken_unit_test( kis_perspective_transform_worker_test.cpp
     TEST_NAME kis_perspective_transform_worker_test
     LINK_LIBRARIES kritaimage Qt5::Test
     NAME_PREFIX "libs-image-"
 )
diff --git a/libs/image/tests/kis_selection_test.cpp b/libs/image/tests/kis_selection_test.cpp
index 1fc12397a7..83f43e7214 100644
--- a/libs/image/tests/kis_selection_test.cpp
+++ b/libs/image/tests/kis_selection_test.cpp
@@ -1,340 +1,341 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_test.h"
 #include <QTest>
 
 
 #include <kis_debug.h>
 #include <QRect>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_datamanager.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_mask.h"
 #include "kis_image.h"
 #include "kis_transparency_mask.h"
 #include "testutil.h"
 
 #include <KoColorModelStandardIds.h>
 
 void KisSelectionTest::testGrayColorspaceConversion()
 {
     const KoColorSpace *csA =
         KoColorSpaceRegistry::instance()->
         colorSpace(GrayAColorModelID.id(),
                    Integer8BitsColorDepthID.id(),
                    QString());
 
     const KoColorSpace *csNoA =
         KoColorSpaceRegistry::instance()->alpha8();
 
     QVERIFY(csA);
     QVERIFY(csNoA);
 
     QCOMPARE(csA->pixelSize(), 2U);
     QCOMPARE(csNoA->pixelSize(), 1U);
 
     quint8 color1[1] = {128};
     quint8 color2[2] = {64,32};
 
     csA->convertPixelsTo(color2, color1, csNoA, 1,
                          KoColorConversionTransformation::internalRenderingIntent(),
                          KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color1[0], 8);
 
     csNoA->convertPixelsTo(color1, color2, csA, 1,
                            KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color2[0], 8);
     QCOMPARE((int)color2[1], 255);
 }
 
 void KisSelectionTest::testGrayColorspaceOverComposition()
 {
     const KoColorSpace *csA =
         KoColorSpaceRegistry::instance()->
         colorSpace(GrayAColorModelID.id(),
                    Integer8BitsColorDepthID.id(),
                    QString());
     const KoColorSpace *csNoA =
         KoColorSpaceRegistry::instance()->alpha8();
 
     QVERIFY(csA);
     QVERIFY(csNoA);
 
     QCOMPARE(csA->pixelSize(), 2U);
     QCOMPARE(csNoA->pixelSize(), 1U);
 
     quint8 color0[2] = {32,255};
     quint8 color1[2] = {128,64};
     quint8 color3[1] = {32};
 
     KoCompositeOp::ParameterInfo params;
     params.dstRowStart = color0;
     params.dstRowStride = 0;
     params.srcRowStart = color1;
     params.srcRowStride = 0;
     params.maskRowStart = 0;
     params.maskRowStride = 0;
     params.rows = 1;
     params.cols = 1;
     params.opacity = 1.0;
     params.flow = 1.0;
 
     csA->bitBlt(csA, params, csA->compositeOp(COMPOSITE_OVER),
                 KoColorConversionTransformation::internalRenderingIntent(),
                 KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color0[0], 56);
     QCOMPARE((int)color0[1], 255);
 
     params.dstRowStart = color3;
 
     csNoA->bitBlt(csA, params, csNoA->compositeOp(COMPOSITE_OVER),
                   KoColorConversionTransformation::internalRenderingIntent(),
                   KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color3[0], 56);
 }
 
 void KisSelectionTest::testSelectionComponents()
 {
     KisSelectionSP selection = new KisSelection();
 
-    QCOMPARE(selection->hasPixelSelection(), false);
-    QCOMPARE(selection->hasShapeSelection(), false);
+    QCOMPARE(selection->hasNonEmptyPixelSelection(), false);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), false);
     QCOMPARE(selection->shapeSelection(), (void*)0);
 
     selection->pixelSelection()->select(QRect(10,10,10,10));
-    QCOMPARE(selection->hasPixelSelection(), true);
+    QCOMPARE(selection->hasNonEmptyPixelSelection(), true);
     QCOMPARE(selection->selectedExactRect(), QRect(10,10,10,10));
 }
 
 void KisSelectionTest::testSelectionActions()
 {
     KisSelectionSP selection = new KisSelection();
-    QVERIFY(selection->hasPixelSelection() == false);
-    QVERIFY(selection->hasShapeSelection() == false);
+    QVERIFY(selection->hasNonEmptyPixelSelection() == false);
+    QVERIFY(selection->hasNonEmptyShapeSelection() == false);
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(0, 0, 20, 20));
 
     KisPixelSelectionSP tmpSel = new KisPixelSelection();
     tmpSel->select(QRect(10, 0, 20, 20));
 
     pixelSelection->applySelection(tmpSel, SELECTION_ADD);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0, 0, 30, 20));
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 30, 20));
 
     pixelSelection->clear();
     pixelSelection->select(QRect(0, 0, 20, 20));
 
     pixelSelection->applySelection(tmpSel, SELECTION_SUBTRACT);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0, 0, 10, 20));
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 10, 20));
 
     pixelSelection->clear();
     pixelSelection->select(QRect(0, 0, 20, 20));
 
     pixelSelection->applySelection(tmpSel, SELECTION_INTERSECT);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(10, 0, 10, 20));
     QCOMPARE(selection->selectedExactRect(), QRect(10, 0, 10, 20));
 }
 
 void KisSelectionTest::testInvertSelection()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1024, 1024, cs, "stest");
 
     KisSelectionSP selection = new KisSelection(new KisDefaultBounds(image));
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(20, 20, 20, 20));
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 30, 30), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MIN_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 512, 512), MIN_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(20, 20, 20, 20));
 
     pixelSelection->invert();
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 100, 100), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 22, 22), MIN_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 512, 512), MAX_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(pixelSelection->selectedRect(), QRect(0,0,1024,1024));
 
     selection->updateProjection();
 
     QCOMPARE(selection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(selection->selectedRect(), QRect(0,0,1024,1024));
 
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 100, 100), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 22, 22), MIN_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 10, 10), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 0, 0), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 512, 512), MAX_SELECTED);
 }
 
 void KisSelectionTest::testInvertSelectionSemi()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1024, 1024, cs, "stest");
 
     KisSelectionSP selection = new KisSelection(new KisDefaultBounds(image));
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     quint8 selectedness = 42;
     pixelSelection->select(QRect(20, 20, 20, 20), selectedness);
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 30, 30), selectedness);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MIN_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(20, 20, 20, 20));
 
     pixelSelection->invert();
 
     quint8 invertedSelectedness = MAX_SELECTED - selectedness;
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 30, 30), invertedSelectedness);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MAX_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(pixelSelection->selectedRect(), QRect(0,0,1024,1024));
 
     selection->updateProjection();
 
     QCOMPARE(selection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(selection->selectedRect(), QRect(0,0,1024,1024));
 
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 30, 30), invertedSelectedness);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 0, 0), MAX_SELECTED);
 }
 
 void KisSelectionTest::testCopy()
 {
     KisSelectionSP sel = new KisSelection();
     sel->pixelSelection()->select(QRect(10, 10, 200, 200), 128);
 
     sel->updateProjection();
 
     KisSelectionSP sel2 = new KisSelection(*sel.data());
     QCOMPARE(sel2->selectedExactRect(), sel->selectedExactRect());
 
     QPoint errpoint;
     if (!TestUtil::comparePaintDevices(errpoint, sel->projection(), sel2->projection())) {
         sel2->projection()->convertToQImage(0, 0, 0, 200, 200).save("merge_visitor6.png");
         QFAIL(QString("Failed to copy selection, first different pixel: %1,%2 ")
               .arg(errpoint.x())
               .arg(errpoint.y())
               .toLatin1());
     }
 }
 
 void KisSelectionTest::testSelectionExactBounds()
 {
     QRect referenceImageRect(0,0,1000,1000);
     QRect referenceDeviceRect(100,100,1040,1040);
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     KisImageSP image = new KisImage(0, referenceImageRect.width(),
                                     referenceImageRect.height(),
                                     cs, "stest");
 
     KisPaintDeviceSP device = new KisPaintDevice(cs);
+    device->setDefaultBounds(new KisDefaultBounds(image));
     device->fill(referenceDeviceRect, KoColor(Qt::white, cs));
 
     QCOMPARE(device->exactBounds(), referenceDeviceRect);
 
     KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(device));
 
     quint8 defaultPixel = MAX_SELECTED;
     selection->pixelSelection()->setDefaultPixel(KoColor(&defaultPixel, selection->pixelSelection()->colorSpace()));
 
     // the selection uses device's extent only for performance reasons
     // \see bug 320213
     QCOMPARE(selection->selectedExactRect(), device->extent() | referenceImageRect);
 }
 
 void KisSelectionTest::testSetParentNodeAfterCreation()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 100, 100, cs, "stest");
     KisSelectionSP selection = new KisSelection();
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
 
     QCOMPARE(selection->parentNode(), KisNodeWSP(0));
     QCOMPARE(selection->pixelSelection()->parentNode(), KisNodeWSP(0));
 
     selection->setParentNode(image->root());
 
     QCOMPARE(selection->parentNode(), KisNodeWSP(image->root()));
     QCOMPARE(selection->pixelSelection()->parentNode(), KisNodeWSP(image->root()));
 }
 
 void KisSelectionTest::testSetParentNodeBeforeCreation()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 100, 100, cs, "stest");
     KisSelectionSP selection = new KisSelection();
 
     selection->setParentNode(image->root());
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
 
     QCOMPARE(selection->parentNode(), KisNodeWSP(image->root()));
     QCOMPARE(selection->pixelSelection()->parentNode(), KisNodeWSP(image->root()));
 }
 
 void KisSelectionTest::testOutlineGeneration()
 {
     KisSelectionSP sel = new KisSelection();
     sel->pixelSelection()->select(QRect(428,436, 430,211), 128);
 
     QVERIFY(sel->outlineCacheValid());
 
     QPainterPath originalOutline = sel->outlineCache();
 
     sel->pixelSelection()->invalidateOutlineCache();
     sel->recalculateOutlineCache();
 
     QPainterPath calculatedOutline = sel->outlineCache();
 
     QPainterPath closedSubPath = calculatedOutline;
     closedSubPath.closeSubpath();
 
     /**
      * Our outline generation code has a small problem: it can
      * generate a polygon, which isn't closed (it'll repeat the first
      * point instead). There is a special workaround for it in
      * KisPixelSelection::recalculateOutlineCache(), which explicitly
      * closes the path, so here we just check it.
      */
 
     bool isClosed = closedSubPath == calculatedOutline;
     QVERIFY(isClosed);
 }
 
 KISTEST_MAIN(KisSelectionTest)
 
 
diff --git a/libs/libkis/Selection.cpp b/libs/libkis/Selection.cpp
index 7c17819288..3c4989c758 100644
--- a/libs/libkis/Selection.cpp
+++ b/libs/libkis/Selection.cpp
@@ -1,334 +1,334 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Selection.h"
 
 #include <KoColorSpace.h>
 #include "kis_iterator_ng.h"
 #include <kis_selection.h>
 #include <kis_pixel_selection.h>
 #include <kis_paint_device.h>
 #include <kis_selection_filters.h>
 #include <kis_painter.h>
 #include <kis_clipboard.h>
 #include <QByteArray>
 
 #include <Node.h>
 
 struct Selection::Private {
     Private() {}
     KisSelectionSP selection;
 };
 
 Selection::Selection(KisSelectionSP selection, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->selection = selection;
 }
 
 
 Selection::Selection(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->selection = new KisSelection();
 }
 
 Selection::~Selection()
 {
     delete d;
 }
 
 bool Selection::operator==(const Selection &other) const
 {
     return (d->selection == other.d->selection);
 }
 
 bool Selection::operator!=(const Selection &other) const
 {
     return !(operator==(other));
 }
 
 Selection *Selection::duplicate() const
 {
     return new Selection(d->selection ? new KisSelection(*d->selection)
                          : new KisSelection());
 }
 
 int Selection::width() const
 {
     if (!d->selection) return 0;
     return d->selection->selectedExactRect().width();
 }
 
 int Selection::height() const
 {
     if (!d->selection) return 0;
     return d->selection->selectedExactRect().height();
 }
 
 int Selection::x() const
 {
     if (!d->selection) return 0;
     int xPos = d->selection->x();
-    if (d->selection->hasPixelSelection()) {
+    if (d->selection->hasNonEmptyPixelSelection()) {
         xPos = d->selection->selectedExactRect().x();
     }
     return xPos;
 }
 
 int Selection::y() const
 {
     if (!d->selection) return 0;
     int yPos = d->selection->y();
-    if (d->selection->hasPixelSelection()) {
+    if (d->selection->hasNonEmptyPixelSelection()) {
         yPos = d->selection->selectedExactRect().y();
     }
     return yPos;
 }
 
 void Selection::move(int x, int y)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->moveTo(QPoint(x, y));
 }
 
 
 void Selection::clear()
 {
     if (!d->selection) return;
     d->selection->clear();
 }
 
 void Selection::contract(int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x(), y(), width() - value, height() - value));
 }
 
 void Selection::copy(Node *node)
 {
     if (!node) return;
     if (!d->selection) return;
     if (node->node()->exactBounds().isEmpty()) return;
     if (!node->node()->hasEditablePaintDevice()) return;
 
     KisPaintDeviceSP dev = node->node()->paintDevice();
     KisPaintDeviceSP clip = new KisPaintDevice(dev->colorSpace());
     KisPaintDeviceSP selectionProjection = d->selection->projection();
 
     const KoColorSpace *cs = clip->colorSpace();
     const KoColorSpace *selCs = d->selection->projection()->colorSpace();
 
     QRect rc = d->selection->selectedExactRect();
 
     KisPainter::copyAreaOptimized(QPoint(), dev, clip, rc);
 
     KisHLineIteratorSP layerIt = clip->createHLineIteratorNG(0, 0, rc.width());
     KisHLineConstIteratorSP selectionIt = selectionProjection->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 
     for (qint32 y = 0; y < rc.height(); y++) {
         for (qint32 x = 0; x < rc.width(); x++) {
 
             qreal dstAlpha = cs->opacityF(layerIt->rawData());
             qreal sel = selCs->opacityF(selectionIt->oldRawData());
             qreal newAlpha = sel * dstAlpha / (1.0 - dstAlpha + sel * dstAlpha);
             float mask = newAlpha / dstAlpha;
 
             cs->applyAlphaNormedFloatMask(layerIt->rawData(), &mask, 1);
 
             layerIt->nextPixel();
             selectionIt->nextPixel();
         }
         layerIt->nextRow();
         selectionIt->nextRow();
     }
 
     KisClipboard::instance()->setClip(clip, rc.topLeft());
 }
 
 void Selection::cut(Node* node)
 {
     if (!node) return;
     if (!d->selection) return;
     if (node->node()->exactBounds().isEmpty()) return;
     if (!node->node()->hasEditablePaintDevice()) return;
     KisPaintDeviceSP dev = node->node()->paintDevice();
     copy(node);
     dev->clearSelection(d->selection);
     node->node()->setDirty(d->selection->selectedExactRect());
 }
 
 void Selection::paste(Node *destination, int x, int y)
 {
     if (!destination) return;
     if (!d->selection) return;
     if (!KisClipboard::instance()->hasClip()) return;
 
     KisPaintDeviceSP src = KisClipboard::instance()->clip(QRect(), false);
     KisPaintDeviceSP dst = destination->node()->paintDevice();
     if (!dst) return;
     KisPainter::copyAreaOptimized(QPoint(x, y),
                                   src,
                                   dst,
                                   src->exactBounds(),
                                   d->selection);
     destination->node()->setDirty();
 }
 
 void Selection::erode()
 {
     if (!d->selection) return;
     KisErodeSelectionFilter esf;
     QRect rc = esf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     esf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::dilate()
 {
     if (!d->selection) return;
     KisDilateSelectionFilter dsf;
     QRect rc = dsf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     dsf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::border(int xRadius, int yRadius)
 {
     if (!d->selection) return;
     KisBorderSelectionFilter sf(xRadius, yRadius);
     QRect rc = sf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::feather(int radius)
 {
     if (!d->selection) return;
     KisFeatherSelectionFilter fsf(radius);
     QRect rc = fsf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     fsf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::grow(int xradius, int yradius)
 {
     if (!d->selection) return;
     KisGrowSelectionFilter gsf(xradius, yradius);
     QRect rc = gsf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     gsf.process(d->selection->pixelSelection(), rc);
 }
 
 
 void Selection::shrink(int xRadius, int yRadius, bool edgeLock)
 {
     if (!d->selection) return;
     KisShrinkSelectionFilter sf(xRadius, yRadius, edgeLock);
     QRect rc = sf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::smooth()
 {
     if (!d->selection) return;
     KisSmoothSelectionFilter sf;
     QRect rc = sf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 
 void Selection::invert()
 {
     if (!d->selection) return;
     KisInvertSelectionFilter sf;
     QRect rc = sf.changeRect(d->selection->selectedExactRect(), d->selection->pixelSelection()->defaultBounds());
     sf.process(d->selection->pixelSelection(), rc);
 }
 
 void Selection::resize(int w, int h)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x(), y(), w, h));
 }
 
 void Selection::select(int x, int y, int w, int h, int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(QRect(x, y, w, h), value);
 }
 
 void Selection::selectAll(Node *node, int value)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->select(node->node()->exactBounds(), value);
 }
 
 void Selection::replace(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_REPLACE);
 }
 
 void Selection::add(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_ADD);
 }
 
 void Selection::subtract(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_SUBTRACT);
 }
 
 void Selection::intersect(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_INTERSECT);
 }
 
 void Selection::symmetricdifference(Selection *selection)
 {
     if (!d->selection) return;
     d->selection->pixelSelection()->applySelection(selection->selection()->pixelSelection(), SELECTION_SYMMETRICDIFFERENCE);
 }
 
 
 QByteArray Selection::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
     if (!d->selection) return ba;
     KisPaintDeviceSP dev = d->selection->projection();
     quint8 *data = new quint8[w * h];
     dev->readBytes(data, x, y, w, h);
     ba = QByteArray((const char*)data, (int)(w * h));
     delete[] data;
     return ba;
 }
 
 void Selection::setPixelData(QByteArray value, int x, int y, int w, int h)
 {
     if (!d->selection) return;
     KisPixelSelectionSP dev = d->selection->pixelSelection();
     if (!dev) return;
     dev->writeBytes((const quint8*)value.constData(), x, y, w, h);
 }
 
 KisSelectionSP Selection::selection() const
 {
     return d->selection;
 }
 
 
diff --git a/libs/ui/flake/kis_shape_controller.cpp b/libs/ui/flake/kis_shape_controller.cpp
index 3ac7afe702..19ed55bab7 100644
--- a/libs/ui/flake/kis_shape_controller.cpp
+++ b/libs/ui/flake/kis_shape_controller.cpp
@@ -1,271 +1,267 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_shape_controller.h"
 
 
 #include <klocalizedstring.h>
 
 #include <KoShape.h>
 #include <KoShapeContainer.h>
 #include <KoShapeManager.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KisView.h>
 #include <KoSelection.h>
 #include <KoShapeLayer.h>
 #include <KoPathShape.h>
 #include <KoColorSpaceConstants.h>
 #include <KoCanvasController.h>
 
 #include "kis_node_manager.h"
 #include "kis_shape_selection.h"
 #include "kis_selection.h"
 #include "kis_selection_component.h"
 #include "kis_adjustment_layer.h"
 #include "kis_clone_layer.h"
 #include "canvas/kis_canvas2.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_group_layer.h"
 #include "kis_node_shape.h"
 #include "kis_node_shapes_graph.h"
 #include "kis_name_server.h"
 #include "kis_mask.h"
 #include "kis_shape_layer.h"
 #include "KisViewManager.h"
 #include "kis_node.h"
 
 #include <KoDocumentResourceManager.h>
 #include <KoDataCenterBase.h>
 #include <commands/kis_image_layer_add_command.h>
 #include <kis_undo_adapter.h>
 #include "KoSelectedShapesProxy.h"
 #include "kis_signal_auto_connection.h"
 
 #include "KoAddRemoveShapeCommands.h"
 
 
 struct KisShapeController::Private
 {
 public:
     KisDocument *doc;
     KisNameServer *nameServer;
     KisSignalAutoConnectionsStore imageConnections;
 
     KisNodeShapesGraph shapesGraph;
 };
 
 KisShapeController::KisShapeController(KisDocument *doc, KisNameServer *nameServer)
     : KisDummiesFacadeBase(doc)
     , m_d(new Private())
 {
     m_d->doc = doc;
     m_d->nameServer = nameServer;
     resourceManager()->setUndoStack(doc->undoStack());
 }
 
 
 KisShapeController::~KisShapeController()
 {
     KisNodeDummy *node = m_d->shapesGraph.rootDummy();
     if (node) {
         m_d->shapesGraph.removeNode(node->node());
     }
 
     delete m_d;
 }
 
 void KisShapeController::slotUpdateDocumentResolution()
 {
     const qreal pixelsPerInch = m_d->doc->image()->xRes() * 72.0;
     resourceManager()->setResource(KoDocumentResourceManager::DocumentResolution, pixelsPerInch);
 }
 
 void KisShapeController::slotUpdateDocumentSize()
 {
     resourceManager()->setResource(KoDocumentResourceManager::DocumentRectInPixels, m_d->doc->image()->bounds());
 }
 
 void KisShapeController::addNodeImpl(KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KisNodeShape *newShape =
         m_d->shapesGraph.addNode(node, parent, aboveThis);
     // XXX: what are we going to do with this shape?
     Q_UNUSED(newShape);
 
     KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(node.data());
     if (shapeLayer) {
         /**
          * Forward signals for global shape manager
          * \see comment in the constructor of KisCanvas2
          */
         connect(shapeLayer, SIGNAL(selectionChanged()),
                 SIGNAL(selectionChanged()));
         connect(shapeLayer->shapeManager(), SIGNAL(selectionContentChanged()),
                 SIGNAL(selectionContentChanged()));
         connect(shapeLayer, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
                 SIGNAL(currentLayerChanged(const KoShapeLayer*)));
     }
 }
 
 void KisShapeController::removeNodeImpl(KisNodeSP node)
 {
     KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(node.data());
     if (shapeLayer) {
         shapeLayer->disconnect(this);
     }
 
     m_d->shapesGraph.removeNode(node);
 }
 
 bool KisShapeController::hasDummyForNode(KisNodeSP node) const
 {
     return m_d->shapesGraph.containsNode(node);
 }
 
 KisNodeDummy* KisShapeController::dummyForNode(KisNodeSP node) const
 {
     return m_d->shapesGraph.nodeToDummy(node);
 }
 
 KisNodeDummy* KisShapeController::rootDummy() const
 {
     return m_d->shapesGraph.rootDummy();
 }
 
 int KisShapeController::dummiesCount() const
 {
     return m_d->shapesGraph.shapesCount();
 }
 static inline bool belongsToShapeSelection(KoShape* shape) {
     return dynamic_cast<KisShapeSelectionMarker*>(shape->userData());
 }
 
 KoShapeContainer *KisShapeController::createParentForShapes(const QList<KoShape *> shapes, KUndo2Command *parentCommand)
 {
     KoShapeContainer *resultParent = 0;
     KisCommandUtils::CompositeCommand *resultCommand =
         new KisCommandUtils::CompositeCommand(parentCommand);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!shapes.isEmpty(), resultParent);
     Q_FOREACH (KoShape *shape, shapes) {
         KIS_SAFE_ASSERT_RECOVER_BREAK(!shape->parent());
     }
 
     KisCanvas2 *canvas = dynamic_cast<KisCanvas2*>(KoToolManager::instance()->activeCanvasController()->canvas());
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas, resultParent);
 
     const bool baseBelongsToSelection = belongsToShapeSelection(shapes.first());
     bool allSameBelongsToShapeSelection = true;
 
     Q_FOREACH (KoShape *shape, shapes) {
         allSameBelongsToShapeSelection &= belongsToShapeSelection(shape) == baseBelongsToSelection;
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!baseBelongsToSelection || allSameBelongsToShapeSelection, resultParent);
 
     if (baseBelongsToSelection && allSameBelongsToShapeSelection) {
         KisSelectionSP selection = canvas->viewManager()->selection();
         if (selection) {
             KisSelectionComponent* shapeSelectionComponent = selection->shapeSelection();
 
             if (!shapeSelectionComponent) {
-                // TODO: this change will land in the next patch only!
-                // shapeSelectionComponent = new KisShapeSelection(this, image(), selection);
-                // resultCommand->addCommand(selection->convertToVectorSelection(shapeSelectionComponent));
-
-                // TODO: now, the old implementation for the patch "compilability" rule
-                selection->setShapeSelection(new KisShapeSelection(this, image(), selection));
+                shapeSelectionComponent = new KisShapeSelection(this, image(), selection);
+                resultCommand->addCommand(selection->convertToVectorSelection(shapeSelectionComponent));
             }
 
             KisShapeSelection * shapeSelection = static_cast<KisShapeSelection*>(shapeSelectionComponent);
             resultParent = shapeSelection;
         }
     } else {
         KisShapeLayer *shapeLayer =
                 dynamic_cast<KisShapeLayer*>(
                     canvas->selectedShapesProxy()->selection()->activeLayer());
 
         if (!shapeLayer) {
             shapeLayer = new KisShapeLayer(this, image(),
                                            i18n("Vector Layer %1", m_d->nameServer->number()),
                                            OPACITY_OPAQUE_U8);
 
             resultCommand->addCommand(
                         new KisImageLayerAddCommand(image(),
                                                     shapeLayer,
                                                     image()->rootLayer(),
                                                     image()->rootLayer()->childCount()));
         }
 
         resultParent = shapeLayer;
     }
 
     return resultParent;
 }
 
 QRectF KisShapeController::documentRectInPixels() const
 {
     return m_d->doc->image()->bounds();
 }
 
 qreal KisShapeController::pixelsPerInch() const
 {
     return m_d->doc->image()->xRes() * 72.0;
 }
 
 void KisShapeController::setInitialShapeForCanvas(KisCanvas2 *canvas)
 {
     if (!image()) return;
 
     KisNodeSP rootNode = image()->root();
 
     if (m_d->shapesGraph.containsNode(rootNode)) {
         Q_ASSERT(canvas);
         Q_ASSERT(canvas->shapeManager());
         KoSelection *selection = canvas->shapeManager()->selection();
         if (selection && m_d->shapesGraph.nodeToShape(rootNode)) {
             selection->select(m_d->shapesGraph.nodeToShape(rootNode));
             KoToolManager::instance()->switchToolRequested(KoToolManager::instance()->preferredToolForSelection(selection->selectedShapes()));
         }
     }
 }
 
 void KisShapeController::setImage(KisImageWSP image)
 {
     m_d->imageConnections.clear();
 
     if (image) {
         m_d->imageConnections.addConnection(image, SIGNAL(sigResolutionChanged(double, double)), this, SLOT(slotUpdateDocumentResolution()));
         m_d->imageConnections.addConnection(image, SIGNAL(sigSizeChanged(QPointF, QPointF)), this, SLOT(slotUpdateDocumentSize()));
     }
     slotUpdateDocumentResolution();
     slotUpdateDocumentSize();
 
     KisDummiesFacadeBase::setImage(image);
 }
 
 KoShapeLayer* KisShapeController::shapeForNode(KisNodeSP node) const
 {
     if (node) {
         return m_d->shapesGraph.nodeToShape(node);
     }
     return 0;
 }
 
diff --git a/libs/ui/flake/kis_shape_selection_model.cpp b/libs/ui/flake/kis_shape_selection_model.cpp
index 8a1e9ab558..2cb7a29d65 100644
--- a/libs/ui/flake/kis_shape_selection_model.cpp
+++ b/libs/ui/flake/kis_shape_selection_model.cpp
@@ -1,178 +1,174 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_shape_selection_model.h"
 #include "kis_debug.h"
 
 #include <KoShapeContainer.h>
 #include <KoShapeBackground.h>
 #include <KoShapeManager.h>
 
 #include "kis_shape_selection.h"
 #include "kis_selection.h"
 #include "kis_image.h"
 #include "kis_update_selection_job.h"
 
 
 KisShapeSelectionModel::KisShapeSelectionModel(KisImageWSP image, KisSelectionWSP selection, KisShapeSelection* shapeSelection)
     : m_image(image)
     , m_parentSelection(selection)
     , m_shapeSelection(shapeSelection)
     , m_updatesEnabled(true)
 {
 }
 
 KisShapeSelectionModel::~KisShapeSelectionModel()
 {
     m_image = 0;
     m_parentSelection = 0;
 }
 
 void KisShapeSelectionModel::requestUpdate(const QRect &updateRect)
 {
     m_shapeSelection->recalculateOutlineCache();
 
     if (m_updatesEnabled) {
         m_parentSelection->requestCompressedProjectionUpdate(updateRect);
     }
 }
 
 void KisShapeSelectionModel::add(KoShape *child)
 {
     if (!m_shapeSelection) return;
 
     if (m_shapeMap.contains(child))
         return;
 
     child->setStroke(KoShapeStrokeModelSP());
     child->setBackground( QSharedPointer<KoShapeBackground>(0));
     m_shapeMap.insert(child, child->boundingRect());
     m_shapeSelection->shapeManager()->addShape(child);
 
     QRect updateRect = child->boundingRect().toAlignedRect();
     if (m_image.isValid()) {
         QTransform matrix;
         matrix.scale(m_image->xRes(), m_image->yRes());
         updateRect = matrix.mapRect(updateRect);
     }
 
     if (m_shapeMap.count() == 1) {
         // The shape is the first one, so the shape selection just got created
         // Pixel selection provides no longer the datamanager of the selection
         // so update the whole selection
         requestUpdate(QRect());
     } else {
         requestUpdate(updateRect);
     }
 }
 
 void KisShapeSelectionModel::remove(KoShape *child)
 {
     if (!m_shapeMap.contains(child)) return;
 
     QRect updateRect = child->boundingRect().toAlignedRect();
     m_shapeMap.remove(child);
 
     if (m_shapeSelection) {
         m_shapeSelection->shapeManager()->remove(child);
     }
     if (m_image.isValid()) {
         QTransform matrix;
         matrix.scale(m_image->xRes(), m_image->yRes());
         updateRect = matrix.mapRect(updateRect);
         if (m_shapeSelection) { // No m_shapeSelection indicates the selection is being deleted
             requestUpdate(updateRect);
-
-            if (m_updatesEnabled && m_shapeMap.isEmpty()) {
-                m_parentSelection->notifyShapeSelectionBecameEmpty();
-            }
         }
     }
 }
 
 void KisShapeSelectionModel::setUpdatesEnabled(bool enabled)
 {
     m_updatesEnabled = enabled;
 }
 
 bool KisShapeSelectionModel::updatesEnabled() const
 {
     return m_updatesEnabled;
 }
 
 void KisShapeSelectionModel::setClipped(const KoShape *child, bool clipping)
 {
     Q_UNUSED(child);
     Q_UNUSED(clipping);
 }
 
 bool KisShapeSelectionModel::isClipped(const KoShape *child) const
 {
     Q_UNUSED(child);
     return false;
 }
 
 void KisShapeSelectionModel::setInheritsTransform(const KoShape *shape, bool inherit)
 {
     Q_UNUSED(shape);
     Q_UNUSED(inherit);
 }
 
 bool KisShapeSelectionModel::inheritsTransform(const KoShape *shape) const
 {
     Q_UNUSED(shape);
     return false;
 }
 
 int KisShapeSelectionModel::count() const
 {
     return m_shapeMap.count();
 }
 
 QList<KoShape*> KisShapeSelectionModel::shapes() const
 {
     return QList<KoShape*>(m_shapeMap.keys());
 }
 void KisShapeSelectionModel::containerChanged(KoShapeContainer *, KoShape::ChangeType)
 {
 }
 
 void KisShapeSelectionModel::childChanged(KoShape * child, KoShape::ChangeType type)
 {
     if (!m_shapeSelection) return;
 
     // TODO: check if still needed
     if (type == KoShape::ParentChanged) return;
 
     QRectF changedRect = m_shapeMap[child];
     changedRect = changedRect.united(child->boundingRect());
     m_shapeMap[child] = child->boundingRect();
 
     if (m_image.isValid()) {
         QTransform matrix;
         matrix.scale(m_image->xRes(), m_image->yRes());
         changedRect = matrix.mapRect(changedRect);
     }
 
     requestUpdate(changedRect.toAlignedRect());
 }
 
 void KisShapeSelectionModel::setShapeSelection(KisShapeSelection* selection)
 {
     m_shapeSelection = selection;
 }
diff --git a/libs/ui/kis_selection_decoration.cc b/libs/ui/kis_selection_decoration.cc
index c6253a2b03..c7589f36d3 100644
--- a/libs/ui/kis_selection_decoration.cc
+++ b/libs/ui/kis_selection_decoration.cc
@@ -1,226 +1,226 @@
 /*
  * Copyright (c) 2008 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_decoration.h"
 
 #include <QPainter>
 #include <QVarLengthArray>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include "kis_types.h"
 #include "KisViewManager.h"
 #include "kis_selection.h"
 #include "kis_image.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_pixel_selection.h"
 #include "kis_update_outline_job.h"
 #include "kis_selection_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_coordinates_converter.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_image_config.h"
 #include "KisImageConfigNotifier.h"
 #include "kis_painting_tweaks.h"
 #include "KisView.h"
 #include "kis_selection_mask.h"
 #include <KisPart.h>
 
 static const unsigned int ANT_LENGTH = 4;
 static const unsigned int ANT_SPACE = 4;
 static const unsigned int ANT_ADVANCE_WIDTH = ANT_LENGTH + ANT_SPACE;
 
 KisSelectionDecoration::KisSelectionDecoration(QPointer<KisView>view)
     : KisCanvasDecoration("selection", view),
       m_signalCompressor(40 /*ms*/, KisSignalCompressor::FIRST_ACTIVE),
       m_offset(0),
       m_mode(Ants)
 {
     KisPaintingTweaks::initAntsPen(&m_antsPen, &m_outlinePen,
                                    ANT_LENGTH, ANT_SPACE);
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 
     m_antsTimer = new QTimer(this);
     m_antsTimer->setInterval(150);
     m_antsTimer->setSingleShot(false);
     connect(m_antsTimer, SIGNAL(timeout()), SLOT(antsAttackEvent()));
 
     connect(&m_signalCompressor, SIGNAL(timeout()), SLOT(slotStartUpdateSelection()));
 
     // selections should be at the top of the stack
     setPriority(100);
 }
 
 KisSelectionDecoration::~KisSelectionDecoration()
 {
 }
 
 KisSelectionDecoration::Mode KisSelectionDecoration::mode() const
 {
     return m_mode;
 }
 
 void KisSelectionDecoration::setMode(Mode mode)
 {
     m_mode = mode;
     selectionChanged();
 }
 
 bool KisSelectionDecoration::selectionIsActive()
 {
     KisSelectionSP selection = view()->selection();
     return visible() && selection &&
-        (selection->hasPixelSelection() || selection->hasShapeSelection()) &&
+        (selection->hasNonEmptyPixelSelection() || selection->hasNonEmptyShapeSelection()) &&
         selection->isVisible();
 }
 
 void KisSelectionDecoration::selectionChanged()
 {
     KisSelectionMaskSP mask = qobject_cast<KisSelectionMask*>(view()->currentNode().data());
     if (!mask || !mask->active() || !mask->visible(true)) {
         mask = 0;
     }
 
     if (!view()->isCurrent() ||
         view()->viewManager()->mainWindow() == KisPart::instance()->currentMainwindow()) {
 
         view()->image()->setOverlaySelectionMask(mask);
     }
 
     KisSelectionSP selection = view()->selection();
 
     if (!mask && selection && selectionIsActive()) {
         if ((m_mode == Ants && selection->outlineCacheValid()) ||
             (m_mode == Mask && selection->thumbnailImageValid())) {
 
             m_signalCompressor.stop();
 
             if (m_mode == Ants) {
                 m_outlinePath = selection->outlineCache();
                 m_antsTimer->start();
             } else {
                 m_thumbnailImage = selection->thumbnailImage();
                 m_thumbnailImageTransform = selection->thumbnailImageTransform();
             }
             if (view() && view()->canvasBase()) {
                 view()->canvasBase()->updateCanvas();
             }
 
         } else {
             m_signalCompressor.start();
         }
     } else {
         m_signalCompressor.stop();
         m_outlinePath = QPainterPath();
         m_thumbnailImage = QImage();
         m_thumbnailImageTransform = QTransform();
         view()->canvasBase()->updateCanvas();
         m_antsTimer->stop();
     }
 }
 
 void KisSelectionDecoration::slotStartUpdateSelection()
 {
     KisSelectionSP selection = view()->selection();
     if (!selection) return;
 
     view()->image()->addSpontaneousJob(new KisUpdateOutlineJob(selection, m_mode == Mask, m_maskColor));
 }
 
 void KisSelectionDecoration::slotConfigChanged()
 {
     KisImageConfig imageConfig(true);
     KisConfig cfg(true);
 
     m_maskColor = imageConfig.selectionOverlayMaskColor();
     m_antialiasSelectionOutline = cfg.antialiasSelectionOutline();
 }
 
 void KisSelectionDecoration::antsAttackEvent()
 {
     KisSelectionSP selection = view()->selection();
     if (!selection) return;
 
     if (selectionIsActive()) {
         m_offset = (m_offset + 1) % ANT_ADVANCE_WIDTH;
         m_antsPen.setDashOffset(m_offset);
         view()->canvasBase()->updateCanvas();
     }
 }
 
 void KisSelectionDecoration::drawDecoration(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter, KisCanvas2 *canvas)
 {
     Q_UNUSED(updateRect);
     Q_UNUSED(canvas);
 
     if (!selectionIsActive()) return;
     if ((m_mode == Ants && m_outlinePath.isEmpty()) ||
         (m_mode == Mask && m_thumbnailImage.isNull())) return;
 
     QTransform transform = converter->imageToWidgetTransform();
 
     gc.save();
     gc.setTransform(transform, false);
 
     if (m_mode == Mask) {
         gc.setRenderHints(QPainter::SmoothPixmapTransform |
                           QPainter::HighQualityAntialiasing, false);
 
         gc.setTransform(m_thumbnailImageTransform, true);
         gc.drawImage(QPoint(), m_thumbnailImage);
 
         QRect r1 = m_thumbnailImageTransform.inverted().mapRect(view()->image()->bounds());
         QRect r2 = m_thumbnailImage.rect();
 
         QPainterPath p1;
         p1.addRect(r1);
 
         QPainterPath p2;
         p2.addRect(r2);
 
         gc.setBrush(m_maskColor);
         gc.setPen(Qt::NoPen);
         gc.drawPath(p1 - p2);
 
     } else /* if (m_mode == Ants) */ {
         gc.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing, m_antialiasSelectionOutline);
 
         // render selection outline in white
         gc.setPen(m_outlinePen);
         gc.drawPath(m_outlinePath);
 
         // render marching ants in black (above the white outline)
         gc.setPen(m_antsPen);
         gc.drawPath(m_outlinePath);
     }
     gc.restore();
 }
 
 void KisSelectionDecoration::setVisible(bool v)
 {
     KisCanvasDecoration::setVisible(v);
     selectionChanged();
 }
 
 
diff --git a/libs/ui/kis_selection_manager.cc b/libs/ui/kis_selection_manager.cc
index b469249eb5..c719835b53 100644
--- a/libs/ui/kis_selection_manager.cc
+++ b/libs/ui/kis_selection_manager.cc
@@ -1,740 +1,740 @@
 
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  The outline algorithm uses the limn algorithm of fontutils by
  *  Karl Berry <karl@cs.umb.edu> and Kathryn Hargreaves <letters@cs.umb.edu>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_manager.h"
 #include <QApplication>
 #include <QClipboard>
 #include <QColor>
 #include <QTimer>
 #include <QMimeData>
 
 #include <QAction>
 #include <ktoggleaction.h>
 #include <klocalizedstring.h>
 #include <kstandardaction.h>
 #include <kactioncollection.h>
 
 #include "KoCanvasController.h"
 #include "KoChannelInfo.h"
 #include "KoIntegerMaths.h"
 #include <KisDocument.h>
 #include <KisMainWindow.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoSelectedShapesProxy.h>
 #include <KoShapeStroke.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KoToolProxy.h>
 #include <KoSvgPaste.h>
 #include <kis_icon.h>
 
 #include "kis_adjustment_layer.h"
 #include "kis_node_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_config.h"
 #include "kis_convolution_painter.h"
 #include "kis_convolution_kernel.h"
 #include "kis_debug.h"
 #include "kis_fill_painter.h"
 #include "kis_group_layer.h"
 #include "kis_layer.h"
 #include "kis_statusbar.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_painter.h"
 #include "kis_transaction.h"
 #include "kis_selection.h"
 #include "kis_types.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_undo_adapter.h"
 #include "kis_pixel_selection.h"
 #include "flake/kis_shape_selection.h"
 #include "commands/kis_selection_commands.h"
 #include "kis_selection_mask.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_selection_decoration.h"
 #include "canvas/kis_canvas_decoration.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_iterator_ng.h"
 #include "kis_clipboard.h"
 #include "KisViewManager.h"
 #include "kis_selection_filters.h"
 #include "kis_figure_painting_tool_helper.h"
 #include "KisView.h"
 #include "dialogs/kis_dlg_stroke_selection_properties.h"
 
 #include "actions/kis_selection_action_factories.h"
 #include "actions/KisPasteActionFactories.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "operations/kis_operation_configuration.h"
 //new
 #include "kis_node_query_path.h"
 #include "kis_tool_shape.h"
 
 KisSelectionManager::KisSelectionManager(KisViewManager * view)
         : m_view(view)
         , m_adapter(new KisNodeCommandsAdapter(view))
 {
     m_clipboard = KisClipboard::instance();
 }
 
 KisSelectionManager::~KisSelectionManager()
 {
 }
 
 void KisSelectionManager::setup(KisActionManager* actionManager)
 {
     m_cut = actionManager->createStandardAction(KStandardAction::Cut, this, SLOT(cut()));
     m_copy = actionManager->createStandardAction(KStandardAction::Copy, this, SLOT(copy()));
     m_paste = actionManager->createStandardAction(KStandardAction::Paste, this, SLOT(paste()));
 
     KisAction *action = actionManager->createAction("copy_sharp");
     connect(action, SIGNAL(triggered()), this, SLOT(copySharp()));
 
     action = actionManager->createAction("cut_sharp");
     connect(action, SIGNAL(triggered()), this, SLOT(cutSharp()));
 
     m_pasteNew = actionManager->createAction("paste_new");
     connect(m_pasteNew, SIGNAL(triggered()), this, SLOT(pasteNew()));
 
     m_pasteAt = actionManager->createAction("paste_at");
     connect(m_pasteAt, SIGNAL(triggered()), this, SLOT(pasteAt()));
 
     m_pasteAsReference = actionManager->createAction("paste_as_reference");
     connect(m_pasteAsReference, SIGNAL(triggered()), this, SLOT(pasteAsReference()));
 
     m_copyMerged = actionManager->createAction("copy_merged");
     connect(m_copyMerged, SIGNAL(triggered()), this, SLOT(copyMerged()));
 
     m_selectAll = actionManager->createAction("select_all");
     connect(m_selectAll, SIGNAL(triggered()), this, SLOT(selectAll()));
 
     m_deselect = actionManager->createAction("deselect");
     connect(m_deselect, SIGNAL(triggered()), this, SLOT(deselect()));
 
     m_clear = actionManager->createAction("clear");
     connect(m_clear, SIGNAL(triggered()), SLOT(clear()));
 
     m_reselect = actionManager->createAction("reselect");
     connect(m_reselect, SIGNAL(triggered()), this, SLOT(reselect()));
 
     m_invert = actionManager->createAction("invert_selection");
     m_invert->setOperationID("invertselection");
 
     actionManager->registerOperation(new KisInvertSelectionOperation);
 
     m_copyToNewLayer = actionManager->createAction("copy_selection_to_new_layer");
     connect(m_copyToNewLayer, SIGNAL(triggered()), this, SLOT(copySelectionToNewLayer()));
 
     m_cutToNewLayer = actionManager->createAction("cut_selection_to_new_layer");
     connect(m_cutToNewLayer, SIGNAL(triggered()), this, SLOT(cutToNewLayer()));
 
     m_fillForegroundColor = actionManager->createAction("fill_selection_foreground_color");
     connect(m_fillForegroundColor, SIGNAL(triggered()), this, SLOT(fillForegroundColor()));
 
     m_fillBackgroundColor  = actionManager->createAction("fill_selection_background_color");
     connect(m_fillBackgroundColor, SIGNAL(triggered()), this, SLOT(fillBackgroundColor()));
 
     m_fillPattern = actionManager->createAction("fill_selection_pattern");
     connect(m_fillPattern, SIGNAL(triggered()), this, SLOT(fillPattern()));
 
     m_fillForegroundColorOpacity  = actionManager->createAction("fill_selection_foreground_color_opacity");
     connect(m_fillForegroundColorOpacity, SIGNAL(triggered()), this, SLOT(fillForegroundColorOpacity()));
 
     m_fillBackgroundColorOpacity  = actionManager->createAction("fill_selection_background_color_opacity");
     connect(m_fillBackgroundColorOpacity, SIGNAL(triggered()), this, SLOT(fillBackgroundColorOpacity()));
 
     m_fillPatternOpacity  = actionManager->createAction("fill_selection_pattern_opacity");
     connect(m_fillPatternOpacity, SIGNAL(triggered()), this, SLOT(fillPatternOpacity()));
 
     m_strokeShapes  = actionManager->createAction("stroke_shapes");
     connect(m_strokeShapes, SIGNAL(triggered()), this, SLOT(paintSelectedShapes()));
 
     m_toggleDisplaySelection  = actionManager->createAction("toggle_display_selection");
     connect(m_toggleDisplaySelection, SIGNAL(triggered()), this, SLOT(toggleDisplaySelection()));
     m_toggleDisplaySelection->setChecked(true);
 
     m_imageResizeToSelection  = actionManager->createAction("resizeimagetoselection");
     connect(m_imageResizeToSelection, SIGNAL(triggered()), this, SLOT(imageResizeToSelection()));
 
     action = actionManager->createAction("edit_selection");
     connect(action, SIGNAL(triggered()), SLOT(editSelection()));
 
     action = actionManager->createAction("convert_to_vector_selection");
     connect(action, SIGNAL(triggered()), SLOT(convertToVectorSelection()));
 
     action = actionManager->createAction("convert_to_raster_selection");
     connect(action, SIGNAL(triggered()), SLOT(convertToRasterSelection()));
 
     action = actionManager->createAction("convert_shapes_to_vector_selection");
     connect(action, SIGNAL(triggered()), SLOT(convertShapesToVectorSelection()));
 
     action = actionManager->createAction("convert_selection_to_shape");
     connect(action, SIGNAL(triggered()), SLOT(convertToShape()));
 
     m_toggleSelectionOverlayMode  = actionManager->createAction("toggle-selection-overlay-mode");
     connect(m_toggleSelectionOverlayMode, SIGNAL(triggered()), SLOT(slotToggleSelectionDecoration()));
 
     m_strokeSelected = actionManager->createAction("stroke_selection");
     connect(m_strokeSelected, SIGNAL(triggered()), SLOT(slotStrokeSelection()));
 
     QClipboard *cb = QApplication::clipboard();
     connect(cb, SIGNAL(dataChanged()), SLOT(clipboardDataChanged()));
 }
 
 
 void KisSelectionManager::setView(QPointer<KisView>imageView)
 {
     if (m_imageView && m_imageView->canvasBase()) {
         disconnect(m_imageView->canvasBase()->toolProxy(), SIGNAL(toolChanged(QString)), this, SLOT(clipboardDataChanged()));
 
         KoSelection *selection = m_imageView->canvasBase()->globalShapeManager()->selection();
         selection->disconnect(this, SLOT(shapeSelectionChanged()));
         KisSelectionDecoration *decoration = qobject_cast<KisSelectionDecoration*>(m_imageView->canvasBase()->decoration("selection").data());
         if (decoration) {
             disconnect(SIGNAL(currentSelectionChanged()), decoration);
         }
         m_imageView->image()->undoAdapter()->disconnect(this);
         m_selectionDecoration = 0;
     }
 
     m_imageView = imageView;
     if (m_imageView) {
         connect(m_imageView->canvasBase()->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(shapeSelectionChanged()), Qt::UniqueConnection);
 
         KisSelectionDecoration* decoration = qobject_cast<KisSelectionDecoration*>(m_imageView->canvasBase()->decoration("selection").data());
         if (!decoration) {
             decoration = new KisSelectionDecoration(m_imageView);
             decoration->setVisible(true);
             m_imageView->canvasBase()->addDecoration(decoration);
         }
         m_selectionDecoration = decoration;
         connect(this, SIGNAL(currentSelectionChanged()), decoration, SLOT(selectionChanged()));
         connect(m_imageView->image()->undoAdapter(), SIGNAL(selectionChanged()), SLOT(selectionChanged()));
         connect(m_imageView->canvasBase()->toolProxy(), SIGNAL(toolChanged(QString)), SLOT(clipboardDataChanged()));
 
     }
 }
 
 
 void KisSelectionManager::clipboardDataChanged()
 {
     m_view->updateGUI();
 }
 
 bool KisSelectionManager::havePixelsSelected()
 {
     KisSelectionSP activeSelection = m_view->selection();
     return activeSelection && !activeSelection->selectedRect().isEmpty();
 }
 
 bool KisSelectionManager::havePixelsInClipboard()
 {
     return m_clipboard->hasClip();
 }
 
 bool KisSelectionManager::haveShapesSelected()
 {
     if (m_view && m_view->canvasBase()) {
         return m_view->canvasBase()->selectedShapesProxy()->selection()->count() > 0;
     }
     return false;
 }
 
 bool KisSelectionManager::haveShapesInClipboard()
 {
     KoSvgPaste paste;
     return paste.hasShapes();
 }
 
 bool KisSelectionManager::haveAnySelectionWithPixels()
 {
     KisSelectionSP selection = m_view->selection();
-    return selection && selection->hasPixelSelection();
+    return selection && selection->hasNonEmptyPixelSelection();
 }
 
 bool KisSelectionManager::haveShapeSelectionWithShapes()
 {
     KisSelectionSP selection = m_view->selection();
-    return selection && selection->hasShapeSelection();
+    return selection && selection->hasNonEmptyShapeSelection();
 }
 
 bool KisSelectionManager::haveRasterSelectionWithPixels()
 {
     KisSelectionSP selection = m_view->selection();
-    return selection && selection->hasPixelSelection() && !selection->hasShapeSelection();
+    return selection && selection->hasNonEmptyPixelSelection() && !selection->hasNonEmptyShapeSelection();
 }
 
 void KisSelectionManager::updateGUI()
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_clipboard);
     if (!m_view || !m_clipboard) return;
 
     bool havePixelsSelected = this->havePixelsSelected();
     bool havePixelsInClipboard = this->havePixelsInClipboard();
     bool haveShapesSelected = this->haveShapesSelected();
     bool haveShapesInClipboard = this->haveShapesInClipboard();
     bool haveDevice = m_view->activeDevice();
 
     KisLayerSP activeLayer = m_view->activeLayer();
     KisImageWSP image = activeLayer ? activeLayer->image() : 0;
     bool canReselect = image && image->canReselectGlobalSelection();
     bool canDeselect =  image && image->globalSelection();
 
     m_clear->setEnabled(haveDevice || havePixelsSelected || haveShapesSelected);
     m_cut->setEnabled(havePixelsSelected || haveShapesSelected);
     m_copy->setEnabled(havePixelsSelected || haveShapesSelected);
     m_paste->setEnabled(havePixelsInClipboard || haveShapesInClipboard);
     m_pasteAt->setEnabled(havePixelsInClipboard || haveShapesInClipboard);
     // FIXME: how about pasting shapes?
     m_pasteNew->setEnabled(havePixelsInClipboard);
     m_pasteAsReference->setEnabled(haveDevice);
 
     m_selectAll->setEnabled(true);
     m_deselect->setEnabled(canDeselect);
     m_reselect->setEnabled(canReselect);
 
 //    m_load->setEnabled(true);
 //    m_save->setEnabled(havePixelsSelected);
 
     updateStatusBar();
     emit signalUpdateGUI();
 }
 
 void KisSelectionManager::updateStatusBar()
 {
     if (m_view && m_view->statusBar()) {
         m_view->statusBar()->setSelection(m_view->image());
     }
 }
 
 void KisSelectionManager::selectionChanged()
 {
     m_view->updateGUI();
     emit currentSelectionChanged();
 }
 
 void KisSelectionManager::cut()
 {
     KisCutCopyActionFactory factory;
     factory.run(true, false, m_view);
 }
 
 void KisSelectionManager::copy()
 {
     KisCutCopyActionFactory factory;
     factory.run(false, false, m_view);
 }
 
 void KisSelectionManager::cutSharp()
 {
     KisCutCopyActionFactory factory;
     factory.run(true, true, m_view);
 }
 
 void KisSelectionManager::copySharp()
 {
     KisCutCopyActionFactory factory;
     factory.run(false, true, m_view);
 }
 
 void KisSelectionManager::copyMerged()
 {
     KisCopyMergedActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::paste()
 {
     KisPasteActionFactory factory;
     factory.run(false, m_view);
 }
 
 void KisSelectionManager::pasteAt()
 {
     KisPasteActionFactory factory;
     factory.run(true, m_view);
 }
 
 void KisSelectionManager::pasteAsReference()
 {
     KisPasteReferenceActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::pasteNew()
 {
     KisPasteNewActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::selectAll()
 {
     KisSelectAllActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::deselect()
 {
     KisDeselectActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::invert()
 {
     if(m_invert)
         m_invert->trigger();
 }
 
 void KisSelectionManager::reselect()
 {
     KisReselectActionFactory factory;
     factory.run(m_view);
 }
 
 
 #include <KoToolManager.h>
 #include <KoInteractionTool.h>
 
 void KisSelectionManager::editSelection()
 {
     KisSelectionSP selection = m_view->selection();
     if (!selection) return;
 
     KisAction *action = m_view->actionManager()->actionByName("show-global-selection-mask");
     KIS_SAFE_ASSERT_RECOVER_RETURN(action);
 
     if (!action->isChecked()) {
         action->setChecked(true);
         emit action->toggled(true);
         emit action->triggered(true);
     }
 
     KisNodeSP node = selection->parentNode();
     KIS_SAFE_ASSERT_RECOVER_RETURN(node);
 
     m_view->nodeManager()->slotNonUiActivatedNode(node);
 
     if (selection->hasShapeSelection()) {
         KisShapeSelection *shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
         KIS_SAFE_ASSERT_RECOVER_RETURN(shapeSelection);
 
         KoToolManager::instance()->switchToolRequested(KoInteractionTool_ID);
 
         QList<KoShape*> shapes = shapeSelection->shapes();
 
         if (shapes.isEmpty()) {
             KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "no shapes");
             return;
         }
 
         Q_FOREACH (KoShape *shape, shapes) {
             m_view->canvasBase()->selectedShapesProxy()->selection()->select(shape);
         }
     } else {
         KoToolManager::instance()->switchToolRequested("KisToolTransform");
     }
 }
 
 void KisSelectionManager::convertToVectorSelection()
 {
     KisSelectionToVectorActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::convertToRasterSelection()
 {
     KisSelectionToRasterActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::convertShapesToVectorSelection()
 {
     KisShapesToVectorSelectionActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::convertToShape()
 {
     KisSelectionToShapeActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::clear()
 {
     KisClearActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::fillForegroundColor()
 {
     KisFillActionFactory  factory;
     factory.run("fg", m_view);
 }
 
 void KisSelectionManager::fillBackgroundColor()
 {
     KisFillActionFactory factory;
     factory.run("bg", m_view);
 }
 
 void KisSelectionManager::fillPattern()
 {
     KisFillActionFactory factory;
     factory.run("pattern", m_view);
 }
 
 void KisSelectionManager::fillForegroundColorOpacity()
 {
     KisFillActionFactory  factory;
     factory.run("fg_opacity", m_view);
 }
 
 void KisSelectionManager::fillBackgroundColorOpacity()
 {
     KisFillActionFactory factory;
     factory.run("bg_opacity", m_view);
 }
 
 void KisSelectionManager::fillPatternOpacity()
 {
     KisFillActionFactory factory;
     factory.run("pattern_opacity", m_view);
 }
 
 void KisSelectionManager::copySelectionToNewLayer()
 {
     copy();
     paste();
 }
 
 void KisSelectionManager::cutToNewLayer()
 {
     cut();
     paste();
 }
 
 void KisSelectionManager::toggleDisplaySelection()
 {
     KIS_ASSERT_RECOVER_RETURN(m_selectionDecoration);
 
     m_selectionDecoration->toggleVisibility();
     m_toggleDisplaySelection->blockSignals(true);
     m_toggleDisplaySelection->setChecked(m_selectionDecoration->visible());
     m_toggleDisplaySelection->blockSignals(false);
 
     emit displaySelectionChanged();
 }
 
 bool KisSelectionManager::displaySelection()
 {
     return m_toggleDisplaySelection->isChecked();
 }
 
 void KisSelectionManager::shapeSelectionChanged()
 {
     KoShapeManager* shapeManager = m_view->canvasBase()->globalShapeManager();
 
     KoSelection * selection = shapeManager->selection();
     QList<KoShape*> selectedShapes = selection->selectedShapes();
 
     KoShapeStrokeSP border(new KoShapeStroke(0, Qt::lightGray));
     Q_FOREACH (KoShape* shape, shapeManager->shapes()) {
         if (dynamic_cast<KisShapeSelection*>(shape->parent())) {
             if (selectedShapes.contains(shape))
                 shape->setStroke(border);
             else
                 shape->setStroke(KoShapeStrokeSP());
         }
     }
     m_view->updateGUI();
 }
 
 void KisSelectionManager::imageResizeToSelection()
 {
     KisImageResizeToSelectionActionFactory factory;
     factory.run(m_view);
 }
 
 void KisSelectionManager::paintSelectedShapes()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = m_view->activeLayer();
     if (!layer) return;
 
     QList<KoShape*> shapes = m_view->canvasBase()->shapeManager()->selection()->selectedShapes();
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, i18n("Stroked Shapes"), OPACITY_OPAQUE_U8);
 
     KUndo2MagicString actionName = kundo2_i18n("Stroke Shapes");
 
     m_adapter->beginMacro(actionName);
     m_adapter->addNode(paintLayer.data(), layer->parent().data(), layer.data());
 
     KisFigurePaintingToolHelper helper(actionName,
                                        image,
                                        paintLayer.data(),
                                        m_view->canvasResourceProvider()->resourceManager(),
                                        KisToolShapeUtils::StrokeStyleForeground,
                                        KisToolShapeUtils::FillStyleNone);
 
     Q_FOREACH (KoShape* shape, shapes) {
         QTransform matrix = shape->absoluteTransformation() * QTransform::fromScale(image->xRes(), image->yRes());
         QPainterPath mapedOutline = matrix.map(shape->outline());
         helper.paintPainterPath(mapedOutline);
     }
     m_adapter->endMacro();
 }
 
 void KisSelectionManager::slotToggleSelectionDecoration()
 {
     KIS_ASSERT_RECOVER_RETURN(m_selectionDecoration);
 
     KisSelectionDecoration::Mode mode =
         m_selectionDecoration->mode() ?
         KisSelectionDecoration::Ants : KisSelectionDecoration::Mask;
 
     m_selectionDecoration->setMode(mode);
     emit displaySelectionChanged();
 }
 
 bool KisSelectionManager::showSelectionAsMask() const
 {
     if (m_selectionDecoration) {
         return m_selectionDecoration->mode() == KisSelectionDecoration::Mask;
     }
     return false;
 }
 void KisSelectionManager::slotStrokeSelection()
 {
     KisImageWSP image = m_view->image();
 
     if (!image ) {
         return;
     }
 
     KisNodeSP currentNode = m_view->canvasResourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     bool isVectorLayer = false;
     if (currentNode->inherits("KisShapeLayer")) {
         isVectorLayer = true;
     }
 
     QPointer<KisDlgStrokeSelection> dlg = new KisDlgStrokeSelection(image, m_view, isVectorLayer);
 
     if (dlg->exec() == QDialog::Accepted) {
         StrokeSelectionOptions params = dlg->getParams();
         if (params.brushSelected){
             KisStrokeBrushSelectionActionFactory factory;
             factory.run(m_view, params);
         }
         else {
             KisStrokeSelectionActionFactory factory;
             factory.run(m_view, params);
         }
     }
     delete dlg;
 
 
 }
 
 #include "kis_image_barrier_locker.h"
 #include "kis_selection_tool_helper.h"
 
 void KisSelectionManager::selectOpaqueOnNode(KisNodeSP node, SelectionAction action)
 {
     KisImageSP image = m_view->image();
 
     if (!m_view->blockUntilOperationsFinished(image)) {
         return;
     }
 
     KUndo2MagicString actionName;
     KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
     KisCanvas2 *canvas = m_view->canvasBase();
 
 
     {
         KisImageBarrierLocker locker(image);
 
         KisPaintDeviceSP device = node->projection();
         if (!device) device = node->paintDevice();
         if (!device) device = node->original();
 
         if (!device) return;
 
         QRect rc = device->exactBounds();
         if (rc.isEmpty()) return;
 
         KIS_ASSERT_RECOVER_RETURN(canvas);
 
         /**
          * If there is nothing selected, just create a new selection
          */
         if (!canvas->imageView()->selection()) {
             action = SELECTION_REPLACE;
         }
 
         switch (action) {
         case SELECTION_ADD:
             actionName = kundo2_i18n("Select Opaque (Add)");
             break;
         case SELECTION_SUBTRACT:
             actionName = kundo2_i18n("Select Opaque (Subtract)");
             break;
         case SELECTION_INTERSECT:
             actionName = kundo2_i18n("Select Opaque (Intersect)");
             break;
         case SELECTION_SYMMETRICDIFFERENCE:
             actionName = kundo2_i18n("Select Opaque (Symmetric Difference)");
             break;
         default:
             actionName = kundo2_i18n("Select Opaque");
             break;
         }
 
         qint32 x, y, w, h;
         rc.getRect(&x, &y, &w, &h);
 
         const KoColorSpace * cs = device->colorSpace();
 
         KisHLineConstIteratorSP deviter = device->createHLineConstIteratorNG(x, y, w);
         KisHLineIteratorSP selIter = tmpSel ->createHLineIteratorNG(x, y, w);
 
         for (int row = y; row < h + y; ++row) {
             do {
                 *selIter->rawData() = cs->opacityU8(deviter->oldRawData());
             } while (deviter->nextPixel() && selIter->nextPixel());
             deviter->nextRow();
             selIter->nextRow();
         }
     }
 
     KisSelectionToolHelper helper(canvas, actionName);
     tmpSel->invalidateOutlineCache();
     helper.selectPixelSelection(tmpSel, action);
 }
diff --git a/libs/ui/tests/kis_shape_selection_test.cpp b/libs/ui/tests/kis_shape_selection_test.cpp
index d49cffac52..9e45c2dd93 100644
--- a/libs/ui/tests/kis_shape_selection_test.cpp
+++ b/libs/ui/tests/kis_shape_selection_test.cpp
@@ -1,192 +1,341 @@
 /*
  *  Copyright (c) 2008 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_shape_selection_test.h"
 #include <QTest>
 
 #include <kis_debug.h>
 #include <QRect>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoPathShape.h>
 
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image.h"
 #include "testutil.h"
 #include "kistest.h"
 #include <KisPart.h>
 #include <KisDocument.h>
 #include "kis_transaction.h"
 
 void KisShapeSelectionTest::testAddChild()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
     QColor qc(Qt::white);
     qc.setAlpha(0);
     KoColor bgColor(qc, cs);
     doc->newImage("test", 300, 300, cs, bgColor, KisConfig::CANVAS_COLOR, 1, "test", 100);
     KisImageSP image = doc->image();
 
     KisSelectionSP selection = new KisSelection();
-    QVERIFY(selection->hasPixelSelection() == false);
-    QVERIFY(selection->hasShapeSelection() == false);
+    QVERIFY(!selection->hasNonEmptyPixelSelection());
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(0, 0, 100, 100));
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 25, 25), MAX_SELECTED);
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
 
     QRectF rect(50, 50, 100, 100);
     QTransform matrix;
     matrix.scale(1 / image->xRes(), 1 / image->yRes());
     rect = matrix.mapRect(rect);
 
     KoPathShape* shape = new KoPathShape();
     shape->setShapeId(KoPathShapeId);
     shape->moveTo(rect.topLeft());
     shape->lineTo(rect.topRight());
     shape->lineTo(rect.bottomRight());
     shape->lineTo(rect.bottomLeft());
     shape->close();
 
     KisShapeSelection * shapeSelection = new KisShapeSelection(doc->shapeController(), image, selection);
-    selection->setShapeSelection(shapeSelection);
+    selection->convertToVectorSelectionNoUndo(shapeSelection);
     shapeSelection->addShape(shape);
 
-    QVERIFY(selection->hasShapeSelection());
+    QVERIFY(selection->hasNonEmptyShapeSelection());
 
     selection->updateProjection();
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 100, 100));
 }
 
 KoPathShape *createRectangularShape(const QRectF &rect)
 {
     KoPathShape* shape = new KoPathShape();
     shape->setShapeId(KoPathShapeId);
     shape->moveTo(rect.topLeft());
     shape->lineTo(rect.topRight());
     shape->lineTo(rect.bottomRight());
     shape->lineTo(rect.bottomLeft());
     shape->close();
 
     return shape;
 }
 
 void KisShapeSelectionTest::testUndoFlattening()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
     KoColor bgColor(QColor(255, 255, 255, 0), cs);
     doc->newImage("test", 300, 300, cs, bgColor, KisConfig::CANVAS_COLOR, 1, "test", 100);
     KisImageSP image = doc->image();
 
     QCOMPARE(image->locked(), false);
 
     KisSelectionSP selection = new KisSelection();
-    QCOMPARE(selection->hasPixelSelection(), false);
-    QCOMPARE(selection->hasShapeSelection(), false);
+    QCOMPARE(selection->hasNonEmptyPixelSelection(), false);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), false);
 
     selection->setParentNode(image->root());
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(0, 0, 100, 100));
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 25, 25), MAX_SELECTED);
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
 
     QTransform matrix;
     matrix.scale(1 / image->xRes(), 1 / image->yRes());
     const QRectF srcRect1(50, 50, 100, 100);
     const QRectF rect1 = matrix.mapRect(srcRect1);
 
-    KisShapeSelection * shapeSelection = new KisShapeSelection(doc->shapeController(), image, selection);
-    selection->setShapeSelection(shapeSelection);
+    KisShapeSelection * shapeSelection1 = new KisShapeSelection(doc->shapeController(), image, selection);
+    selection->convertToVectorSelectionNoUndo(shapeSelection1);
 
     KoPathShape *shape1 = createRectangularShape(rect1);
-    shapeSelection->addShape(shape1);
+    shapeSelection1->addShape(shape1);
 
-    QVERIFY(selection->hasShapeSelection());
+    QVERIFY(selection->hasNonEmptyShapeSelection());
 
     selection->pixelSelection()->clear();
     QCOMPARE(selection->selectedExactRect(), QRect());
 
     selection->updateProjection();
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), srcRect1.toRect());
     QCOMPARE(selection->outlineCacheValid(), true);
     QCOMPARE(selection->outlineCache().boundingRect(), srcRect1);
-    QCOMPARE(selection->hasShapeSelection(), true);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), true);
 
-    KisTransaction t1(selection->pixelSelection());
+    KisSelectionTransaction t1(selection->pixelSelection());
     selection->pixelSelection()->clear();
     KUndo2Command *cmd1 = t1.endAndTake();
+    cmd1->redo(); // first redo
 
     QTest::qWait(400);
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), QRect());
     QCOMPARE(selection->outlineCacheValid(), true);
     QCOMPARE(selection->outlineCache().boundingRect(), QRectF());
-    QCOMPARE(selection->hasShapeSelection(), false);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), false);
 
     const QRectF srcRect2(10, 10, 20, 20);
     const QRectF rect2 = matrix.mapRect(srcRect2);
     KoPathShape *shape2 = createRectangularShape(rect2);
-    shapeSelection->addShape(shape2);
+
+    KisShapeSelection * shapeSelection2 = new KisShapeSelection(doc->shapeController(), image, selection);
+    KUndo2Command *cmd2 = selection->convertToVectorSelection(shapeSelection2);
+    cmd2->redo(); // first redo
+
+    shapeSelection2->addShape(shape2);
 
     QTest::qWait(400);
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), srcRect2.toRect());
     QCOMPARE(selection->outlineCacheValid(), true);
     QCOMPARE(selection->outlineCache().boundingRect(), srcRect2);
-    QCOMPARE(selection->hasShapeSelection(), true);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), true);
 
-    shapeSelection->removeShape(shape2);
+    shapeSelection1->removeShape(shape2);
 
     QTest::qWait(400);
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), QRect());
     QCOMPARE(selection->outlineCacheValid(), true);
     QCOMPARE(selection->outlineCache().boundingRect(), QRectF());
-    QCOMPARE(selection->hasShapeSelection(), false);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), false);
 
+    cmd2->undo();
     cmd1->undo();
 
     QTest::qWait(400);
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), srcRect1.toRect());
     QCOMPARE(selection->outlineCacheValid(), true);
     QCOMPARE(selection->outlineCache().boundingRect(), srcRect1);
-    QCOMPARE(selection->hasShapeSelection(), true);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), true);
+
+    delete cmd2;
+    delete cmd1;
+    QTest::qWait(400);
+
+}
+
+#include "kis_paint_device_debug_utils.h"
+
+void KisShapeSelectionTest::testHistoryOnFlattening()
+{
+    const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
+    QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
+    KoColor bgColor(QColor(255, 255, 255, 0), cs);
+    doc->newImage("test", 300, 300, cs, bgColor, KisConfig::CANVAS_COLOR, 1, "test", 100);
+    KisImageSP image = doc->image();
+
+    QCOMPARE(image->locked(), false);
+
+    KisSelectionSP selection = new KisSelection();
+    QCOMPARE(selection->hasNonEmptyPixelSelection(), false);
+    QCOMPARE(selection->hasNonEmptyShapeSelection(), false);
+
+    selection->setParentNode(image->root());
+
+    KisPixelSelectionSP pixelSelection = selection->pixelSelection();
+
+    KisSelectionTransaction t0(pixelSelection);
+    pixelSelection->select(QRect(70, 70, 180, 20));
+    QScopedPointer<KUndo2Command> cmd0(t0.endAndTake());
+    cmd0->redo(); // first redo
+
+    KisSelectionTransaction t1(pixelSelection);
+    pixelSelection->clear();
+    pixelSelection->select(QRect(0, 0, 100, 100));
+    QScopedPointer<KUndo2Command> cmd1(t1.endAndTake());
+    cmd1->redo(); // first redo
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "00_0pixel", "dd");
+    QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 25, 25), MAX_SELECTED);
+    QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
+
+    QTransform matrix;
+    matrix.scale(1 / image->xRes(), 1 / image->yRes());
+    const QRectF srcRect1(50, 50, 100, 100);
+    const QRectF rect1 = matrix.mapRect(srcRect1);
+
+    KisShapeSelection * shapeSelection = new KisShapeSelection(doc->shapeController(), image, selection);
+
+    QScopedPointer<KUndo2Command> cmd2(selection->convertToVectorSelection(shapeSelection));
+    cmd2->redo();
+
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "00_1converted", "dd");
+    QCOMPARE(selection->selectedExactRect(), QRect());
+
+    KoPathShape *shape1 = createRectangularShape(rect1);
+    shapeSelection->addShape(shape1);
+
+    QVERIFY(selection->hasNonEmptyShapeSelection());
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "01_vector", "dd");
+    QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 100, 100));
+
+    KisSelectionTransaction flatteningTransaction(pixelSelection);
+    pixelSelection->select(QRect(80, 80, 100, 83));
+
+    QScopedPointer<KUndo2Command> cmd3(flatteningTransaction.endAndTake());
+    cmd3->redo(); // first redo!
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "02_flattened", "dd");
+    QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 130, 113));
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
+
+    cmd3->undo();
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "03_undo_flattening", "dd");
+    QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 100, 100));
+    QVERIFY(selection->hasNonEmptyShapeSelection());
+
+    cmd3->redo();
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "04_redo_flattening", "dd");
+    QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 130, 113));
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
+
+    cmd3->undo();
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "05_2ndundo_flattening", "dd");
+    QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 100, 100));
+    QVERIFY(selection->hasNonEmptyShapeSelection());
+
+    shapeSelection->removeShape(shape1);
+
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "06_undo_add_shape", "dd");
+    QVERIFY(selection->shapeSelection());
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
+    QCOMPARE(selection->selectedExactRect(), QRect());
+
+    cmd2->undo();
+
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "07_undo_conversion", "dd");
+    QVERIFY(!selection->shapeSelection());
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
+    QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
+
+    cmd1->undo();
+
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "08_undo_initial_paint", "dd");
+    QVERIFY(!selection->shapeSelection());
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
+    QCOMPARE(selection->selectedExactRect(), QRect(70, 70, 180, 20));
+
+    cmd0->undo();
+
+    QTest::qWait(200);
+    image->waitForDone();
+
+    // KIS_DUMP_DEVICE_2(pixelSelection, QRect(0,0,300,300), "09_undo_zero_paint", "dd");
+    QVERIFY(!selection->shapeSelection());
+    QVERIFY(!selection->hasNonEmptyShapeSelection());
+    QCOMPARE(selection->selectedExactRect(), QRect());
 }
 
 
 KISTEST_MAIN(KisShapeSelectionTest)
 
 
diff --git a/libs/ui/tests/kis_shape_selection_test.h b/libs/ui/tests/kis_shape_selection_test.h
index d7340b9692..57f0d5294b 100644
--- a/libs/ui/tests/kis_shape_selection_test.h
+++ b/libs/ui/tests/kis_shape_selection_test.h
@@ -1,36 +1,38 @@
 /*
  *  Copyright (c) 2008 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_SHAPE_SELETION_TEST_H
 #define KIS_SHAPE_SELETION_TEST_H
 
 #include <QtTest>
 
 class KisShapeSelectionTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
 
     void testAddChild();
 
     void testUndoFlattening();
+
+    void testHistoryOnFlattening();
 };
 
 #endif
 
diff --git a/libs/ui/tests/util.h b/libs/ui/tests/util.h
index f7e8a5b64b..7d01674acd 100644
--- a/libs/ui/tests/util.h
+++ b/libs/ui/tests/util.h
@@ -1,230 +1,230 @@
 /*
  *  Copyright (c) 2008 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 _UTIL_H_
 #define _UTIL_H_
 
 #include <QTest>
 #include <QBitArray>
 
 #include <KisDocument.h>
 #include <KoDocumentInfo.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoShapeContainer.h>
 #include <KoColorSpace.h>
 #include <KoPathShape.h>
 
 #include <kis_count_visitor.h>
 #include "kis_types.h"
 #include "filter/kis_filter_registry.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter.h"
 #include "KisPart.h"
 #include "kis_image.h"
 #include "kis_pixel_selection.h"
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_clone_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_shape_layer.h"
 #include "kis_filter_mask.h"
 #include "kis_transparency_mask.h"
 #include "kis_selection_mask.h"
 #include "kis_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_shape_selection.h"
 #include "kis_default_bounds.h"
 #include "kis_transform_mask_params_interface.h"
 #include "kis_shape_controller.h"
 #include <KisGlobalResourcesInterface.h>
 
 
 KisSelectionSP createPixelSelection(KisPaintDeviceSP paintDevice)
 {
     KisSelectionSP pixelSelection = new KisSelection(new KisSelectionDefaultBounds(paintDevice));
 
     KisFillPainter gc(pixelSelection->pixelSelection());
     gc.fillRect(10, 10, 200, 200, KoColor(gc.device()->colorSpace()));
     gc.fillRect(150, 150, 200, 200, KoColor(QColor(100, 100, 100, 100), gc.device()->colorSpace()));
     gc.end();
 
     return pixelSelection;
 }
 
 KisSelectionSP createVectorSelection(KisPaintDeviceSP paintDevice, KisImageWSP image, KoShapeControllerBase *shapeController)
 {
     KisSelectionSP vectorSelection = new KisSelection(new KisSelectionDefaultBounds(paintDevice));
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF(10, 10) + QPointF(100, 0));
     path->lineTo(QPointF(100, 100));
     path->lineTo(QPointF(10, 10) + QPointF(0, 100));
     path->close();
     path->normalize();
     KisShapeSelection* shapeSelection = new KisShapeSelection(shapeController, image, vectorSelection);
     shapeSelection->addShape(path);
-    vectorSelection->setShapeSelection(shapeSelection);
+    vectorSelection->convertToVectorSelectionNoUndo(shapeSelection);
 
     return vectorSelection;
 }
 
 QTransform createTestingTransform() {
     return QTransform(1,2,3,4,5,6,7,8,9);
 }
 
 KisDocument* createCompleteDocument(bool shouldMaskToShapeLayer = false)
 {
     KisImageWSP image = new KisImage(0, 1024, 1024, KoColorSpaceRegistry::instance()->rgb8(), "test for roundtrip");
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
     doc->setCurrentImage(image);
     doc->documentInfo()->setAboutInfo("title", image->objectName());
 
     KisGroupLayerSP group1 = new KisGroupLayer(image, "group1", 50);
 
     KisGroupLayerSP group2 = new KisGroupLayer(image, "group2", 100);
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paintlayer1", OPACITY_OPAQUE_U8);
     paintLayer1->setUserLocked(true);
     QBitArray channelFlags(4);
     channelFlags[0] = true;
     channelFlags[2] = true;
     paintLayer1->setChannelFlags(channelFlags);
 
     {
         KisFillPainter gc(paintLayer1->paintDevice());
         gc.fillRect(10, 10, 200, 200, KoColor(Qt::red, paintLayer1->paintDevice()->colorSpace()));
         gc.end();
     }
 
     KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paintlayer2", OPACITY_TRANSPARENT_U8, KoColorSpaceRegistry::instance()->lab16());
     paintLayer2->setVisible(false);
     {
         KisFillPainter gc(paintLayer2->paintDevice());
         gc.fillRect(0, 0, 900, 1024, KoColor(QColor(10, 20, 30), paintLayer2->paintDevice()->colorSpace()));
         gc.end();
     }
 
 
     KisCloneLayerSP cloneLayer1 = new KisCloneLayer(group1, image, "clonelayer1", 150);
     cloneLayer1->setX(100);
     cloneLayer1->setY(100);
 
     KisSelectionSP pixelSelection = createPixelSelection(paintLayer1->paintDevice());
     KisFilterConfigurationSP kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration(KisGlobalResourcesInterface::instance());
     Q_ASSERT(kfc);
     KisAdjustmentLayerSP adjustmentLayer1 = new KisAdjustmentLayer(image, "adjustmentLayer1", kfc->cloneWithResourcesSnapshot(), pixelSelection);
 
     KisSelectionSP vectorSelection = createVectorSelection(paintLayer2->paintDevice(), image, doc->shapeController());
     KisAdjustmentLayerSP adjustmentLayer2 = new KisAdjustmentLayer(image, "adjustmentLayer2", kfc->cloneWithResourcesSnapshot(), vectorSelection);
 
     image->addNode(paintLayer1);
     image->addNode(group1);
     image->addNode(paintLayer2, group1);
     image->addNode(group2);
     image->addNode(cloneLayer1, group2);
     image->addNode(adjustmentLayer1, group2);
 
 //    KoShapeContainer * parentContainer =
 //        dynamic_cast<KoShapeContainer*>(doc->shapeForNode(group1));
 
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF(10, 10) + QPointF(100, 0));
     path->lineTo(QPointF(100, 100));
     path->lineTo(QPointF(10, 10) + QPointF(0, 100));
     path->close();
     path->normalize();
     KisShapeLayerSP shapeLayer = new KisShapeLayer(doc->shapeController(), image, "shapeLayer1", 75);
     shapeLayer->addShape(path);
     image->addNode(shapeLayer, group1);
     image->addNode(adjustmentLayer2, group1);
 
     KisFilterMaskSP filterMask1 = new KisFilterMask();
     filterMask1->setName("filterMask1");
 
     kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration(KisGlobalResourcesInterface::instance());
     filterMask1->setFilter(kfc->cloneWithResourcesSnapshot());
     kfc = 0; // kfc cannot be shared!
 
     filterMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(filterMask1, paintLayer1);
 
     KisFilterMaskSP filterMask2 = new KisFilterMask();
     filterMask2->setName("filterMask2");
 
     kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration(KisGlobalResourcesInterface::instance());
     filterMask2->setFilter(kfc->cloneWithResourcesSnapshot());
     kfc = 0; // kfc cannot be shared!
 
     filterMask2->setSelection(createVectorSelection(paintLayer2->paintDevice(), image, doc->shapeController()));
     image->addNode(filterMask2, paintLayer2);
 
     KisTransparencyMaskSP transparencyMask1 = new KisTransparencyMask();
     transparencyMask1->setName("transparencyMask1");
     transparencyMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(transparencyMask1, group1);
 
     KisTransparencyMaskSP transparencyMask2 = new KisTransparencyMask();
     transparencyMask2->setName("transparencyMask2");
     transparencyMask2->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(transparencyMask2, group2);
 
     KisSelectionMaskSP selectionMask1 = new KisSelectionMask(image);
     image->addNode(selectionMask1, paintLayer1);
     selectionMask1->setName("selectionMask1");
     selectionMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
 
     KisSelectionMaskSP selectionMask2 = new KisSelectionMask(image);
     selectionMask2->setName("selectionMask2");
     selectionMask2->setSelection(createPixelSelection(paintLayer2->paintDevice()));
     image->addNode(selectionMask2, paintLayer2);
 
     KisTransformMaskSP transformMask = new KisTransformMask();
     transformMask->setName("testTransformMask");
     transformMask->setTransformParams(KisTransformMaskParamsInterfaceSP(
                                           new KisDumbTransformMaskParams(createTestingTransform())));
 
     image->addNode(transformMask, paintLayer2);
 
     if (shouldMaskToShapeLayer) {
         // add all-visible transparency mask to crash a shape layer
         KisTransparencyMaskSP transparencyMask3 = new KisTransparencyMask();
         transparencyMask3->setName("crashy-transparency-mask");
         transparencyMask3->initSelection(shapeLayer);
         image->addNode(transparencyMask3, shapeLayer);
     }
 
     return doc;
 }
 
 KisDocument *createEmptyDocument()
 {
     KisImageWSP image = new KisImage(0, 1024, 1024, KoColorSpaceRegistry::instance()->rgb8(), "test for roundtrip");
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     doc->setCurrentImage(image);
     doc->documentInfo()->setAboutInfo("title", image->objectName());
 
     return doc;
 }
 
 
 #endif
diff --git a/plugins/impex/libkra/kis_kra_load_visitor.cpp b/plugins/impex/libkra/kis_kra_load_visitor.cpp
index b33f3fc0ee..455acc28e8 100644
--- a/plugins/impex/libkra/kis_kra_load_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_load_visitor.cpp
@@ -1,803 +1,803 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_kra_load_visitor.h"
 #include "kis_kra_tags.h"
 #include "flake/kis_shape_layer.h"
 #include "flake/KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 #include <KisImportExportManager.h>
 
 #include <QRect>
 #include <QBuffer>
 #include <QByteArray>
 #include <QMessageBox>
 
 #include <KoMD5Generator.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoFileDialog.h>
 #include <KoStore.h>
 #include <KoColorSpace.h>
 #include <KoShapeControllerBase.h>
 #include <KisGlobalResourcesInterface.h>
 
 // kritaimage
 #include <kis_meta_data_io_backend.h>
 #include <kis_meta_data_store.h>
 #include <kis_types.h>
 #include <kis_node_visitor.h>
 #include <kis_image.h>
 #include <kis_selection.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_adjustment_layer.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_datamanager.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_pixel_selection.h>
 #include <kis_clone_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transform_mask_params_interface.h>
 #include "kis_transform_mask_params_factory_registry.h"
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <lazybrush/kis_colorize_mask.h>
 #include <lazybrush/kis_lazy_fill_tools.h>
 #include "kis_shape_selection.h"
 #include "kis_colorize_dom_utils.h"
 #include "kis_dom_utils.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 #include "kis_filter_registry.h"
 #include "kis_generator_registry.h"
 
 
 using namespace KRA;
 
 QString expandEncodedDirectory(const QString& _intern)
 {
 
     QString intern = _intern;
 
     QString result;
     int pos;
     while ((pos = intern.indexOf('/')) != -1) {
         if (QChar(intern.at(0)).isDigit())
             result += "part";
         result += intern.left(pos + 1);   // copy numbers (or "pictures") + "/"
         intern = intern.mid(pos + 1);   // remove the dir we just processed
     }
 
     if (!intern.isEmpty() && QChar(intern.at(0)).isDigit())
         result += "part";
     result += intern;
 
     return result;
 }
 
 
 KisKraLoadVisitor::KisKraLoadVisitor(KisImageSP image,
                                      KoStore *store,
                                      KoShapeControllerBase *shapeController,
                                      QMap<KisNode *, QString> &layerFilenames,
                                      QMap<KisNode *, QString> &keyframeFilenames,
                                      const QString & name,
                                      int syntaxVersion)
     : KisNodeVisitor()
     , m_image(image)
     , m_store(store)
     , m_external(false)
     , m_layerFilenames(layerFilenames)
     , m_keyframeFilenames(keyframeFilenames)
     , m_name(name)
     , m_shapeController(shapeController)
 {
     m_store->pushDirectory();
 
     if (!m_store->enterDirectory(m_name)) {
         QStringList directories = m_store->directoryList();
         dbgKrita << directories;
         if (directories.size() > 0) {
             dbgFile << "Could not locate the directory, maybe some encoding issue? Grab the first directory, that'll be the image one." << m_name << directories;
             m_name = directories.first();
         }
         else {
             dbgFile << "Could not enter directory" << m_name << ", probably an old-style file with 'part' added.";
             m_name = expandEncodedDirectory(m_name);
         }
     }
     else {
         m_store->popDirectory();
     }
     m_syntaxVersion = syntaxVersion;
 }
 
 void KisKraLoadVisitor::setExternalUri(const QString &uri)
 {
     m_external = true;
     m_uri = uri;
 }
 
 bool KisKraLoadVisitor::visit(KisExternalLayer * layer)
 {
     bool result = false;
 
     if (auto *referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer)) {
         Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
             auto *reference = dynamic_cast<KisReferenceImage*>(shape);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, false);
 
             while (!reference->loadImage(m_store)) {
                 if (reference->embed()) {
                     m_errorMessages << i18n("Could not load embedded reference image %1 ", reference->internalFile());
                     break;
                 } else {
                     QString msg = i18nc(
                         "@info",
                         "A reference image linked to an external file could not be loaded.\n\n"
                         "Path: %1\n\n"
                         "Do you want to select another location?", reference->filename());
 
                     int locateManually = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
                     QString url;
                     if (locateManually == QMessageBox::Yes) {
                         KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
                         dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
                         url = dialog.filename();
                     }
 
                     if (url.isEmpty()) {
                         break;
                     } else {
                         reference->setFilename(url);
                     }
                 }
             }
         }
     } else if (KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer)) {
 
         if (!loadMetaData(layer)) {
             return false;
         }
 
         m_store->pushDirectory();
         m_store->enterDirectory(getLocation(layer, DOT_SHAPE_LAYER)) ;
         result =  shapeLayer->loadLayer(m_store);
         m_store->popDirectory();
 
     }
 
     result = visitAll(layer) && result;
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisPaintLayer *layer)
 {
     loadNodeKeyframes(layer);
 
     if (!loadPaintDevice(layer->paintDevice(), getLocation(layer))) {
         return false;
     }
     if (!loadProfile(layer->paintDevice(), getLocation(layer, DOT_ICC))) {
         return false;
     }
     if (!loadMetaData(layer)) {
         return false;
     }
 
     if (m_syntaxVersion == 1) {
         // Check whether there is a file with a .mask extension in the
         // layer directory, if so, it's an old-style transparency mask
         // that should be converted.
         QString location = getLocation(layer, ".mask");
 
         if (m_store->open(location)) {
 
             KisSelectionSP selection = KisSelectionSP(new KisSelection());
             KisPixelSelectionSP pixelSelection = selection->pixelSelection();
             if (!pixelSelection->read(m_store->device())) {
                 pixelSelection->disconnect();
             } else {
                 KisTransparencyMask* mask = new KisTransparencyMask();
                 mask->setSelection(selection);
                 m_image->addNode(mask, layer, layer->firstChild());
             }
             m_store->close();
         }
     }
     bool result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisGroupLayer *layer)
 {
     if (*layer->colorSpace() != *m_image->colorSpace()) {
         layer->resetCache(m_image->colorSpace());
     }
 
     if (!loadMetaData(layer)) {
         return false;
     }
 
     bool result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisAdjustmentLayer* layer)
 {
     loadNodeKeyframes(layer);
 
     // Adjustmentlayers are tricky: there's the 1.x style and the 2.x
     // style, which has selections with selection components
     bool result = true;
     if (m_syntaxVersion == 1) {
         KisSelectionSP selection = new KisSelection();
         KisPixelSelectionSP pixelSelection = selection->pixelSelection();
         result = loadPaintDevice(pixelSelection, getLocation(layer, ".selection"));
         layer->setInternalSelection(selection);
     } else if (m_syntaxVersion == 2) {
         result = loadSelection(getLocation(layer), layer->internalSelection());
 
     } else {
         // We use the default, empty selection
     }
 
     if (!loadMetaData(layer)) {
         return false;
     }
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(layer->filter()->name());
     KisFilterConfigurationSP  kfc = filter->factoryConfiguration(KisGlobalResourcesInterface::instance());
 
     loadFilterConfiguration(kfc, getLocation(layer, DOT_FILTERCONFIG));
     fixOldFilterConfigurations(kfc);
     kfc->createLocalResourcesSnapshot();
 
     layer->setFilter(kfc);
 
     result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisGeneratorLayer *layer)
 {
     if (!loadMetaData(layer)) {
         return false;
     }
     bool result = true;
 
     loadNodeKeyframes(layer);
     result = loadSelection(getLocation(layer), layer->internalSelection());
 
     KisGeneratorSP filter = KisGeneratorRegistry::instance()->value(layer->filter()->name());
     KisFilterConfigurationSP  kfc = filter->factoryConfiguration(KisGlobalResourcesInterface::instance());
 
     result = loadFilterConfiguration(kfc, getLocation(layer, DOT_FILTERCONFIG));
     kfc->createLocalResourcesSnapshot();
 
     layer->setFilter(kfc);
 
     result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisCloneLayer *layer)
 {
     if (!loadMetaData(layer)) {
         return false;
     }
 
     // the layer might have already been lazily initialized
     // from the mask loading code
     if (layer->copyFrom()) {
         return true;
     }
 
     KisNodeSP srcNode = layer->copyFromInfo().findNode(m_image->rootLayer());
     if (!srcNode.isNull()) {
         KisLayerSP srcLayer = qobject_cast<KisLayer*>(srcNode.data());
         Q_ASSERT(srcLayer);
 
         layer->setCopyFrom(srcLayer);
     } else {
         m_warningMessages.append(i18nc("Loading a .kra file", "The file contains a clone layer that has an incorrect source node id. "
                                                               "This layer will be converted into a paint layer."));
     }
 
     // Clone layers have no data except for their masks
     bool result = visitAll(layer);
     return result;
 }
 
 void KisKraLoadVisitor::initSelectionForMask(KisMask *mask)
 {
     KisLayer *cloneLayer = dynamic_cast<KisCloneLayer*>(mask->parent().data());
     if (cloneLayer) {
         // the clone layers should be initialized out of order
         // and lazily, because their original() is still not
         // initialized
         cloneLayer->accept(*this);
     }
 
     KisLayer *parentLayer = qobject_cast<KisLayer*>(mask->parent().data());
     // the KisKraLoader must have already set the parent for us
     Q_ASSERT(parentLayer);
     mask->initSelection(parentLayer);
 }
 
 bool KisKraLoadVisitor::visit(KisFilterMask *mask)
 {
     initSelectionForMask(mask);
 
     loadNodeKeyframes(mask);
 
     bool result = true;
     result = loadSelection(getLocation(mask), mask->selection());
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(mask->filter()->name());
     KisFilterConfigurationSP  kfc = filter->factoryConfiguration(KisGlobalResourcesInterface::instance());
     result = loadFilterConfiguration(kfc, getLocation(mask, DOT_FILTERCONFIG));
     fixOldFilterConfigurations(kfc);
     kfc->createLocalResourcesSnapshot();
 
     mask->setFilter(kfc);
 
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisTransformMask *mask)
 {
     QString location = getLocation(mask, DOT_TRANSFORMCONFIG);
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         if (!data.isEmpty()) {
             QDomDocument doc;
             doc.setContent(data);
 
             QDomElement rootElement = doc.documentElement();
 
             QDomElement main;
 
             if (!KisDomUtils::findOnlyElement(rootElement, "main", &main/*, &m_errorMessages*/)) {
                 return false;
             }
 
             QString id = main.attribute("id", "not-valid");
 
             if (id == "not-valid") {
                 m_errorMessages << i18n("Could not load \"id\" of the transform mask");
                 return false;
             }
 
             QDomElement data;
 
             if (!KisDomUtils::findOnlyElement(rootElement, "data", &data, &m_errorMessages)) {
                 return false;
             }
 
             KisTransformMaskParamsInterfaceSP params =
                 KisTransformMaskParamsFactoryRegistry::instance()->createParams(id, data);
 
             if (!params) {
                 m_errorMessages << i18n("Could not create transform mask params");
                 return false;
             }
 
             mask->setTransformParams(params);
 
             loadNodeKeyframes(mask);
             params->clearChangedFlag();
 
             return true;
         }
     }
 
     return false;
 }
 
 bool KisKraLoadVisitor::visit(KisTransparencyMask *mask)
 {
     initSelectionForMask(mask);
 
     loadNodeKeyframes(mask);
 
     return loadSelection(getLocation(mask), mask->selection());
 }
 
 bool KisKraLoadVisitor::visit(KisSelectionMask *mask)
 {
     initSelectionForMask(mask);
     return loadSelection(getLocation(mask), mask->selection());
 }
 
 bool KisKraLoadVisitor::visit(KisColorizeMask *mask)
 {
     m_store->pushDirectory();
     QString location = getLocation(mask, DOT_COLORIZE_MASK);
     m_store->enterDirectory(location) ;
 
     QByteArray data;
     if (!m_store->extractFile("content.xml", data))
         return false;
 
     QDomDocument doc;
     if (!doc.setContent(data))
         return false;
 
     QVector<KisLazyFillTools::KeyStroke> strokes;
     if (!KisDomUtils::loadValue(doc.documentElement(), COLORIZE_KEYSTROKES_SECTION, &strokes, mask->colorSpace()))
         return false;
 
     int i = 0;
     Q_FOREACH (const KisLazyFillTools::KeyStroke &stroke, strokes) {
         const QString fileName = QString("%1_%2").arg(COLORIZE_KEYSTROKE).arg(i++);
         loadPaintDevice(stroke.dev, fileName);
     }
 
     mask->setKeyStrokesDirect(QList<KisLazyFillTools::KeyStroke>::fromVector(strokes));
 
     loadPaintDevice(mask->coloringProjection(), COLORIZE_COLORING_DEVICE);
     mask->resetCache();
 
     m_store->popDirectory();
     return true;
 }
 
 QStringList KisKraLoadVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 QStringList KisKraLoadVisitor::warningMessages() const
 {
     return m_warningMessages;
 }
 
 struct SimpleDevicePolicy
 {
     bool read(KisPaintDeviceSP dev, QIODevice *stream) {
         return dev->read(stream);
     }
 
     void setDefaultPixel(KisPaintDeviceSP dev, const KoColor &defaultPixel) const {
         return dev->setDefaultPixel(defaultPixel);
     }
 };
 
 struct FramedDevicePolicy
 {
     FramedDevicePolicy(int frameId)
         :  m_frameId(frameId) {}
 
     bool read(KisPaintDeviceSP dev, QIODevice *stream) {
         return dev->framesInterface()->readFrame(stream, m_frameId);
     }
 
     void setDefaultPixel(KisPaintDeviceSP dev, const KoColor &defaultPixel) const {
         return dev->framesInterface()->setFrameDefaultPixel(defaultPixel, m_frameId);
     }
 
     int m_frameId;
 };
 
 bool KisKraLoadVisitor::loadPaintDevice(KisPaintDeviceSP device, const QString& location)
 {
     // Layer data
     KisPaintDeviceFramesInterface *frameInterface = device->framesInterface();
     QList<int> frames;
 
     if (frameInterface) {
         frames = device->framesInterface()->frames();
     }
 
     if (!frameInterface || frames.count() <= 1) {
         return loadPaintDeviceFrame(device, location, SimpleDevicePolicy());
     } else {
         KisRasterKeyframeChannel *keyframeChannel = device->keyframeChannel();
 
         for (int i = 0; i < frames.count(); i++) {
             int id = frames[i];
             if (keyframeChannel->frameFilename(id).isEmpty()) {
                 m_warningMessages << i18n("Could not find keyframe pixel data for frame %1 in %2.", id, location);
             }
             else {
                 Q_ASSERT(!keyframeChannel->frameFilename(id).isEmpty());
                 QString frameFilename = getLocation(keyframeChannel->frameFilename(id));
                 Q_ASSERT(!frameFilename.isEmpty());
 
                 if (!loadPaintDeviceFrame(device, frameFilename, FramedDevicePolicy(id))) {
                     m_warningMessages << i18n("Could not load keyframe pixel data for frame %1 in %2.", id, location);
                 }
             }
         }
     }
 
     return true;
 }
 
 template<class DevicePolicy>
 bool KisKraLoadVisitor::loadPaintDeviceFrame(KisPaintDeviceSP device, const QString &location, DevicePolicy policy)
 {
     {
         const int pixelSize = device->colorSpace()->pixelSize();
         KoColor color(Qt::transparent, device->colorSpace());
 
         if (m_store->open(location + ".defaultpixel")) {
             if (m_store->size() == pixelSize) {
                 m_store->read((char*)color.data(), pixelSize);
             }
 
             m_store->close();
         }
 
         policy.setDefaultPixel(device, color);
     }
 
     if (m_store->open(location)) {
         if (!policy.read(device, m_store->device())) {
             m_warningMessages << i18n("Could not read pixel data: %1.", location);
             device->disconnect();
             m_store->close();
             return true;
         }
         m_store->close();
     } else {
         m_warningMessages << i18n("Could not load pixel data: %1.", location);
         return true;
     }
 
     return true;
 }
 
 
 bool KisKraLoadVisitor::loadProfile(KisPaintDeviceSP device, const QString& location)
 {
     if (m_store->hasFile(location)) {
         m_store->open(location);
         QByteArray data;
         data.resize(m_store->size());
         dbgFile << "Data to load: " << m_store->size() << " from " << location << " with color space " << device->colorSpace()->id();
         int read = m_store->read(data.data(), m_store->size());
         dbgFile << "Profile size: " << data.size() << " " << m_store->atEnd() << " " << m_store->device()->bytesAvailable() << " " << read;
         m_store->close();
 
         QByteArray hash = KoMD5Generator::generateHash(data);
 
         if (m_profileCache.contains(hash)) {
             if (device->setProfile(m_profileCache[hash], 0)) {
                 return true;
             }
         }
         else {
             // Create a colorspace with the embedded profile
             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(device->colorSpace()->colorModelId().id(), device->colorSpace()->colorDepthId().id(), data);
             m_profileCache[hash] = profile;
             if (device->setProfile(profile, 0)) {
                 return true;
             }
 
         }
     }
     m_warningMessages << i18n("Could not load profile: %1.", location);
     return true;
 }
 
 bool KisKraLoadVisitor::loadFilterConfiguration(KisFilterConfigurationSP kfc, const QString& location)
 {
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         if (!data.isEmpty()) {
             QDomDocument doc;
             doc.setContent(data);
             QDomElement e = doc.documentElement();
             if (e.tagName() == "filterconfig") {
                 kfc->fromLegacyXML(e);
             } else {
                 kfc->fromXML(e);
             }
             loadDeprecatedFilter(kfc);
             return true;
         }
     }
     m_warningMessages << i18n("Could not filter configuration %1.", location);
     return true;
 }
 
 void KisKraLoadVisitor::fixOldFilterConfigurations(KisFilterConfigurationSP kfc)
 {
     KisFilterSP filter = KisFilterRegistry::instance()->value(kfc->name());
     KIS_SAFE_ASSERT_RECOVER_RETURN(filter);
 
     if (!filter->configurationAllowedForMask(kfc)) {
         filter->fixLoadedFilterConfigurationForMasks(kfc);
     }
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(filter->configurationAllowedForMask(kfc));
 }
 
 bool KisKraLoadVisitor::loadMetaData(KisNode* node)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(node);
     if (!layer) return true;
 
     KisMetaData::IOBackend* backend = KisMetaData::IOBackendRegistry::instance()->get("xmp");
 
     if (!backend || !backend->supportLoading()) {
         if (backend)
             dbgFile << "Backend " << backend->id() << " does not support loading.";
         else
             dbgFile << "Could not load the XMP backend at all";
         return true;
     }
 
     QString location = getLocation(node, QString(".") + backend->id() +  DOT_METADATA);
     dbgFile << "going to load " << backend->id() << ", " << backend->name() << " from " << location;
 
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         QBuffer buffer(&data);
         if (!backend->loadFrom(layer->metaData(), &buffer)) {
             m_warningMessages << i18n("Could not load metadata for layer %1.", layer->name());
         }
     }
     return true;
 }
 
 bool KisKraLoadVisitor::loadSelection(const QString& location, KisSelectionSP dstSelection)
 {
     // by default the selection is expected to be fully transparent
     {
         KisPixelSelectionSP pixelSelection = dstSelection->pixelSelection();
         KoColor transparent(Qt::transparent, pixelSelection->colorSpace());
         pixelSelection->setDefaultPixel(transparent);
     }
 
     // Pixel selection
     bool result = true;
     QString pixelSelectionLocation = location + DOT_PIXEL_SELECTION;
     if (m_store->hasFile(pixelSelectionLocation)) {
         KisPixelSelectionSP pixelSelection = dstSelection->pixelSelection();
         result = loadPaintDevice(pixelSelection, pixelSelectionLocation);
         if (!result) {
             m_warningMessages << i18n("Could not load raster selection %1.", location);
         }
         pixelSelection->invalidateOutlineCache();
     }
 
     // Shape selection
     QString shapeSelectionLocation = location + DOT_SHAPE_SELECTION;
     if (m_store->hasFile(shapeSelectionLocation + "/content.svg") ||
         m_store->hasFile(shapeSelectionLocation + "/content.xml")) {
 
         m_store->pushDirectory();
         m_store->enterDirectory(shapeSelectionLocation) ;
 
         KisShapeSelection* shapeSelection = new KisShapeSelection(m_shapeController, m_image, dstSelection);
-        dstSelection->setShapeSelection(shapeSelection);
+        dstSelection->convertToVectorSelectionNoUndo(shapeSelection);
         result = shapeSelection->loadSelection(m_store);
         m_store->popDirectory();
         if (!result) {
             m_warningMessages << i18n("Could not load vector selection %1.", location);
         }
     }
     return true;
 }
 
 QString KisKraLoadVisitor::getLocation(KisNode* node, const QString& suffix)
 {
     return getLocation(m_layerFilenames[node], suffix);
 }
 
 QString KisKraLoadVisitor::getLocation(const QString &filename, const QString& suffix)
 {
     QString location = m_external ? QString() : m_uri;
     location += m_name + LAYER_PATH + filename + suffix;
     return location;
 }
 
 void KisKraLoadVisitor::loadNodeKeyframes(KisNode *node)
 {
     if (!m_keyframeFilenames.contains(node)) return;
 
     node->enableAnimation();
 
     const QString &location = getLocation(m_keyframeFilenames[node]);
 
     if (!m_store->open(location)) {
         m_errorMessages << i18n("Could not load keyframes from %1.", location);
         return;
     }
 
     QString errorMsg;
     int errorLine;
     int errorColumn;
 
     QDomDocument dom;
     bool ok = dom.setContent(m_store->device(), &errorMsg, &errorLine, &errorColumn);
     m_store->close();
 
 
     if (!ok) {
         m_errorMessages << i18n("parsing error in the keyframe file %1 at line %2, column %3\nError message: %4", location, errorLine, errorColumn, i18n(errorMsg.toUtf8()));
         return;
     }
 
     QDomElement root = dom.firstChildElement();
 
     for (QDomElement child = root.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toUpper() == "CHANNEL") {
             QString id = child.attribute("name");
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(id, true);
 
             if (!channel) {
                 m_warningMessages << i18n("unknown keyframe channel type: %1 in %2", id, location);
                 continue;
             }
 
             channel->loadXML(child);
         }
     }
 }
 
 void KisKraLoadVisitor::loadDeprecatedFilter(KisFilterConfigurationSP cfg)
 {
     if (cfg->getString("legacy") == "left edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "yFall");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "right edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "yGrowth");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "top edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "xGrowth");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "bottom edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "xFall");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     }
 }
diff --git a/plugins/impex/libkra/kis_kra_save_visitor.cpp b/plugins/impex/libkra/kis_kra_save_visitor.cpp
index a61f5ba456..e9b4d124ff 100644
--- a/plugins/impex/libkra/kis_kra_save_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_save_visitor.cpp
@@ -1,549 +1,549 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2007-2008 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_kra_save_visitor.h"
 #include "kis_kra_tags.h"
 
 #include <QBuffer>
 #include <QByteArray>
 
 #include <KoColorProfile.h>
 #include <KoStore.h>
 #include <KoColorSpace.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_shape_layer.h>
 #include <KisReferenceImagesLayer.h>
 #include <KisReferenceImage.h>
 #include <kis_file_layer.h>
 #include <kis_clone_layer.h>
 #include <kis_mask.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transform_mask_params_interface.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include "lazybrush/kis_colorize_mask.h"
 #include <kis_selection_component.h>
 #include <kis_pixel_selection.h>
 #include <kis_meta_data_store.h>
 #include <kis_meta_data_io_backend.h>
 
 #include "kis_config.h"
 #include "kis_store_paintdevice_writer.h"
 #include "flake/kis_shape_selection.h"
 
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 
 #include "lazybrush/kis_lazy_fill_tools.h"
 #include <KoStoreDevice.h>
 #include "kis_colorize_dom_utils.h"
 #include "kis_dom_utils.h"
 
 
 using namespace KRA;
 
 KisKraSaveVisitor::KisKraSaveVisitor(KoStore *store, const QString & name, QMap<const KisNode*, QString> nodeFileNames)
     : KisNodeVisitor()
     , m_store(store)
     , m_external(false)
     , m_name(name)
     , m_nodeFileNames(nodeFileNames)
     , m_writer(new KisStorePaintDeviceWriter(store))
 {
 }
 
 KisKraSaveVisitor::~KisKraSaveVisitor()
 {
     delete m_writer;
 }
 
 void KisKraSaveVisitor::setExternalUri(const QString &uri)
 {
     m_external = true;
     m_uri = uri;
 }
 
 bool KisKraSaveVisitor::visit(KisExternalLayer * layer)
 {
     bool result = false;
     if (auto* referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer)) {
         result = true;
         Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
             auto *reference = dynamic_cast<KisReferenceImage*>(shape);
             KIS_ASSERT_RECOVER_RETURN_VALUE(reference, false);
             bool saved = reference->saveImage(m_store);
             if (!saved) {
                 m_errorMessages << i18n("Failed to save reference image %1.", reference->internalFile());
                 result = false;
             }
         }
     }
     else if (KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer)) {
         if (!saveMetaData(layer)) {
             m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
             return false;
         }
         m_store->pushDirectory();
         QString location = getLocation(layer, DOT_SHAPE_LAYER);
         result = m_store->enterDirectory(location);
         if (!result) {
             m_errorMessages << i18n("Failed to open %1.", location);
         }
         else {
             result = shapeLayer->saveLayer(m_store);
             m_store->popDirectory();
         }
     }
     else if (KisFileLayer *fileLayer = dynamic_cast<KisFileLayer*>(layer)) {
         Q_UNUSED(fileLayer); // We don't save data for file layers, but we still want to save the masks.
         result = true;
     }
     return result && visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisPaintLayer *layer)
 {
     if (!savePaintDevice(layer->paintDevice(), getLocation(layer))) {
         m_errorMessages << i18n("Failed to save the pixel data for layer %1.", layer->name());
         return false;
     }
     if (!saveAnnotations(layer)) {
         m_errorMessages << i18n("Failed to save the annotations for layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisGroupLayer *layer)
 {
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisAdjustmentLayer* layer)
 {
     if (!layer->filter()) {
         m_errorMessages << i18n("Failed to save the filter layer %1: it has no filter.", layer->name());
         return false;
     }
     if (!saveSelection(layer)) {
         m_errorMessages << i18n("Failed to save the selection for filter layer %1.", layer->name());
         return false;
     }
     if (!saveFilterConfiguration(layer)) {
         m_errorMessages << i18n("Failed to save the filter configuration for filter layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisGeneratorLayer * layer)
 {
     if (!saveSelection(layer)) {
         m_errorMessages << i18n("Failed to save the selection for layer %1.", layer->name());
         return false;
     }
     if (!saveFilterConfiguration(layer)) {
         m_errorMessages << i18n("Failed to save the generator configuration for layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisCloneLayer *layer)
 {
     // Clone layers do not have a profile
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisFilterMask *mask)
 {
     if (!mask->filter()) {
         m_errorMessages << i18n("Failed to save filter mask %1. It has no filter.", mask->name());
         return false;
     }
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for filter mask %1.", mask->name());
         return false;
     }
     if (!saveFilterConfiguration(mask)) {
         m_errorMessages << i18n("Failed to save the filter configuration for filter mask %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisTransformMask *mask)
 {
     QDomDocument doc("transform_params");
 
     QDomElement root = doc.createElement("transform_params");
 
     QDomElement main = doc.createElement("main");
     main.setAttribute("id", mask->transformParams()->id());
 
     QDomElement data = doc.createElement("data");
     mask->transformParams()->toXML(&data);
 
     doc.appendChild(root);
     root.appendChild(main);
     root.appendChild(data);
 
     QString location = getLocation(mask, DOT_TRANSFORMCONFIG);
     if (m_store->open(location)) {
         QByteArray a = doc.toByteArray();
         bool retval = m_store->write(a) == a.size();
 
         if (!retval) {
             warnFile << "Could not write transform mask configuration";
         }
         if (!m_store->close()) {
             warnFile << "Could not close store after writing transform mask configuration";
             retval = false;
         }
         return retval;
     }
     return false;
 }
 
 bool KisKraSaveVisitor::visit(KisTransparencyMask *mask)
 {
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for transparency mask %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisSelectionMask *mask)
 {
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for local selection %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisColorizeMask *mask)
 {
     m_store->pushDirectory();
     QString location = getLocation(mask, DOT_COLORIZE_MASK);
     bool result = m_store->enterDirectory(location);
 
     if (!result) {
         m_errorMessages << i18n("Failed to open %1.", location);
         return false;
     }
 
     if (!m_store->open("content.xml"))
         return false;
 
     KoStoreDevice storeDev(m_store);
 
     QDomDocument doc("doc");
     QDomElement root = doc.createElement("colorize");
     doc.appendChild(root);
     KisDomUtils::saveValue(&root, COLORIZE_KEYSTROKES_SECTION, QVector<KisLazyFillTools::KeyStroke>::fromList(mask->fetchKeyStrokesDirect()));
 
     QTextStream stream(&storeDev);
     stream << doc;
 
     if (!m_store->close())
         return false;
 
     int i = 0;
     Q_FOREACH (const KisLazyFillTools::KeyStroke &stroke, mask->fetchKeyStrokesDirect()) {
         const QString fileName = QString("%1_%2").arg(COLORIZE_KEYSTROKE).arg(i++);
         savePaintDevice(stroke.dev, fileName);
     }
 
     savePaintDevice(mask->coloringProjection(), COLORIZE_COLORING_DEVICE);
 
     m_store->popDirectory();
 
     return true;
 }
 
 QStringList KisKraSaveVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 struct SimpleDevicePolicy
 {
     bool write(KisPaintDeviceSP dev, KisPaintDeviceWriter &store) {
         return dev->write(store);
     }
 
     KoColor defaultPixel(KisPaintDeviceSP dev) const {
         return dev->defaultPixel();
     }
 };
 
 struct FramedDevicePolicy
 {
     FramedDevicePolicy(int frameId)
         :  m_frameId(frameId) {}
 
     bool write(KisPaintDeviceSP dev, KisPaintDeviceWriter &store) {
         return dev->framesInterface()->writeFrame(store, m_frameId);
     }
 
     KoColor defaultPixel(KisPaintDeviceSP dev) const {
         return dev->framesInterface()->frameDefaultPixel(m_frameId);
     }
 
     int m_frameId;
 };
 
 bool KisKraSaveVisitor::savePaintDevice(KisPaintDeviceSP device,
                                         QString location)
 {
     // Layer data
     KisConfig cfg(true);
     m_store->setCompressionEnabled(cfg.compressKra());
 
     KisPaintDeviceFramesInterface *frameInterface = device->framesInterface();
     QList<int> frames;
 
     if (frameInterface) {
         frames = frameInterface->frames();
     }
 
     if (!frameInterface || frames.count() <= 1) {
         savePaintDeviceFrame(device, location, SimpleDevicePolicy());
     } else {
         KisRasterKeyframeChannel *keyframeChannel = device->keyframeChannel();
 
         for (int i = 0; i < frames.count(); i++) {
             int id = frames[i];
 
             QString frameFilename = getLocation(keyframeChannel->frameFilename(id));
             Q_ASSERT(!frameFilename.isEmpty());
 
             if (!savePaintDeviceFrame(device, frameFilename, FramedDevicePolicy(id))) {
                 return false;
             }
         }
     }
 
     m_store->setCompressionEnabled(true);
     return true;
 }
 
 
 template<class DevicePolicy>
 bool KisKraSaveVisitor::savePaintDeviceFrame(KisPaintDeviceSP device, QString location, DevicePolicy policy)
 {
     if (m_store->open(location)) {
         if (!policy.write(device, *m_writer)) {
             device->disconnect();
             m_store->close();
             return false;
         }
 
         m_store->close();
     }
     if (m_store->open(location + ".defaultpixel")) {
         m_store->write((char*)policy.defaultPixel(device).data(), device->colorSpace()->pixelSize());
         m_store->close();
     }
 
     return true;
 }
 
 bool KisKraSaveVisitor::saveAnnotations(KisLayer* layer)
 {
     if (!layer) return false;
     if (!layer->paintDevice()) return false;
     if (!layer->paintDevice()->colorSpace()) return false;
 
     if (layer->paintDevice()->colorSpace()->profile()) {
         const KoColorProfile *profile = layer->paintDevice()->colorSpace()->profile();
         KisAnnotationSP annotation;
         if (profile) {
             QByteArray profileRawData = profile->rawData();
             if (!profileRawData.isEmpty()) {
                 if (profile->type() == "icc") {
                     annotation = new KisAnnotation(ICC, profile->name(), profile->rawData());
                 } else {
                     annotation = new KisAnnotation(PROFILE, profile->name(), profile->rawData());
                 }
             }
         }
 
         if (annotation) {
             // save layer profile
             if (m_store->open(getLocation(layer, DOT_ICC))) {
                 m_store->write(annotation->annotation());
                 m_store->close();
             } else {
                 return false;
             }
         }
     }
     return true;
 
 }
 bool KisKraSaveVisitor::saveSelection(KisNode* node)
 {
     KisSelectionSP selection;
     if (node->inherits("KisMask")) {
         selection = static_cast<KisMask*>(node)->selection();
     } else if (node->inherits("KisAdjustmentLayer")) {
         selection = static_cast<KisAdjustmentLayer*>(node)->internalSelection();
     } else if (node->inherits("KisGeneratorLayer")) {
         selection = static_cast<KisGeneratorLayer*>(node)->internalSelection();
     } else {
         return false;
     }
 
     bool retval = true;
 
-    if (selection->hasPixelSelection()) {
+    if (selection->hasNonEmptyPixelSelection()) {
         KisPaintDeviceSP dev = selection->pixelSelection();
         if (!savePaintDevice(dev, getLocation(node, DOT_PIXEL_SELECTION))) {
             m_errorMessages << i18n("Failed to save the pixel selection data for layer %1.", node->name());
             retval = false;
         }
     }
-    if (selection->hasShapeSelection()) {
+    if (selection->hasNonEmptyShapeSelection()) {
         m_store->pushDirectory();
         retval = m_store->enterDirectory(getLocation(node, DOT_SHAPE_SELECTION));
         if (retval) {
             KisShapeSelection* shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
             if (!shapeSelection) {
                 retval = false;
             }
 
             if (retval && !shapeSelection->saveSelection(m_store)) {
                 m_errorMessages << i18n("Failed to save the vector selection data for layer %1.", node->name());
                 retval = false;
             }
         }
         m_store->popDirectory();
     }
     return retval;
 }
 
 bool KisKraSaveVisitor::saveFilterConfiguration(KisNode* node)
 {
     KisNodeFilterInterface *filterInterface =
             dynamic_cast<KisNodeFilterInterface*>(node);
 
     KisFilterConfigurationSP filter;
 
     if (filterInterface) {
         filter = filterInterface->filter();
     }
 
     bool retval = false;
 
     if (filter) {
         QString location = getLocation(node, DOT_FILTERCONFIG);
         if (m_store->open(location)) {
             QString s = filter->toXML();
             retval = (m_store->write(s.toUtf8(), qstrlen(s.toUtf8())) == qstrlen(s.toUtf8())); m_store->close();
         }
     }
     return retval;
 }
 
 bool KisKraSaveVisitor::saveMetaData(KisNode* node)
 {
     if (!node->inherits("KisLayer")) return true;
 
     KisMetaData::Store* metadata = (static_cast<KisLayer*>(node))->metaData();
     if (metadata->isEmpty()) return true;
 
     // Serialize all the types of metadata there are
     KisMetaData::IOBackend* backend = KisMetaData::IOBackendRegistry::instance()->get("xmp");
     if (!backend->supportSaving()) {
         dbgFile << "Backend " << backend->id() << " does not support saving.";
         return false;
     }
 
     QString location = getLocation(node, QString(".") + backend->id() +  DOT_METADATA);
     dbgFile << "going to save " << backend->id() << ", " << backend->name() << " to " << location;
 
     QBuffer buffer;
     // not that the metadata backends every return anything but true...
     bool retval = backend->saveTo(metadata, &buffer);
 
     if (!retval) {
         m_errorMessages << i18n("The metadata backend failed to save the metadata for %1", node->name());
     }
     else {
         QByteArray data = buffer.data();
         dbgFile << "\t information size is" << data.size();
 
         if (data.size() > 0 && m_store->open(location)) {
             retval = m_store->write(data,  data.size());
             m_store->close();
         }
         if (!retval) {
             m_errorMessages << i18n("Could not write for %1 metadata to the file.", node->name());
         }
     }
     return retval;
 }
 
 QString KisKraSaveVisitor::getLocation(KisNode* node, const QString& suffix)
 {
 
     Q_ASSERT(m_nodeFileNames.contains(node));
     return getLocation(m_nodeFileNames[node], suffix);
 }
 
 QString KisKraSaveVisitor::getLocation(const QString &filename, const QString& suffix)
 {
     QString location = m_external ? QString() : m_uri;
     location += m_name + LAYER_PATH + filename + suffix;
     return location;
 }
diff --git a/plugins/impex/libkra/tests/kis_kra_saver_test.cpp b/plugins/impex/libkra/tests/kis_kra_saver_test.cpp
index 8cf9e50351..5f29ab0282 100644
--- a/plugins/impex/libkra/tests/kis_kra_saver_test.cpp
+++ b/plugins/impex/libkra/tests/kis_kra_saver_test.cpp
@@ -1,553 +1,553 @@
 /*
  *  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_kra_saver_test.h"
 
 #include <QTest>
 
 #include <QBitArray>
 
 #include <KisDocument.h>
 #include <KoDocumentInfo.h>
 #include <KoShapeContainer.h>
 #include <KoPathShape.h>
 
 #include "filter/kis_filter_registry.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter.h"
 #include "kis_image.h"
 #include "kis_pixel_selection.h"
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_clone_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_shape_layer.h"
 #include "kis_filter_mask.h"
 #include "kis_transparency_mask.h"
 #include "kis_selection_mask.h"
 #include "kis_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_shape_selection.h"
 #include "util.h"
 #include "testutil.h"
 #include "kis_keyframe_channel.h"
 #include "kis_image_animation_interface.h"
 #include "kis_layer_properties_icons.h"
 #include <KisGlobalResourcesInterface.h>
 
 #include "kis_transform_mask_params_interface.h"
 
 #include <generator/kis_generator_registry.h>
 
 #include <KoResourcePaths.h>
 #include  <sdk/tests/kistest.h>
 #include <filestest.h>
 
 const QString KraMimetype = "application/x-krita";
 
 void KisKraSaverTest::initTestCase()
 {
     KoResourcePaths::addResourceDir(ResourceType::Patterns, QString(SYSTEM_RESOURCES_DATA_DIR) + "/patterns");
 
     KisFilterRegistry::instance();
     KisGeneratorRegistry::instance();
 }
 
 void KisKraSaverTest::testCrashyShapeLayer()
 {
     /**
      * KisShapeLayer used to call setImage from its destructor and
      * therefore causing an infinite recursion (when at least one transparency
      * mask was preset. This testcase just checks that.
      */
 
     //QScopedPointer<KisDocument> doc(createCompleteDocument(true));
     //Q_UNUSED(doc);
 }
 
 void KisKraSaverTest::testRoundTrip()
 {
     KisDocument* doc = createCompleteDocument();
     KoColor bgColor(Qt::red, doc->image()->colorSpace());
     doc->image()->setDefaultProjectionColor(bgColor);
     doc->exportDocumentSync(QUrl::fromLocalFile("roundtriptest.kra"), doc->mimeType());
 
     QStringList list;
     KisCountVisitor cv1(list, KoProperties());
     doc->image()->rootLayer()->accept(cv1);
 
     KisDocument *doc2 = KisPart::instance()->createDocument();
     bool result = doc2->loadNativeFormat("roundtriptest.kra");
     QVERIFY(result);
 
     KisCountVisitor cv2(list, KoProperties());
     doc2->image()->rootLayer()->accept(cv2);
     QCOMPARE(cv1.count(), cv2.count());
 
     // check whether the BG color is saved correctly
     QCOMPARE(doc2->image()->defaultProjectionColor(), bgColor);
 
     // test round trip of a transform mask
     KisNode* tnode =
         TestUtil::findNode(doc2->image()->rootLayer(), "testTransformMask").data();
     QVERIFY(tnode);
     KisTransformMask *tmask = dynamic_cast<KisTransformMask*>(tnode);
     QVERIFY(tmask);
     KisDumbTransformMaskParams *params = dynamic_cast<KisDumbTransformMaskParams*>(tmask->transformParams().data());
     QVERIFY(params);
     QTransform t = params->testingGetTransform();
     QCOMPARE(t, createTestingTransform());
 
 
     delete doc2;
     delete doc;
 }
 
 void KisKraSaverTest::testSaveEmpty()
 {
     KisDocument* doc = createEmptyDocument();
     doc->exportDocumentSync(QUrl::fromLocalFile("emptytest.kra"), doc->mimeType());
     QStringList list;
     KisCountVisitor cv1(list, KoProperties());
     doc->image()->rootLayer()->accept(cv1);
 
     KisDocument *doc2 = KisPart::instance()->createDocument();
     doc2->loadNativeFormat("emptytest.kra");
 
     KisCountVisitor cv2(list, KoProperties());
     doc2->image()->rootLayer()->accept(cv2);
     QCOMPARE(cv1.count(), cv2.count());
 
     delete doc2;
     delete doc;
 }
 
 #include <generator/kis_generator.h>
 
 void testRoundTripFillLayerImpl(const QString &testName, KisFilterConfigurationSP config)
 {
     TestUtil::ReferenceImageChecker chk(testName, "fill_layer");
     chk.setFuzzy(2);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     // mask parent should be destructed before the document!
     QRect refRect(0,0,512,512);
     TestUtil::MaskParent p(refRect);
 
     doc->setCurrentImage(p.image);
     doc->documentInfo()->setAboutInfo("title", p.image->objectName());
 
     KisSelectionSP selection;
     KisGeneratorLayerSP glayer = new KisGeneratorLayer(p.image, "glayer", config->cloneWithResourcesSnapshot(), selection);
 
     p.image->addNode(glayer, p.image->root(), KisNodeSP());
     glayer->setDirty();
 
     p.image->waitForDone();
     chk.checkImage(p.image, "00_initial_layer_update");
 
     doc->exportDocumentSync(QUrl::fromLocalFile("roundtrip_fill_layer_test.kra"), doc->mimeType());
 
     QScopedPointer<KisDocument> doc2(KisPart::instance()->createDocument());
     doc2->loadNativeFormat("roundtrip_fill_layer_test.kra");
 
     doc2->image()->waitForDone();
     chk.checkImage(doc2->image(), "01_fill_layer_round_trip");
 
     QVERIFY(chk.testPassed());
 }
 
 void KisKraSaverTest::testRoundTripFillLayerColor()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->get("color");
     Q_ASSERT(generator);
 
     // warning: we pass null paint device to the default constructed value
     KisFilterConfigurationSP config = generator->defaultConfiguration(KisGlobalResourcesInterface::instance());
     Q_ASSERT(config);
 
     QVariant v;
     v.setValue(KoColor(Qt::red, cs));
     config->setProperty("color", v);
 
     testRoundTripFillLayerImpl("fill_layer_color", config);
 }
 
 void KisKraSaverTest::testRoundTripFillLayerPattern()
 {
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->get("pattern");
     QVERIFY(generator);
 
     // warning: we pass null paint device to the default constructed value
     KisFilterConfigurationSP config = generator->defaultConfiguration(KisGlobalResourcesInterface::instance());
     QVERIFY(config);
 
     QVariant v;
     v.setValue(QString("11_drawed_furry.png"));
     config->setProperty("pattern", v);
 
     testRoundTripFillLayerImpl("fill_layer_pattern", config);
 }
 
 #include "kis_psd_layer_style.h"
 
 
 void KisKraSaverTest::testRoundTripLayerStyles()
 {
     TestUtil::ReferenceImageChecker chk("kra_saver_test", "layer_styles");
 
     QRect imageRect(0,0,512,512);
 
     // the document should be created before the image!
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(new KisSurrogateUndoStore(), imageRect.width(), imageRect.height(), cs, "test image");
     KisPaintLayerSP layer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
     KisPaintLayerSP layer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8);
     KisPaintLayerSP layer3 = new KisPaintLayer(image, "paint3", OPACITY_OPAQUE_U8);
     image->addNode(layer1);
     image->addNode(layer2);
     image->addNode(layer3);
 
     doc->setCurrentImage(image);
     doc->documentInfo()->setAboutInfo("title", image->objectName());
 
     layer1->paintDevice()->fill(QRect(100, 100, 100, 100), KoColor(Qt::red, cs));
     layer2->paintDevice()->fill(QRect(200, 200, 100, 100), KoColor(Qt::green, cs));
     layer3->paintDevice()->fill(QRect(300, 300, 100, 100), KoColor(Qt::blue, cs));
 
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->dropShadow()->setEffectEnabled(true);
 
 
     style->dropShadow()->setAngle(-90);
     style->dropShadow()->setUseGlobalLight(false);
     layer1->setLayerStyle(style->clone().dynamicCast<KisPSDLayerStyle>());
 
     style->dropShadow()->setAngle(180);
     style->dropShadow()->setUseGlobalLight(true);
     layer2->setLayerStyle(style->clone().dynamicCast<KisPSDLayerStyle>());
 
     style->dropShadow()->setAngle(90);
     style->dropShadow()->setUseGlobalLight(false);
     layer3->setLayerStyle(style->clone().dynamicCast<KisPSDLayerStyle>());
 
     image->initialRefreshGraph();
     chk.checkImage(image, "00_initial_layers");
 
     doc->exportDocumentSync(QUrl::fromLocalFile("roundtrip_layer_styles.kra"), doc->mimeType());
 
 
     QScopedPointer<KisDocument> doc2(KisPart::instance()->createDocument());
     doc2->loadNativeFormat("roundtrip_layer_styles.kra");
 
     doc2->image()->waitForDone();
     chk.checkImage(doc2->image(), "00_initial_layers");
 
     QVERIFY(chk.testPassed());
 }
 
 void KisKraSaverTest::testRoundTripAnimation()
 {
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     QRect imageRect(0,0,512,512);
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(new KisSurrogateUndoStore(), imageRect.width(), imageRect.height(), cs, "test image");
     KisPaintLayerSP layer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
     image->addNode(layer1);
 
     layer1->paintDevice()->fill(QRect(100, 100, 50, 50), KoColor(Qt::black, cs));
     layer1->paintDevice()->setDefaultPixel(KoColor(Qt::red, cs));
 
     KUndo2Command parentCommand;
 
     layer1->enableAnimation();
     KisKeyframeChannel *rasterChannel = layer1->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
     QVERIFY(rasterChannel);
 
     rasterChannel->addKeyframe(10, &parentCommand);
     image->animationInterface()->switchCurrentTimeAsync(10);
     image->waitForDone();
     layer1->paintDevice()->fill(QRect(200, 50, 10, 10), KoColor(Qt::black, cs));
     layer1->paintDevice()->moveTo(25, 15);
     layer1->paintDevice()->setDefaultPixel(KoColor(Qt::green, cs));
 
     rasterChannel->addKeyframe(20, &parentCommand);
     image->animationInterface()->switchCurrentTimeAsync(20);
     image->waitForDone();
     layer1->paintDevice()->fill(QRect(150, 200, 30, 30), KoColor(Qt::black, cs));
     layer1->paintDevice()->moveTo(100, 50);
     layer1->paintDevice()->setDefaultPixel(KoColor(Qt::blue, cs));
 
     QVERIFY(!layer1->isPinnedToTimeline());
     layer1->setPinnedToTimeline(true);
 
     doc->setCurrentImage(image);
     doc->exportDocumentSync(QUrl::fromLocalFile("roundtrip_animation.kra"), doc->mimeType());
 
     QScopedPointer<KisDocument> doc2(KisPart::instance()->createDocument());
     doc2->loadNativeFormat("roundtrip_animation.kra");
     KisImageSP image2 = doc2->image();
     KisNodeSP node = image2->root()->firstChild();
 
     QVERIFY(node->inherits("KisPaintLayer"));
     KisPaintLayerSP layer2 = qobject_cast<KisPaintLayer*>(node.data());
     cs = layer2->paintDevice()->colorSpace();
 
     QCOMPARE(image2->animationInterface()->currentTime(), 20);
     KisKeyframeChannel *channel = layer2->getKeyframeChannel(KisKeyframeChannel::Content.id());
     QVERIFY(channel);
     QCOMPARE(channel->keyframeCount(), 3);
 
     image2->animationInterface()->switchCurrentTimeAsync(0);
     image2->waitForDone();
 
     QCOMPARE(layer2->paintDevice()->nonDefaultPixelArea(), QRect(64, 64, 128, 128));
     QCOMPARE(layer2->paintDevice()->x(), 0);
     QCOMPARE(layer2->paintDevice()->y(), 0);
     QCOMPARE(layer2->paintDevice()->defaultPixel(), KoColor(Qt::red, cs));
 
     image2->animationInterface()->switchCurrentTimeAsync(10);
     image2->waitForDone();
 
     QCOMPARE(layer2->paintDevice()->nonDefaultPixelArea(), QRect(217, 15, 64, 64));
     QCOMPARE(layer2->paintDevice()->x(), 25);
     QCOMPARE(layer2->paintDevice()->y(), 15);
     QCOMPARE(layer2->paintDevice()->defaultPixel(), KoColor(Qt::green, cs));
 
     image2->animationInterface()->switchCurrentTimeAsync(20);
     image2->waitForDone();
 
     QCOMPARE(layer2->paintDevice()->nonDefaultPixelArea(), QRect(228, 242, 64, 64));
     QCOMPARE(layer2->paintDevice()->x(), 100);
     QCOMPARE(layer2->paintDevice()->y(), 50);
     QCOMPARE(layer2->paintDevice()->defaultPixel(), KoColor(Qt::blue, cs));
 
     QVERIFY(layer2->isPinnedToTimeline());
 
 }
 
 #include "lazybrush/kis_lazy_fill_tools.h"
 
 void KisKraSaverTest::testRoundTripColorizeMask()
 {
     QRect imageRect(0,0,512,512);
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     const KoColorSpace * weirdCS = KoColorSpaceRegistry::instance()->rgb16();
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
     KisImageSP image = new KisImage(new KisSurrogateUndoStore(), imageRect.width(), imageRect.height(), cs, "test image");
     doc->setCurrentImage(image);
 
     KisPaintLayerSP layer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, weirdCS);
     image->addNode(layer1);
 
     KisColorizeMaskSP mask = new KisColorizeMask();
     image->addNode(mask, layer1);
     mask->initializeCompositeOp();
     delete mask->setColorSpace(layer1->colorSpace());
 
     {
         KisPaintDeviceSP key1 = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
         key1->fill(QRect(50,50,10,20), KoColor(Qt::black, key1->colorSpace()));
         mask->testingAddKeyStroke(key1, KoColor(Qt::green, layer1->colorSpace()));
         // KIS_DUMP_DEVICE_2(key1, refRect, "key1", "dd");
     }
 
     {
         KisPaintDeviceSP key2 = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
         key2->fill(QRect(150,50,10,20), KoColor(Qt::black, key2->colorSpace()));
         mask->testingAddKeyStroke(key2, KoColor(Qt::red, layer1->colorSpace()));
         // KIS_DUMP_DEVICE_2(key2, refRect, "key2", "dd");
     }
 
     {
         KisPaintDeviceSP key3 = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
         key3->fill(QRect(0,0,10,10), KoColor(Qt::black, key3->colorSpace()));
         mask->testingAddKeyStroke(key3, KoColor(Qt::blue, layer1->colorSpace()), true);
         // KIS_DUMP_DEVICE_2(key3, refRect, "key3", "dd");
     }
 
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, false, image);
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, false, image);
 
 
 
     doc->exportDocumentSync(QUrl::fromLocalFile("roundtrip_colorize.kra"), doc->mimeType());
 
     QScopedPointer<KisDocument> doc2(KisPart::instance()->createDocument());
     doc2->loadNativeFormat("roundtrip_colorize.kra");
     KisImageSP image2 = doc2->image();
     KisNodeSP node = image2->root()->firstChild()->firstChild();
 
     KisColorizeMaskSP mask2 = dynamic_cast<KisColorizeMask*>(node.data());
     QVERIFY(mask2);
 
     QCOMPARE(mask2->compositeOpId(), mask->compositeOpId());
     QCOMPARE(mask2->colorSpace(), mask->colorSpace());
     QCOMPARE(KisLayerPropertiesIcons::nodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool(), false);
     QCOMPARE(KisLayerPropertiesIcons::nodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, true).toBool(), false);
 
     QList<KisLazyFillTools::KeyStroke> strokes = mask->fetchKeyStrokesDirect();
 
     qDebug() << ppVar(strokes.size());
 
     QCOMPARE(strokes[0].dev->exactBounds(), QRect(50,50,10,20));
     QCOMPARE(strokes[0].isTransparent, false);
     QCOMPARE(strokes[0].color.colorSpace(), weirdCS);
 
     QCOMPARE(strokes[1].dev->exactBounds(), QRect(150,50,10,20));
     QCOMPARE(strokes[1].isTransparent, false);
     QCOMPARE(strokes[1].color.colorSpace(), weirdCS);
 
     QCOMPARE(strokes[2].dev->exactBounds(), QRect(0,0,10,10));
     QCOMPARE(strokes[2].isTransparent, true);
     QCOMPARE(strokes[2].color.colorSpace(), weirdCS);
 }
 
 #include <KoColorBackground.h>
 
 void KisKraSaverTest::testRoundTripShapeLayer()
 {
     TestUtil::ReferenceImageChecker chk("kra_saver_test", "shape_layer");
 
     QRect refRect(0,0,512,512);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
     TestUtil::MaskParent p(refRect);
 
     const qreal resolution = 144.0 / 72.0;
     p.image->setResolution(resolution, resolution);
 
     doc->setCurrentImage(p.image);
     doc->documentInfo()->setAboutInfo("title", p.image->objectName());
 
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF( 10, 110));
     path->lineTo(QPointF(110, 110));
     path->lineTo(QPointF(110,  10));
     path->close();
     path->normalize();
     path->setBackground(toQShared(new KoColorBackground(Qt::red)));
 
     path->setName("my_precious_shape");
 
     KisShapeLayerSP shapeLayer = new KisShapeLayer(doc->shapeController(), p.image, "shapeLayer1", 75);
     shapeLayer->addShape(path);
     p.image->addNode(shapeLayer);
     shapeLayer->setDirty();
 
     qApp->processEvents();
     p.image->waitForDone();
 
     chk.checkImage(p.image, "00_initial_layer_update");
 
     doc->exportDocumentSync(QUrl::fromLocalFile("roundtrip_shapelayer_test.kra"), doc->mimeType());
 
     QScopedPointer<KisDocument> doc2(KisPart::instance()->createDocument());
     doc2->loadNativeFormat("roundtrip_shapelayer_test.kra");
 
     qApp->processEvents();
     doc2->image()->waitForDone();
     QCOMPARE(doc2->image()->xRes(), resolution);
     QCOMPARE(doc2->image()->yRes(), resolution);
     chk.checkImage(doc2->image(), "01_shape_layer_round_trip");
 
     QVERIFY(chk.testPassed());
 }
 
 void KisKraSaverTest::testRoundTripShapeSelection()
 {
     TestUtil::ReferenceImageChecker chk("kra_saver_test", "shape_selection");
 
     QRect refRect(0,0,512,512);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
     TestUtil::MaskParent p(refRect);
     doc->setCurrentImage(p.image);
     const qreal resolution = 144.0 / 72.0;
     p.image->setResolution(resolution, resolution);
 
     doc->setCurrentImage(p.image);
     doc->documentInfo()->setAboutInfo("title", p.image->objectName());
 
     p.layer->paintDevice()->setDefaultPixel(KoColor(Qt::green, p.layer->colorSpace()));
 
     KisSelectionSP selection = new KisSelection(p.layer->paintDevice()->defaultBounds());
 
     KisShapeSelection *shapeSelection = new KisShapeSelection(doc->shapeController(), p.image, selection);
-    selection->setShapeSelection(shapeSelection);
+    selection->convertToVectorSelectionNoUndo(shapeSelection);
 
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF( 10, 110));
     path->lineTo(QPointF(110, 110));
     path->lineTo(QPointF(110,  10));
     path->close();
     path->normalize();
     path->setBackground(toQShared(new KoColorBackground(Qt::red)));
     path->setName("my_precious_shape");
 
     shapeSelection->addShape(path);
 
     KisTransparencyMaskSP tmask = new KisTransparencyMask();
     tmask->setSelection(selection);
     p.image->addNode(tmask, p.layer);
 
     tmask->setDirty(p.image->bounds());
 
     qApp->processEvents();
     p.image->waitForDone();
 
     chk.checkImage(p.image, "00_initial_shape_selection");
 
     doc->exportDocumentSync(QUrl::fromLocalFile("roundtrip_shapeselection_test.kra"), doc->mimeType());
 
     QScopedPointer<KisDocument> doc2(KisPart::instance()->createDocument());
     doc2->loadNativeFormat("roundtrip_shapeselection_test.kra");
 
     qApp->processEvents();
     doc2->image()->waitForDone();
     QCOMPARE(doc2->image()->xRes(), resolution);
     QCOMPARE(doc2->image()->yRes(), resolution);
     chk.checkImage(doc2->image(), "00_initial_shape_selection");
 
     KisNodeSP node = doc2->image()->root()->firstChild()->firstChild();
     KisTransparencyMask *newMask = dynamic_cast<KisTransparencyMask*>(node.data());
     QVERIFY(newMask);
 
-    QVERIFY(newMask->selection()->hasShapeSelection());
+    QVERIFY(newMask->selection()->hasNonEmptyShapeSelection());
 
     QVERIFY(chk.testPassed());
 }
 
 
 void KisKraSaverTest::testExportToReadonly()
 {
     TestUtil::testExportToReadonly(QString(FILES_DATA_DIR), KraMimetype);
 }
 
 KISTEST_MAIN(KisKraSaverTest)
diff --git a/plugins/impex/libkra/tests/util.h b/plugins/impex/libkra/tests/util.h
index ce4c705662..1481543127 100644
--- a/plugins/impex/libkra/tests/util.h
+++ b/plugins/impex/libkra/tests/util.h
@@ -1,222 +1,222 @@
 /*
  *  Copyright (c) 2008 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 _UTIL_H_
 #define _UTIL_H_
 
 #include <QTest>
 #include <QBitArray>
 
 #include <KisDocument.h>
 #include <KoDocumentInfo.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoShapeContainer.h>
 #include <KoColorSpace.h>
 #include <KoPathShape.h>
 
 #include <kis_count_visitor.h>
 #include "kis_types.h"
 #include "filter/kis_filter_registry.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter.h"
 #include "KisPart.h"
 #include "kis_image.h"
 #include "kis_pixel_selection.h"
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_clone_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_shape_layer.h"
 #include "kis_filter_mask.h"
 #include "kis_transparency_mask.h"
 #include "kis_selection_mask.h"
 #include "kis_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_shape_selection.h"
 #include "kis_default_bounds.h"
 #include "kis_transform_mask_params_interface.h"
 #include <KisGlobalResourcesInterface.h>
 
 
 KisSelectionSP createPixelSelection(KisPaintDeviceSP paintDevice)
 {
     KisSelectionSP pixelSelection = new KisSelection(new KisSelectionDefaultBounds(paintDevice));
 
     KisFillPainter gc(pixelSelection->pixelSelection());
     gc.fillRect(10, 10, 200, 200, KoColor(gc.device()->colorSpace()));
     gc.fillRect(150, 150, 200, 200, KoColor(QColor(100, 100, 100, 100), gc.device()->colorSpace()));
     gc.end();
 
     return pixelSelection;
 }
 
 KisSelectionSP createVectorSelection(KisPaintDeviceSP paintDevice, KisImageSP image, KoShapeControllerBase *shapeController)
 {
-    KisSelectionSP vectorSelection = new KisSelection(new KisSelectionDefaultBounds(paintDevice));
+    KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(paintDevice));
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF(10, 10) + QPointF(100, 0));
     path->lineTo(QPointF(100, 100));
     path->lineTo(QPointF(10, 10) + QPointF(0, 100));
     path->close();
     path->normalize();
-    KisShapeSelection* shapeSelection = new KisShapeSelection(shapeController, image, vectorSelection);
+    KisShapeSelection* shapeSelection = new KisShapeSelection(shapeController, image, selection);
     shapeSelection->addShape(path);
-    vectorSelection->setShapeSelection(shapeSelection);
+    selection->convertToVectorSelectionNoUndo(shapeSelection);
 
-    return vectorSelection;
+    return selection;
 }
 
 QTransform createTestingTransform() {
     return QTransform(1,2,3,4,5,6,7,8,9);
 }
 
 KisDocument* createCompleteDocument()
 {
     KisImageSP image = new KisImage(0, 1024, 1024, KoColorSpaceRegistry::instance()->rgb8(), "test for roundtrip");
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     doc->setCurrentImage(image);
     doc->documentInfo()->setAboutInfo("title", image->objectName());
 
     KisGroupLayerSP group1 = new KisGroupLayer(image, "group1", 50);
 
     KisGroupLayerSP group2 = new KisGroupLayer(image, "group2", 100);
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paintlayer1", OPACITY_OPAQUE_U8);
     paintLayer1->setUserLocked(true);
     QBitArray channelFlags(4);
     channelFlags[0] = true;
     channelFlags[2] = true;
     paintLayer1->setChannelFlags(channelFlags);
 
     {
         KisFillPainter gc(paintLayer1->paintDevice());
         gc.fillRect(10, 10, 200, 200, KoColor(Qt::red, paintLayer1->paintDevice()->colorSpace()));
         gc.end();
     }
 
     KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paintlayer2", OPACITY_TRANSPARENT_U8, KoColorSpaceRegistry::instance()->lab16());
     paintLayer2->setVisible(false);
     {
         KisFillPainter gc(paintLayer2->paintDevice());
         gc.fillRect(0, 0, 900, 1024, KoColor(QColor(10, 20, 30), paintLayer2->paintDevice()->colorSpace()));
         gc.end();
     }
 
 
     KisCloneLayerSP cloneLayer1 = new KisCloneLayer(group1, image, "clonelayer1", 150);
     cloneLayer1->setX(100);
     cloneLayer1->setY(100);
 
     KisSelectionSP pixelSelection = createPixelSelection(paintLayer1->paintDevice());
     KisFilterConfigurationSP kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration(KisGlobalResourcesInterface::instance());
     Q_ASSERT(kfc);
     KisAdjustmentLayerSP adjustmentLayer1 = new KisAdjustmentLayer(image, "adjustmentLayer1", kfc->cloneWithResourcesSnapshot(), pixelSelection);
 
     KisSelectionSP vectorSelection = createVectorSelection(paintLayer2->paintDevice(), image, doc->shapeController());
     KisAdjustmentLayerSP adjustmentLayer2 = new KisAdjustmentLayer(image, "adjustmentLayer2", kfc->cloneWithResourcesSnapshot(), vectorSelection);
 
     image->addNode(paintLayer1);
     image->addNode(group1);
     image->addNode(paintLayer2, group1);
     image->addNode(group2);
     image->addNode(cloneLayer1, group2);
     image->addNode(adjustmentLayer1, group2);
 
 //    KoShapeContainer * parentContainer =
 //        dynamic_cast<KoShapeContainer*>(doc->shapeForNode(group1));
 
     KoPathShape* path = new KoPathShape();
     path->setShapeId(KoPathShapeId);
     path->moveTo(QPointF(10, 10));
     path->lineTo(QPointF(10, 10) + QPointF(100, 0));
     path->lineTo(QPointF(100, 100));
     path->lineTo(QPointF(10, 10) + QPointF(0, 100));
     path->close();
     path->normalize();
     KisShapeLayerSP shapeLayer = new KisShapeLayer(doc->shapeController(), image, "shapeLayer1", 75);
     shapeLayer->addShape(path);
     image->addNode(shapeLayer, group1);
     image->addNode(adjustmentLayer2, group1);
 
     KisFilterMaskSP filterMask1 = new KisFilterMask();
     filterMask1->setName("filterMask1");
 
     kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration(KisGlobalResourcesInterface::instance());
     filterMask1->setFilter(kfc->cloneWithResourcesSnapshot());
     kfc = 0; // kfc cannot be shared!
 
     filterMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(filterMask1, paintLayer1);
 
     KisFilterMaskSP filterMask2 = new KisFilterMask();
     filterMask2->setName("filterMask2");
 
     kfc = KisFilterRegistry::instance()->get("pixelize")->defaultConfiguration(KisGlobalResourcesInterface::instance());
     filterMask2->setFilter(kfc);
     kfc = 0; // kfc cannot be shared!
 
     filterMask2->setSelection(createVectorSelection(paintLayer2->paintDevice(), image, doc->shapeController()));
     image->addNode(filterMask2, paintLayer2);
 
     KisTransparencyMaskSP transparencyMask1 = new KisTransparencyMask();
     transparencyMask1->setName("transparencyMask1");
     transparencyMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(transparencyMask1, group1);
 
     KisTransparencyMaskSP transparencyMask2 = new KisTransparencyMask();
     transparencyMask2->setName("transparencyMask2");
     transparencyMask2->setSelection(createPixelSelection(paintLayer1->paintDevice()));
     image->addNode(transparencyMask2, group2);
 
     KisSelectionMaskSP selectionMask1 = new KisSelectionMask(image);
     image->addNode(selectionMask1, paintLayer1);
     selectionMask1->setName("selectionMask1");
     selectionMask1->setSelection(createPixelSelection(paintLayer1->paintDevice()));
 
     KisSelectionMaskSP selectionMask2 = new KisSelectionMask(image);
     selectionMask2->setName("selectionMask2");
     selectionMask2->setSelection(createPixelSelection(paintLayer2->paintDevice()));
     image->addNode(selectionMask2, paintLayer2);
 
     KisTransformMaskSP transformMask = new KisTransformMask();
     transformMask->setName("testTransformMask");
     transformMask->setTransformParams(KisTransformMaskParamsInterfaceSP(
                                           new KisDumbTransformMaskParams(createTestingTransform())));
 
     image->addNode(transformMask, paintLayer2);
 
     return doc;
 }
 
 KisDocument *createEmptyDocument()
 {
     KisImageSP image = new KisImage(0, 1024, 1024, KoColorSpaceRegistry::instance()->rgb8(), "test for roundtrip");
 
     KisDocument *doc = qobject_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     doc->setCurrentImage(image);
     doc->documentInfo()->setAboutInfo("title", image->objectName());
 
     return doc;
 }
 
 
 #endif