diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
index cc241a0858..acf3c1af7f 100644
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -1,1890 +1,1892 @@
 /*
  *  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 <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 "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"
 
 
 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;
 
     Private(KisPaintDevice *paintDevice);
     ~Private();
 
     KisPaintDevice *q;
     KisNodeWSP parent;
     QScopedPointer<KisRasterKeyframeChannel> contentChannel;
     KisDefaultBoundsBaseSP defaultBounds;
     QScopedPointer<KisPaintDeviceStrategy> basicStrategy;
     QScopedPointer<KisPaintDeviceWrappedStrategy> wrappedStrategy;
     QScopedPointer<KisPaintDeviceFramesInterface> framesInterface;
     bool isProjectionDevice;
 
     KisPaintDeviceStrategy* currentStrategy();
 
     void init(const KoColorSpace *cs, const quint8 *defaultPixel);
     KUndo2Command* convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags);
     bool assignProfile(const KoColorProfile * profile);
 
     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(); }
 
 
     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(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(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(it.value().data(), true));
                     m_frames.insert(it.key(), data);
                 }
             }
         }
 
         if (rhs->m_lodData) {
             m_lodData.reset(new KisPaintDeviceData(rhs->m_lodData.data(), true));
         }
     }
 
     void prepareClone(KisPaintDeviceSP src)
     {
         prepareCloneImpl(src, src->m_d->currentData());
         Q_ASSERT(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() {
             doSwap(m_insert);
         }
 
         void undo() {
             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 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(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(srcData.data(), true));
         } else {
             DataSP srcData = m_frames.begin().value();
             data = toQShared(new Data(srcData.data(), false));
         }
 
-        if (!copy) {
+        if (!initialFrame && !copy) {
             data->setX(offset.x());
             data->setY(offset.y());
         }
 
         int frameId = nextFreeFrameId++;
 
         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 quint8 *defPixel, int frameId) {
         DataSP data = m_frames[frameId];
         data->dataManager()->setDefaultPixel(defPixel);
     }
 
     const quint8* frameDefaultPixel(int frameId) const {
         DataSP data = m_frames[frameId];
         return data->dataManager()->defaultPixel();
     }
 
     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 LodDataStruct;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
     QRegion regionForLodSyncing() const;
 
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 private:
 
     QRegion syncWholeDevice(Data *srcData);
 
     inline DataSP currentFrameData() const {
         DataSP data;
 
         const int numberOfFrames = contentChannel->keyframeCount();
 
         if (numberOfFrames > 1) {
             int frameId = contentChannel->frameIdAt(defaultBounds->currentTime());
             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(m_data.data(), false));
                 }
             }
             data = m_externalFrameData.data();
         }
 
         return data;
     }
 
     inline void ensureLodDataPreset() const {
         if (!m_lodData) {
             Data *srcData = currentNonLodData();
 
             QMutexLocker l(&m_dataSwitchLock);
             if (!m_lodData) {
                 m_lodData.reset(new Data(srcData, false));
             }
         }
     }
 
     inline Data* currentData() const {
         Data *data = m_data.data();
 
         if (defaultBounds->currentLevelOfDetail()) {
             ensureLodDataPreset();
             data = m_lodData.data();
         } else {
             data = currentNonLodData();
         }
 
         return data;
     }
 
     void prepareCloneImpl(KisPaintDeviceSP src, Data *srcData)
     {
         currentData()->prepareClone(srcData);
 
         q->setDefaultPixel(srcData->dataManager()->defaultPixel());
         q->setDefaultBounds(src->defaultBounds());
     }
 
     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 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)),
       nextFreeFrameId(0)
 {
 }
 
 KisPaintDevice::Private::~Private()
 {
     m_frames.clear();
 }
 
 KisPaintDevice::Private::KisPaintDeviceStrategy* KisPaintDevice::Private::currentStrategy()
 {
     if (!defaultBounds->wrapAroundMode()) {
         return basicStrategy.data();
     }
 
     QRect wrapRect = defaultBounds->bounds();
     if (!wrappedStrategy || wrappedStrategy->wrapRect() != wrapRect) {
         wrappedStrategy.reset(new KisPaintDeviceWrappedStrategy(wrapRect, q, this));
     }
 
     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::LodDataStruct
 {
     LodDataStruct(Data *_lodData) : lodData(_lodData) {}
     Data *lodData;
 };
 
 QRegion KisPaintDevice::Private::regionForLodSyncing() const
 {
     Data *srcData = currentNonLodData();
     return srcData->dataManager()->region().translated(srcData->x(), srcData->y());
 }
 
 KisPaintDevice::Private::LodDataStruct* KisPaintDevice::Private::createLodDataStruct(int newLod)
 {
     Data *srcData = currentNonLodData();
 
     Data *lodData = new Data(srcData, false);
     LodDataStruct *lodStruct = new LodDataStruct(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
     }
 
     //QRegion dirtyRegion = syncWholeDevice(srcData);
     lodData->cache()->invalidate();
 
     return lodStruct;
 }
 
 void KisPaintDevice::Private::updateLodDataStruct(LodDataStruct *dst, const QRect &originalRect)
 {
     Data *lodData = dst->lodData;
     Data *srcData = currentNonLodData();
 
     const int lod = lodData->levelOfDetail();
     const int srcStepSize = 1 << lod;
 
     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 = srcData->dataManager()->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(), srcData->dataManager().data(), srcData->x(), srcData->y()), srcRect);
     InternalSequentialIterator dstIntIt(StrategyPolicy(currentStrategy(), lodData->dataManager().data(), lodData->x(), lodData->y()), dstRect);
 
     int rowsRemaining = srcRect.height();
     while (rowsRemaining > 0) {
 
         int colsRemaining = srcRect.width();
         while (colsRemaining > 0) {
 
             memcpy(blendDataPtr, srcIntIt.rawDataConst(), pixelSize);
             blendDataPtr += pixelSize;
             columnsAccumulated++;
 
             if (columnsAccumulated >= srcStepSize) {
                 blendDataPtr += srcColumnStride;
                 columnsAccumulated = 0;
             }
 
             srcIntIt.nextPixel();
             colsRemaining--;
         }
 
         rowsAccumulated++;
 
         if (rowsAccumulated >= srcStepSize) {
 
             // blend and write the final data
             blendDataPtr = blendData.data();
             for (int i = 0; i < dstRect.width(); i++) {
                 mixOp->mixColors(blendDataPtr, weights.data(), srcCellSize, dstIntIt.rawData());
 
                 blendDataPtr += srcCellStride;
                 dstIntIt.nextPixel();
             }
 
             // reset counters
             rowsAccumulated = 0;
             blendDataPtr = blendData.data();
             blendDataOffset = 0;
         } else {
             blendDataOffset += srcStepStride;
             blendDataPtr = blendData.data() + blendDataOffset;
         }
 
         rowsRemaining--;
     }
 }
 
 void KisPaintDevice::Private::uploadLodDataStruct(LodDataStruct *dst)
 {
     KIS_ASSERT_RECOVER_RETURN(
         dst->lodData->levelOfDetail() == defaultBounds->currentLevelOfDetail());
 
     ensureLodDataPreset();
 
     m_lodData->prepareClone(dst->lodData);
     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(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);
 }
 
 void KisPaintDevice::Private::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     Data *data = m_lodData.data();
     Q_ASSERT(data);
 
     transferFromData(data, targetDevice);
 }
 
 KUndo2Command* KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) {
 
     class DeviceChangeColorSpaceCommand : public KUndo2Command {
     public:
         DeviceChangeColorSpaceCommand(KisPaintDeviceSP device)
             : m_firstRun(true),
               m_device(device)
             {
             }
 
         void emitNotifications() {
             m_device->emitColorSpaceChanged();
             m_device->setDirty();
         }
 
         void redo() {
             KUndo2Command::redo();
 
             if (!m_firstRun) {
                 m_firstRun = false;
                 return;
             }
 
             emitNotifications();
         }
 
         void undo() {
             KUndo2Command::undo();
             emitNotifications();
         }
 
     private:
         bool m_firstRun;
         KisPaintDeviceSP m_device;
     };
 
 
     KUndo2Command *parentCommand = new DeviceChangeColorSpaceCommand(q);
 
     QList<Data*> dataObjects = allDataObjects();;
 
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         data->convertDataColorSpace(dstColorSpace, renderingIntent, conversionFlags, parentCommand);
     }
 
     if (!parentCommand->childCount()) {
         delete parentCommand;
         parentCommand = 0;
     } else {
         q->emitColorSpaceChanged();
     }
 
     return parentCommand;
 
 }
 
 bool KisPaintDevice::Private::assignProfile(const KoColorProfile * profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstColorSpace =
         KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     QList<Data*> dataObjects = allDataObjects();;
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
         data->assignColorSpace(dstColorSpace);
     }
     q->emitProfileChanged();
 
     // no undo information is provided here
     return true;
 }
 
 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, bool copyFrames, KisNode *newParentNode)
     : QObject()
     , KisShared()
     , m_d(new Private(this))
 {
     if (this != &rhs) {
         // 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, copyFrames);
 
         if (copyFrames) {
             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(0);
     }
 }
 
 KisPaintDevice::~KisPaintDevice()
 {
     delete m_d;
 }
 
 void KisPaintDevice::setProjectionDevice(bool value)
 {
     m_d->isProjectionDevice = value;
 }
 
 void KisPaintDevice::prepareClone(KisPaintDeviceSP src)
 {
     m_d->prepareClone(src);
     Q_ASSERT(fastBitBltPossible(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 QRegion & 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);
     }
 }
 
 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::move(const QPoint &pt)
 {
     m_d->currentStrategy()->move(pt);
 }
 
 void KisPaintDevice::move(qint32 x, qint32 y)
 {
     move(QPoint(x, y));
 }
 
 void KisPaintDevice::setX(qint32 x)
 {
     move(QPoint(x, m_d->y()));
 }
 
 void KisPaintDevice::setY(qint32 y)
 {
     move(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();
 }
 
 QRegion 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;
 
     // 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(x, y);
 
     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 = m_d->colorSpace()->opacityU8(defaultPixel());
     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) {
         Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     } else {
         Impl::CheckFullyTransparent compareOp(m_d->colorSpace());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     }
 
     return endRect;
 }
 
 
 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 quint8 *defPixel)
 {
     m_d->dataManager()->setDefaultPixel(defPixel);
     m_d->cache()->invalidate();
 }
 
 const quint8 *KisPaintDevice::defaultPixel() const
 {
     return m_d->dataManager()->defaultPixel();
 }
 
 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)
 {
     Q_ASSERT(*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());
 }
 
 KUndo2Command* KisPaintDevice::convertTo(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     KUndo2Command *command = m_d->convertColorSpace(dstColorSpace, renderingIntent, conversionFlags);
     return command;
 }
 
 bool KisPaintDevice::setProfile(const KoColorProfile * profile)
 {
     return m_d->assignProfile(profile);
 }
 
 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 (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 (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;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(qint32 w, qint32 h, QRect rect) const
 {
     KisPaintDeviceSP thumbnail = new KisPaintDevice(colorSpace());
 
     int srcWidth, srcHeight;
     int srcX0, srcY0;
     QRect e = rect.isValid() ? rect : extent();
     e.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight);
 
     if (w > srcWidth) {
         w = srcWidth;
         h = qint32(double(srcWidth) / w * h);
     }
     if (h > srcHeight) {
         h = srcHeight;
         w = qint32(double(srcHeight) / h * w);
     }
 
     if (srcWidth > srcHeight)
         h = qint32(double(srcHeight) / srcWidth * w);
     else if (srcHeight > srcWidth)
         w = qint32(double(srcWidth) / srcHeight * h);
 
     const qint32 pixelSize = this->pixelSize();
 
     KisRandomConstAccessorSP iter = createRandomConstAccessorNG(0, 0);
     KisRandomAccessorSP dstIter = thumbnail->createRandomAccessorNG(0, 0);
 
     for (qint32 y = 0; y < h; ++y) {
         qint32 iY = srcY0 + (y * srcHeight) / h;
         for (qint32 x = 0; x < w; ++x) {
             qint32 iX = srcX0 + (x * srcWidth) / w;
             iter->moveTo(iX, iY);
             dstIter->moveTo(x,  y);
             memcpy(dstIter->rawData(), iter->rawDataConst(), pixelSize);
         }
     }
     return thumbnail;
 
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, QRect rect, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     KisPaintDeviceSP dev = createThumbnailDevice(w, h, rect);
     QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags);
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     return m_d->cache()->createThumbnail(w, h, 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);
 }
 
 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);
 }
 
 KisRandomAccessorSP KisPaintDevice::createRandomAccessorNG(qint32 x, qint32 y)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createRandomAccessorNG(x, y);
 }
 
 KisRandomConstAccessorSP KisPaintDevice::createRandomConstAccessorNG(qint32 x, qint32 y) const
 {
     return m_d->currentStrategy()->createRandomConstAccessorNG(x, y);
 }
 
 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();
     QRect r = selection->selectedExactRect() & m_d->defaultBounds->bounds();
 
     if (r.isValid()) {
 
         KisHLineIteratorSP devIt = createHLineIteratorNG(r.x(), r.y(), r.width());
         KisHLineConstIteratorSP selectionIt = selection->projection()->createHLineConstIteratorNG(r.x(), r.y(), r.width());
 
         const quint8* defaultPixel_ = defaultPixel();
         bool transparentDefault = (colorSpace->opacityU8(defaultPixel_) == 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_, colorSpace->pixelSize());
                 }
             } while (devIt->nextPixel() && selectionIt->nextPixel());
             devIt->nextRow();
             selectionIt->nextRow();
         }
         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;
 }
 
 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, const KisNodeWSP node)
 {
     Q_ASSERT(!m_d->framesInterface);
     m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
 
     Q_ASSERT(!m_d->contentChannel);
     m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, node, this));
 
     // 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
 {
     Q_ASSERT(m_d->contentChannel);
     return m_d->contentChannel.data();
 }
 
 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();
     qSort(channels);
 
     Q_FOREACH (KoChannelInfo * channelInfo, channels) {
         sizes.append(channelInfo->size());
     }
     return sizes;
 }
 
 KisPaintDevice::MemoryReleaseObject::~MemoryReleaseObject()
 {
     KisDataManager::releaseInternalPools();
 }
 
 KisPaintDevice::MemoryReleaseObject* KisPaintDevice::createMemoryReleaseObject()
 {
     return new MemoryReleaseObject();
 }
 
 struct KisPaintDevice::LodDataStruct {
     LodDataStruct(Private::LodDataStruct *_lodData) : lodData(_lodData) {}
     Private::LodDataStruct *lodData;
 };
 
 QRegion KisPaintDevice::regionForLodSyncing() const
 {
     return m_d->regionForLodSyncing();
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::createLodDataStruct(int lod)
 {
     Private::LodDataStruct *lodData = m_d->createLodDataStruct(lod);
     return new LodDataStruct(lodData);
 }
 
 void KisPaintDevice::updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect)
 {
     m_d->updateLodDataStruct(dst->lodData, srcRect);
 }
 
 void KisPaintDevice::uploadLodDataStruct(LodDataStruct *dst)
 {
     m_d->uploadLodDataStruct(dst->lodData);
 }
 
 
 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 quint8 *defPixel, int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     q->m_d->setFrameDefaultPixel(defPixel, frameId);
 }
 
 const quint8* KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) { return (quint8*)"deadbeef"; }
     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/tests/kis_paint_device_test.cpp b/libs/image/tests/kis_paint_device_test.cpp
index f825d8cceb..d1b3b8e802 100644
--- a/libs/image/tests/kis_paint_device_test.cpp
+++ b/libs/image/tests/kis_paint_device_test.cpp
@@ -1,2260 +1,2269 @@
 /*
  *  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_paint_device_test.h"
 #include <QTest>
 
 #include <QTime>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoStore.h>
 
 #include "kis_paint_device_writer.h"
 #include "kis_painter.h"
 #include "kis_types.h"
 #include "kis_paint_device.h"
 #include "kis_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_selection.h"
 #include "kis_datamanager.h"
 #include "kis_global.h"
 #include "testutil.h"
 #include "kis_transaction.h"
 #include "kis_image.h"
 
 class KisFakePaintDeviceWriter : public KisPaintDeviceWriter {
 public:
     KisFakePaintDeviceWriter(KoStore *store)
         : m_store(store)
     {
     }
 
     bool write(const QByteArray &data) {
         return (m_store->write(data) == data.size());
     }
 
     bool write(const char* data, qint64 length) {
         return (m_store->write(data, length) == length);
     }
 
     KoStore *m_store;
 };
 
 void KisPaintDeviceTest::testCreation()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     QVERIFY(dev->objectName().isEmpty());
 
     dev = new KisPaintDevice(cs);
     QVERIFY(*dev->colorSpace() == *cs);
     QVERIFY(dev->x() == 0);
     QVERIFY(dev->y() == 0);
     QVERIFY(dev->pixelSize() == cs->pixelSize());
     QVERIFY(dev->channelCount() == cs->channelCount());
     QVERIFY(dev->dataManager() != 0);
 
     KisImageSP image = new KisImage(0, 1000, 1000, cs, "merge test");
     KisPaintLayerSP layer = new KisPaintLayer(image, "bla", 125);
 
     dev = new KisPaintDevice(layer.data(), cs);
     QVERIFY(*dev->colorSpace() == *cs);
     QVERIFY(dev->x() == 0);
     QVERIFY(dev->y() == 0);
     QVERIFY(dev->pixelSize() == cs->pixelSize());
     QVERIFY(dev->channelCount() == cs->channelCount());
     QVERIFY(dev->dataManager() != 0);
 
     // Let the layer go out of scope and see what happens
     {
         KisPaintLayerSP l2 = new KisPaintLayer(image, "blabla", 250);
         dev = new KisPaintDevice(l2.data(), cs);
     }
 
 }
 
 
 void KisPaintDeviceTest::testStore()
 {
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KoStore * readStore =
         KoStore::createStore(QString(FILES_DATA_DIR) + QDir::separator() + "store_test.kra", KoStore::Read);
     readStore->open("built image/layers/layer0");
     QVERIFY(dev->read(readStore->device()));
     readStore->close();
     delete readStore;
 
     QVERIFY(dev->exactBounds() == QRect(0, 0, 100, 100));
 
     KoStore * writeStore =
         KoStore::createStore(QString(FILES_OUTPUT_DIR) + QDir::separator() + "store_test_out.kra", KoStore::Write);
     KisFakePaintDeviceWriter fakeWriter(writeStore);
     writeStore->open("built image/layers/layer0");
     QVERIFY(dev->write(fakeWriter));
     writeStore->close();
     delete writeStore;
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     readStore =
         KoStore::createStore(QString(FILES_OUTPUT_DIR) + QDir::separator() + "store_test_out.kra", KoStore::Read);
     readStore->open("built image/layers/layer0");
     QVERIFY(dev2->read(readStore->device()));
     readStore->close();
     delete readStore;
 
     QVERIFY(dev2->exactBounds() == QRect(0, 0, 100, 100));
 
     QPoint pt;
     if (!TestUtil::comparePaintDevices(pt, dev, dev2)) {
         QFAIL(QString("Loading a saved image is not pixel perfect, first different pixel: %1,%2 ").arg(pt.x()).arg(pt.y()).toLatin1());
     }
 
 }
 
 void KisPaintDeviceTest::testGeometry()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, pixel);
     dev->fill(0, 0, 512, 512, pixel);
 
     QCOMPARE(dev->exactBounds(), QRect(0, 0, 512, 512));
     QCOMPARE(dev->extent(), QRect(0, 0, 512, 512));
 
     dev->move(10, 10);
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, 512, 512));
     QCOMPARE(dev->extent(), QRect(10, 10, 512, 512));
 
     dev->crop(50, 50, 50, 50);
     QCOMPARE(dev->exactBounds(), QRect(50, 50, 50, 50));
     QCOMPARE(dev->extent(), QRect(10, 10, 128, 128));
 
     QColor c;
 
     dev->clear(QRect(50, 50, 50, 50));
     dev->pixel(80, 80, &c);
     QVERIFY(c.alpha() == OPACITY_TRANSPARENT_U8);
 
     dev->fill(0, 0, 512, 512, pixel);
     dev->pixel(80, 80, &c);
     QVERIFY(c == Qt::white);
     QVERIFY(c.alpha() == OPACITY_OPAQUE_U8);
 
     dev->clear();
     dev->pixel(80, 80, &c);
     QVERIFY(c.alpha() == OPACITY_TRANSPARENT_U8);
 
     QVERIFY(dev->extent().isEmpty());
     QVERIFY(dev->exactBounds().isEmpty());
 
 }
 
 void KisPaintDeviceTest::testClear()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 
     dev->clear();
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 
     QRect fillRect1(50, 100, 150, 100);
     dev->fill(fillRect1, KoColor(Qt::red, cs));
 
     QCOMPARE(dev->extent(), QRect(0, 64, 256, 192));
     QCOMPARE(dev->exactBounds(), fillRect1);
 
     dev->clear(QRect(100, 100, 100, 100));
 
     QCOMPARE(dev->extent(), QRect(0, 64, 256, 192));
     QCOMPARE(dev->exactBounds(), QRect(50, 100, 50, 100));
 
     dev->clear();
 
     QVERIFY(!dev->extent().isValid());
     QVERIFY(!dev->exactBounds().isValid());
 }
 
 void KisPaintDeviceTest::testCrop()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, pixel);
     dev->fill(-14, 8, 433, 512, pixel);
 
     QVERIFY(dev->exactBounds() == QRect(-14, 8, 433, 512));
 
     // Crop inside
     dev->crop(50, 50, 150, 150);
     QVERIFY(dev->exactBounds() == QRect(50, 50, 150, 150));
 
     // Crop outside, pd should not grow
     dev->crop(0, 0, 1000, 1000);
     QVERIFY(dev->exactBounds() == QRect(50, 50, 150, 150));
 }
 
 void KisPaintDeviceTest::testRoundtripReadWrite()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
     dev->convertFromQImage(image, 0);
 
     quint8* bytes = new quint8[cs->pixelSize() * image.width() * image.height()];
     memset(bytes, 0, image.width() * image.height() * dev->pixelSize());
     dev->readBytes(bytes, image.rect());
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->writeBytes(bytes, image.rect());
     QVERIFY(dev2->exactBounds() == image.rect());
 
     dev2->convertToQImage(0, 0, 0, image.width(), image.height()).save("readwrite.png");
 
 
     QPoint pt;
     if (!TestUtil::comparePaintDevices(pt, dev, dev2)) {
         QFAIL(QString("Failed round trip using readBytes and writeBytes, first different pixel: %1,%2 ").arg(pt.x()).arg(pt.y()).toLatin1());
     }
 }
 
 void logFailure(const QString & reason, const KoColorSpace * srcCs, const KoColorSpace * dstCs)
 {
     QString profile1("no profile");
     QString profile2("no profile");
     if (srcCs->profile())
         profile1 = srcCs->profile()->name();
     if (dstCs->profile())
         profile2 = dstCs->profile()->name();
 
     QWARN(QString("Failed %1 %2 -> %3 %4 %5")
           .arg(srcCs->name())
           .arg(profile1)
           .arg(dstCs->name())
           .arg(profile2)
           .arg(reason)
           .toLatin1());
 }
 
 void KisPaintDeviceTest::testColorSpaceConversion()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "tile.png");
     const KoColorSpace* srcCs = KoColorSpaceRegistry::instance()->rgb8();
     const KoColorSpace* dstCs = KoColorSpaceRegistry::instance()->lab16();
     KisPaintDeviceSP dev = new KisPaintDevice(srcCs);
     dev->convertFromQImage(image, 0);
     dev->move(10, 10);   // Unalign with tile boundaries
     KUndo2Command* cmd = dev->convertTo(dstCs);
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, image.width(), image.height()));
     QCOMPARE(dev->pixelSize(), dstCs->pixelSize());
     QVERIFY(*dev->colorSpace() == *dstCs);
 
     cmd->redo();
     cmd->undo();
 
     QCOMPARE(dev->exactBounds(), QRect(10, 10, image.width(), image.height()));
     QCOMPARE(dev->pixelSize(), srcCs->pixelSize());
     QVERIFY(*dev->colorSpace() == *srcCs);
 
     delete cmd;
 }
 
 
 void KisPaintDeviceTest::testRoundtripConversion()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
 
     QPoint errpoint;
 
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_paint_device_test_test_roundtrip_qimage.png");
         result.save("kis_paint_device_test_test_roundtrip_result.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testFastBitBlt()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dstDev = new KisPaintDevice(cs);
     KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
     srcDev->convertFromQImage(image, 0);
 
     QRect cloneRect(100,100,200,200);
     QPoint errpoint;
 
 
     QVERIFY(dstDev->fastBitBltPossible(srcDev));
     dstDev->fastBitBlt(srcDev, cloneRect);
 
     QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                                cloneRect.width(), cloneRect.height());
     QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
 
     if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     // Test Rough version
     dstDev->clear();
     dstDev->fastBitBltRough(srcDev, cloneRect);
 
     srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                        cloneRect.width(), cloneRect.height());
     dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                        cloneRect.width(), cloneRect.height());
 
     if (!TestUtil::compareQImages(errpoint, srcImage, dstImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     srcDev->move(10,10);
     QVERIFY(!dstDev->fastBitBltPossible(srcDev));
 }
 
 void KisPaintDeviceTest::testMakeClone()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP srcDev = new KisPaintDevice(cs);
     srcDev->convertFromQImage(image, 0);
     srcDev->move(10,10);
 
     const KoColorSpace * weirdCS = KoColorSpaceRegistry::instance()->lab16();
     KisPaintDeviceSP dstDev = new KisPaintDevice(weirdCS);
     dstDev->move(1000,1000);
 
     QVERIFY(!dstDev->fastBitBltPossible(srcDev));
 
     QRect cloneRect(100,100,200,200);
     QPoint errpoint;
 
     dstDev->makeCloneFrom(srcDev, cloneRect);
 
     QVERIFY(*dstDev->colorSpace() == *srcDev->colorSpace());
     QCOMPARE(dstDev->pixelSize(), srcDev->pixelSize());
     QCOMPARE(dstDev->x(), srcDev->x());
     QCOMPARE(dstDev->y(), srcDev->y());
     QCOMPARE(dstDev->exactBounds(), cloneRect);
 
     QImage srcImage = srcDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
     QImage dstImage = dstDev->convertToQImage(0, cloneRect.x(), cloneRect.y(),
                                               cloneRect.width(), cloneRect.height());
     if (!TestUtil::compareQImages(errpoint, dstImage, srcImage)) {
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testThumbnail()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     {
         KisPaintDeviceSP thumb = dev->createThumbnailDevice(50, 50);
         QRect rc = thumb->exactBounds();
         QVERIFY(rc.width() <= 50);
         QVERIFY(rc.height() <= 50);
     }
     {
         QImage thumb = dev->createThumbnail(50, 50);
         QVERIFY(!thumb.isNull());
         QVERIFY(thumb.width() <= 50);
         QVERIFY(thumb.height() <= 50);
         image.save("kis_paint_device_test_test_thumbnail.png");
     }
 }
 
 void KisPaintDeviceTest::testThumbnailDeviceWithOffset()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     dev->setX(10);
     dev->setY(10);
 
     QImage thumb = dev->createThumbnail(640,441,QRect(10,10,640,441));
 
     image.save("oring.png");
     thumb.save("thumb.png");
 
     QPoint pt;
     QVERIFY(TestUtil::compareQImages(pt, thumb, image));
 }
 
 void KisPaintDeviceTest::testCaching()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* whitePixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, whitePixel);
 
     quint8* blackPixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::black, blackPixel);
 
     dev->fill(0, 0, 512, 512, whitePixel);
     QImage thumb1 = dev->createThumbnail(50, 50);
     QRect exactBounds1 = dev->exactBounds();
 
     dev->fill(0, 0, 768, 768, blackPixel);
     QImage thumb2 = dev->createThumbnail(50, 50);
     QRect exactBounds2 = dev->exactBounds();
 
     dev->move(10, 10);
     QImage thumb3 = dev->createThumbnail(50, 50);
     QRect exactBounds3 = dev->exactBounds();
 
     dev->crop(50, 50, 50, 50);
     QImage thumb4 = dev->createThumbnail(50, 50);
     QRect exactBounds4 = dev->exactBounds();
 
     QVERIFY(thumb1 != thumb2);
     QVERIFY(thumb2 == thumb3); // Cache miss, but image is the same
     QVERIFY(thumb3 != thumb4);
     QVERIFY(thumb4 != thumb1);
 
     QCOMPARE(exactBounds1, QRect(0,0,512,512));
     QCOMPARE(exactBounds2, QRect(0,0,768,768));
     QCOMPARE(exactBounds3, QRect(10,10,768,768));
     QCOMPARE(exactBounds4, QRect(50,50,50,50));
 }
 
 void KisPaintDeviceTest::testRegion()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* whitePixel = new quint8[cs->pixelSize()];
     cs->fromQColor(Qt::white, whitePixel);
 
     dev->fill(0, 0, 10, 10, whitePixel);
     dev->fill(70, 70, 10, 10, whitePixel);
     dev->fill(129, 0, 10, 10, whitePixel);
     dev->fill(0, 1030, 10, 10, whitePixel);
 
     QRegion referenceRegion;
     referenceRegion += QRect(0,0,64,64);
     referenceRegion += QRect(64,64,64,64);
     referenceRegion += QRect(128,0,64,64);
     referenceRegion += QRect(0,1024,64,64);
 
     QCOMPARE(dev->exactBounds(), QRect(0,0,139,1040));
     QCOMPARE(dev->region(), referenceRegion);
 }
 
 void KisPaintDeviceTest::testPixel()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QColor c = Qt::red;
     quint8 opacity = 125;
 
     c.setAlpha(opacity);
     dev->setPixel(5, 5, c);
 
     QColor c2;
 
     dev->pixel(5, 5, &c2);
 
     QVERIFY(c == c2);
     QVERIFY(opacity == c2.alpha());
 
 }
 
 void KisPaintDeviceTest::testPlanarReadWrite()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     quint8* pixel = new quint8[cs->pixelSize()];
     cs->fromQColor(QColor(255, 200, 155, 100), pixel);
     dev->fill(0, 0, 5000, 5000, pixel);
     delete[] pixel;
 
     QColor c1;
     dev->pixel(5, 5, &c1);
 
     QVector<quint8*> planes = dev->readPlanarBytes(500, 500, 100, 100);
     QVector<quint8*> swappedPlanes;
 
     QCOMPARE((int)planes.size(), (int)dev->channelCount());
 
     for (int i = 0; i < 100*100; i++) {
         // BGRA encoded
         QVERIFY(planes.at(2)[i] == 255);
         QVERIFY(planes.at(1)[i] == 200);
         QVERIFY(planes.at(0)[i] == 155);
         QVERIFY(planes.at(3)[i] == 100);
     }
 
     for (uint i = 1; i < dev->channelCount() + 1; ++i) {
         swappedPlanes.append(planes[dev->channelCount() - i]);
     }
 
     dev->writePlanarBytes(swappedPlanes, 0, 0, 100, 100);
 
     dev->convertToQImage(0, 0, 0, 1000, 1000).save("planar.png");
 
     dev->pixel(5, 5, &c1);
 
     QVERIFY(c1.red() == 200);
     QVERIFY(c1.green() == 255);
     QVERIFY(c1.blue() == 100);
     QVERIFY(c1.alpha() == 155);
 
     dev->pixel(75, 50, &c1);
 
     QVERIFY(c1.red() == 200);
     QVERIFY(c1.green() == 255);
     QVERIFY(c1.blue() == 100);
     QVERIFY(c1.alpha() == 155);
 
     // check if one of the planes is Null.
     Q_ASSERT(planes.size() == 4);
     delete [] planes[2];
     planes[2] = 0;
     dev->writePlanarBytes(planes, 0, 0, 100, 100);
     dev->convertToQImage(0, 0, 0, 1000, 1000).save("planar_noR.png");
 
     dev->pixel(75, 50, &c1);
 
     QCOMPARE(c1.red(), 200);
     QCOMPARE(c1.green(), 200);
     QCOMPARE(c1.blue(), 155);
     QCOMPARE(c1.alpha(), 100);
 
     QVector<quint8*>::iterator i;
     for (i = planes.begin(); i != planes.end(); ++i)
     {
         delete [] *i;
     }
     swappedPlanes.clear();
 }
 
 void KisPaintDeviceTest::testBltPerformance()
 {
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP fdev = new KisPaintDevice(cs);
     fdev->convertFromQImage(image, 0);
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
 
     QTime t;
     t.start();
 
     int x;
     for (x = 0; x < 1000; ++x) {
         KisPainter gc(dev);
         gc.bitBlt(QPoint(0, 0), fdev, image.rect());
     }
 
     dbgKrita << x
     << "blits"
     << " done in "
     << t.elapsed()
     << "ms";
 
 
 }
 
 void KisPaintDeviceTest::testDeviceDuplication()
 {
     QRect fillRect(0,0,64,64);
     quint8 fillPixel[4]={255,255,255,255};
     QRect clearRect(10,10,20,20);
     QImage referenceImage;
     QImage resultImage;
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP device = new KisPaintDevice(cs);
 
 //    dbgKrita<<"FILLING";
     device->fill(fillRect.left(), fillRect.top(),
                  fillRect.width(), fillRect.height(),fillPixel);
     referenceImage = device->convertToQImage(0);
 
 
     KisTransaction transaction1(device);
 //    dbgKrita<<"CLEARING";
     device->clear(clearRect);
 
     transaction1.revert();
 
     resultImage = device->convertToQImage(0);
     QVERIFY(resultImage == referenceImage);
 
     KisPaintDeviceSP clone =  new KisPaintDevice(*device);
 
     KisTransaction transaction(clone);
 //    dbgKrita<<"CLEARING";
     clone->clear(clearRect);
 
     transaction.revert();
 
     resultImage = clone->convertToQImage(0);
     QVERIFY(resultImage == referenceImage);
 
 }
 
 void KisPaintDeviceTest::testTranslate()
 {
     QRect fillRect(0,0,64,64);
     quint8 fillPixel[4]={255,255,255,255};
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP device = new KisPaintDevice(cs);
 
     device->fill(fillRect.left(), fillRect.top(),
                  fillRect.width(), fillRect.height(),fillPixel);
 
     device->setX(-10);
     device->setY(10);
     QCOMPARE(device->exactBounds(), QRect(-10,10,64,64));
     QCOMPARE(device->extent(), QRect(-10,10,64,64));
 }
 
 void KisPaintDeviceTest::testOpacity()
 {
     // blt a semi-transparent image on a white paint device
 
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent.png");
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP fdev = new KisPaintDevice(cs);
     fdev->convertFromQImage(image, 0);
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(0, 0, 640, 441, KoColor(Qt::white, cs).data());
     KisPainter gc(dev);
     gc.bitBlt(QPoint(0, 0), fdev, image.rect());
 
     QImage result = dev->convertToQImage(0, 0, 0, 640, 441);
     QImage checkResult(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa_transparent_result.png");
     QPoint errpoint;
 
     if (!TestUtil::compareQImages(errpoint, checkResult, result, 1)) {
         checkResult.save("kis_paint_device_test_test_blt_fixed_opactiy_expected.png");
         result.save("kis_paint_device_test_test_blt_fixed_opacity_result.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisPaintDeviceTest::testExactBoundsWeirdNullAlphaCase()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     dev->fill(QRect(10,10,10,10), KoColor(Qt::white, cs));
 
     QCOMPARE(dev->exactBounds(), QRect(10,10,10,10));
 
     const quint8 weirdPixelData[4] = {0,10,0,0};
     KoColor weirdColor(weirdPixelData, cs);
     dev->setPixel(6,6,weirdColor);
 
     // such weird pixels should not change our opinion about
     // device's size
     QCOMPARE(dev->exactBounds(), QRect(10,10,10,10));
 }
 
 void KisPaintDeviceTest::benchmarkExactBoundsNullDefaultPixel()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     QRect fillRect(60,60, 1930, 1930);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QRect measuredRect;
 
     QBENCHMARK {
         // invalidate the cache
         dev->setDirty();
         measuredRect = dev->exactBounds();
     }
 
     QCOMPARE(measuredRect, fillRect);
 }
 
 void KisPaintDeviceTest::testAmortizedExactBounds()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
 
     QRect fillRect(60,60, 833, 833);
     QRect extent(0,0,896,896);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QCOMPARE(dev->exactBounds(), fillRect);
     QCOMPARE(dev->extent(), extent);
 
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 
     dev->setDirty();
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 
     dev->setDirty();
     QCOMPARE(dev->exactBoundsAmortized(), extent);
 
     QTest::qSleep(1100);
 
     QCOMPARE(dev->exactBoundsAmortized(), fillRect);
 }
 
 void KisPaintDeviceTest::testNonDefaultPixelArea()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QVERIFY(dev->exactBounds().isEmpty());
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     KoColor defPixel(Qt::red, cs);
     dev->setDefaultPixel(defPixel.data());
 
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     QRect fillRect(10,11,18,14);
 
     dev->fill(fillRect, KoColor(Qt::white, cs));
 
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QCOMPARE(dev->nonDefaultPixelArea(), fillRect);
 
 
     // non-default pixel variant should also handle weird pixels
 
     const quint8 weirdPixelData[4] = {0,10,0,0};
     KoColor weirdColor(weirdPixelData, cs);
     dev->setPixel(100,100,weirdColor);
 
     // such weird pixels should not change our opinion about
     // device's size
     QCOMPARE(dev->exactBounds(), KisDefaultBounds::infiniteRect);
     QCOMPARE(dev->nonDefaultPixelArea(), fillRect | QRect(100,100,1,1));
 }
 
 void KisPaintDeviceTest::testExactBoundsNonTransparent()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1000, 1000, cs, "merge test");
     KisPaintLayerSP layer = new KisPaintLayer(image, "bla", 125);
     KisPaintDeviceSP dev = layer->paintDevice();
 
     QVERIFY(dev);
 
     QRect imageRect(0,0,1000,1000);
 
     KoColor defPixel(Qt::red, cs);
     dev->setDefaultPixel(defPixel.data());
 
     QCOMPARE(dev->exactBounds(), imageRect);
     QVERIFY(dev->nonDefaultPixelArea().isEmpty());
 
     KoColor fillPixel(Qt::white, cs);
 
     dev->fill(imageRect, KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), imageRect);
     QCOMPARE(dev->nonDefaultPixelArea(), imageRect);
 
     dev->fill(QRect(1000,0, 1, 1000), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,0,1001,1000));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,0,1001,1000));
 
     dev->fill(QRect(0,1000, 1000, 1), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,0,1001,1001));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,0,1001,1001));
 
     dev->fill(QRect(0,-1, 1000, 1), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(0,-1,1001,1002));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(0,-1,1001,1002));
 
     dev->fill(QRect(-1,0, 1, 1000), KoColor(Qt::white, cs));
     QCOMPARE(dev->exactBounds(), QRect(-1,-1,1002,1002));
     QCOMPARE(dev->nonDefaultPixelArea(), QRect(-1,-1,1002,1002));
 }
 
 KisPaintDeviceSP createWrapAroundPaintDevice(const KoColorSpace *cs)
 {
     struct TestingDefaultBounds : public KisDefaultBoundsBase {
         QRect bounds() const {
             return QRect(0,0,20,20);
         }
         bool wrapAroundMode() const {
             return true;
         }
         int currentLevelOfDetail() const {
             return 0;
         }
         int currentTime() const {
             return 0;
         }
         bool externalFrameActive() const {
             return false;
         }
     };
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     KisDefaultBoundsBaseSP bounds = new TestingDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     return dev;
 }
 
 void checkReadWriteRoundTrip(KisPaintDeviceSP dev,
                              const QRect &rc)
 {
     KisPaintDeviceSP deviceCopy = new KisPaintDevice(*dev.data());
 
     QRect readRect(10, 10, 20, 20);
     int bufSize = rc.width() * rc.height() * dev->pixelSize();
 
     QScopedArrayPointer<quint8> buf1(new quint8[bufSize]);
 
     deviceCopy->readBytes(buf1.data(), rc);
 
     deviceCopy->clear();
     QVERIFY(deviceCopy->extent().isEmpty());
 
 
     QScopedArrayPointer<quint8> buf2(new quint8[bufSize]);
     deviceCopy->writeBytes(buf1.data(), rc);
     deviceCopy->readBytes(buf2.data(), rc);
 
     QVERIFY(!memcmp(buf1.data(), buf2.data(), bufSize));
 }
 
 
 void KisPaintDeviceTest::testReadBytesWrapAround()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     const int pixelSize = dev->pixelSize();
 
     {
         QRect readRect(10, 10, 20, 20);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final1.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check weird case when the read rect is larger than wrap rect
         QRect readRect(10, 10, 30, 30);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final2.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // even more large
         QRect readRect(10, 10, 40, 40);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final3.png");
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 7) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 8) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (7 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (8 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (27 + readRect.width() * 27) * pixelSize, c2.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (28 + readRect.width() * 28) * pixelSize, c2.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (32 + readRect.width() * 12) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (33 + readRect.width() * 13) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (12 + readRect.width() * 32) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (13 + readRect.width() * 33) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (32 + readRect.width() * 32) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (33 + readRect.width() * 33) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap rect contains the read rect entirely
         QRect readRect(1, 1, 10, 10);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final4.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap happens only on vertical side of the rect
         QRect readRect(1, 1, 29, 10);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final5.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (21 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (22 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 
     {
         // check if the wrap happens only on horizontal side of the rect
         QRect readRect(1, 1, 10, 29);
         QScopedArrayPointer<quint8> buf(new quint8[readRect.width() *
                                               readRect.height() *
                                               pixelSize]);
         dev->readBytes(buf.data(), readRect);
         //dev->convertToQImage(0, readRect.x(), readRect.y(), readRect.width(), readRect.height()).save("final6.png");
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 1) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 2) * pixelSize, c1.data(), pixelSize));
 
         QVERIFY(memcmp(buf.data() + (1 + readRect.width() * 21) * pixelSize, c1.data(), pixelSize));
         QVERIFY(!memcmp(buf.data() + (2 + readRect.width() * 22) * pixelSize, c1.data(), pixelSize));
 
         checkReadWriteRoundTrip(dev, readRect);
     }
 }
 
 #include "kis_random_accessor_ng.h"
 
 void KisPaintDeviceTest::testWrappedRandomAccessor()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     const int pixelSize = dev->pixelSize();
 
     int x;
     int y;
 
     x = 3;
     y = 3;
     KisRandomAccessorSP dstIt = dev->createRandomAccessorNG(x, y);
 
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 23;
     y = 23;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 3;
     y = 23;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 23;
     y = 3;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = -17;
     y = 3;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = 3;
     y = -17;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 
     x = -17;
     y = -17;
     dstIt->moveTo(x, y);
     QVERIFY(!memcmp(dstIt->rawData(), c1.data(), pixelSize));
     QCOMPARE(dstIt->numContiguousColumns(x), 17);
     QCOMPARE(dstIt->numContiguousRows(y), 17);
 }
 
 #include "kis_iterator_ng.h"
 
 static bool nextRowGeneral(KisHLineIteratorSP it, int y, const QRect &rc) {
     it->nextRow();
     return y < rc.height();
 }
 
 static bool nextRowGeneral(KisVLineIteratorSP it, int y, const QRect &rc) {
     it->nextColumn();
     return y < rc.width();
 }
 
 template <class T>
 bool checkXY(const QPoint &pt, const QPoint &realPt) {
     Q_UNUSED(pt);
     Q_UNUSED(realPt);
     return false;
 }
 
 template <>
 bool checkXY<KisHLineIteratorSP>(const QPoint &pt, const QPoint &realPt) {
     return pt == realPt;
 }
 
 template <>
 bool checkXY<KisVLineIteratorSP>(const QPoint &pt, const QPoint &realPt) {
     return pt.x() == realPt.y() && pt.y() == realPt.x();
 }
 #include <kis_wrapped_rect.h>
 template <class T>
 bool checkConseqPixels(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     Q_UNUSED(value);
     Q_UNUSED(pt);
     Q_UNUSED(wrappedRect);
     return false;
 }
 
 template <>
 bool checkConseqPixels<KisHLineIteratorSP>(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     int x = KisWrappedRect::xToWrappedX(pt.x(), wrappedRect.wrapRect());
     int borderX = wrappedRect.originalRect().x() + wrappedRect.wrapRect().width();
     int conseq = x >= borderX ? wrappedRect.wrapRect().right() - x + 1 : borderX - x;
     conseq = qMin(conseq, wrappedRect.originalRect().right() - pt.x() + 1);
 
     return value == conseq;
 }
 
 template <>
 bool checkConseqPixels<KisVLineIteratorSP>(int value, const QPoint &pt, const KisWrappedRect &wrappedRect) {
     Q_UNUSED(pt);
     Q_UNUSED(wrappedRect);
     return value == 1;
 }
 
 template <class IteratorSP>
 IteratorSP createIterator(KisPaintDeviceSP dev, const QRect &rc) {
     Q_UNUSED(dev);
     Q_UNUSED(rc);
     return 0;
 }
 
 template <>
 KisHLineIteratorSP createIterator(KisPaintDeviceSP dev,
                                   const QRect &rc) {
     return dev->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 }
 
 template <>
 KisVLineIteratorSP createIterator(KisPaintDeviceSP dev,
                                   const QRect &rc) {
     return dev->createVLineIteratorNG(rc.x(), rc.y(), rc.height());
 }
 
 template <class IteratorSP>
 void testWrappedLineIterator(QString testName, const QRect &rect)
 {
     testName = QString("%1_%2_%3_%4_%5")
         .arg(testName)
         .arg(rect.x())
         .arg(rect.y())
         .arg(rect.width())
         .arg(rect.height());
 
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     // test rect fits the wrap rect in both dimensions
     IteratorSP it = createIterator<IteratorSP>(dev, rect);
 
     int y = 0;
     do {
         int x = 0;
         do {
             quint8 *data = it->rawData();
 
             data[0] = 10 * x;
             data[1] = 10 * y;
             data[2] = 0;
             data[3] = 255;
 
             x++;
         } while (it->nextPixel());
     } while (nextRowGeneral(it, ++y, rect));
 
     QRect rc = dev->defaultBounds()->bounds() | dev->exactBounds();
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
 
     QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators", testName));
 }
 
 template <class IteratorSP>
 void testWrappedLineIterator(const QString &testName)
 {
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,20,20));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,10,20));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,20,10));
     testWrappedLineIterator<IteratorSP>(testName, QRect(10,10,10,10));
     testWrappedLineIterator<IteratorSP>(testName, QRect(0,0,20,20));
 }
 
 void KisPaintDeviceTest::testWrappedHLineIterator()
 {
     testWrappedLineIterator<KisHLineIteratorSP>("hline_iterator");
 }
 
 void KisPaintDeviceTest::testWrappedVLineIterator()
 {
     testWrappedLineIterator<KisVLineIteratorSP>("vline_iterator");
 }
 
 template <class IteratorSP>
 void testWrappedLineIteratorReadMoreThanBounds(QString testName)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     // fill device with a gradient
     QRect bounds = dev->defaultBounds()->bounds();
     for (int y = bounds.y(); y < bounds.y() + bounds.height(); y++) {
         for (int x = bounds.x(); x < bounds.x() + bounds.width(); x++) {
             QColor c((10 * x) % 255, (10 * y) % 255, 0, 255);
             dev->setPixel(x, y, c);
         }
     }
 
     // test rect doesn't fit the wrap rect in both dimentions
     const QRect &rect(bounds.adjusted(-6,-6,8,8));
     KisRandomAccessorSP dstIt = dst->createRandomAccessorNG(rect.x(), rect.y());
     IteratorSP it = createIterator<IteratorSP>(dev, rect);
 
     for (int y = rect.y(); y < rect.y() + rect.height(); y++) {
         for (int x = rect.x(); x < rect.x() + rect.width(); x++) {
             quint8 *data = it->rawData();
 
             QVERIFY(checkConseqPixels<IteratorSP>(it->nConseqPixels(), QPoint(x, y), KisWrappedRect(rect, bounds)));
 
             dstIt->moveTo(x, y);
             memcpy(dstIt->rawData(), data, cs->pixelSize());
 
             QVERIFY(checkXY<IteratorSP>(QPoint(it->x(), it->y()), QPoint(x,y)));
 
             bool stepDone = it->nextPixel();
             QCOMPARE(stepDone, x < rect.x() + rect.width() - 1);
         }
         if (!nextRowGeneral(it, y, rect)) break;
     }
 
     testName = QString("%1_%2_%3_%4_%5")
         .arg(testName)
         .arg(rect.x())
         .arg(rect.y())
         .arg(rect.width())
         .arg(rect.height());
 
     QRect rc = rect;
     QImage result = dst->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QImage ref = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
 
     QVERIFY(TestUtil::checkQImage(result, "paint_device_test", "wrapped_iterators_huge", testName, 1));
 }
 
 void KisPaintDeviceTest::testWrappedHLineIteratorReadMoreThanBounds()
 {
     testWrappedLineIteratorReadMoreThanBounds<KisHLineIteratorSP>("hline_iterator");
 }
 
 void KisPaintDeviceTest::testWrappedVLineIteratorReadMoreThanBounds()
 {
     testWrappedLineIteratorReadMoreThanBounds<KisVLineIteratorSP>("vline_iterator");
 }
 
 void KisPaintDeviceTest::testMoveWrapAround()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = createWrapAroundPaintDevice(cs);
 
     KoColor c1(Qt::red, cs);
     KoColor c2(Qt::green, cs);
 
     dev->setPixel(3, 3, c1);
     dev->setPixel(18, 18, c2);
 
     // QRect rc = dev->defaultBounds()->bounds();
 
     //dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height()).save("move0.png");
     QCOMPARE(dev->exactBounds(), QRect(3,3,16,16));
     dev->move(QPoint(10,10));
     QCOMPARE(dev->exactBounds(), QRect(8,8,6,6));
     //dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height()).save("move1.png");
 
 }
 
 #include "kis_lock_free_cache.h"
 
 #define NUM_TYPES 3
 
 // high-concurrency
 #define NUM_CYCLES 500000
 #define NUM_THREADS 4
 
 
 struct TestingCache : KisLockFreeCache<int> {
     int calculateNewValue() const {
         return m_realValue;
     }
 
     QAtomicInt m_realValue;
 };
 
 class CacheStressJob : public QRunnable
 {
 public:
     CacheStressJob(TestingCache &cache)
         : m_cache(cache),
           m_oldValue(0)
     {
     }
 
     void run() {
         for(qint32 i = 0; i < NUM_CYCLES; i++) {
             qint32 type = i % NUM_TYPES;
 
             switch(type) {
             case 0:
                 m_cache.m_realValue.ref();
                 m_oldValue = m_cache.m_realValue;
                 m_cache.invalidate();
                 break;
             case 1:
             {
                 int newValue = m_cache.getValue();
                 Q_ASSERT(newValue >= m_oldValue);
                 Q_UNUSED(newValue);
             }
                 break;
             case 3:
                 QTest::qSleep(3);
                 break;
             }
         }
     }
 
 private:
     TestingCache &m_cache;
     int m_oldValue;
 };
 
 void KisPaintDeviceTest::testCacheState()
 {
     TestingCache cache;
 
     QList<CacheStressJob*> jobsList;
     CacheStressJob *job;
 
     for(qint32 i = 0; i < NUM_THREADS; i++) {
         //job = new CacheStressJob(value, cacheValue, cacheState);
         job = new CacheStressJob(cache);
         job->setAutoDelete(true);
         jobsList.append(job);
     }
 
     QThreadPool pool;
     pool.setMaxThreadCount(NUM_THREADS);
 
     Q_FOREACH (job, jobsList) {
         pool.start(job);
     }
 
     pool.waitForDone();
 }
 
 struct TestingLodDefaultBounds : public KisDefaultBoundsBase {
     TestingLodDefaultBounds(const QRect &bounds = QRect(0,0,100,100))
         : m_lod(0), m_bounds(bounds) {}
 
     QRect bounds() const {
         return m_bounds;
     }
     bool wrapAroundMode() const {
         return false;
     }
 
     int currentLevelOfDetail() const {
         return m_lod;
     }
 
     int currentTime() const {
         return 0;
     }
     bool externalFrameActive() const {
         return false;
     }
 
     void testingSetLevelOfDetail(int lod) {
         m_lod = lod;
     }
 
 private:
     int m_lod;
     QRect m_bounds;
 };
 
 void fillGradientDevice(KisPaintDeviceSP dev, const QRect &rect, bool flat = false)
 {
     if (flat) {
         dev->fill(rect, KoColor(Qt::red, dev->colorSpace()));
     } else {
         // fill device with a gradient
         KisSequentialIterator it(dev, rect);
         do {
             QColor c((10 * it.x()) & 0xFF, (10 * it.y()) & 0xFF, 0, 255);
             KoColor color(c, dev->colorSpace());
             memcpy(it.rawData(), color.data(), dev->pixelSize());
         } while (it.nextPixel());
     }
 }
 #include "kis_lod_transform.h"
 void KisPaintDeviceTest::testLodTransform()
 {
     const int lod = 2; // round to 4
     KisLodTransform t(lod);
 
     QRect rc1(-16, -16, 8, 8);
     QRect rc2(-16, -16, 7, 7);
     QRect rc3(-15, -15, 7, 7);
 
     QCOMPARE(t.alignedRect(rc1, lod), rc1);
     QCOMPARE(t.alignedRect(rc2, lod), rc1);
     QCOMPARE(t.alignedRect(rc3, lod), rc1);
 }
 
 #include "krita_utils.h"
 void syncLodCache(KisPaintDeviceSP dev, int levelOfDetail)
 {
     KisPaintDevice::LodDataStruct* s = dev->createLodDataStruct(levelOfDetail);
 
     QRegion region = dev->regionForLodSyncing();
     Q_FOREACH(QRect rect2, KritaUtils::splitRegionIntoPatches(region, KritaUtils::optimalPatchSize())) {
         dev->updateLodDataStruct(s, rect2);
     }
 
     dev->uploadLodDataStruct(s);
 }
 
 void KisPaintDeviceTest::testLodDevice()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     // QRect rect = dev->defaultBounds()->bounds();
     // fillGradientDevice(dev, rect);
     fillGradientDevice(dev, QRect(50,50,30,30));
 
     QCOMPARE(dev->exactBounds(), QRect(50,50,30,30));
 
     QImage result;
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "initial"));
 
     bounds->testingSetLevelOfDetail(1);
     syncLodCache(dev, 1);
     QCOMPARE(dev->exactBounds(), QRect(25,25,15,15));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1"));
 
     bounds->testingSetLevelOfDetail(2);
     QCOMPARE(dev->exactBounds(), QRect(25,25,15,15));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1"));
 
     syncLodCache(dev, 2);
     QCOMPARE(dev->exactBounds(), QRect(12,12,8,8));
 
     qDebug() << ppVar(dev->exactBounds());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod2"));
 
     bounds->testingSetLevelOfDetail(0);
 
     dev->setX(20);
     dev->setY(10);
 
     bounds->testingSetLevelOfDetail(1);
     syncLodCache(dev, 1);
 
     QCOMPARE(dev->exactBounds(), QRect(35,30,15,15));
 
 
     qDebug() << ppVar(dev->exactBounds()) << ppVar(dev->x()) << ppVar(dev->y());
     result = dev->convertToQImage(0,0,0,100,100);
     /*QVERIFY*/(TestUtil::checkQImage(result, "paint_device_test",
                                   "lod", "lod1-offset-6-14"));
 }
 
 void KisPaintDeviceTest::benchmarkLod1Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,6000,4000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(1);
         syncLodCache(dev, 1);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod2Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,6000,4000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(2);
         syncLodCache(dev, 2);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod3Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,3000,2000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(3);
         syncLodCache(dev, 3);
     }
 }
 
 void KisPaintDeviceTest::benchmarkLod4Generation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestingLodDefaultBounds *bounds = new TestingLodDefaultBounds(QRect(0,0,3000,2000));
     dev->setDefaultBounds(bounds);
 
     // fill device with a gradient
     QRect rect = dev->defaultBounds()->bounds();
     fillGradientDevice(dev, rect, true);
 
     QBENCHMARK {
         bounds->testingSetLevelOfDetail(4);
         syncLodCache(dev, 4);
     }
 }
 
 #include "kis_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 #include "testing_timed_default_bounds.h"
 
 void KisPaintDeviceTest::testFramesLeaking()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
-    // Itinial state: one frame, m_data shared
+    // Itinial state: one frame, m_data is kept separate
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add keyframe at position 10
     channel->addKeyframe(10);
 
-    // two frames, m_data is null
+    // two frames, m_data has a default empty value
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add keyframe at position 20
     channel->addKeyframe(20);
 
-    // three frames, m_data is null, current frame is 0
+    // three frames, m_data is default, current frame is 0
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 3);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // switch to frame 10
     bounds->testingSetTime(10);
 
-    // three frames, m_data is null, current frame is 10
+    // three frames, m_data is default, current frame is 10
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[1]);
     QCOMPARE(o.m_frames.size(), 3);
 
     // switch to frame 20
     bounds->testingSetTime(20);
 
-    // three frames, m_data is null, current frame is 20
+    // three frames, m_data is default, current frame is 20
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[2]);
     QCOMPARE(o.m_frames.size(), 3);
 
     // switch to frame 15
     bounds->testingSetTime(15);
 
-    // three frames, m_data is null, current frame is 10
+    // three frames, m_data is default, current frame is 10
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QVERIFY(o.m_currentData == o.m_frames[1]);
     QCOMPARE(o.m_frames.size(), 3);
 
     KisKeyframeSP key;
 
     // deletion of frame 0 is forbidden
     key = channel->keyframeAt(0);
     QVERIFY(key);
     QVERIFY(channel->deleteKeyframe(key));
 
     // delete keyframe at position 11
     key = channel->activeKeyframeAt(11);
     QVERIFY(key);
     QCOMPARE(key->time(), 10);
     QVERIFY(channel->deleteKeyframe(key));
 
-    // two frames, m_data is null, current frame is 0
+    // two frames, m_data is default, current frame is 0
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 2);
 
     // deletion of frame 0 is forbidden
     key = channel->activeKeyframeAt(11);
     QVERIFY(key);
     QCOMPARE(key->time(), 0);
     QVERIFY(channel->deleteKeyframe(key));
 
     // nothing changed
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 2);
 
     // delete keyframe at position 20
     key = channel->activeKeyframeAt(20);
     QVERIFY(key);
     QCOMPARE(key->time(), 20);
     QVERIFY(channel->deleteKeyframe(key));
 
-    // one keyframe is left at position 0, m_data is shared
+    // one keyframe is left at position 0, m_data is default
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data);
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     //QVERIFY(o.m_currentData == o.m_frames[0]);
     QCOMPARE(o.m_frames.size(), 1);
 
     // ensure all the objects in the list of all objects are unique
     QList<KisPaintDeviceData*> allObjects = i->testingGetDataObjectsList();
     QSet<KisPaintDeviceData*> uniqueObjects;
     Q_FOREACH (KisPaintDeviceData *obj, allObjects) {
         if (!obj) continue;
         QVERIFY(!uniqueObjects.contains(obj));
         uniqueObjects.insert(obj);
     }
 }
 
 void KisPaintDeviceTest::testFramesUndoRedo()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
+    int frameId = -1;
+    const int time = 1;
 
-    int frameId = i->createFrame(false, 0, QPoint(), &cmdAdd);
+    channel->addKeyframe(time, &cmdAdd);
+    frameId = channel->frameIdAt(time);
+    //int frameId = i->createFrame(false, 0, QPoint(), &cmdAdd);
 
     QCOMPARE(frameId, 1);
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.undo();
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.redo();
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdRemove;
-    i->deleteFrame(1, &cmdRemove);
+    KisKeyframeSP keyframe = channel->keyframeAt(time);
+    QVERIFY(keyframe);
+
+    channel->deleteKeyframe(keyframe, &cmdRemove);
+
+    //i->deleteFrame(1, &cmdRemove);
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.redo();
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 }
 
 void KisPaintDeviceTest::testFramesUndoRedoWithChannel()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
 
     KisKeyframeSP frame = channel->addKeyframe(10, &cmdAdd);
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.undo();
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdAdd.redo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdRemove;
     channel->deleteKeyframe(frame, &cmdRemove);
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.redo();
 
     QVERIFY(!channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdRemove.undo();
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     KUndo2Command cmdMove;
     channel->moveKeyframe(frame, 12, &cmdMove);
 
     QVERIFY(!channel->keyframeAt(10));
     QVERIFY(channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdMove.undo();
 
     QVERIFY(channel->keyframeAt(10));
     QVERIFY(!channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
     cmdMove.redo();
 
     QVERIFY(!channel->keyframeAt(10));
     QVERIFY(channel->keyframeAt(12));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // default m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 }
 
 void fillRect(KisPaintDeviceSP dev, int time, const QRect &rc, TestUtil::TestingTimedDefaultBounds *bounds)
 {
     KUndo2Command parentCommand;
     KisRasterKeyframeChannel *channel = dev->keyframeChannel();
     KisKeyframeSP frame = channel->addKeyframe(time, &parentCommand);
 
     const int oldTime = bounds->currentTime();
     bounds->testingSetTime(time);
 
     KoColor color(Qt::red, dev->colorSpace());
     dev->fill(rc, color);
 
     bounds->testingSetTime(oldTime);
 }
 
 bool checkRect(KisPaintDeviceSP dev, int time, const QRect &rc, TestUtil::TestingTimedDefaultBounds *bounds)
 {
     const int oldTime = bounds->currentTime();
     bounds->testingSetTime(time);
 
     bool result = dev->exactBounds() == rc;
 
     if (!result) {
         qDebug() << "Failed to check frame:" << ppVar(time) << ppVar(rc) << ppVar(dev->exactBounds());
     }
 
     bounds->testingSetTime(oldTime);
 
     return result;
 }
 
 void testCrossDeviceFrameCopyImpl(bool useChannel)
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev1 = new KisPaintDevice(cs);
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
 
     const KoColorSpace *cs3 = KoColorSpaceRegistry::instance()->rgb16();
     KisPaintDeviceSP dev3 = new KisPaintDevice(cs3);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev1->setDefaultBounds(bounds);
     dev2->setDefaultBounds(bounds);
     dev3->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel1 = dev1->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     KisPaintDeviceFramesInterface *i1 = dev1->framesInterface();
     QVERIFY(channel1);
     QVERIFY(i1);
 
     KisRasterKeyframeChannel *channel2 = dev2->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     KisPaintDeviceFramesInterface *i2 = dev2->framesInterface();
     QVERIFY(channel2);
     QVERIFY(i2);
 
     KisRasterKeyframeChannel *channel3 = dev3->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     KisPaintDeviceFramesInterface *i3 = dev3->framesInterface();
     QVERIFY(channel3);
     QVERIFY(i3);
 
     fillRect(dev1, 10, QRect(100,100,100,100), bounds);
     fillRect(dev2, 20, QRect(200,200,100,100), bounds);
     fillRect(dev3, 30, QRect(300,300,100,100), bounds);
 
     QCOMPARE(dev1->exactBounds(), QRect());
 
     const int dstFrameId1 = channel1->frameIdAt(10);
     const int srcFrameId2 = channel2->frameIdAt(20);
     const int srcFrameId3 = channel3->frameIdAt(30);
 
     KUndo2Command cmd1;
     if (!useChannel) {
         dev1->framesInterface()->uploadFrame(srcFrameId2, dstFrameId1, dev2);
     } else {
         KisKeyframeSP k = channel1->copyExternalKeyframe(channel2, 20, 10, &cmd1);
     }
 
     QCOMPARE(dev1->exactBounds(), QRect());
     QVERIFY(checkRect(dev1, 10, QRect(200,200,100,100), bounds));
 
     if (useChannel) {
         cmd1.undo();
         QVERIFY(checkRect(dev1, 10, QRect(100,100,100,100), bounds));
     }
 
     KUndo2Command cmd2;
     if (!useChannel) {
         dev1->framesInterface()->uploadFrame(srcFrameId3, dstFrameId1, dev3);
     } else {
         KisKeyframeSP k = channel1->copyExternalKeyframe(channel3, 30, 10, &cmd2);
     }
 
     QCOMPARE(dev1->exactBounds(), QRect());
     QVERIFY(checkRect(dev1, 10, QRect(300,300,100,100), bounds));
 
     if (useChannel) {
         cmd2.undo();
         QVERIFY(checkRect(dev1, 10, QRect(100,100,100,100), bounds));
     }
 }
 
 void KisPaintDeviceTest::testCrossDeviceFrameCopyDirect()
 {
     testCrossDeviceFrameCopyImpl(false);
 }
 
 void KisPaintDeviceTest::testCrossDeviceFrameCopyChannel()
 {
     testCrossDeviceFrameCopyImpl(true);
 }
 
 #include "kis_surrogate_undo_adapter.h"
 
 void KisPaintDeviceTest::testLazyFrameCreation()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     bounds->testingSetTime(10);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisSurrogateUndoAdapter undoAdapter;
 
     {
         KisTransaction transaction1(dev);
         transaction1.commit(&undoAdapter);
     }
 
     QCOMPARE(i->frames().size(), 2);
 
     undoAdapter.undoAll();
 
     QCOMPARE(i->frames().size(), 1);
 
     undoAdapter.redoAll();
 
     QCOMPARE(i->frames().size(), 2);
 }
 
 void KisPaintDeviceTest::testCopyPaintDeviceWithFrames()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KisKeyframeChannel::Content, 0);
     QVERIFY(channel);
 
     KisPaintDeviceFramesInterface *i = dev->framesInterface();
     QVERIFY(i);
 
     QCOMPARE(i->frames().size(), 1);
 
     KisPaintDeviceFramesInterface::TestingDataObjects o;
 
     // Itinial state: one frame, m_data shared
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 1);
-    QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    QVERIFY(o.m_currentData == o.m_frames[0]);
 
 
     // add a keyframe
 
     KUndo2Command cmdAdd;
 
     KisKeyframeSP frame = channel->addKeyframe(10, &cmdAdd);
 
     QVERIFY(channel->keyframeAt(10));
 
     o = i->testingGetDataObjects();
-    QVERIFY(!o.m_data);
+    QVERIFY(o.m_data); // m_data should always be present
     QVERIFY(!o.m_lodData);
     QVERIFY(!o.m_externalFrameData);
     QCOMPARE(o.m_frames.size(), 2);
-    //QVERIFY(o.m_currentData == o.m_frames.begin().value());
+    //QVERIFY(o.m_currentData == o.m_frames[0]);
 
     KisPaintDeviceSP newDev = new KisPaintDevice(*dev, true, 0);
 
     QVERIFY(channel->keyframeAt(0));
     QVERIFY(channel->keyframeAt(10));
 }
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/variance.hpp>
 #include <boost/accumulators/statistics/min.hpp>
 #include <boost/accumulators/statistics/max.hpp>
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/uniform_smallint.hpp>
 
 #include "KoCompositeOpRegistry.h"
 
 
 using namespace boost::accumulators;
 
 accumulator_set<qreal, stats<tag::variance, tag::max, tag::min> > accum;
 
 
 void KisPaintDeviceTest::testCompositionAssociativity()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
 
     qsrand(500);
 
     boost::mt11213b _rnd0(qrand());
     boost::mt11213b _rnd1(qrand());
     boost::mt11213b _rnd2(qrand());
     boost::mt11213b _rnd3(qrand());
 
     boost::uniform_smallint<int> rnd0(0, 255);
     boost::uniform_smallint<int> rnd1(0, 255);
     boost::uniform_smallint<int> rnd2(0, 255);
     boost::uniform_smallint<int> rnd3(0, 255);
 
     QList<KoCompositeOp*> allCompositeOps = cs->compositeOps();
 
     Q_FOREACH (const KoCompositeOp *op, allCompositeOps) {
 
         accumulator_set<qreal, stats<tag::variance, tag::max, tag::min> > accum;
 
         const int numIterations = 10000;
 
         for (int j = 0; j < numIterations; j++) {
             KoColor c1(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             KoColor c2(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             KoColor c3(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             //KoColor c4(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
             //KoColor c5(QColor(rnd0(_rnd0), rnd1(_rnd1), rnd2(_rnd2), rnd3(_rnd3)), cs);
 
             KoColor r1(QColor(Qt::transparent), cs);
             KoColor r2(QColor(Qt::transparent), cs);
             KoColor r3(QColor(Qt::transparent), cs);
 
             op->composite(r1.data(), 0, c1.data(), 0, 0,0, 1,1, 255);
             op->composite(r1.data(), 0, c2.data(), 0, 0,0, 1,1, 255);
             op->composite(r1.data(), 0, c3.data(), 0, 0,0, 1,1, 255);
             //op->composite(r1.data(), 0, c4.data(), 0, 0,0, 1,1, 255);
             //op->composite(r1.data(), 0, c5.data(), 0, 0,0, 1,1, 255);
 
             op->composite(r3.data(), 0, c2.data(), 0, 0,0, 1,1, 255);
             op->composite(r3.data(), 0, c3.data(), 0, 0,0, 1,1, 255);
             //op->composite(r3.data(), 0, c4.data(), 0, 0,0, 1,1, 255);
             //op->composite(r3.data(), 0, c5.data(), 0, 0,0, 1,1, 255);
 
             op->composite(r2.data(), 0, c1.data(), 0, 0,0, 1,1, 255);
             op->composite(r2.data(), 0, r3.data(), 0, 0,0, 1,1, 255);
 
             const quint8 *p1 = r1.data();
             const quint8 *p2 = r2.data();
 
             if (memcmp(p1, p2, 4) != 0) {
                 for (int i = 0; i < 4; i++) {
                     accum(qAbs(p1[i] - p2[i]));
                 }
             }
 
         }
 
         qDebug("Errors for op %25s err rate %7.2f var %7.2f max %7.2f",
                op->id().toAscii().data(),
                (qreal(count(accum)) / (4 * numIterations)),
                variance(accum),
                count(accum) > 0 ? (max)(accum) : 0);
     }
 }
 
 QTEST_MAIN(KisPaintDeviceTest)