diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index fc61678ea7..0fa838c0a5 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,1613 +1,1612 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image.h"
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QPainter>
 #include <QSize>
 #include <QDateTime>
 #include <QRect>
 #include <QRegion>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorProfile.h"
 #include <KoCompositeOpRegistry.h>
 #include "KisProofingConfiguration.h"
 
 #include "recorder/kis_action_recorder.h"
 #include "kis_adjustment_layer.h"
 #include "kis_annotation.h"
 #include "kis_change_profile_visitor.h"
 #include "kis_colorspace_convert_visitor.h"
 #include "kis_count_visitor.h"
 #include "kis_filter_strategy.h"
 #include "kis_group_layer.h"
 #include "commands/kis_image_commands.h"
 #include "kis_layer.h"
 #include "kis_meta_data_merge_strategy_registry.h"
 #include "kis_name_server.h"
 #include "kis_paint_layer.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_transaction.h"
 #include "kis_meta_data_merge_strategy.h"
 #include "kis_memory_statistics_server.h"
 
 #include "kis_image_config.h"
 #include "kis_update_scheduler.h"
 #include "kis_image_signal_router.h"
 #include "kis_image_animation_interface.h"
 #include "kis_stroke_strategy.h"
 #include "kis_image_barrier_locker.h"
 
 
 #include "kis_undo_stores.h"
 #include "kis_legacy_undo_adapter.h"
 #include "kis_post_execution_undo_adapter.h"
 
 #include "kis_transform_worker.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "processing/kis_crop_selections_processing_visitor.h"
 #include "processing/kis_transform_processing_visitor.h"
 #include "commands_new/kis_image_resize_command.h"
 #include "commands_new/kis_image_set_resolution_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_layer_composition.h"
 #include "kis_wrapped_rect.h"
 #include "kis_crop_saved_extra_data.h"
 #include "kis_layer_utils.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_suspend_projection_updates_stroke_strategy.h"
 #include "kis_sync_lod_cache_stroke_strategy.h"
 
 #include "kis_projection_updates_filter.h"
 
 #include "kis_layer_projection_plane.h"
 
 #include "kis_update_time_monitor.h"
 #include "kis_image_barrier_locker.h"
 
 #include <QtCore>
 
 #include <functional>
 
 #include "kis_time_range.h"
 
 // #define SANITY_CHECKS
 
 #ifdef SANITY_CHECKS
 #define SANITY_CHECK_LOCKED(name)                                       \
     if (!locked()) warnKrita() << "Locking policy failed:" << name          \
                                << "has been called without the image"       \
                                   "being locked";
 #else
 #define SANITY_CHECK_LOCKED(name)
 #endif
 
 
 class KisImage::KisImagePrivate
 {
 public:
     KisImagePrivate(KisImage *_q, qint32 w, qint32 h, const KoColorSpace *c, KisUndoStore *u)
         : q(_q)
         , lockedForReadOnly(false)
         , width(w)
         , height(h)
         , colorSpace(c)
         , nserver(1)
         , undoStore(u)
         , legacyUndoAdapter(u, _q)
         , postExecutionUndoAdapter(u, _q)
         , recorder(_q)
         , signalRouter(_q)
         , animationInterface(0)
         , scheduler(_q)
     {}
 
     KisImage *q;
 
     quint32 lockCount = 0;
     bool lockedForReadOnly;
 
     qint32 width;
     qint32 height;
 
     double xres = 1.0;
     double yres = 1.0;
 
     const KoColorSpace * colorSpace;
     KisProofingConfiguration *proofingConfig = 0;
 
     KisSelectionSP deselectedGlobalSelection;
     KisGroupLayerSP rootLayer; // The layers are contained in here
     QList<KisLayer*> dirtyLayers; // for thumbnails
     QList<KisLayerComposition*> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted = false;
 
     KisNameServer nserver;
 
     KisUndoStore *undoStore;
     KisLegacyUndoAdapter legacyUndoAdapter;
     KisPostExecutionUndoAdapter postExecutionUndoAdapter;
 
     KisActionRecorder recorder;
 
     vKisAnnotationSP annotations;
 
     QAtomicInt disableUIUpdateSignals;
     KisProjectionUpdatesFilterSP projectionUpdatesFilter;
     KisImageSignalRouter signalRouter;
     KisImageAnimationInterface *animationInterface;
     KisUpdateScheduler scheduler;
     QAtomicInt disableDirtyRequests;
 
 
     KisCompositeProgressProxy compositeProgressProxy;
 
     bool blockLevelOfDetail = false;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc);
 };
 
 KisImage::KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name)
         : QObject(0)
         , KisShared()
 {
     setObjectName(name);
     // Handle undoStore == 0 and colorSpace == 0 cases
     if (!undoStore) {
         undoStore = new KisDumbUndoStore();
     }
 
     const KoColorSpace *c;
     if (colorSpace != 0) {
         c = colorSpace;
     } else {
         c = KoColorSpaceRegistry::instance()->rgb8();
     }
     m_d = new KisImagePrivate(this, width, height, c, undoStore);
 
 
     {
         KisImageConfig cfg;
         if (cfg.enableProgressReporting()) {
             m_d->scheduler.setProgressProxy(&m_d->compositeProgressProxy);
         }
 
         // Each of these lambdas defines a new factory function.
         m_d->scheduler.setLod0ToNStrokeStrategyFactory(
             [=](bool forgettable) {
                 return KisLodSyncPair(
                     new KisSyncLodCacheStrokeStrategy(KisImageWSP(this), forgettable),
                     KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP(this)));
             });
 
         m_d->scheduler.setSuspendUpdatesStrokeStrategyFactory(
             [=]() {
                 return KisSuspendResumePair(
                     new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(this), true),
                     KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP(this)));
             });
 
         m_d->scheduler.setResumeUpdatesStrokeStrategyFactory(
             [=]() {
                 return KisSuspendResumePair(
                     new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(this), false),
                     KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP(this)));
             });
     }
 
     setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
 
     m_d->animationInterface = new KisImageAnimationInterface(this);
 
     connect(this, SIGNAL(sigImageModified()), KisMemoryStatisticsServer::instance(), SLOT(notifyImageChanged()));
 }
 
 KisImage::~KisImage()
 {
     dbgImage << "deleting kisimage" << objectName();
 
     /**
      * Request the tools to end currently running strokes
      */
     waitForDone();
 
     /**
      * Stop animation interface. It may use the rootLayer.
      */
     delete m_d->animationInterface;
 
     /**
      * First delete the nodes, while strokes
      * and undo are still alive
      */
     m_d->rootLayer = 0;
 
     delete m_d->undoStore;
     delete m_d;
     disconnect(); // in case Qt gets confused
 }
 
 void KisImage::aboutToAddANode(KisNode *parent, int index)
 {
     KisNodeGraphListener::aboutToAddANode(parent, index);
     SANITY_CHECK_LOCKED("aboutToAddANode");
 }
 
 void KisImage::nodeHasBeenAdded(KisNode *parent, int index)
 {
     KisNodeGraphListener::nodeHasBeenAdded(parent, index);
 
     SANITY_CHECK_LOCKED("nodeHasBeenAdded");
     m_d->signalRouter.emitNodeHasBeenAdded(parent, index);
 
     KisNodeSP newNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(newNode.data())) {
         stopIsolatedMode();
     }
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data())) {
         stopIsolatedMode();
     }
 
     KisNodeGraphListener::aboutToRemoveANode(parent, index);
 
     SANITY_CHECK_LOCKED("aboutToRemoveANode");
     m_d->signalRouter.emitAboutToRemoveANode(parent, index);
 }
 
 void KisImage::nodeChanged(KisNode* node)
 {
     KisNodeGraphListener::nodeChanged(node);
     requestStrokeEnd();
     m_d->signalRouter.emitNodeChanged(node);
 }
 
 void KisImage::invalidateAllFrames()
 {
     invalidateFrames(KisTimeRange::infinite(0), QRect());
 }
 
 KisSelectionSP KisImage::globalSelection() const
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
     if (selectionMask) {
         return selectionMask->selection();
     } else {
         return 0;
     }
 }
 
 void KisImage::setGlobalSelection(KisSelectionSP globalSelection)
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
 
     if (!globalSelection) {
         if (selectionMask) {
             removeNode(selectionMask);
         }
     }
     else {
         if (!selectionMask) {
             selectionMask = new KisSelectionMask(this);
             selectionMask->initSelection(m_d->rootLayer);
             addNode(selectionMask);
             // If we do not set the selection now, the setActive call coming next
             // can be very, very expensive, depending on the size of the image.
             selectionMask->setSelection(globalSelection);
             selectionMask->setActive(true);
         }
         else {
             selectionMask->setSelection(globalSelection);
         }
 
         Q_ASSERT(m_d->rootLayer->childCount() > 0);
         Q_ASSERT(m_d->rootLayer->selectionMask());
     }
 
     m_d->deselectedGlobalSelection = 0;
     m_d->legacyUndoAdapter.emitSelectionChanged();
 }
 
 void KisImage::deselectGlobalSelection()
 {
     KisSelectionSP savedSelection = globalSelection();
     setGlobalSelection(0);
     m_d->deselectedGlobalSelection = savedSelection;
 }
 
 bool KisImage::canReselectGlobalSelection()
 {
     return m_d->deselectedGlobalSelection;
 }
 
 void KisImage::reselectGlobalSelection()
 {
     if(m_d->deselectedGlobalSelection) {
         setGlobalSelection(m_d->deselectedGlobalSelection);
     }
 }
 
 QString KisImage::nextLayerName(const QString &_baseName) const
 {
     QString baseName = _baseName;
 
     if (m_d->nserver.currentSeed() == 0) {
         m_d->nserver.number();
         return i18n("background");
     }
 
     if (baseName.isEmpty()) {
         baseName = i18n("Layer");
     }
 
     return QString("%1 %2").arg(baseName).arg(m_d->nserver.number());
 }
 
 void KisImage::rollBackLayerName()
 {
     m_d->nserver.rollback();
 }
 
 KisCompositeProgressProxy* KisImage::compositeProgressProxy()
 {
     return &m_d->compositeProgressProxy;
 }
 
 bool KisImage::locked() const
 {
     return m_d->lockCount != 0;
 }
 
 void KisImage::barrierLock(bool readOnly)
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.barrierLock();
         m_d->lockedForReadOnly = readOnly;
     } else {
         m_d->lockedForReadOnly &= readOnly;
     }
 
     m_d->lockCount++;
 }
 
 bool KisImage::tryBarrierLock(bool readOnly)
 {
     bool result = true;
 
     if (!locked()) {
         result = m_d->scheduler.tryBarrierLock();
         m_d->lockedForReadOnly = readOnly;
     }
 
     if (result) {
         m_d->lockCount++;
         m_d->lockedForReadOnly &= readOnly;
     }
 
     return result;
 }
 
 bool KisImage::isIdle()
 {
     return !locked() && m_d->scheduler.isIdle();
 }
 
 void KisImage::lock()
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.lock();
     }
     m_d->lockCount++;
     m_d->lockedForReadOnly = false;
 }
 
 void KisImage::unlock()
 {
     Q_ASSERT(locked());
 
     if (locked()) {
         m_d->lockCount--;
 
         if (m_d->lockCount == 0) {
             m_d->scheduler.unlock(!m_d->lockedForReadOnly);
         }
     }
 }
 
 void KisImage::blockUpdates()
 {
     m_d->scheduler.blockUpdates();
 }
 
 void KisImage::unblockUpdates()
 {
     m_d->scheduler.unblockUpdates();
 }
 
 void KisImage::setSize(const QSize& size)
 {
     m_d->width = size.width();
     m_d->height = size.height();
 }
 
 void KisImage::resizeImageImpl(const QRect& newRect, bool cropLayers)
 {
     if (newRect == bounds() && !cropLayers) return;
 
     KUndo2MagicString actionName = cropLayers ?
         kundo2_i18n("Crop Image") :
         kundo2_i18n("Resize Image");
 
     KisImageSignalVector emitSignals;
     emitSignals << ComplexSizeChangedSignal(newRect, newRect.size());
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(cropLayers ?
                                   KisCropSavedExtraData::CROP_IMAGE :
                                   KisCropSavedExtraData::RESIZE_IMAGE,
                                   newRect);
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName, extraData);
 
     if (cropLayers || !newRect.topLeft().isNull()) {
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(newRect, cropLayers, true);
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
     applicator.applyCommand(new KisImageResizeCommand(this, newRect.size()));
     applicator.end();
 }
 
 void KisImage::resizeImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, false);
 }
 
 void KisImage::cropImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, true);
 }
 
 
 void KisImage::cropNode(KisNodeSP node, const QRect& newRect)
 {
     bool isLayer = dynamic_cast<KisLayer*>(node.data());
     KUndo2MagicString actionName = isLayer ?
         kundo2_i18n("Crop Layer") :
         kundo2_i18n("Crop Mask");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(KisCropSavedExtraData::CROP_LAYER,
                                   newRect, node);
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName, extraData);
 
     KisProcessingVisitorSP visitor =
         new KisCropProcessingVisitor(newRect, true, false);
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     bool resolutionChanged = xres != xRes() && yres != yRes();
     bool sizeChanged = size != this->size();
 
     if (!resolutionChanged && !sizeChanged) return;
 
     KisImageSignalVector emitSignals;
     if (resolutionChanged) emitSignals << ResolutionChangedSignal;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), size);
     emitSignals << ModifiedSignal;
 
     KUndo2MagicString actionName = sizeChanged ?
         kundo2_i18n("Scale Image") :
         kundo2_i18n("Change Image Resolution");
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         (resolutionChanged || sizeChanged) ?
                 KisProcessingApplicator::NO_UI_UPDATES :
                 KisProcessingApplicator::NONE;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     qreal sx = qreal(size.width()) / this->size().width();
     qreal sy = qreal(size.height()) / this->size().height();
 
     QTransform shapesCorrection;
 
     if (resolutionChanged) {
         shapesCorrection = QTransform::fromScale(xRes() / xres, yRes() / yres);
     }
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(sx, sy,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy,
                                           shapesCorrection);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resolutionChanged) {
         KUndo2Command *parent =
             new KisResetShapesCommand(m_d->rootLayer);
         new KisImageSetResolutionCommand(this, xres, yres, parent);
         applicator.applyCommand(parent);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, size));
     }
 
     applicator.end();
 }
 
 void KisImage::scaleNode(KisNodeSP node, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(scaleX, scaleY,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           bool resizeImage,
                           double radians)
 {
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   0, 0, 0, 0,
                                   radians,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         if (resizeImage) {
             QRect newRect = transform.mapRect(bounds());
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(rootNode->exactBounds()).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != width() || newSize.height() != height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     // These flags determine whether updates are transferred to the UI during processing
     KisProcessingApplicator::ProcessingFlags signalFlags =
         sizeChanged ?
         KisProcessingApplicator::NO_UI_UPDATES :
         KisProcessingApplicator::NONE;
 
 
     KisProcessingApplicator applicator(this, rootNode,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bicubic");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
     applicator.end();
 }
 
 
 void KisImage::rotateImage(double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Image"), root(), true, radians);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Layer"), node, false, radians);
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          const QPointF &origin)
 {
     //angleX, angleY are in degrees
     const qreal pi = 3.1415926535897932385;
     const qreal deg2rad = pi / 180.0;
 
     qreal tanX = tan(angleX * deg2rad);
     qreal tanY = tan(angleY * deg2rad);
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   tanX, tanY, origin.x(), origin.y(),
                                   0,
                                   0, 0, 0, 0);
 
         QRect newRect = worker.transform().mapRect(bounds());
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         KisProcessingApplicator::RECURSIVE;
     if (resizeImage) signalFlags |= KisProcessingApplicator::NO_UI_UPDATES;
 
     KisProcessingApplicator applicator(this, rootNode,
                                        signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bilinear");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY)
 {
     QPointF shearOrigin = QRectF(bounds()).center();
 
     shearImpl(kundo2_i18n("Shear layer"), node, false,
               angleX, angleY, shearOrigin);
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, QPointF());
 }
 
 void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!dstColorSpace) return;
 
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Image Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
 
     KisColorSpaceConvertVisitor visitor(this, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     m_d->rootLayer->accept(visitor);
 
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     const KoColorSpace *srcCs = colorSpace();
 
     if (!dstCs) return false;
 
     m_d->colorSpace = dstCs;
 
     KisChangeProfileVisitor visitor(srcCs, dstCs);
     return m_d->rootLayer->accept(visitor);
 
 }
 
 void KisImage::convertProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     if (*m_d->colorSpace == *dstColorSpace) return;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Projection Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
     m_d->rootLayer->resetCache();
     m_d->signalRouter.emitNotification(ColorSpaceChangedSignal);
 }
 
 const KoColorSpace * KisImage::colorSpace() const
 {
     return m_d->colorSpace;
 }
 
 const KoColorProfile * KisImage::profile() const
 {
     return colorSpace()->profile();
 }
 
 double KisImage::xRes() const
 {
     return m_d->xres;
 }
 
 double KisImage::yRes() const
 {
     return m_d->yres;
 }
 
 void KisImage::setResolution(double xres, double yres)
 {
     m_d->xres = xres;
     m_d->yres = yres;
     m_d->signalRouter.emitNotification(ResolutionChangedSignal);
 }
 
 QPointF KisImage::documentToPixel(const QPointF &documentCoord) const
 {
     return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
 }
 
 QPoint KisImage::documentToIntPixel(const QPointF &documentCoord) const
 {
     QPointF pixelCoord = documentToPixel(documentCoord);
     return QPoint((int)pixelCoord.x(), (int)pixelCoord.y());
 }
 
 QRectF KisImage::documentToPixel(const QRectF &documentRect) const
 {
     return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
 }
 
 QRect KisImage::documentToIntPixel(const QRectF &documentRect) const
 {
     return documentToPixel(documentRect).toAlignedRect();
 }
 
 QPointF KisImage::pixelToDocument(const QPointF &pixelCoord) const
 {
     return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
 }
 
 QPointF KisImage::pixelToDocument(const QPoint &pixelCoord) const
 {
     return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
 }
 
 QRectF KisImage::pixelToDocument(const QRectF &pixelCoord) const
 {
     return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
 }
 
 qint32 KisImage::width() const
 {
     return m_d->width;
 }
 
 qint32 KisImage::height() const
 {
     return m_d->height;
 }
 
 KisGroupLayerSP KisImage::rootLayer() const
 {
     Q_ASSERT(m_d->rootLayer);
     return m_d->rootLayer;
 }
 
 KisPaintDeviceSP KisImage::projection() const
 {
     if (m_d->isolatedRootNode) {
         return m_d->isolatedRootNode->projection();
     }
 
 
     Q_ASSERT(m_d->rootLayer);
     KisPaintDeviceSP projection = m_d->rootLayer->projection();
     Q_ASSERT(projection);
     return projection;
 }
 
 qint32 KisImage::nlayers() const
 {
     QStringList list;
     list << "KisLayer";
 
     KisCountVisitor visitor(list, KoProperties());
     m_d->rootLayer->accept(visitor);
     return visitor.count();
 }
 
 qint32 KisImage::nHiddenLayers() const
 {
     QStringList list;
     list << "KisLayer";
     KoProperties properties;
     properties.setProperty("visible", false);
     KisCountVisitor visitor(list, properties);
     m_d->rootLayer->accept(visitor);
 
     return visitor.count();
 }
 
 void KisImage::flatten()
 {
     KisLayerUtils::flattenImage(this);
 }
 
 void KisImage::mergeMultipleLayers(QList<KisNodeSP> mergedNodes, KisNodeSP putAfter)
 {
     if (!KisLayerUtils::tryMergeSelectionMasks(this, mergedNodes, putAfter)) {
         KisLayerUtils::mergeMultipleLayers(this, mergedNodes, putAfter);
     }
 }
 
 void KisImage::mergeDown(KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
 {
     KisLayerUtils::mergeDown(this, layer, strategy);
 }
 
 void KisImage::flattenLayer(KisLayerSP layer)
 {
     KisLayerUtils::flattenLayer(this, layer);
 }
 
 
 void KisImage::setModified()
 {
     m_d->signalRouter.emitNotification(ModifiedSignal);
 }
 
 QImage KisImage::convertToQImage(QRect imageRect,
                                  const KoColorProfile * profile)
 {
     qint32 x;
     qint32 y;
     qint32 w;
     qint32 h;
     imageRect.getRect(&x, &y, &w, &h);
     return convertToQImage(x, y, w, h, profile);
 }
 
 QImage KisImage::convertToQImage(qint32 x,
                                  qint32 y,
                                  qint32 w,
                                  qint32 h,
                                  const KoColorProfile * profile)
 {
     KisPaintDeviceSP dev = projection();
     if (!dev) return QImage();
     QImage image = dev->convertToQImage(const_cast<KoColorProfile*>(profile), x, y, w, h,
                                         KoColorConversionTransformation::internalRenderingIntent(),
                                         KoColorConversionTransformation::internalConversionFlags());
 
     return image;
 }
 
 
 
 QImage KisImage::convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile)
 {
     if (scaledImageSize.isEmpty()) {
         return QImage();
     }
 
     KisPaintDeviceSP dev = new KisPaintDevice(colorSpace());
     KisPainter gc;
     gc.copyAreaOptimized(QPoint(0, 0), projection(), dev, bounds());
     gc.end();
     double scaleX = qreal(scaledImageSize.width()) / width();
     double scaleY = qreal(scaledImageSize.height()) / height();
 
     QPointer<KoUpdater> updater = new KoDummyUpdater();
 
     KisTransformWorker worker(dev, scaleX, scaleY, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, updater, KisFilterStrategyRegistry::instance()->value("Bicubic"));
     worker.run();
 
     delete updater;
 
     return dev->convertToQImage(profile);
 }
 void KisImage::notifyLayersChanged()
 {
     m_d->signalRouter.emitNotification(LayersChangedSignal);
 }
 
 QRect KisImage::bounds() const
 {
     return QRect(0, 0, width(), height());
 }
 
 QRect KisImage::effectiveLodBounds() const
 {
     QRect boundRect = bounds();
 
     const int lod = currentLevelOfDetail();
     if (lod > 0) {
         KisLodTransform t(lod);
         boundRect = t.map(boundRect);
     }
 
     return boundRect;
 }
 
 KisPostExecutionUndoAdapter* KisImage::postExecutionUndoAdapter() const
 {
     return &m_d->postExecutionUndoAdapter;
 }
 
 void KisImage::setUndoStore(KisUndoStore *undoStore)
 {
 
     m_d->legacyUndoAdapter.setUndoStore(undoStore);
     m_d->postExecutionUndoAdapter.setUndoStore(undoStore);
     delete m_d->undoStore;
     m_d->undoStore = undoStore;
 }
 
 KisUndoStore* KisImage::undoStore()
 {
     return m_d->undoStore;
 }
 
 KisUndoAdapter* KisImage::undoAdapter() const
 {
     return &m_d->legacyUndoAdapter;
 }
 
 KisActionRecorder* KisImage::actionRecorder() const
 {
     return &m_d->recorder;
 }
 
 void KisImage::setDefaultProjectionColor(const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->rootLayer);
     m_d->rootLayer->setDefaultProjectionColor(color);
 }
 
 KoColor KisImage::defaultProjectionColor() const
 {
     KIS_ASSERT_RECOVER(m_d->rootLayer) {
         return KoColor(Qt::transparent, m_d->colorSpace);
     }
 
     return m_d->rootLayer->defaultProjectionColor();
 }
 
 void KisImage::setRootLayer(KisGroupLayerSP rootLayer)
 {
     stopIsolatedMode();
 
     KoColor defaultProjectionColor(Qt::transparent, m_d->colorSpace);
 
     if (m_d->rootLayer) {
         m_d->rootLayer->setGraphListener(0);
         m_d->rootLayer->disconnect();
 
         KisPaintDeviceSP original = m_d->rootLayer->original();
         defaultProjectionColor.setColor(original->defaultPixel(), original->colorSpace());
     }
 
     m_d->rootLayer = rootLayer;
     m_d->rootLayer->disconnect();
     m_d->rootLayer->setGraphListener(this);
 
     KisPaintDeviceSP newOriginal = m_d->rootLayer->original();
     defaultProjectionColor.convertTo(newOriginal->colorSpace());
     newOriginal->setDefaultPixel(defaultProjectionColor.data());
 
     setRoot(m_d->rootLayer.data());
 }
 
 void KisImage::addAnnotation(KisAnnotationSP annotation)
 {
     // Find the icc annotation, if there is one
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == annotation->type()) {
             *it = annotation;
             return;
         }
         ++it;
     }
     m_d->annotations.push_back(annotation);
 }
 
 KisAnnotationSP KisImage::annotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             return *it;
         }
         ++it;
     }
     return KisAnnotationSP(0);
 }
 
 void KisImage::removeAnnotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             m_d->annotations.erase(it);
             return;
         }
         ++it;
     }
 }
 
 vKisAnnotationSP_it KisImage::beginAnnotations()
 {
     return m_d->annotations.begin();
 }
 
 vKisAnnotationSP_it KisImage::endAnnotations()
 {
     return m_d->annotations.end();
 }
 
 void KisImage::notifyAboutToBeDeleted()
 {
     emit sigAboutToBeDeleted();
 }
 
 KisImageSignalRouter* KisImage::signalRouter()
 {
     return &m_d->signalRouter;
 }
 
 void KisImage::waitForDone()
 {
     requestStrokeEnd();
     m_d->scheduler.waitForDone();
 }
 
 KisStrokeId KisImage::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     /**
      * Ask open strokes to end gracefully. All the strokes clients
      * (including the one calling this method right now) will get
      * a notification that they should probably end their strokes.
      * However this is purely their choice whether to end a stroke
      * or not.
      */
     if (strokeStrategy->requestsOtherStrokesToEnd()) {
         requestStrokeEnd();
     }
 
     /**
      * Some of the strokes can cancel their work with undoing all the
      * changes they did to the paint devices. The problem is that undo
      * stack will know nothing about it. Therefore, just notify it
      * explicitly
      */
     if (strokeStrategy->clearsRedoOnStart()) {
         m_d->undoStore->purgeRedoState();
     }
 
     return m_d->scheduler.startStroke(strokeStrategy);
 }
 
 void KisImage::KisImagePrivate::notifyProjectionUpdatedInPatches(const QRect &rc)
 {
     KisImageConfig imageConfig;
     int patchWidth = imageConfig.updatePatchWidth();
     int patchHeight = imageConfig.updatePatchHeight();
 
     for (int y = 0; y < rc.height(); y += patchHeight) {
         for (int x = 0; x < rc.width(); x += patchWidth) {
             QRect patchRect(x, y, patchWidth, patchHeight);
             patchRect &= rc;
 
             QtConcurrent::run(std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
     if (!tryBarrierLock()) return false;
 
     unlock();
 
     m_d->isolatedRootNode = node;
     emit sigIsolatedModeChanged();
 
     // the GUI uses our thread to do the color space conversion so we
     // need to emit this signal in multiple threads
     m_d->notifyProjectionUpdatedInPatches(bounds());
 
     invalidateAllFrames();
     return true;
 }
 
 void KisImage::stopIsolatedMode()
 {
     if (!m_d->isolatedRootNode)  return;
 
     KisNodeSP oldRootNode = m_d->isolatedRootNode;
     m_d->isolatedRootNode = 0;
 
     emit sigIsolatedModeChanged();
 
     // the GUI uses our thread to do the color space conversion so we
     // need to emit this signal in multiple threads
     m_d->notifyProjectionUpdatedInPatches(bounds());
     invalidateAllFrames();
 
     // TODO: Substitute notifyProjectionUpdated() with this code
     // when update optimization is implemented
     //
     // QRect updateRect = bounds() | oldRootNode->extent();
     // oldRootNode->setDirty(updateRect);
 }
 
 KisNodeSP KisImage::isolatedModeRoot() const
 {
     return m_d->isolatedRootNode;
 }
 
 void KisImage::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     KisUpdateTimeMonitor::instance()->reportJobStarted(data);
     m_d->scheduler.addJob(id, data);
 }
 
 void KisImage::endStroke(KisStrokeId id)
 {
     m_d->scheduler.endStroke(id);
 }
 
 bool KisImage::cancelStroke(KisStrokeId id)
 {
     return m_d->scheduler.cancelStroke(id);
 }
 
 bool KisImage::KisImagePrivate::tryCancelCurrentStrokeAsync()
 {
     return scheduler.tryCancelCurrentStrokeAsync();
 }
 
 void KisImage::requestUndoDuringStroke()
 {
     emit sigUndoDuringStrokeRequested();
 }
 
 void KisImage::requestStrokeCancellation()
 {
     if (!m_d->tryCancelCurrentStrokeAsync()) {
         emit sigStrokeCancellationRequested();
     }
 }
 
 void KisImage::requestStrokeEnd()
 {
     emit sigStrokeEndRequested();
     emit sigStrokeEndRequestedActiveNodeFiltered();
 }
 
 void KisImage::requestStrokeEndActiveNode()
 {
     emit sigStrokeEndRequested();
 }
 
 void KisImage::refreshGraph(KisNodeSP root)
 {
     refreshGraph(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraph(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefresh(root, rc, cropRect);
 }
 
 void KisImage::initialRefreshGraph()
 {
     /**
      * NOTE: Tricky part. We set crop rect to null, so the clones
      * will not rely on precalculated projections of their sources
      */
 
     refreshGraphAsync(0, bounds(), QRect());
     waitForDone();
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root)
 {
     refreshGraphAsync(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc)
 {
     refreshGraphAsync(root, rc, bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefreshAsync(root, rc, cropRect);
 }
 
 void KisImage::requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect)
 {
     KIS_ASSERT_RECOVER_RETURN(pseudoFilthy);
 
     m_d->animationInterface->notifyNodeChanged(pseudoFilthy.data(), rc, false);
     m_d->scheduler.updateProjectionNoFilthy(pseudoFilthy, rc, cropRect);
 }
 
 void KisImage::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_d->scheduler.addSpontaneousJob(spontaneousJob);
 }
 
 void KisImage::setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter)
 {
     // udpate filters are *not* recursive!
     KIS_ASSERT_RECOVER_NOOP(!filter || !m_d->projectionUpdatesFilter);
 
     m_d->projectionUpdatesFilter = filter;
 }
 
 KisProjectionUpdatesFilterSP KisImage::projectionUpdatesFilter() const
 {
     return m_d->projectionUpdatesFilter;
 }
 
 void KisImage::disableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP(new KisDropAllProjectionUpdatesFilter()));
 }
 
 void KisImage::enableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
 }
 
 void KisImage::disableUIUpdates()
 {
     m_d->disableUIUpdateSignals.ref();
 }
 
 void KisImage::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
 }
 
 void KisImage::notifyProjectionUpdated(const QRect &rc)
 {
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(rc);
 
     if (!m_d->disableUIUpdateSignals) {
         int lod = currentLevelOfDetail();
         QRect dirtyRect = !lod ? rc : KisLodTransform::upscaledRect(rc, lod);
 
         if (dirtyRect.isEmpty()) return;
 
         emit sigImageUpdated(dirtyRect);
     }
 }
 
 void KisImage::notifySelectionChanged()
 {
     /**
      * The selection is calculated asynchromously, so it is not
      * handled by disableUIUpdates() and other special signals of
      * KisImageSignalRouter
      */
     m_d->legacyUndoAdapter.emitSelectionChanged();
 
     /**
      * Editing of selection masks doesn't necessary produce a
      * setDirty() call, so in the end of the stroke we need to request
      * direct update of the UI's cache.
      */
     if (m_d->isolatedRootNode &&
         dynamic_cast<KisSelectionMask*>(m_d->isolatedRootNode.data())) {
 
         notifyProjectionUpdated(bounds());
     }
 }
 
 void KisImage::requestProjectionUpdateImpl(KisNode *node,
                                            const QRect &rect,
                                            const QRect &cropRect)
 {
     if (rect.isEmpty()) return;
 
     KisNodeGraphListener::requestProjectionUpdate(node, rect);
     m_d->scheduler.updateProjection(node, rect, cropRect);
 }
 
 void KisImage::requestProjectionUpdate(KisNode *node, const QRect& rect)
 {
     if (m_d->projectionUpdatesFilter
         && m_d->projectionUpdatesFilter->filter(this, node, rect)) {
 
         return;
     }
 
     m_d->animationInterface->notifyNodeChanged(node, rect, false);
 
     /**
      * Here we use 'permitted' instead of 'active' intentively,
      * because the updates may come after the actual stroke has been
      * finished. And having some more updates for the stroke not
      * supporting the wrap-around mode will not make much harm.
      */
     if (m_d->wrapAroundModePermitted) {
         const QRect boundRect = effectiveLodBounds();
         KisWrappedRect splitRect(rect, boundRect);
 
         Q_FOREACH (const QRect &rc, splitRect) {
             requestProjectionUpdateImpl(node, rc, boundRect);
         }
     } else {
         requestProjectionUpdateImpl(node, rect, bounds());
     }
 }
 
 void KisImage::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->animationInterface->invalidateFrames(range, rect);
 }
 
 void KisImage::requestTimeSwitch(int time)
 {
     m_d->animationInterface->requestTimeSwitchNonGUI(time);
 }
 
 QList<KisLayerComposition*> KisImage::compositions()
 {
     return m_d->compositions;
 }
 
 void KisImage::addComposition(KisLayerComposition* composition)
 {
     m_d->compositions.append(composition);
 }
 
 void KisImage::removeComposition(KisLayerComposition* composition)
 {
     m_d->compositions.removeAll(composition);
     delete composition;
 }
 
 bool checkMasksNeedConversion(KisNodeSP root, const QRect &bounds)
 {
     KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(root.data());
     if (mask &&
         (!bounds.contains(mask->paintDevice()->exactBounds()) ||
          mask->selection()->hasShapeSelection())) {
 
         return true;
     }
 
     KisNodeSP node = root->firstChild();
 
     while (node) {
         if (checkMasksNeedConversion(node, bounds)) {
             return true;
         }
 
         node = node->nextSibling();
     }
 
     return false;
 }
 
 void KisImage::setWrapAroundModePermitted(bool value)
 {
     m_d->wrapAroundModePermitted = value;
 
     if (m_d->wrapAroundModePermitted &&
         checkMasksNeedConversion(root(), bounds())) {
 
         KisProcessingApplicator applicator(this, root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Crop Selections"));
 
         KisProcessingVisitorSP visitor =
             new KisCropSelectionsProcessingVisitor(bounds());
 
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
         applicator.end();
     }
 }
 
 bool KisImage::wrapAroundModePermitted() const
 {
     return m_d->wrapAroundModePermitted;
 }
 
 bool KisImage::wrapAroundModeActive() const
 {
     return m_d->wrapAroundModePermitted &&
         m_d->scheduler.wrapAroundModeSupported();
 }
 
 void KisImage::setDesiredLevelOfDetail(int lod)
 {
     if (m_d->blockLevelOfDetail) {
         qWarning() << "WARNING: KisImage::setDesiredLevelOfDetail()"
                    << "was called while LoD functionality was being blocked!";
         return;
     }
 
     m_d->scheduler.setDesiredLevelOfDetail(lod);
 }
 
 int KisImage::currentLevelOfDetail() const
 {
     if (m_d->blockLevelOfDetail) {
         return 0;
     }
 
     return m_d->scheduler.currentLevelOfDetail();
 }
 
 void KisImage::setLevelOfDetailBlocked(bool value)
 {
     KisImageBarrierLockerRaw l(this);
 
     if (value && !m_d->blockLevelOfDetail) {
         m_d->scheduler.setDesiredLevelOfDetail(0);
     }
 
     m_d->blockLevelOfDetail = value;
 }
 
 void KisImage::explicitRegenerateLevelOfDetail()
 {
     if (!m_d->blockLevelOfDetail) {
         m_d->scheduler.explicitRegenerateLevelOfDetail();
     }
 }
 
 bool KisImage::levelOfDetailBlocked() const
 {
     return m_d->blockLevelOfDetail;
 }
 
 void KisImage::notifyNodeCollpasedChanged()
 {
     emit sigNodeCollapsedChanged();
 }
 
 KisImageAnimationInterface* KisImage::animationInterface() const
 {
     return m_d->animationInterface;
 }
 
 void KisImage::setProofingConfiguration(KisProofingConfiguration *proofingConfig)
 {
     m_d->proofingConfig = proofingConfig;
     emit sigProofingConfigChanged();
 }
 
 KisProofingConfiguration *KisImage::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
-        qDebug()<<"Image: No proofing config found, generating one.";
         m_d->proofingConfig = new KisProofingConfiguration();
     }
     return m_d->proofingConfig;
 }
diff --git a/libs/pigment/KoColorSpace.cpp b/libs/pigment/KoColorSpace.cpp
index 4882de91e9..c0a47de633 100644
--- a/libs/pigment/KoColorSpace.cpp
+++ b/libs/pigment/KoColorSpace.cpp
@@ -1,819 +1,818 @@
 /*
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoColorSpace.h"
 #include "KoColorSpace_p.h"
 
 #include "KoChannelInfo.h"
 #include "DebugPigment.h"
 #include "KoCompositeOp.h"
 #include "KoColorTransformation.h"
 #include "KoColorTransformationFactory.h"
 #include "KoColorTransformationFactoryRegistry.h"
 #include "KoColorConversionCache.h"
 #include "KoColorConversionSystem.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 #include "KoCopyColorConversionTransformation.h"
 #include "KoFallBackColorTransformation.h"
 #include "KoUniqueNumberForIdServer.h"
 #include "KoMixColorsOp.h"
 #include "KoConvolutionOp.h"
 #include "KoCompositeOpRegistry.h"
 #include "KoColorSpaceEngine.h"
 
 #include <QThreadStorage>
 #include <QByteArray>
 #include <QBitArray>
 #include <QPolygonF>
 #include <QPointF>
 
 #include <math.h>
 
 KoColorSpace::KoColorSpace()
         : d(new Private())
 {
 }
 
 KoColorSpace::KoColorSpace(const QString &id, const QString &name, KoMixColorsOp* mixColorsOp, KoConvolutionOp* convolutionOp)
         : d(new Private())
 {
     d->id = id;
     d->idNumber = KoUniqueNumberForIdServer::instance()->numberForId(d->id);
     d->name = name;
     d->mixColorsOp = mixColorsOp;
     d->convolutionOp = convolutionOp;
     d->transfoToRGBA16 = 0;
     d->transfoFromRGBA16 = 0;
     d->transfoToLABA16 = 0;
     d->transfoFromLABA16 = 0;
     d->gamutXYY = QPolygonF();
     d->TRCXYY = QPolygonF();
     d->colorants = QVector <qreal> (0);
     d->lumaCoefficients = QVector <qreal> (0);
     d->iccEngine = 0;
     d->deletability = NotOwnedByRegistry;
 }
 
 KoColorSpace::~KoColorSpace()
 {
     Q_ASSERT(d->deletability != OwnedByRegistryDoNotDelete);
 
     qDeleteAll(d->compositeOps);
     Q_FOREACH (KoChannelInfo * channel, d->channels) {
         delete channel;
     }
     if (d->deletability == NotOwnedByRegistry) {
         KoColorConversionCache* cache = KoColorSpaceRegistry::instance()->colorConversionCache();
         if (cache) {
             cache->colorSpaceIsDestroyed(this);
         }
     }
     delete d->mixColorsOp;
     delete d->convolutionOp;
     delete d->transfoToRGBA16;
     delete d->transfoFromRGBA16;
     delete d->transfoToLABA16;
     delete d->transfoFromLABA16;
     delete d;
 }
 
 bool KoColorSpace::operator==(const KoColorSpace& rhs) const
 {
     const KoColorProfile* p1 = rhs.profile();
     const KoColorProfile* p2 = profile();
     return d->idNumber == rhs.d->idNumber && ((p1 == p2) || (*p1 == *p2));
 }
 
 QString KoColorSpace::id() const
 {
     return d->id;
 }
 
 QString KoColorSpace::name() const
 {
     return d->name;
 }
 
 //Color space info stuff.
 QPolygonF KoColorSpace::gamutXYY() const
 {
     if (d->gamutXYY.empty()) {
         //now, let's decide on the boundary. This is a bit tricky because icc profiles can be both matrix-shaper and cLUT at once if the maker so pleases.
         //first make a list of colors.
         qreal max = 1.0;
         if ((colorModelId().id()=="CMYKA" || colorModelId().id()=="LABA") && colorDepthId().id()=="F32") {
             //boundaries for cmyka/laba have trouble getting the max values for Float, and are pretty awkward in general.
             max = this->channels()[0]->getUIMax();
 
         }
         int samples = 5;//amount of samples in our color space.
         QString name = KoColorSpaceRegistry::instance()->colorSpaceFactory("XYZAF32")->defaultProfile();
         const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F32", name);
         quint8 *data = new quint8[pixelSize()];
         quint8 data2[16]; // xyza f32 is 4 floats, that is 16 bytes per pixel.
         //QVector <qreal> sampleCoordinates(pow(colorChannelCount(),samples));
         //sampleCoordinates.fill(0.0);
 
         // This is fixed to 5 since the maximum number of channels are 5 for CMYKA
         QVector <float> channelValuesF(5);//for getting the coordinates.
 
         for(int x=0;x<samples;x++){
             if (colorChannelCount()==1) {//gray
                 channelValuesF[0]=(max/(samples-1))*(x);
                 channelValuesF[1]=max;
                 fromNormalisedChannelsValue(data, channelValuesF);
                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric, KoColorConversionTransformation::adjustmentConversionFlags());
                 xyzColorSpace->normalisedChannelsValue(data2, channelValuesF);
                 qreal x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                 qreal y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                 d->gamutXYY << QPointF(x,y);
             } else {
                 for(int y=0;y<samples;y++){
                     for(int z=0;z<samples;z++){
                         if (colorChannelCount()==4) {
                             for(int k=0;k<samples;k++){
                                 channelValuesF[0] = (max / (samples - 1)) * (x);
                                 channelValuesF[1] = (max / (samples - 1)) * (y);
                                 channelValuesF[2] = (max / (samples - 1)) * (z);
                                 channelValuesF[3] = (max / (samples - 1)) * (k);
                                 channelValuesF[4] = max;
                                 fromNormalisedChannelsValue(data, channelValuesF);
                                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric, KoColorConversionTransformation::adjustmentConversionFlags());
                                 xyzColorSpace->normalisedChannelsValue(data2, channelValuesF);
                                 qreal x = channelValuesF[0] / (channelValuesF[0] + channelValuesF[1] + channelValuesF[2]);
                                 qreal y = channelValuesF[1] / (channelValuesF[0] + channelValuesF[1] + channelValuesF[2]);
                                 d->gamutXYY<< QPointF(x,y);
                             }
                         } else {
                             channelValuesF[0]=(max/(samples-1))*(x);
                             channelValuesF[1]=(max/(samples-1))*(y);
                             channelValuesF[2]=(max/(samples-1))*(z);
                             channelValuesF[3]=max;
                             if (colorModelId().id()!="XYZA") { //no need for conversion when using xyz.
                                 fromNormalisedChannelsValue(data, channelValuesF);
                                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
                                 xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
                             }
                             qreal x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             qreal y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->gamutXYY<< QPointF(x,y);
                         }
                     }
                 }
 
             }
         }
         delete[] data;
         //if we ever implement a boundary-checking thing I'd add it here.
         return d->gamutXYY;
     } else {
         return d->gamutXYY;
     }
 }
 
 QPolygonF KoColorSpace::estimatedTRCXYY() const
 {
     if (d->TRCXYY.empty()){
         qreal max = 1.0;
         if ((colorModelId().id()=="CMYKA" || colorModelId().id()=="LABA") && colorDepthId().id()=="F32") {
             //boundaries for cmyka/laba have trouble getting the max values for Float, and are pretty awkward in general.
             max = this->channels()[0]->getUIMax();
         }
         QString name = KoColorSpaceRegistry::instance()->colorSpaceFactory("XYZAF16")->defaultProfile();
         const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F16", name);
         quint8 *data = new quint8[pixelSize()];
         quint8 data2[8]; // xyza is 8 bytes per pixel.
 
         // This is fixed to 5 since the maximum number of channels are 5 for CMYKA
         QVector <float> channelValuesF(5);//for getting the coordinates.
 
         for (quint32 i=0; i<colorChannelCount(); i++) {
             qreal colorantY=1.0;
             if (colorModelId().id()!="CMYKA") {
                 for (int j=5; j>0; j--){
                     channelValuesF.fill(0.0);
                     channelValuesF[i] = ((max/4)*(5-j));
 
                     if (colorModelId().id()!="XYZA") { //no need for conversion when using xyz.
                         fromNormalisedChannelsValue(data, channelValuesF);
                         convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
                         xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
                     }
 
                     if (j==0) {
                         colorantY = channelValuesF[1];
                         if (d->colorants.size()<2){
                             d->colorants.resize(3*colorChannelCount());
                             d->colorants[i]  = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+1]= channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+2]= channelValuesF[1];
                         }
                     }
                     d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/4)*(5-j)));
                 }
             } else {
                 for (int j=0; j<5; j++){
                     channelValuesF.fill(0.0);
                     channelValuesF[i] = ((max/4)*(j));
 
                     fromNormalisedChannelsValue(data, channelValuesF);
 
                     convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
 
                     xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
 
                     if (j==0) {
                         colorantY = channelValuesF[1];
                         if (d->colorants.size()<2){
                             d->colorants.resize(3*colorChannelCount());
                             d->colorants[i]  = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+1]= channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+2]= channelValuesF[1];
                         }
                     }
                     d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/4)*(j)));
                 }
             }
         }
 
         delete[] data;
         return d->TRCXYY;
     } else {
         return d->TRCXYY;
     }
 }
 
 QVector <qreal> KoColorSpace::colorants() const
 {
     if (d->colorants.size()>1){
         return d->colorants;
     } else if (profile() && profile()->hasColorants()) {
         d->colorants.resize(3*colorChannelCount());
         d->colorants = profile()->getColorantsxyY();
         return d->colorants;
     } else {
         estimatedTRCXYY();
         return d->colorants;
     }
 }
 QVector <qreal> KoColorSpace::lumaCoefficients() const
 {
     if (d->lumaCoefficients.size()>1){
         return d->lumaCoefficients;
     } else {
         d->lumaCoefficients.resize(3);
         if (colorModelId().id()!="RGBA") {
             d->lumaCoefficients.fill(0.33);
         } else {
             colorants();
             if (d->colorants[2]<0 || d->colorants[5]<0 || d->colorants[8]<0) {
                 d->lumaCoefficients[0]=0.2126;
                 d->lumaCoefficients[1]=0.7152;
                 d->lumaCoefficients[2]=0.0722;
             } else {
                 d->lumaCoefficients[0]=d->colorants[2];
                 d->lumaCoefficients[1]=d->colorants[5];
                 d->lumaCoefficients[2]=d->colorants[8];
             }
         }
         return d->lumaCoefficients;
     }
 }
 
 QList<KoChannelInfo *> KoColorSpace::channels() const
 {
     return d->channels;
 }
 
 QBitArray KoColorSpace::channelFlags(bool color, bool alpha) const
 {
     QBitArray ba(d->channels.size());
     if (!color && !alpha) return ba;
 
     for (int i = 0; i < d->channels.size(); ++i) {
         KoChannelInfo * channel = d->channels.at(i);
         if ((color && channel->channelType() == KoChannelInfo::COLOR) ||
                 (alpha && channel->channelType() == KoChannelInfo::ALPHA))
             ba.setBit(i, true);
     }
     return ba;
 }
 
 void KoColorSpace::addChannel(KoChannelInfo * ci)
 {
     d->channels.push_back(ci);
 }
 bool KoColorSpace::hasCompositeOp(const QString& id) const
 {
     return d->compositeOps.contains(id);
 }
 
 QList<KoCompositeOp*> KoColorSpace::compositeOps() const
 {
     return d->compositeOps.values();
 }
 
 KoMixColorsOp* KoColorSpace::mixColorsOp() const
 {
     return d->mixColorsOp;
 }
 
 
 KoConvolutionOp* KoColorSpace::convolutionOp() const
 {
     return d->convolutionOp;
 }
 
 const KoCompositeOp * KoColorSpace::compositeOp(const QString & id) const
 {
     const QHash<QString, KoCompositeOp*>::ConstIterator it = d->compositeOps.constFind(id);
     if (it != d->compositeOps.constEnd()) {
         return it.value();
     }
     else {
         warnPigment << "Asking for non-existent composite operation " << id << ", returning " << COMPOSITE_OVER;
         return d->compositeOps.value(COMPOSITE_OVER);
     }
 }
 
 void KoColorSpace::addCompositeOp(const KoCompositeOp * op)
 {
     if (op->colorSpace()->id() == id()) {
         d->compositeOps.insert(op->id(), const_cast<KoCompositeOp*>(op));
     }
 }
 
 const KoColorConversionTransformation* KoColorSpace::toLabA16Converter() const
 {
     if (!d->transfoToLABA16) {
         d->transfoToLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->lab16(""), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoToLABA16;
 }
 
 const KoColorConversionTransformation* KoColorSpace::fromLabA16Converter() const
 {
     if (!d->transfoFromLABA16) {
         d->transfoFromLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->lab16(""), this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoFromLABA16;
 }
 const KoColorConversionTransformation* KoColorSpace::toRgbA16Converter() const
 {
     if (!d->transfoToRGBA16) {
         d->transfoToRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->rgb16(""), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoToRGBA16;
 }
 const KoColorConversionTransformation* KoColorSpace::fromRgbA16Converter() const
 {
     if (!d->transfoFromRGBA16) {
         d->transfoFromRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->rgb16("") , this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoFromRGBA16;
 }
 
 void KoColorSpace::toLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     toLabA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::fromLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     fromLabA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::toRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     toRgbA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::fromRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     fromRgbA16Converter()->transform(src, dst, nPixels);
 }
 
 KoColorConversionTransformation* KoColorSpace::createColorConverter(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     if (*this == *dstColorSpace) {
         return new KoCopyColorConversionTransformation(this);
     } else {
         return KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, dstColorSpace, renderingIntent, conversionFlags);
     }
 }
 
 bool KoColorSpace::convertPixelsTo(const quint8 * src,
                                    quint8 * dst,
                                    const KoColorSpace * dstColorSpace,
                                    quint32 numPixels,
                                    KoColorConversionTransformation::Intent renderingIntent,
                                    KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     if (*this == *dstColorSpace) {
         if (src != dst) {
             memcpy(dst, src, numPixels * sizeof(quint8) * pixelSize());
         }
     } else {
         KoCachedColorConversionTransformation cct = KoColorSpaceRegistry::instance()->colorConversionCache()->cachedConverter(this, dstColorSpace, renderingIntent, conversionFlags);
         cct.transformation()->transform(src, dst, numPixels);
     }
     return true;
 }
 
 KoColorConversionTransformation * KoColorSpace::createProofingTransform(const KoColorSpace *dstColorSpace, const KoColorSpace *proofingSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::Intent proofingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, quint8 *gamutWarning) const
 {
     if (!d->iccEngine) {
         d->iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
-        qDebug() << ">>>>>>>>>>>>>>>>>>>> we got a proofing engine";
     }
     if (!d->iccEngine) return false;
 
     return d->iccEngine->createColorProofingTransformation(this, dstColorSpace, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning);
 }
 
 bool KoColorSpace::proofPixelsTo(const quint8 *src,
                                  quint8 *dst,
                                  quint32 numPixels,
                                  KoColorConversionTransformation *proofingTransform) const
 {
     proofingTransform->transform(src, dst, numPixels);
 
     //the transform is deleted in the destructor.
     return true;
 }
 
 void KoColorSpace::bitBlt(const KoColorSpace* srcSpace, const KoCompositeOp::ParameterInfo& params, const KoCompositeOp* op,
                           KoColorConversionTransformation::Intent renderingIntent,
                           KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     Q_ASSERT_X(*op->colorSpace() == *this, "KoColorSpace::bitBlt", QString("Composite op is for color space %1 (%2) while this is %3 (%4)").arg(op->colorSpace()->id()).arg(op->colorSpace()->profile()->name()).arg(id()).arg(profile()->name()).toLatin1());
 
     if(params.rows <= 0 || params.cols <= 0)
         return;
 
     if(!(*this == *srcSpace)) {
          if (preferCompositionInSourceColorSpace() &&
              srcSpace->hasCompositeOp(op->id())) {
 
              quint32           conversionDstBufferStride = params.cols * srcSpace->pixelSize();
              QVector<quint8> * conversionDstCache        = threadLocalConversionCache(params.rows * conversionDstBufferStride);
              quint8*           conversionDstData         = conversionDstCache->data();
 
              for(qint32 row=0; row<params.rows; row++) {
                  convertPixelsTo(params.dstRowStart + row * params.dstRowStride,
                                  conversionDstData  + row * conversionDstBufferStride, srcSpace, params.cols,
                                  renderingIntent, conversionFlags);
              }
 
              // FIXME: do not calculate the otherOp every time
              const KoCompositeOp *otherOp = srcSpace->compositeOp(op->id());
 
              KoCompositeOp::ParameterInfo paramInfo(params);
              paramInfo.dstRowStart  = conversionDstData;
              paramInfo.dstRowStride = conversionDstBufferStride;
              otherOp->composite(paramInfo);
 
              for(qint32 row=0; row<params.rows; row++) {
                  srcSpace->convertPixelsTo(conversionDstData  + row * conversionDstBufferStride,
                                            params.dstRowStart + row * params.dstRowStride, this, params.cols,
                                            renderingIntent, conversionFlags);
              }
 
         } else {
             quint32           conversionBufferStride = params.cols * pixelSize();
             QVector<quint8> * conversionCache        = threadLocalConversionCache(params.rows * conversionBufferStride);
             quint8*           conversionData         = conversionCache->data();
 
             for(qint32 row=0; row<params.rows; row++) {
                 srcSpace->convertPixelsTo(params.srcRowStart + row * params.srcRowStride,
                                           conversionData     + row * conversionBufferStride, this, params.cols,
                                           renderingIntent, conversionFlags);
             }
 
             KoCompositeOp::ParameterInfo paramInfo(params);
             paramInfo.srcRowStart  = conversionData;
             paramInfo.srcRowStride = conversionBufferStride;
             op->composite(paramInfo);
         }
     }
     else {
         op->composite(params);
     }
 }
 
 
 QVector<quint8> * KoColorSpace::threadLocalConversionCache(quint32 size) const
 {
     QVector<quint8> * ba = 0;
     if (!d->conversionCache.hasLocalData()) {
         ba = new QVector<quint8>(size, '0');
         d->conversionCache.setLocalData(ba);
     } else {
         ba = d->conversionCache.localData();
         if ((quint8)ba->size() < size)
             ba->resize(size);
     }
     return ba;
 }
 
 KoColorTransformation* KoColorSpace::createColorTransformation(const QString & id, const QHash<QString, QVariant> & parameters) const
 {
     KoColorTransformationFactory* factory = KoColorTransformationFactoryRegistry::instance()->get(id);
     if (!factory) return 0;
     QPair<KoID, KoID> model(colorModelId(), colorDepthId());
     QList< QPair<KoID, KoID> > models = factory->supportedModels();
     if (models.isEmpty() || models.contains(model)) {
         return factory->createTransformation(this, parameters);
     } else {
         // Find the best solution
         // TODO use the color conversion cache
         KoColorConversionTransformation* csToFallBack = 0;
         KoColorConversionTransformation* fallBackToCs = 0;
         KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverters(this, models, csToFallBack, fallBackToCs);
         Q_ASSERT(csToFallBack);
         Q_ASSERT(fallBackToCs);
         KoColorTransformation* transfo = factory->createTransformation(fallBackToCs->srcColorSpace(), parameters);
         return new KoFallBackColorTransformation(csToFallBack, fallBackToCs, transfo);
     }
 }
 
 void KoColorSpace::increaseLuminosity(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     if (profile()->hasTRC()){
         //only linearise and crunch the luma if there's a TRC
         profile()->linearizeFloatValue(channelValues);
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = pow(luma, 1/2.2);
         luma = qMin(1.0, luma + step);
         luma = pow(luma, 2.2);
         channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     } else {
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = qMin(1.0, luma + step);
         channelValues = fromHSY(&hue, &sat, &luma);
     }
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseLuminosity(quint8 * pixel, qreal step) const {
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     if (profile()->hasTRC()){
         //only linearise and crunch the luma if there's a TRC
         profile()->linearizeFloatValue(channelValues);
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = pow(luma, 1/2.2);
         if (luma-step<0.0) {
             luma=0.0;
         } else {
             luma -= step;
         }
         luma = pow(luma, 2.2);
         channelValues = fromHSY(&hue, &sat, &luma);
         profile()->delinearizeFloatValue(channelValues);
     } else {
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         if (luma-step<0.0) {
             luma=0.0;
         } else {
             luma -= step;
         }
         channelValues = fromHSY(&hue, &sat, &luma);
     }
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseSaturation(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     sat += step;
     sat = qBound(0.0, sat, 1.0);
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseSaturation(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     sat -= step;
     sat = qBound(0.0, sat, 1.0);
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseHue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount(); //doesn't work for cmyka...
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     if (hue+step>1.0){
         hue=(hue+step)- 1.0;
     } else {
         hue += step;
     }
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseHue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     if (hue-step<0.0){
         hue=1.0-(step-hue);
     } else {
         hue -= step;
     }
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 void KoColorSpace::increaseRed(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     u += step;
     u = qBound(0.0, u, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseGreen(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     u -= step;
     u = qBound(0.0, u, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseBlue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     v += step;
     v = qBound(0.0, v, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseYellow(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     v -= step;
     v = qBound(0.0, v, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 QImage KoColorSpace::convertToQImage(const quint8 *data, qint32 width, qint32 height,
                                      const KoColorProfile *dstProfile,
                                      KoColorConversionTransformation::Intent renderingIntent,
                                      KoColorConversionTransformation::ConversionFlags conversionFlags) const
 
 {
     QImage img = QImage(width, height, QImage::Format_ARGB32);
 
     const KoColorSpace * dstCS = KoColorSpaceRegistry::instance()->rgb8(dstProfile);
 
     if (data)
         this->convertPixelsTo(const_cast<quint8 *>(data), img.bits(), dstCS, width * height, renderingIntent, conversionFlags);
 
     return img;
 }
 
 bool KoColorSpace::preferCompositionInSourceColorSpace() const
 {
     return false;
 }
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index e785ebc3e3..b923ec26d2 100644
--- a/libs/ui/canvas/kis_canvas2.cpp
+++ b/libs/ui/canvas/kis_canvas2.cpp
@@ -1,968 +1,968 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) Lukáš Tvrdý <lukast.dev@gmail.com>, (C) 2010
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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_canvas2.h"
 
 #include <QApplication>
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QTime>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QDesktopWidget>
 
 #include <kis_debug.h>
 
 #include <KoUnit.h>
 #include <KoShapeManager.h>
 #include <KoColorProfile.h>
 #include <KoCanvasControllerWidget.h>
 #include <KisDocument.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 
 #include <kis_lod_transform.h>
 #include "kis_tool_proxy.h"
 #include "kis_coordinates_converter.h"
 #include "kis_prescaled_projection.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "KisDocument.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_abstract_canvas_widget.h"
 #include "kis_qpainter_canvas.h"
 #include "kis_group_layer.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_node_manager.h"
 #include "kis_selection.h"
 #include "kis_selection_component.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image_config.h"
 #include "kis_infinity_manager.h"
 #include "kis_signal_compressor.h"
 #include "kis_display_color_converter.h"
 #include "kis_exposure_gamma_correction_interface.h"
 #include "KisView.h"
 #include "kis_canvas_controller.h"
 #include "kis_grid_config.h"
 
 #include "kis_animation_player.h"
 #include "kis_animation_frame_cache.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl.h"
 #include "kis_fps_decoration.h"
 
 #include "KoColorConversionTransformation.h"
 #include "KisProofingConfiguration.h"
 
 #include <kis_favorite_resource_manager.h>
 #include <kis_popup_palette.h>
 
 #include "input/kis_input_manager.h"
 #include "kis_painting_assistants_decoration.h"
 
 #include "kis_canvas_updates_compressor.h"
 
 class Q_DECL_HIDDEN KisCanvas2::KisCanvas2Private
 {
 
 public:
 
     KisCanvas2Private(KoCanvasBase *parent, KisCoordinatesConverter* coordConverter, QPointer<KisView> view, KoCanvasResourceManager* resourceManager)
         : coordinatesConverter(coordConverter)
         , view(view)
         , shapeManager(parent)
         , toolProxy(parent)
         , displayColorConverter(resourceManager, view)
     {
     }
 
     KisCoordinatesConverter *coordinatesConverter;
     QPointer<KisView>view;
     KisAbstractCanvasWidget *canvasWidget = 0;
     KoShapeManager shapeManager;
     bool currentCanvasIsOpenGL;
     int openGLFilterMode;
     KisToolProxy toolProxy;
     KisPrescaledProjectionSP prescaledProjection;
     bool vastScrolling;
 
     KisSignalCompressor updateSignalCompressor;
     QRect savedUpdateRect;
 
     QBitArray channelFlags;
     KisProofingConfiguration *proofingConfig = 0;
     bool softProofing = false;
     bool gamutCheck = false;
     bool proofingConfigUpdated = false;
 
     KisPopupPalette *popupPalette = 0;
     KisDisplayColorConverter displayColorConverter;
 
     KisCanvasUpdatesCompressor projectionUpdatesCompressor;
     KisAnimationPlayer *animationPlayer;
     KisAnimationFrameCacheSP frameCache;
     bool lodAllowedInCanvas;
     bool bootstrapLodBlocked;
 
     bool effectiveLodAllowedInCanvas() {
         return lodAllowedInCanvas && !bootstrapLodBlocked;
     }
 };
 
 KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeBasedDocumentBase *sc)
     : KoCanvasBase(sc, resourceManager)
     , m_d(new KisCanvas2Private(this, coordConverter, view, resourceManager))
 {
     /**
      * While loading LoD should be blocked. Only when GUI has finished
      * loading and zoom level settled down, LoD is given a green
      * light.
      */
     m_d->bootstrapLodBlocked = true;
     connect(view->mainWindow(), SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
 
     m_d->updateSignalCompressor.setDelay(10);
     m_d->updateSignalCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 
 
 }
 
 void KisCanvas2::setup()
 {
     // a bit of duplication from slotConfigChanged()
     KisConfig cfg;
     m_d->vastScrolling = cfg.vastScrolling();
     m_d->lodAllowedInCanvas = cfg.levelOfDetailEnabled();
 
     createCanvas(cfg.useOpenGL());
 
     setLodAllowedInCanvas(m_d->lodAllowedInCanvas);
     m_d->animationPlayer = new KisAnimationPlayer(this);
     connect(m_d->view->canvasController()->proxyObject, SIGNAL(moveDocumentOffset(QPoint)), SLOT(documentOffsetMoved(QPoint)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 
     /**
      * We switch the shape manager every time vector layer or
      * shape selection is activated. Flake does not expect this
      * and connects all the signals of the global shape manager
      * to the clients in the constructor. To workaround this we
      * forward the signals of local shape managers stored in the
      * vector layers to the signals of global shape manager. So the
      * sequence of signal deliveries is the following:
      *
      * shapeLayer.m_d.canvas.m_shapeManager.selection() ->
      * shapeLayer ->
      * shapeController ->
      * globalShapeManager.selection()
      */
 
     KisShapeController *kritaShapeController = static_cast<KisShapeController*>(shapeController()->documentBase());
     connect(kritaShapeController, SIGNAL(selectionChanged()),
             this, SLOT(slotSelectionChanged()));
     connect(kritaShapeController, SIGNAL(selectionContentChanged()),
             globalShapeManager(), SIGNAL(selectionContentChanged()));
     connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             globalShapeManager()->selection(), SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(&m_d->updateSignalCompressor, SIGNAL(timeout()), SLOT(slotDoCanvasUpdate()));
 }
 
 KisCanvas2::~KisCanvas2()
 {
     if (m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->forcedStopOnExit();
     }
     delete m_d;
 }
 
 void KisCanvas2::setCanvasWidget(QWidget * widget)
 {
     KisAbstractCanvasWidget *tmp = dynamic_cast<KisAbstractCanvasWidget*>(widget);
     Q_ASSERT_X(tmp, "setCanvasWidget", "Cannot cast the widget to a KisAbstractCanvasWidget");
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(widget);
     }
 
     if(m_d->canvasWidget != 0)
     {
         tmp->setDecorations(m_d->canvasWidget->decorations());
 
         // Redundant check for the constructor case, see below
         if(viewManager() != 0)
             viewManager()->inputManager()->removeTrackedCanvas(this);
     }
 
     m_d->canvasWidget = tmp;
 
     // Either tmp was null or we are being called by KisCanvas2 constructor that is called by KisView
     // constructor, so the view manager still doesn't exists.
     if(m_d->canvasWidget != 0 && viewManager() != 0)
         viewManager()->inputManager()->addTrackedCanvas(this);
 
     if (!m_d->canvasWidget->decoration(INFINITY_DECORATION_ID)) {
         KisInfinityManager *manager = new KisInfinityManager(m_d->view, this);
         manager->setVisible(true);
         m_d->canvasWidget->addDecoration(manager);
     }
 
     widget->setAutoFillBackground(false);
     widget->setAttribute(Qt::WA_OpaquePaintEvent);
     widget->setMouseTracking(true);
     widget->setAcceptDrops(true);
 
     KoCanvasControllerWidget *controller = dynamic_cast<KoCanvasControllerWidget*>(canvasController());
     if (controller) {
         Q_ASSERT(controller->canvas() == this);
         controller->changeCanvasWidget(widget);
     }
 }
 
 bool KisCanvas2::canvasIsOpenGL() const
 {
     return m_d->currentCanvasIsOpenGL;
 }
 
 KisOpenGL::FilterMode KisCanvas2::openGLFilterMode() const
 {
     return KisOpenGL::FilterMode(m_d->openGLFilterMode);
 }
 
 void KisCanvas2::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     QTransform transform = coordinatesConverter()->imageToDocumentTransform();
 
     const QPoint intSpacing = m_d->view->document()->gridConfig().spacing();
     const QPoint intOffset = m_d->view->document()->gridConfig().offset();
 
     QPointF size = transform.map(QPointF(intSpacing));
     spacing->rwidth() = size.x();
     spacing->rheight() = size.y();
 
     *offset = transform.map(QPointF(intOffset));
 }
 
 bool KisCanvas2::snapToGrid() const
 {
     return m_d->view->document()->gridConfig().snapToGrid();
 }
 
 qreal KisCanvas2::rotationAngle() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 bool KisCanvas2::xAxisMirrored() const
 {
     return m_d->coordinatesConverter->xAxisMirrored();
 }
 
 bool KisCanvas2::yAxisMirrored() const
 {
     return m_d->coordinatesConverter->yAxisMirrored();
 }
 
 void KisCanvas2::channelSelectionChanged()
 {
     KisImageWSP image = this->image();
     m_d->channelFlags = image->rootLayer()->channelFlags();
 
     image->barrierLock();
     m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
     startUpdateInPatches(image->bounds());
 
     image->unlock();
 
 }
 
 void KisCanvas2::addCommand(KUndo2Command *command)
 {
     // This method exists to support flake-related operations
     m_d->view->document()->addCommand(command);
 }
 
 KoShapeManager* KisCanvas2::shapeManager() const
 {
     if (!viewManager()) return globalShapeManager();
     if (!viewManager()->nodeManager()) return globalShapeManager();
 
     KisLayerSP activeLayer = viewManager()->nodeManager()->activeLayer();
     if (activeLayer && activeLayer->isEditable()) {
         KisShapeLayer * shapeLayer = dynamic_cast<KisShapeLayer*>(activeLayer.data());
         if (shapeLayer) {
             return shapeLayer->shapeManager();
         }
         KisSelectionSP selection = activeLayer->selection();
         if (selection && !selection.isNull()) {
             if (selection->hasShapeSelection()) {
                 KoShapeManager* m = dynamic_cast<KisShapeSelection*>(selection->shapeSelection())->shapeManager();
                 return m;
             }
 
         }
     }
     return globalShapeManager();
 }
 
 KoShapeManager * KisCanvas2::globalShapeManager() const
 {
     return &m_d->shapeManager;
 }
 
 void KisCanvas2::updateInputMethodInfo()
 {
     // TODO call (the protected) QWidget::updateMicroFocus() on the proper canvas widget...
 }
 
 const KisCoordinatesConverter* KisCanvas2::coordinatesConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KoViewConverter* KisCanvas2::viewConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KisInputManager* KisCanvas2::globalInputManager() const
 {
     return m_d->view->globalInputManager();
 }
 
 QWidget* KisCanvas2::canvasWidget()
 {
     return m_d->canvasWidget->widget();
 }
 
 const QWidget* KisCanvas2::canvasWidget() const
 {
     return m_d->canvasWidget->widget();
 }
 
 
 KoUnit KisCanvas2::unit() const
 {
     KoUnit unit(KoUnit::Pixel);
 
     KisImageWSP image = m_d->view->image();
     if (image) {
         if (!qFuzzyCompare(image->xRes(), image->yRes())) {
             warnKrita << "WARNING: resolution of the image is anisotropic"
                        << ppVar(image->xRes())
                        << ppVar(image->yRes());
         }
 
         const qreal resolution = image->xRes();
         unit.setFactor(resolution);
     }
 
     return unit;
 }
 
 KoToolProxy * KisCanvas2::toolProxy() const
 {
     return &m_d->toolProxy;
 }
 
 void KisCanvas2::createQPainterCanvas()
 {
     m_d->currentCanvasIsOpenGL = false;
 
     KisQPainterCanvas * canvasWidget = new KisQPainterCanvas(this, m_d->coordinatesConverter, m_d->view);
     m_d->prescaledProjection = new KisPrescaledProjection();
     m_d->prescaledProjection->setCoordinatesConverter(m_d->coordinatesConverter);
     m_d->prescaledProjection->setMonitorProfile(m_d->displayColorConverter.monitorProfile(),
                                                 m_d->displayColorConverter.renderingIntent(),
                                                 m_d->displayColorConverter.conversionFlags());
     m_d->prescaledProjection->setDisplayFilter(m_d->displayColorConverter.displayFilter());
     canvasWidget->setPrescaledProjection(m_d->prescaledProjection);
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createOpenGLCanvas()
 {
     KisConfig cfg;
     m_d->openGLFilterMode = cfg.openGLFilteringMode();
     m_d->currentCanvasIsOpenGL = true;
 
     KisOpenGLCanvas2 *canvasWidget = new KisOpenGLCanvas2(this, m_d->coordinatesConverter, 0, m_d->view->image(), &m_d->displayColorConverter);
     m_d->frameCache = KisAnimationFrameCache::getFrameCache(canvasWidget->openGLImageTextures());
 
     setCanvasWidget(canvasWidget);
 
     if (canvasWidget->needsFpsDebugging() && !decoration(KisFpsDecoration::idTag)) {
         addDecoration(new KisFpsDecoration(imageView()));
     }
 }
 
 void KisCanvas2::createCanvas(bool useOpenGL)
 {
     // deinitialize previous canvas structures
     m_d->prescaledProjection = 0;
     m_d->frameCache = 0;
 
     KisConfig cfg;
     QDesktopWidget dw;
     const KoColorProfile *profile = cfg.displayProfile(dw.screenNumber(imageView()));
     m_d->displayColorConverter.setMonitorProfile(profile);
 
     if (useOpenGL) {
         if (KisOpenGL::hasOpenGL()) {
             createOpenGLCanvas();
             if (cfg.canvasState() == "OPENGL_FAILED") {
                 // Creating the opengl canvas failed, fall back
                 warnKrita << "OpenGL Canvas initialization returned OPENGL_FAILED. Falling back to QPainter.";
                 createQPainterCanvas();
             }
         } else {
             warnKrita << "Tried to create OpenGL widget when system doesn't have OpenGL\n";
             createQPainterCanvas();
         }
     }
     else {
         createQPainterCanvas();
     }
 
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(m_d->canvasWidget->widget());
     }
 
 }
 
 void KisCanvas2::initializeImage()
 {
     KisImageWSP image = m_d->view->image();
 
     m_d->coordinatesConverter->setImage(image);
 
     connect(image, SIGNAL(sigImageUpdated(QRect)), SLOT(startUpdateCanvasProjection(QRect)), Qt::DirectConnection);
     connect(this, SIGNAL(sigCanvasCacheUpdated()), SLOT(updateCanvasProjection()));
     connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
     connect(image, SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), SLOT(startResizingImage()), Qt::DirectConnection);
     connect(this, SIGNAL(sigContinueResizeImage(qint32,qint32)), SLOT(finishResizingImage(qint32,qint32)));
 
     connectCurrentCanvas();
 }
 
 void KisCanvas2::connectCurrentCanvas()
 {
     KisImageWSP image = m_d->view->image();
 
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setImage(image);
     }
 
     startResizingImage();
 
     emit imageChanged(image);
     setLodAllowedInCanvas(m_d->lodAllowedInCanvas);
 }
 
 void KisCanvas2::resetCanvas(bool useOpenGL)
 {
     // we cannot reset the canvas before it's created, but this method might be called,
     // for instance when setting the monitor profile.
     if (!m_d->canvasWidget) {
         return;
     }
     KisConfig cfg;
     bool needReset = (m_d->currentCanvasIsOpenGL != useOpenGL) ||
         (m_d->currentCanvasIsOpenGL &&
          m_d->openGLFilterMode != cfg.openGLFilteringMode());
 
     if (needReset) {
         createCanvas(useOpenGL);
         connectCurrentCanvas();
         notifyZoomChanged();
     }
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::startUpdateInPatches(const QRect &imageRect)
 {
     if (m_d->currentCanvasIsOpenGL) {
         startUpdateCanvasProjection(imageRect);
     } else {
         KisImageConfig imageConfig;
         int patchWidth = imageConfig.updatePatchWidth();
         int patchHeight = imageConfig.updatePatchHeight();
 
         for (int y = 0; y < imageRect.height(); y += patchHeight) {
             for (int x = 0; x < imageRect.width(); x += patchWidth) {
                 QRect patchRect(x, y, patchWidth, patchHeight);
                 startUpdateCanvasProjection(patchRect);
             }
         }
     }
 }
 
 void KisCanvas2::setDisplayFilter(KisDisplayFilter *displayFilter)
 {
     m_d->displayColorConverter.setDisplayFilter(displayFilter);
     KisImageWSP image = this->image();
 
     image->barrierLock();
 
     m_d->canvasWidget->setDisplayFilter(displayFilter);
 
     image->unlock();
 }
 
 KisDisplayFilter *KisCanvas2::displayFilter() const
 {
     return m_d->displayColorConverter.displayFilter();
 }
 
 KisDisplayColorConverter* KisCanvas2::displayColorConverter() const
 {
     return &m_d->displayColorConverter;
 }
 
 KisExposureGammaCorrectionInterface* KisCanvas2::exposureGammaCorrectionInterface() const
 {
     KisDisplayFilter *displayFilter =
         m_d->displayColorConverter.displayFilter();
 
     return displayFilter ?
         displayFilter->correctionInterface() :
         KisDumbExposureGammaCorrectionInterface::instance();
 }
 
 void KisCanvas2::setProofingOptions(bool softProof, bool gamutCheck)
 {
     m_d->proofingConfig = this->image()->proofingConfiguration();
     if (!m_d->proofingConfig) {
         qDebug()<<"Canvas: No proofing config found, generating one.";
         m_d->proofingConfig = new KisProofingConfiguration();
     }
     KoColorConversionTransformation::ConversionFlags conversionFlags = m_d->proofingConfig->conversionFlags;
 
     if (softProof && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::SoftProofing;
     } else {
         conversionFlags = conversionFlags &  ~KoColorConversionTransformation::SoftProofing;
     }
-    if (gamutCheck && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
+    if (gamutCheck && softProof && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::GamutCheck;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::GamutCheck;
     }
     m_d->proofingConfig->conversionFlags = conversionFlags;
 
-    qDebug()<<"setting softproofing in canvas: "<<softProof <<", "<<gamutCheck;
-    qDebug()<<conversionFlags.testFlag(KoColorConversionTransformation::SoftProofing);
-    qDebug()<<conversionFlags.testFlag(KoColorConversionTransformation::GamutCheck);
     m_d->proofingConfigUpdated = true;
     startUpdateInPatches(this->image()->bounds());
 
 }
 
 void KisCanvas2::slotSoftProofing(bool softProofing)
 {
     m_d->softProofing = softProofing;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotGamutCheck(bool gamutCheck)
 {
     m_d->gamutCheck = gamutCheck;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotChangeProofingConfig()
 {
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::setProofingConfigUpdated(bool updated)
 {
     m_d->proofingConfigUpdated = updated;
 }
 
 bool KisCanvas2::proofingConfigUpdated()
 {
     return m_d->proofingConfigUpdated;
 }
 
 KisProofingConfiguration *KisCanvas2::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
-        qDebug()<<"No proofing config found, generating one";
-        m_d->proofingConfig = new KisProofingConfiguration();
+        m_d->proofingConfig = this->image()->proofingConfiguration();
+        if (!m_d->proofingConfig) {
+            qDebug()<<"Canvas: No proofing config found, generating one.";
+            m_d->proofingConfig = new KisProofingConfiguration();
+        }
     }
     return m_d->proofingConfig;
 }
 
 void KisCanvas2::startResizingImage()
 {
     KisImageWSP image = this->image();
     qint32 w = image->width();
     qint32 h = image->height();
 
     emit sigContinueResizeImage(w, h);
 
     QRect imageBounds(0, 0, w, h);
     startUpdateInPatches(imageBounds);
 }
 
 void KisCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->canvasWidget->finishResizingImage(w, h);
 }
 
 void KisCanvas2::startUpdateCanvasProjection(const QRect & rc)
 {
     KisUpdateInfoSP info = m_d->canvasWidget->startUpdateCanvasProjection(rc, m_d->channelFlags);
     if (m_d->projectionUpdatesCompressor.putUpdateInfo(info)) {
         emit sigCanvasCacheUpdated();
     }
 }
 
 void KisCanvas2::updateCanvasProjection()
 {
     while (KisUpdateInfoSP info = m_d->projectionUpdatesCompressor.takeUpdateInfo()) {
         QRect vRect = m_d->canvasWidget->updateCanvasProjection(info);
         if (!vRect.isEmpty()) {
             updateCanvasWidgetImpl(m_d->coordinatesConverter->viewportToWidget(vRect).toAlignedRect());
         }
     }
 
     // TODO: Implement info->dirtyViewportRect() for KisOpenGLCanvas2 to avoid updating whole canvas
     if (m_d->currentCanvasIsOpenGL) {
         updateCanvasWidgetImpl();
     }
 }
 
 void KisCanvas2::slotDoCanvasUpdate()
 {
     if (m_d->canvasWidget->isBusy()) {
         // just restarting the timer
         updateCanvasWidgetImpl(m_d->savedUpdateRect);
         return;
     }
 
     if (m_d->savedUpdateRect.isEmpty()) {
         m_d->canvasWidget->widget()->update();
         emit updateCanvasRequested(m_d->canvasWidget->widget()->rect());
     } else {
         emit updateCanvasRequested(m_d->savedUpdateRect);
         m_d->canvasWidget->widget()->update(m_d->savedUpdateRect);
     }
 
     m_d->savedUpdateRect = QRect();
 }
 
 void KisCanvas2::updateCanvasWidgetImpl(const QRect &rc)
 {
     if (!m_d->updateSignalCompressor.isActive() ||
         !m_d->savedUpdateRect.isEmpty()) {
         m_d->savedUpdateRect |= rc;
     }
     m_d->updateSignalCompressor.start();
 }
 
 void KisCanvas2::updateCanvas()
 {
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::updateCanvas(const QRectF& documentRect)
 {
     if (m_d->currentCanvasIsOpenGL && m_d->canvasWidget->decorations().size() > 0) {
         updateCanvasWidgetImpl();
     }
     else {
         // updateCanvas is called from tools, never from the projection
         // updates, so no need to prescale!
         QRect widgetRect = m_d->coordinatesConverter->documentToWidget(documentRect).toAlignedRect();
         widgetRect.adjust(-2, -2, 2, 2);
         if (!widgetRect.isEmpty()) {
             updateCanvasWidgetImpl(widgetRect);
         }
     }
 }
 
 void KisCanvas2::disconnectCanvasObserver(QObject *object)
 {
     KoCanvasBase::disconnectCanvasObserver(object);
     m_d->view->disconnect(object);
 }
 
 void KisCanvas2::notifyZoomChanged()
 {
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->notifyZoomChanged();
     }
 
     notifyLevelOfDetailChange();
     updateCanvas(); // update the canvas, because that isn't done when zooming using KoZoomAction
 }
 
 void KisCanvas2::notifyLevelOfDetailChange()
 {
     if (!m_d->effectiveLodAllowedInCanvas()) return;
 
     KisImageSP image = this->image();
 
     const qreal effectiveZoom = m_d->coordinatesConverter->effectiveZoom();
 
     KisConfig cfg;
     const int maxLod = cfg.numMipmapLevels();
 
     int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
     image->setDesiredLevelOfDetail(lod);
 }
 
 void KisCanvas2::preScale()
 {
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->preScale();
     }
 }
 
 const KoColorProfile *  KisCanvas2::monitorProfile()
 {
     return m_d->displayColorConverter.monitorProfile();
 }
 
 KisViewManager* KisCanvas2::viewManager() const
 {
     if (m_d->view) {
         return m_d->view->viewManager();
     }
     return 0;
 }
 
 QPointer<KisView>KisCanvas2::imageView() const
 {
     return m_d->view;
 }
 
 KisImageWSP KisCanvas2::image() const
 {
     return m_d->view->image();
 
 }
 
 KisImageWSP KisCanvas2::currentImage() const
 {
     return m_d->view->image();
 }
 
 void KisCanvas2::documentOffsetMoved(const QPoint &documentOffset)
 {
     QPointF offsetBefore = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
     m_d->coordinatesConverter->setDocumentOffset(documentOffset);
     QPointF offsetAfter = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
 
     QPointF moveOffset = offsetAfter - offsetBefore;
 
     if (!m_d->currentCanvasIsOpenGL)
         m_d->prescaledProjection->viewportMoved(moveOffset);
 
     emit documentOffsetUpdateFinished();
 
     updateCanvas();
 }
 
 void KisCanvas2::slotConfigChanged()
 {
     KisConfig cfg;
     m_d->vastScrolling = cfg.vastScrolling();
 
     resetCanvas(cfg.useOpenGL());
     slotSetDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this->canvasWidget())));
 
 }
 
 void KisCanvas2::refetchDataFromImage()
 {
     KisImageSP image = this->image();
     KisImageBarrierLocker l(image);
     startUpdateInPatches(image->bounds());
 }
 
 void KisCanvas2::slotSetDisplayProfile(const KoColorProfile *monitorProfile)
 {
     if (m_d->displayColorConverter.monitorProfile() == monitorProfile) return;
 
     m_d->displayColorConverter.setMonitorProfile(monitorProfile);
 
     KisImageWSP image = this->image();
 
     image->barrierLock();
 
     m_d->canvasWidget->setDisplayProfile(&m_d->displayColorConverter);
 
     refetchDataFromImage();
 }
 
 void KisCanvas2::addDecoration(KisCanvasDecorationSP deco)
 {
     m_d->canvasWidget->addDecoration(deco);
 }
 
 KisCanvasDecorationSP KisCanvas2::decoration(const QString& id) const
 {
     return m_d->canvasWidget->decoration(id);
 }
 
 
 QPoint KisCanvas2::documentOrigin() const
 {
     /**
      * In Krita we don't use document origin anymore.
      * All the centering when needed (vastScrolling < 0.5) is done
      * automatically by the KisCoordinatesConverter.
      */
 
     return QPoint();
 }
 
 QPoint KisCanvas2::documentOffset() const
 {
     return m_d->coordinatesConverter->documentOffset();
 }
 
 void KisCanvas2::setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager)
 {
     m_d->popupPalette = new KisPopupPalette(favoriteResourceManager, displayColorConverter()->displayRendererInterface(), m_d->canvasWidget->widget());
     m_d->popupPalette->showPopupPalette(false);
 }
 
 void KisCanvas2::setCursor(const QCursor &cursor)
 {
     canvasWidget()->setCursor(cursor);
 }
 
 KisAnimationFrameCacheSP KisCanvas2::frameCache() const
 {
     return m_d->frameCache;
 }
 
 KisAnimationPlayer *KisCanvas2::animationPlayer() const
 {
     return m_d->animationPlayer;
 }
 
 void KisCanvas2::slotSelectionChanged()
 {
     KisShapeLayer* shapeLayer = dynamic_cast<KisShapeLayer*>(viewManager()->activeLayer().data());
     if (!shapeLayer) {
         return;
     }
     m_d->shapeManager.selection()->deselectAll();
     Q_FOREACH (KoShape* shape, shapeLayer->shapeManager()->selection()->selectedShapes()) {
         m_d->shapeManager.selection()->select(shape);
     }
 }
 
 bool KisCanvas2::isPopupPaletteVisible() const
 {
     if (!m_d->popupPalette) {
         return false;
     }
     return m_d->popupPalette->isVisible();
 }
 
 
 void KisCanvas2::setWrapAroundViewingMode(bool value)
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         infinityDecoration->setVisible(!value);
     }
 
     m_d->canvasWidget->setWrapAroundViewingMode(value);
 }
 
 bool KisCanvas2::wrapAroundViewingMode() const
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         return !(infinityDecoration->visible());
     }
     return false;
 }
 
 void KisCanvas2::bootstrapFinished()
 {
     if (!m_d->bootstrapLodBlocked) return;
 
     m_d->bootstrapLodBlocked = false;
     setLodAllowedInCanvas(m_d->lodAllowedInCanvas);
 }
 
 void KisCanvas2::setLodAllowedInCanvas(bool value)
 {
     if (!KisOpenGL::supportsGLSL13()) {
         qWarning() << "WARNING: Level of Detail functionality is available only with openGL + GLSL 1.3 support";
     }
 
     m_d->lodAllowedInCanvas =
             value &&
             m_d->currentCanvasIsOpenGL &&
             KisOpenGL::supportsGLSL13() &&
             (m_d->openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
              m_d->openGLFilterMode == KisOpenGL::HighQualityFiltering);
 
     KisImageSP image = this->image();
 
     if (m_d->effectiveLodAllowedInCanvas() != !image->levelOfDetailBlocked()) {
 
         image->setLevelOfDetailBlocked(!m_d->effectiveLodAllowedInCanvas());
         notifyLevelOfDetailChange();
     }
 
     KisConfig cfg;
     cfg.setLevelOfDetailEnabled(m_d->lodAllowedInCanvas);
 }
 
 bool KisCanvas2::lodAllowedInCanvas() const
 {
     return m_d->lodAllowedInCanvas;
 }
 
 void KisCanvas2::slotShowPopupPalette(const QPoint &p)
 {
     if (!m_d->popupPalette) {
         return;
     }
 
     m_d->popupPalette->showPopupPalette(p);
 }
 
 KisPaintingAssistantsDecorationSP KisCanvas2::paintingAssistantsDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("paintingAssistantsDecoration");
     return qobject_cast<KisPaintingAssistantsDecoration*>(deco.data());
 }
diff --git a/libs/ui/kra/kis_kra_loader.cpp b/libs/ui/kra/kis_kra_loader.cpp
index 9796c10567..19dab3e5a6 100644
--- a/libs/ui/kra/kis_kra_loader.cpp
+++ b/libs/ui/kra/kis_kra_loader.cpp
@@ -1,1130 +1,1127 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kra/kis_kra_loader.h"
 
 #include <QApplication>
 #include <QStringList>
 
 #include <QMessageBox>
 
 #include <QUrl>
 #include <QBuffer>
 
 #include <KoStore.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorProfile.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <KisImportExportManager.h>
 #include <KoXmlReader.h>
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <generator/kis_generator.h>
 #include <generator/kis_generator_layer.h>
 #include <generator/kis_generator_registry.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_base_node.h>
 #include <kis_clone_layer.h>
 #include <kis_debug.h>
 #include <kis_assert.h>
 #include <kis_external_layer_iface.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <kis_layer_composition.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <kis_psd_layer_style_resource.h>
 #include "kis_resource_server_provider.h"
 #include "kis_keyframe_channel.h"
 
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_kra_load_visitor.h"
 #include "kis_dom_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "KisProofingConfiguration.h"
 
 /*
 
   Color model id comparison through the ages:
 
 2.4        2.5          2.6         ideal
 
 ALPHA      ALPHA        ALPHA       ALPHAU8
 
 CMYK       CMYK         CMYK        CMYKAU8
            CMYKAF32     CMYKAF32
 CMYKA16    CMYKAU16     CMYKAU16
 
 GRAYA      GRAYA        GRAYA       GRAYAU8
 GrayF32    GRAYAF32     GRAYAF32
 GRAYA16    GRAYAU16     GRAYAU16
 
 LABA       LABA         LABA        LABAU16
            LABAF32      LABAF32
            LABAU8       LABAU8
 
 RGBA       RGBA         RGBA        RGBAU8
 RGBA16     RGBA16       RGBA16      RGBAU16
 RgbAF32    RGBAF32      RGBAF32
 RgbAF16    RgbAF16      RGBAF16
 
 XYZA16     XYZA16       XYZA16      XYZAU16
            XYZA8        XYZA8       XYZAU8
 XyzAF16    XyzAF16      XYZAF16
 XyzAF32    XYZAF32      XYZAF32
 
 YCbCrA     YCBCRA8      YCBCRA8     YCBCRAU8
 YCbCrAU16  YCBCRAU16    YCBCRAU16
            YCBCRF32     YCBCRF32
  */
 
 using namespace KRA;
 
 struct KisKraLoader::Private
 {
 public:
 
     KisDocument* document;
     QString imageName; // used to be stored in the image, is now in the documentInfo block
     QString imageComment; // used to be stored in the image, is now in the documentInfo block
     QMap<KisNode*, QString> layerFilenames; // temp storage during loading
     int syntaxVersion; // version of the fileformat we are loading
     vKisNodeSP selectedNodes; // the nodes that were active when saving the document.
     QMap<QString, QString> assistantsFilenames;
     QList<KisPaintingAssistantSP> assistants;
     QMap<KisNode*, QString> keyframeFilenames;
     QStringList errorMessages;
 };
 
 void convertColorSpaceNames(QString &colorspacename, QString &profileProductName) {
     if (colorspacename  == "Grayscale + Alpha") {
         colorspacename  = "GRAYA";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF32") {
         colorspacename = "RGBAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF16") {
         colorspacename = "RGBAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "CMYKA16") {
         colorspacename = "CMYKAU16";
     }
     else if (colorspacename == "GrayF32") {
         colorspacename =  "GRAYAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "GRAYA16") {
         colorspacename  = "GRAYAU16";
     }
     else if (colorspacename == "XyzAF16") {
         colorspacename  = "XYZAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "XyzAF32") {
         colorspacename  = "XYZAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "YCbCrA") {
         colorspacename  = "YCBCRA8";
     }
     else if (colorspacename == "YCbCrAU16") {
         colorspacename  = "YCBCRAU16";
     }
 }
 
 KisKraLoader::KisKraLoader(KisDocument * document, int syntaxVersion)
         : m_d(new Private())
 {
     m_d->document = document;
     m_d->syntaxVersion = syntaxVersion;
 }
 
 
 KisKraLoader::~KisKraLoader()
 {
     delete m_d;
 }
 
 
 KisImageWSP KisKraLoader::loadXML(const KoXmlElement& element)
 {
     QString attr;
     KisImageWSP image = 0;
     QString name;
     qint32 width;
     qint32 height;
     QString profileProductName;
     double xres;
     double yres;
     QString colorspacename;
     const KoColorSpace * cs;
 
     if ((attr = element.attribute(MIME)) == NATIVE_MIMETYPE) {
 
         if ((m_d->imageName = element.attribute(NAME)).isNull()) {
             m_d->errorMessages << i18n("Image does not have a name.");
             return KisImageWSP(0);
         }
 
         if ((attr = element.attribute(WIDTH)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a width.");
             return KisImageWSP(0);
         }
         width = KisDomUtils::toInt(attr);
 
         if ((attr = element.attribute(HEIGHT)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a height.");
             return KisImageWSP(0);
         }
 
         height = KisDomUtils::toInt(attr);
 
         m_d->imageComment = element.attribute(DESCRIPTION);
 
         xres = 100.0 / 72.0;
         if (!(attr = element.attribute(X_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
 
             if (value > 1.0) {
                 xres = value / 72.0;
             }
         }
 
         yres = 100.0 / 72.0;
         if (!(attr = element.attribute(Y_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
             if (value > 1.0) {
                 yres = value / 72.0;
             }
         }
 
         if ((colorspacename = element.attribute(COLORSPACE_NAME)).isNull()) {
             // An old file: take a reasonable default.
             // Krita didn't support anything else in those
             // days anyway.
             colorspacename = "RGBA";
         }
 
         profileProductName = element.attribute(PROFILE);
         // A hack for an old colorspacename
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
 
         if (profileProductName.isNull()) {
             // no mention of profile so get default profile";
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, profileProductName);
         }
 
         if (cs == 0) {
             // try once more without the profile
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
             if (cs == 0) {
                 m_d->errorMessages << i18n("Image specifies an unsupported color model: %1.", colorspacename);
                 return KisImageWSP(0);
             }
         }
-        qDebug()<<"start loading proofing data";
         KisProofingConfiguration *proofingConfig = new KisProofingConfiguration();
-        qDebug()<<"start loading the name";
         if (!(attr = element.attribute(PROOFINGPROFILENAME)).isNull()) {
             proofingConfig->proofingProfile = attr;
         }
         if (!(attr = element.attribute(PROOFINGMODEL)).isNull()) {
             proofingConfig->proofingModel = attr;
         }
         if (!(attr = element.attribute(PROOFINGDEPTH)).isNull()) {
             proofingConfig->proofingDepth = attr;
         }
         if (!(attr = element.attribute(PROOFINGINTENT)).isNull()) {
             proofingConfig->intent = (KoColorConversionTransformation::Intent) KisDomUtils::toInt(attr);
         }
 
         if (m_d->document) {
             image = new KisImage(m_d->document->createUndoStore(), width, height, cs, name);
         }
         else {
             image = new KisImage(0, width, height, cs, name);
         }
         image->setResolution(xres, yres);
         loadNodes(element, image, const_cast<KisGroupLayer*>(image->rootLayer().data()));
 
 
         KoXmlNode child;
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == CANVASPROJECTIONCOLOR) {
                 if (e.hasAttribute(COLORBYTEDATA)) {
                     QByteArray colorData = QByteArray::fromBase64(e.attribute("ColorData").toLatin1());
                     KoColor color((const quint8*)colorData.data(), image->colorSpace());
                     image->setDefaultProjectionColor(color);
                 }
             }
 
             if(e.tagName()== PROOFINGWARNINGCOLOR) {
                 QDomDocument dom;
                 KoXml::asQDomElement(dom, e);
                 QDomElement eq = dom.firstChildElement();
                 proofingConfig->warningColor = KoColor::fromXML(eq.firstChildElement(), Integer8BitsColorDepthID.id(), QHash<QString, QString>());
-                qDebug()<<KoColor::toQString(proofingConfig->warningColor);
             }
 
             if (e.tagName().toLower() == "animation") {
                 loadAnimationMetadata(e, image);
             }
         }
 
         image->setProofingConfiguration(proofingConfig);
 
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == "compositions") {
                 loadCompositions(e, image);
             }
         }
     }
     KoXmlNode child;
 
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         KoXmlElement e = child.toElement();
         if (e.tagName() == "grid") {
             loadGrid(e);
         } else if (e.tagName() == "guides") {
             loadGuides(e);
         } else if (e.tagName() == "assistants") {
             loadAssistantsList(e);
         }
     }
 
     return image;
 }
 
 void KisKraLoader::loadBinaryData(KoStore * store, KisImageWSP image, const QString & uri, bool external)
 {
     // icc profile: if present, this overrides the profile product name loaded in loadXML.
     QString location = external ? QString() : uri;
     location += m_d->imageName + ICC_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray data; data.resize(store->size());
             bool res = (store->read(data.data(), store->size()) > -1);
             store->close();
             if (res) {
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(image->colorSpace()->colorModelId().id(), image->colorSpace()->colorDepthId().id(), data);
                 if (profile && profile->valid()) {
                     res = image->assignImageProfile(profile);
                 }
                 if (!res) {
                     profile = KoColorSpaceRegistry::instance()->profileByName(KoColorSpaceRegistry::instance()->colorSpaceFactory(image->colorSpace()->id())->defaultProfile());
                     Q_ASSERT(profile && profile->valid());
                     image->assignImageProfile(profile);
                 }
             }
         }
     }
     //load the embed proofing profile, it only needs to be loaded into Krita, not assigned.
     location = external ? QString() : uri;
     location += m_d->imageName + ICC_PROOFING_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray proofingData;
             proofingData.resize(store->size());
             bool proofingProfileRes = (store->read(proofingData.data(), store->size())>-1);
             store->close();
             if (proofingProfileRes)
             {
                 const KoColorProfile *proofingProfile = KoColorSpaceRegistry::instance()->createColorProfile(image->proofingConfiguration()->proofingModel, image->proofingConfiguration()->proofingDepth, proofingData);
                 if (proofingProfile->valid()){
 
                     //if (KoColorSpaceEngineRegistry::instance()->get("icc")) {
                     //    KoColorSpaceEngineRegistry::instance()->get("icc")->addProfile(proofingProfile->fileName());
                     //}
                     KoColorSpaceRegistry::instance()->addProfile(proofingProfile);
                 }
             }
         }
     }
 
 
     // Load the layers data: if there is a profile associated with a layer it will be set now.
     KisKraLoadVisitor visitor(image, store, m_d->layerFilenames, m_d->imageName, m_d->syntaxVersion);
 
     if (external) {
         visitor.setExternalUri(uri);
     }
 
     image->rootLayer()->accept(visitor);
     if (!visitor.errorMessages().isEmpty()) {
         m_d->errorMessages.append(visitor.errorMessages());
     }
 
     // annotations
     // exif
     location = external ? QString() : uri;
     location += m_d->imageName + EXIF_PATH;
     if (store->hasFile(location)) {
         QByteArray data;
         store->open(location);
         data = store->read(store->size());
         store->close();
         image->addAnnotation(KisAnnotationSP(new KisAnnotation("exif", "", data)));
     }
 
 
     // layer styles
     location = external ? QString() : uri;
     location += m_d->imageName + LAYER_STYLES_PATH;
     if (store->hasFile(location)) {
         KisPSDLayerStyleCollectionResource *collection =
             new KisPSDLayerStyleCollectionResource("Embedded Styles.asl");
 
         collection->setName(i18nc("Auto-generated layer style collection name for embedded styles (collection)", "<%1> (embedded)", m_d->imageName));
 
         KIS_ASSERT_RECOVER_NOOP(!collection->valid());
 
         store->open(location);
         {
             KoStoreDevice device(store);
             device.open(QIODevice::ReadOnly);
 
             /**
              * ASL loading code cannot work with non-sequential IO devices,
              * so convert the device beforehand!
              */
             QByteArray buf = device.readAll();
             QBuffer raDevice(&buf);
             raDevice.open(QIODevice::ReadOnly);
             collection->loadFromDevice(&raDevice);
         }
         store->close();
 
         if (collection->valid()) {
             KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
             server->addResource(collection, false);
 
             collection->assignAllLayerStyles(image->root());
         } else {
             warnKrita << "WARNING: Couldn't load layer styles library from .kra!";
             delete collection;
         }
     }
 
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("title").isNull())
         m_d->document->documentInfo()->setAboutInfo("title", m_d->imageName);
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("comment").isNull())
         m_d->document->documentInfo()->setAboutInfo("comment", m_d->imageComment);
 
     loadAssistants(store, uri, external);
 }
 
 void KisKraLoader::loadKeyframes(KoStore *store, const QString uri, bool external)
 {
     QMap<KisNode*, QString>::iterator it;
 
     for (it = m_d->keyframeFilenames.begin(); it != m_d->keyframeFilenames.end(); it++) {
         KisNodeSP node = it.key();
         QString filename = it.value();
 
         QString location =
                 (external ? QString() : uri)
                 + m_d->imageName + LAYER_PATH + filename;
 
         loadNodeKeyframes(store, location, node);
     }
 }
 
 void KisKraLoader::loadNodeKeyframes(KoStore *store, const QString &location, KisNodeSP node)
 {
     if (!store->open(location)) {
         m_d->errorMessages << i18n("Could not load keyframes from %1.", location);
         return;
     }
 
     QString errorMsg;
     int errorLine;
     int errorColumn;
     KoXmlDocument doc = KoXmlDocument(true);
 
     bool ok = doc.setContent(store->device(), &errorMsg, &errorLine, &errorColumn);
     store->close();
 
     if (!ok) {
         m_d->errorMessages << i18n("parsing error in the keyframe file %1 at line %2, column %3\nError message: %4", location, errorLine, errorColumn, i18n(errorMsg.toUtf8()));
         return;
     }
 
     QDomDocument dom;
     KoXml::asQDomElement(dom, doc.documentElement());
     QDomElement root = dom.firstChildElement();
 
     for (QDomElement child = root.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toUpper() == "CHANNEL") {
             QString id = child.attribute("name");
             KisKeyframeChannel *channel = node->getKeyframeChannel(id);
 
             if (!channel) {
                 m_d->errorMessages << i18n("unknown keyframe channel type: %1 in %2", id, location);
                 continue;
             }
 
             channel->loadXML(child);
         }
     }
 }
 
 vKisNodeSP KisKraLoader::selectedNodes() const
 {
     return m_d->selectedNodes;
 }
 
 QList<KisPaintingAssistantSP> KisKraLoader::assistants() const
 {
     return m_d->assistants;
 }
 
 QStringList KisKraLoader::errorMessages() const
 {
     return m_d->errorMessages;
 }
 
 void KisKraLoader::loadAssistants(KoStore *store, const QString &uri, bool external)
 {
     QString file_path;
     QString location;
     QMap<int ,KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistant* assistant = 0;
     QMap<QString,QString>::const_iterator loadedAssistant = m_d->assistantsFilenames.constBegin();
     while (loadedAssistant != m_d->assistantsFilenames.constEnd()){
         const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(loadedAssistant.value());
         if (factory) {
             assistant = factory->createPaintingAssistant();
             location = external ? QString() : uri;
             location += m_d->imageName + ASSISTANTS_PATH;
             file_path = location + loadedAssistant.key();
             assistant->loadXml(store, handleMap, file_path);
             //If an assistant has too few handles than it should according to it's own setup, just don't load it//
             if (assistant->handles().size()==assistant->numHandles()){
                 m_d->assistants.append(toQShared(assistant));
             }
         }
         loadedAssistant++;
     }
 }
 
 void KisKraLoader::loadAnimationMetadata(const KoXmlElement &element, KisImageWSP image)
 {
     QDomDocument qDom;
     KoXml::asQDomElement(qDom, element);
     QDomElement qElement = qDom.firstChildElement();
 
     float framerate;
     KisTimeRange range;
     int currentTime;
 
     KisImageAnimationInterface *animation = image->animationInterface();
 
     if (KisDomUtils::loadValue(qElement, "framerate", &framerate)) {
         animation->setFramerate(framerate);
     }
 
     if (KisDomUtils::loadValue(qElement, "range", &range)) {
         animation->setFullClipRange(range);
     }
 
     if (KisDomUtils::loadValue(qElement, "currentTime", &currentTime)) {
         animation->switchCurrentTimeAsync(currentTime);
     }
 }
 
 KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageWSP image, KisNodeSP parent)
 {
 
     KoXmlNode node = element.firstChild();
     KoXmlNode child;
 
     if (!node.isNull()) {
 
         if (node.isElement()) {
 
             if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
                 for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
                     KisNodeSP node = loadNode(child.toElement(), image, parent);
                     if (node) {
                         image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
                         image->addNode(node, parent);
                         if (node->inherits("KisLayer") && child.childNodesCount() > 0) {
                             loadNodes(child.toElement(), image, node);
                         }
                     }
                 }
             }
         }
     }
 
     return parent;
 }
 
 KisNodeSP KisKraLoader::loadNode(const KoXmlElement& element, KisImageWSP image, KisNodeSP parent)
 {
     // Nota bene: If you add new properties to layers, you should
     // ALWAYS define a default value in case the property is not
     // present in the layer definition: this helps a LOT with backward
     // compatibility.
     QString name = element.attribute(NAME, "No Name");
 
     QUuid id = QUuid(element.attribute(UUID, QUuid().toString()));
 
     qint32 x = element.attribute(X, "0").toInt();
     qint32 y = element.attribute(Y, "0").toInt();
 
     qint32 opacity = element.attribute(OPACITY, QString::number(OPACITY_OPAQUE_U8)).toInt();
     if (opacity < OPACITY_TRANSPARENT_U8) opacity = OPACITY_TRANSPARENT_U8;
     if (opacity > OPACITY_OPAQUE_U8) opacity = OPACITY_OPAQUE_U8;
 
     const KoColorSpace* colorSpace = 0;
     if ((element.attribute(COLORSPACE_NAME)).isNull()) {
         dbgFile << "No attribute color space for layer: " << name;
         colorSpace = image->colorSpace();
     }
     else {
         QString colorspacename = element.attribute(COLORSPACE_NAME);
         QString profileProductName;
 
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
         dbgFile << "Searching color space: " << colorspacename << colorspaceModel << colorspaceDepth << " for layer: " << name;
         // use default profile - it will be replaced later in completeLoading
 
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         dbgFile << "found colorspace" << colorSpace;
         if (!colorSpace) {
             m_d->errorMessages << i18n("Layer %1 specifies an unsupported color model: %2.", name, colorspacename);
             return 0;
         }
     }
 
     const bool visible = element.attribute(VISIBLE, "1") == "0" ? false : true;
     const bool locked = element.attribute(LOCKED, "0") == "0" ? false : true;
     const bool collapsed = element.attribute(COLLAPSED, "0") == "0" ? false : true;
     const int colorLabelIndex = element.attribute(COLOR_LABEL, "0").toInt();
 
     // Now find out the layer type and do specific handling
     QString nodeType;
 
     if (m_d->syntaxVersion == 1) {
         nodeType = element.attribute("layertype");
         if (nodeType.isEmpty()) {
             nodeType = PAINT_LAYER;
         }
     }
     else {
         nodeType = element.attribute(NODE_TYPE);
     }
 
     if (nodeType.isEmpty()) {
         m_d->errorMessages << i18n("Layer %1 has an unsupported type.", name);
         return 0;
     }
 
 
     KisNodeSP node = 0;
 
     if (nodeType == PAINT_LAYER)
         node = loadPaintLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GROUP_LAYER)
         node = loadGroupLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == ADJUSTMENT_LAYER)
         node = loadAdjustmentLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == SHAPE_LAYER)
         node = loadShapeLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GENERATOR_LAYER)
         node = loadGeneratorLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == CLONE_LAYER)
         node = loadCloneLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == FILTER_MASK)
         node = loadFilterMask(element, parent);
     else if (nodeType == TRANSFORM_MASK)
         node = loadTransformMask(element, parent);
     else if (nodeType == TRANSPARENCY_MASK)
         node = loadTransparencyMask(element, parent);
     else if (nodeType == SELECTION_MASK)
         node = loadSelectionMask(image, element, parent);
     else if (nodeType == FILE_LAYER) {
         node = loadFileLayer(element, image, name, opacity);
     }
     else {
         m_d->errorMessages << i18n("Layer %1 has an unsupported type: %2.", name, nodeType);
         return 0;
     }
 
     // Loading the node went wrong. Return empty node and leave to
     // upstream to complain to the user
     if (!node) {
         m_d->errorMessages << i18n("Failure loading layer %1 of type: %2.", name, nodeType);
         return 0;
     }
 
     node->setVisible(visible, true);
     node->setUserLocked(locked);
     node->setCollapsed(collapsed);
     node->setColorLabelIndex(colorLabelIndex);
     node->setX(x);
     node->setY(y);
     node->setName(name);
 
     if (! id.isNull())          // if no uuid in file, new one has been generated already
         node->setUuid(id);
 
     if (node->inherits("KisLayer")) {
         KisLayer* layer           = qobject_cast<KisLayer*>(node.data());
         QBitArray channelFlags    = stringToFlags(element.attribute(CHANNEL_FLAGS, ""), colorSpace->channelCount());
         QString   compositeOpName = element.attribute(COMPOSITE_OP, "normal");
 
         layer->setChannelFlags(channelFlags);
         layer->setCompositeOpId(compositeOpName);
 
         if (element.hasAttribute(LAYER_STYLE_UUID)) {
             QString uuidString = element.attribute(LAYER_STYLE_UUID);
             QUuid uuid(uuidString);
             if (!uuid.isNull()) {
                 KisPSDLayerStyleSP dumbLayerStyle(new KisPSDLayerStyle());
                 dumbLayerStyle->setUuid(uuid);
                 layer->setLayerStyle(dumbLayerStyle);
             } else {
                 warnKrita << "WARNING: Layer style for layer" << layer->name() << "contains invalid UUID" << uuidString;
             }
         }
     }
 
     if (node->inherits("KisGroupLayer")) {
         if (element.hasAttribute(PASS_THROUGH_MODE)) {
             bool value = element.attribute(PASS_THROUGH_MODE, "0") != "0";
 
             KisGroupLayer *group = qobject_cast<KisGroupLayer*>(node.data());
             group->setPassThroughMode(value);
         }
     }
 
     if (node->inherits("KisPaintLayer")) {
         KisPaintLayer* layer            = qobject_cast<KisPaintLayer*>(node.data());
         QBitArray      channelLockFlags = stringToFlags(element.attribute(CHANNEL_LOCK_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelLockFlags(channelLockFlags);
 
         bool onionEnabled = element.attribute(ONION_SKIN_ENABLED, "0") == "0" ? false : true;
         layer->setOnionSkinEnabled(onionEnabled);
 
         bool timelineEnabled = element.attribute(VISIBLE_IN_TIMELINE, "0") == "0" ? false : true;
         layer->setUseInTimeline(timelineEnabled);
     }
 
     if (element.attribute(FILE_NAME).isNull()) {
         m_d->layerFilenames[node.data()] = name;
     }
     else {
         m_d->layerFilenames[node.data()] = element.attribute(FILE_NAME);
     }
 
     if (element.hasAttribute("selected") && element.attribute("selected") == "true")  {
         m_d->selectedNodes.append(node);
     }
 
     if (element.hasAttribute(KEYFRAME_FILE)) {
         node->enableAnimation();
         m_d->keyframeFilenames.insert(node.data(), element.attribute(KEYFRAME_FILE));
     }
 
     return node;
 }
 
 
 KisNodeSP KisKraLoader::loadPaintLayer(const KoXmlElement& element, KisImageWSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     KisPaintLayer* layer;
 
     layer = new KisPaintLayer(image, name, opacity, cs);
     Q_CHECK_PTR(layer);
 
     // Load exif info
     /*TODO: write and use the legacy stuff to load that exif tag
       for( KoXmlNode node = element.firstChild(); !node.isNull(); node = node.nextSibling() )
       {
       KoXmlElement e = node.toElement();
       if ( !e.isNull() && e.tagName() == "ExifInfo" )
       {
       layer->paintDevice()->exifInfo()->load(e);
       }
       }*/
     // TODO load metadata
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadFileLayer(const KoXmlElement& element, KisImageWSP image, const QString& name, quint32 opacity)
 {
     QString filename = element.attribute("source", QString());
     if (filename.isNull()) return 0;
     bool scale = (element.attribute("scale", "true")  == "true");
     int scalingMethod = element.attribute("scalingmethod", "-1").toInt();
     if (scalingMethod < 0) {
         if (scale) {
             scalingMethod = KisFileLayer::ToImagePPI;
         }
         else {
             scalingMethod = KisFileLayer::None;
         }
     }
 
     QString documentPath;
     if (m_d->document) {
         documentPath = m_d->document->url().toLocalFile();
     }
     QFileInfo info(documentPath);
     QString basePath = info.absolutePath();
 
     QString fullPath = basePath + QDir::separator() + filename;
     // Entering the event loop to show the messagebox will delete the image, so up the ref by one
     image->ref();
     if (!QFileInfo(fullPath).exists()) {
 
         qApp->setOverrideCursor(Qt::ArrowCursor);
         QString msg = i18nc(
             "@info",
             "The file associated to a file layer with the name \"%1\" is not found.<nl/><nl/>"
             "Expected path:<nl/>"
             "%2<nl/><nl/>"
             "Do you want to locate it manually?", name, fullPath);
 
         int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
         if (result == QMessageBox::Yes) {
 
             KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
             dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
             dialog.setDefaultDir(basePath);
             QString url = dialog.filename();
 
             if (!QFileInfo(basePath).exists()) {
                 filename = url;
             } else {
                 QDir d(basePath);
                 filename = d.relativeFilePath(url);
             }
         }
 
         qApp->restoreOverrideCursor();
     }
 
     KisLayer *layer = new KisFileLayer(image, basePath, filename, (KisFileLayer::ScalingMethod)scalingMethod, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 }
 
 KisNodeSP KisKraLoader::loadGroupLayer(const KoXmlElement& element, KisImageWSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     Q_UNUSED(cs);
     QString attr;
     KisGroupLayer* layer;
 
     layer = new KisGroupLayer(image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadAdjustmentLayer(const KoXmlElement& element, KisImageWSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     // XXX: do something with filterversion?
     Q_UNUSED(cs);
     QString attr;
     KisAdjustmentLayer* layer;
     QString filtername;
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid adjustmentlayer! We should warn about it!
         warnFile << "No filter in adjustment layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfiguration * kfc = f->defaultConfiguration(0);
 
     // We'll load the configuration and the selection later.
     layer = new KisAdjustmentLayer(image, name, kfc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadShapeLayer(const KoXmlElement& element, KisImageWSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
 
     Q_UNUSED(element);
     Q_UNUSED(cs);
 
     QString attr;
     KoShapeBasedDocumentBase * shapeController = 0;
     if (m_d->document) {
         shapeController = m_d->document->shapeController();
     }
     KisShapeLayer* layer = new KisShapeLayer(shapeController, image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadGeneratorLayer(const KoXmlElement& element, KisImageWSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
     // XXX: do something with generator version?
     KisGeneratorLayer* layer;
     QString generatorname = element.attribute(GENERATOR_NAME);
 
     if (generatorname.isNull()) {
         // XXX: Invalid generator layer! We should warn about it!
         warnFile << "No generator in generator layer";
         return 0;
     }
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorname);
     if (!generator) {
         warnFile << "No generator for generatorname" << generatorname << "";
         return 0; // XXX: We don't have this generator. We should warn about it!
     }
 
     KisFilterConfiguration * kgc = generator->defaultConfiguration(0);
 
     // We'll load the configuration and the selection later.
     layer = new KisGeneratorLayer(image, name, kgc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadCloneLayer(const KoXmlElement& element, KisImageWSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
 
     KisCloneLayerSP layer = new KisCloneLayer(0, image, name, opacity);
 
     KisCloneInfo info;
     if (! (element.attribute(CLONE_FROM_UUID)).isNull()) {
         info = KisCloneInfo(QUuid(element.attribute(CLONE_FROM_UUID)));
     } else {
         if ((element.attribute(CLONE_FROM)).isNull()) {
             return 0;
         } else {
             info = KisCloneInfo(element.attribute(CLONE_FROM));
         }
     }
     layer->setCopyFromInfo(info);
 
     if ((element.attribute(CLONE_TYPE)).isNull()) {
         return 0;
     } else {
         layer->setCopyType((CopyLayerType) element.attribute(CLONE_TYPE).toInt());
     }
 
     return layer;
 }
 
 
 KisNodeSP KisKraLoader::loadFilterMask(const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(parent);
     QString attr;
     KisFilterMask* mask;
     QString filtername;
 
     // XXX: should we check the version?
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid filter layer! We should warn about it!
         warnFile << "No filter in filter layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfiguration * kfc = f->defaultConfiguration(0);
 
     // We'll load the configuration and the selection later.
     mask = new KisFilterMask();
     mask->setFilter(kfc);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransformMask(const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(element);
     Q_UNUSED(parent);
 
     KisTransformMask* mask;
 
     /**
      * We'll load the transform configuration later on a stage
      * of binary data loading
      */
     mask = new KisTransformMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransparencyMask(const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(element);
     Q_UNUSED(parent);
     KisTransparencyMask* mask = new KisTransparencyMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadSelectionMask(KisImageWSP image, const KoXmlElement& element, KisNodeSP parent)
 {
     Q_UNUSED(parent);
     KisSelectionMaskSP mask = new KisSelectionMask(image);
     bool active = element.attribute(ACTIVE, "1") == "0" ? false : true;
     mask->setActive(active);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageWSP image)
 {
     KoXmlNode child;
 
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
 
         KoXmlElement e = child.toElement();
         QString name = e.attribute("name");
         bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
 
         KisLayerComposition* composition = new KisLayerComposition(image, name);
         composition->setExportEnabled(exportEnabled);
 
         KoXmlNode value;
         for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
             KoXmlElement e = value.toElement();
             QUuid uuid(e.attribute("uuid"));
             bool visible = e.attribute("visible", "1") == "0" ? false : true;
             composition->setVisible(uuid, visible);
             bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
             composition->setCollapsed(uuid, collapsed);
         }
 
         image->addComposition(composition);
     }
 }
 
 void KisKraLoader::loadAssistantsList(const KoXmlElement &elem)
 {
     KoXmlNode child;
     int count = 0;
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
         KoXmlElement e = child.toElement();
         QString type = e.attribute("type");
         QString file_name = e.attribute("filename");
         m_d->assistantsFilenames.insert(file_name,type);
         count++;
 
     }
 }
 
 void KisKraLoader::loadGrid(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGridConfig config;
     config.loadDynamicDataFromXml(domElement);
     config.loadStaticData();
     m_d->document->setGridConfig(config);
 }
 
 void KisKraLoader::loadGuides(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGuidesConfig guides;
     guides.loadFromXml(domElement);
     m_d->document->setGuidesConfig(guides);
 }
diff --git a/libs/ui/opengl/kis_opengl_image_textures.cpp b/libs/ui/opengl/kis_opengl_image_textures.cpp
index 16abb3e971..9886b32c5d 100644
--- a/libs/ui/opengl/kis_opengl_image_textures.cpp
+++ b/libs/ui/opengl/kis_opengl_image_textures.cpp
@@ -1,633 +1,635 @@
 /*
  *  Copyright (c) 2005-2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "opengl/kis_opengl_image_textures.h"
 
 #include <QOpenGLFunctions>
 #include <QOpenGLContext>
 
 #include <QMessageBox>
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 
 #include "kis_image.h"
 #include "kis_config.h"
 #include "KisPart.h"
 
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #ifndef GL_BGRA
 #define GL_BGRA 0x80E1
 #endif
 
 
 KisOpenGLImageTextures::ImageTexturesMap KisOpenGLImageTextures::imageTexturesMap;
 
 KisOpenGLImageTextures::KisOpenGLImageTextures()
     : m_image(0)
     , m_monitorProfile(0)
+    , m_proofingConfig(0)
+    , m_proofingTransform(0)
+    , m_createNewProofingTransform(true)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_allChannelsSelected(true)
     , m_useOcio(false)
     , m_initialized(false)
-    , m_proofingConfig(0)
-    , m_proofingTransform(0)
-    , m_createNewProofingTransform(true)
 {
     KisConfig cfg;
     m_renderingIntent = (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 
     m_conversionFlags = KoColorConversionTransformation::HighQuality;
     if (cfg.useBlackPointCompensation()) m_conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) m_conversionFlags |= KoColorConversionTransformation::NoOptimization;
     m_useOcio = cfg.useOcio();
 }
 
 KisOpenGLImageTextures::KisOpenGLImageTextures(KisImageWSP image,
                                                const KoColorProfile *monitorProfile,
                                                KoColorConversionTransformation::Intent renderingIntent,
                                                KoColorConversionTransformation::ConversionFlags conversionFlags)
     : m_image(image)
     , m_monitorProfile(monitorProfile)
     , m_renderingIntent(renderingIntent)
     , m_conversionFlags(conversionFlags)
+    , m_proofingConfig(0)
+    , m_proofingTransform(0)
     , m_tilesDestinationColorSpace(0)
+    , m_createNewProofingTransform(true)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_allChannelsSelected(true)
     , m_useOcio(false)
     , m_initialized(false)
 {
     Q_ASSERT(renderingIntent < 4);
 }
 
 void KisOpenGLImageTextures::initGL(QOpenGLFunctions *f)
 {
     if (f) {
         m_glFuncs = f;
     } else {
         errUI << "Tried to create OpenGLImageTextures with uninitialized QOpenGLFunctions";
     }
 
     getTextureSize(&m_texturesInfo);
     m_glFuncs->glGenTextures(1, &m_checkerTexture);
     createImageTextureTiles();
 
     KisOpenGLUpdateInfoSP info = updateCache(m_image->bounds());
     recalculateCache(info);
 }
 
 KisOpenGLImageTextures::~KisOpenGLImageTextures()
 {
     ImageTexturesMap::iterator it = imageTexturesMap.find(m_image);
     if (it != imageTexturesMap.end()) {
         KisOpenGLImageTextures *textures = it.value();
         if (textures == this) {
             dbgUI << "Removing shared image context from map";
             imageTexturesMap.erase(it);
         }
     }
 
     destroyImageTextureTiles();
     m_glFuncs->glDeleteTextures(1, &m_checkerTexture);
 }
 
 KisImageSP KisOpenGLImageTextures::image() const
 {
     return m_image;
 }
 
 bool KisOpenGLImageTextures::imageCanShareTextures()
 {
     KisConfig cfg;
     if (cfg.useOcio()) return false;
     if (KisPart::instance()->mainwindowCount() == 1) return true;
     if (qApp->desktop()->screenCount() == 1) return true;
     for (int i = 1; i < qApp->desktop()->screenCount(); i++) {
         if (cfg.displayProfile(i) != cfg.displayProfile(i - 1)) {
             return false;
         }
     }
     return true;
 }
 
 KisOpenGLImageTexturesSP KisOpenGLImageTextures::getImageTextures(KisImageWSP image,
                                                                   const KoColorProfile *monitorProfile,
                                                                   KoColorConversionTransformation::Intent renderingIntent,
                                                                   KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     // Disabled until we figure out why we're deleting the shared textures on closing the second view on a single image
     if (false && imageCanShareTextures()) {
         ImageTexturesMap::iterator it = imageTexturesMap.find(image);
 
         if (it != imageTexturesMap.end()) {
             KisOpenGLImageTexturesSP textures = it.value();
             textures->setMonitorProfile(monitorProfile, renderingIntent, conversionFlags);
 
             return textures;
         } else {
             KisOpenGLImageTextures *imageTextures = new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
             imageTexturesMap[image] = imageTextures;
             dbgUI << "Added shareable textures to map";
 
             return imageTextures;
         }
     } else {
         return new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
     }
 }
 
 QRect KisOpenGLImageTextures::calculateTileRect(int col, int row) const
 {
     return m_image->bounds() &
             QRect(col * m_texturesInfo.effectiveWidth,
                   row * m_texturesInfo.effectiveHeight,
                   m_texturesInfo.effectiveWidth,
                   m_texturesInfo.effectiveHeight);
 }
 
 void KisOpenGLImageTextures::createImageTextureTiles()
 {
 
     destroyImageTextureTiles();
     updateTextureFormat();
 
     if (!m_tilesDestinationColorSpace) {
         qDebug() << "No destination colorspace!!!!";
         return;
     }
 
 
     m_storedImageBounds = m_image->bounds();
     const int lastCol = xToCol(m_image->width());
     const int lastRow = yToRow(m_image->height());
 
     m_numCols = lastCol + 1;
 
     // Default color is transparent black
     const int pixelSize = m_tilesDestinationColorSpace->pixelSize();
     QByteArray emptyTileData((m_texturesInfo.width) * (m_texturesInfo.height) * pixelSize, 0);
 
     KisConfig config;
     KisOpenGL::FilterMode mode = (KisOpenGL::FilterMode)config.openGLFilteringMode();
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
 
         m_initialized = true;
         dbgUI  << "OpenGL: creating texture tiles of size" << m_texturesInfo.height << "x" << m_texturesInfo.width;
 
         m_textureTiles.reserve((lastRow+1)*m_numCols);
         for (int row = 0; row <= lastRow; row++) {
             for (int col = 0; col <= lastCol; col++) {
                 QRect tileRect = calculateTileRect(col, row);
 
                 KisTextureTile *tile = new KisTextureTile(tileRect,
                                                           &m_texturesInfo,
                                                           emptyTileData,
                                                           mode,
                                                           config.useOpenGLTextureBuffer(),
                                                           config.numMipmapLevels(),
                                                           f);
                 m_textureTiles.append(tile);
             }
         }
     }
     else {
         dbgUI << "Tried to init texture tiles without a current OpenGL Context.";
     }
 }
 
 void KisOpenGLImageTextures::destroyImageTextureTiles()
 {
     if (m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         delete tile;
     }
     m_textureTiles.clear();
     m_storedImageBounds = QRect();
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCache(const QRect& rect)
 {
     return updateCacheImpl(rect, true);
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheNoConversion(const QRect& rect)
 {
     return updateCacheImpl(rect, false);
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheImpl(const QRect& rect, bool convertColorSpace)
 {
     const KoColorSpace *dstCS = m_tilesDestinationColorSpace;
 
     ConversionOptions options;
 
     if (convertColorSpace) {
         options = ConversionOptions(dstCS, m_renderingIntent, m_conversionFlags);
     }
 
     KisOpenGLUpdateInfoSP info = new KisOpenGLUpdateInfo(options);
 
     QRect updateRect = rect & m_image->bounds();
     if (updateRect.isEmpty() || !(m_initialized)) return info;
 
     /**
      * Why the rect is artificial? That's easy!
      * It does not represent any real piece of the image. It is
      * intentionally stretched to get through the overlappping
      * stripes of neutrality and poke neighbouring tiles.
      * Thanks to the rect we get the coordinates of all the tiles
      * involved into update process
      */
 
     QRect artificialRect = stretchRect(updateRect, m_texturesInfo.border);
     artificialRect &= m_image->bounds();
 
     int firstColumn = xToCol(artificialRect.left());
     int lastColumn = xToCol(artificialRect.right());
     int firstRow = yToRow(artificialRect.top());
     int lastRow = yToRow(artificialRect.bottom());
 
     QBitArray channelFlags; // empty by default
 
     if (m_channelFlags.size() != m_image->projection()->colorSpace()->channels().size()) {
         setChannelFlags(QBitArray());
     }
     if (!m_useOcio) { // Ocio does its own channel flipping
         if (!m_allChannelsSelected) { // and we do it only if necessary
             channelFlags = m_channelFlags;
         }
     }
 
     qint32 numItems = (lastColumn - firstColumn + 1) * (lastRow - firstRow + 1);
     info->tileList.reserve(numItems);
 
     const QRect bounds = m_image->bounds();
     const int levelOfDetail = m_image->currentLevelOfDetail();
 
     QRect alignedUpdateRect = updateRect;
     QRect alignedBounds = bounds;
 
     if (levelOfDetail) {
         alignedUpdateRect = KisLodTransform::alignedRect(alignedUpdateRect, levelOfDetail);
         alignedBounds = KisLodTransform::alignedRect(alignedBounds, levelOfDetail);
     }
 
     for (int col = firstColumn; col <= lastColumn; col++) {
         for (int row = firstRow; row <= lastRow; row++) {
 
             const QRect tileRect = calculateTileRect(col, row);
             const QRect tileTextureRect = stretchRect(tileRect, m_texturesInfo.border);
 
             QRect alignedTileTextureRect = levelOfDetail ?
                         KisLodTransform::alignedRect(tileTextureRect, levelOfDetail) :
                         tileTextureRect;
 
             KisTextureTileUpdateInfoSP tileInfo(
                         new KisTextureTileUpdateInfo(col, row,
                                                      alignedTileTextureRect,
                                                      alignedUpdateRect,
                                                      alignedBounds,
                                                      levelOfDetail));
             // Don't update empty tiles
             if (tileInfo->valid()) {
                 tileInfo->retrieveData(m_image, channelFlags, m_onlyOneChannelSelected, m_selectedChannelIndex);
 
                 //create transform
                 if (m_createNewProofingTransform) {
                     const KoColorSpace *proofingSpace = KoColorSpaceRegistry::instance()->colorSpace(m_proofingConfig->proofingModel,m_proofingConfig->proofingDepth,m_proofingConfig->proofingProfile);
                     m_proofingTransform = tileInfo->generateProofingTransform(dstCS, proofingSpace, m_renderingIntent, m_proofingConfig->intent, m_proofingConfig->conversionFlags, m_proofingConfig->warningColor);
                     m_createNewProofingTransform = false;
                 }
 
                 if (convertColorSpace) {
                     if (m_proofingConfig && m_proofingTransform && m_proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::SoftProofing)) {
                         tileInfo->proofTo(dstCS, m_proofingConfig->conversionFlags, m_proofingTransform);
                     } else {
                         tileInfo->convertTo(dstCS, m_renderingIntent, m_conversionFlags);
                     }
                 }
 
                 info->tileList.append(tileInfo);
             }
             else {
                 dbgUI << "Trying to create an empty tileinfo record" << col << row << tileTextureRect << updateRect << m_image->bounds();
             }
         }
     }
 
     info->assignDirtyImageRect(rect);
     info->assignLevelOfDetail(levelOfDetail);
     return info;
 }
 
 void KisOpenGLImageTextures::recalculateCache(KisUpdateInfoSP info)
 {
     if (!m_initialized) {
         dbgUI << "OpenGL: Tried to edit image texture cache before it was initialized.";
         return;
     }
 
     KisOpenGLUpdateInfoSP glInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if(!glInfo) return;
 
     KisTextureTileUpdateInfoSP tileInfo;
     Q_FOREACH (tileInfo, glInfo->tileList) {
         KisTextureTile *tile = getTextureTileCR(tileInfo->tileCol(), tileInfo->tileRow());
         KIS_ASSERT_RECOVER_RETURN(tile);
 
         tile->update(*tileInfo);
     }
 }
 
 void KisOpenGLImageTextures::generateCheckerTexture(const QImage &checkImage)
 {
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
         dbgUI << "Attaching checker texture" << checkerTexture();
         f->glBindTexture(GL_TEXTURE_2D, checkerTexture());
 
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
         f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
         QImage img = checkImage;
         if (checkImage.width() != BACKGROUND_TEXTURE_SIZE || checkImage.height() != BACKGROUND_TEXTURE_SIZE) {
             img = checkImage.scaled(BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE);
         }
         f->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE,
                         0, GL_BGRA, GL_UNSIGNED_BYTE, img.constBits());
     }
     else {
         dbgUI << "OpenGL: Tried to generate checker texture before OpenGL was initialized.";
     }
 
 }
 
 GLuint KisOpenGLImageTextures::checkerTexture()
 {
     if (m_glFuncs) {
         if (m_checkerTexture == 0) {
             m_glFuncs->glGenTextures(1, &m_checkerTexture);
         }
         return m_checkerTexture;
     }
     else {
         dbgUI << "Tried to access checker texture before OpenGL was initialized";
         return 0;
     }
 }
 
 void KisOpenGLImageTextures::updateConfig(bool useBuffer, int NumMipmapLevels)
 {
     if(m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         tile->setUseBuffer(useBuffer);
         tile->setNumMipmapLevels(NumMipmapLevels);
     }
 }
 
 void KisOpenGLImageTextures::slotImageSizeChanged(qint32 /*w*/, qint32 /*h*/)
 {
     createImageTextureTiles();
 }
 
 void KisOpenGLImageTextures::setMonitorProfile(const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     //dbgUI << "Setting monitor profile to" << monitorProfile->name() << renderingIntent << conversionFlags;
     m_monitorProfile = monitorProfile;
     m_renderingIntent = renderingIntent;
     m_conversionFlags = conversionFlags;
 
     createImageTextureTiles();
 }
 
 void KisOpenGLImageTextures::setChannelFlags(const QBitArray &channelFlags)
 {
     m_channelFlags = channelFlags;
     int selectedChannels = 0;
     const KoColorSpace *projectionCs = m_image->projection()->colorSpace();
     QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
     if (m_channelFlags.size() != channelInfo.size()) {
         m_channelFlags = QBitArray();
     }
 
     for (int i = 0; i < m_channelFlags.size(); ++i) {
         if (m_channelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
             selectedChannels++;
             m_selectedChannelIndex = i;
         }
     }
     m_allChannelsSelected = (selectedChannels == m_channelFlags.size());
     m_onlyOneChannelSelected = (selectedChannels == 1);
 }
 
 void KisOpenGLImageTextures::setProofingConfig(KisProofingConfiguration *proofingConfig)
 {
     m_proofingConfig = proofingConfig;
-    qDebug()<<"set";
     m_createNewProofingTransform = true;
 }
 
 void KisOpenGLImageTextures::getTextureSize(KisGLTexturesInfo *texturesInfo)
 {
     KisConfig cfg;
 
     const GLint preferredTextureSize = cfg.openGLTextureSize();
 
     GLint maxTextureSize;
     if (m_glFuncs) {
         m_glFuncs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
     }
     else {
         dbgUI << "OpenGL: Tried to read texture size before OpenGL was initialized.";
         maxTextureSize = GL_MAX_TEXTURE_SIZE;
     }
 
     texturesInfo->width = qMin(preferredTextureSize, maxTextureSize);
     texturesInfo->height = qMin(preferredTextureSize, maxTextureSize);
 
     texturesInfo->border = cfg.textureOverlapBorder();
 
     texturesInfo->effectiveWidth = texturesInfo->width - 2 * texturesInfo->border;
     texturesInfo->effectiveHeight = texturesInfo->height - 2 * texturesInfo->border;
 }
 
 bool KisOpenGLImageTextures::internalColorManagementActive() const
 {
     return m_internalColorManagementActive;
 }
 
 bool KisOpenGLImageTextures::setInternalColorManagementActive(bool value)
 {
     bool needsFinalRegeneration = m_internalColorManagementActive != value;
 
     if (needsFinalRegeneration) {
         m_internalColorManagementActive = value;
         createImageTextureTiles();
 
         // at this point the value of m_internalColorManagementActive might
         // have been forcely reverted to 'false' in case of some problems
     }
 
     return needsFinalRegeneration;
 }
 
 void KisOpenGLImageTextures::updateTextureFormat()
 {
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (!(m_image && ctx)) return;
 
     m_texturesInfo.internalFormat = GL_RGBA8;
     m_texturesInfo.type = GL_UNSIGNED_BYTE;
     m_texturesInfo.format = GL_BGRA;
 
     KoID colorModelId = m_image->colorSpace()->colorModelId();
     KoID colorDepthId = m_image->colorSpace()->colorDepthId();
 
     KoID destinationColorModelId = RGBAColorModelID;
     KoID destinationColorDepthId = Integer8BitsColorDepthID;
 
     dbgUI << "Choosing texture format:";
 
     if (colorModelId == RGBAColorModelID) {
         if (colorDepthId == Float16BitsColorDepthID) {
 
             if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA16F_ARB;
                 dbgUI << "Using ARB half";
             }
             else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT16_ATI;
                 dbgUI << "Using ATI half";
             }
 
             bool haveBuiltInOpenExr = false;
 #ifdef HAVE_OPENEXR
             haveBuiltInOpenExr = true;
 #endif
 
             if (haveBuiltInOpenExr && ctx->hasExtension("GL_ARB_half_float_pixel")) {
                 m_texturesInfo.type = GL_HALF_FLOAT_ARB;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half";
             } else {
                 m_texturesInfo.type = GL_FLOAT;
                 destinationColorDepthId = Float32BitsColorDepthID;
                 dbgUI << "Pixel type float";
             }
             m_texturesInfo.format = GL_RGBA;
         }
         else if (colorDepthId == Float32BitsColorDepthID) {
             if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA32F_ARB;
                 dbgUI << "Using ARB float";
             } else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT32_ATI;
                 dbgUI << "Using ATI float";
             }
 
             m_texturesInfo.type = GL_FLOAT;
             m_texturesInfo.format = GL_RGBA;
             destinationColorDepthId = Float32BitsColorDepthID;
         }
         else if (colorDepthId == Integer16BitsColorDepthID) {
             m_texturesInfo.internalFormat = GL_RGBA16;
             m_texturesInfo.type = GL_UNSIGNED_SHORT;
             m_texturesInfo.format = GL_BGRA;
             destinationColorDepthId = Integer16BitsColorDepthID;
             dbgUI << "Using 16 bits rgba";
         }
     }
     else {
         // We will convert the colorspace to 16 bits rgba, instead of 8 bits
         if (colorDepthId == Integer16BitsColorDepthID) {
             m_texturesInfo.internalFormat = GL_RGBA16;
             m_texturesInfo.type = GL_UNSIGNED_SHORT;
             m_texturesInfo.format = GL_BGRA;
             destinationColorDepthId = Integer16BitsColorDepthID;
             dbgUI << "Using conversion to 16 bits rgba";
         }
     }
 
     if (!m_internalColorManagementActive &&
             colorModelId != destinationColorModelId) {
 
         KisConfig cfg;
         KisConfig::OcioColorManagementMode cm = cfg.ocioColorManagementMode();
 
         if (cm != KisConfig::INTERNAL) {
             QMessageBox::critical(0,
                                   i18nc("@title:window", "Krita"),
                                   i18n("You enabled OpenColorIO based color management, but your image is not an RGB image.\n"
                                        "OpenColorIO-based color management only works with RGB images.\n"
                                        "Please check the settings in the LUT docker.\n"
                                        "OpenColorIO will now be deactivated."));
         }
 
         warnUI << "WARNING: Internal color management was forcely enabled";
         warnUI << "Color Management Mode: " << cm;
         warnUI << ppVar(m_image->colorSpace());
         warnUI << ppVar(destinationColorModelId);
         warnUI << ppVar(destinationColorDepthId);
 
         cfg.setOcioColorManagementMode(KisConfig::INTERNAL);
         m_internalColorManagementActive = true;
     }
 
     const KoColorProfile *profile =
             m_internalColorManagementActive ||
             colorModelId != destinationColorModelId ?
                 m_monitorProfile : m_image->colorSpace()->profile();
 
     /**
      * TODO: add an optimization so that the tile->convertTo() method
      *       would not be called when not needed (DK)
      */
 
     m_tilesDestinationColorSpace =
             KoColorSpaceRegistry::instance()->colorSpace(destinationColorModelId.id(),
                                                          destinationColorDepthId.id(),
                                                          profile);
 }
 
diff --git a/plugins/color/lcms2engine/IccColorSpaceEngine.cpp b/plugins/color/lcms2engine/IccColorSpaceEngine.cpp
index 90640ffaef..1311b3a5b5 100644
--- a/plugins/color/lcms2engine/IccColorSpaceEngine.cpp
+++ b/plugins/color/lcms2engine/IccColorSpaceEngine.cpp
@@ -1,315 +1,310 @@
 /*
  *  Copyright (c) 2007-2008 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "IccColorSpaceEngine.h"
 
 #include "KoColorModelStandardIds.h"
 
 #include <klocalizedstring.h>
 
 #include "LcmsColorSpace.h"
 
 #include <QDebug>
 
 // -- KoLcmsColorConversionTransformation --
 
 class KoLcmsColorConversionTransformation : public KoColorConversionTransformation
 {
 public:
     KoLcmsColorConversionTransformation(const KoColorSpace *srcCs, quint32 srcColorSpaceType, LcmsColorProfileContainer *srcProfile,
                                         const KoColorSpace *dstCs, quint32 dstColorSpaceType, LcmsColorProfileContainer *dstProfile,
                                         Intent renderingIntent,
                                         ConversionFlags conversionFlags)
         : KoColorConversionTransformation(srcCs, dstCs, renderingIntent, conversionFlags)
         , m_transform(0)
     {
         Q_ASSERT(srcCs);
         Q_ASSERT(dstCs);
         Q_ASSERT(renderingIntent < 4);
 
         if (srcCs->colorDepthId() == Integer8BitsColorDepthID
                 || srcCs->colorDepthId() == Integer16BitsColorDepthID) {
 
             if ((srcProfile->name().contains(QLatin1String("linear"), Qt::CaseInsensitive) ||
                  dstProfile->name().contains(QLatin1String("linear"), Qt::CaseInsensitive)) &&
                     !conversionFlags.testFlag(KoColorConversionTransformation::NoOptimization)) {
                 conversionFlags |= KoColorConversionTransformation::NoOptimization;
             }
         }
 
         m_transform = cmsCreateTransform(srcProfile->lcmsProfile(),
                                          srcColorSpaceType,
                                          dstProfile->lcmsProfile(),
                                          dstColorSpaceType,
                                          renderingIntent,
                                          conversionFlags);
 
         Q_ASSERT(m_transform);
     }
 
     ~KoLcmsColorConversionTransformation()
     {
         cmsDeleteTransform(m_transform);
     }
 
 public:
 
     virtual void transform(const quint8 *src, quint8 *dst, qint32 numPixels) const
     {
         Q_ASSERT(m_transform);
 
         qint32 srcPixelSize = srcColorSpace()->pixelSize();
         qint32 dstPixelSize = dstColorSpace()->pixelSize();
 
         cmsDoTransform(m_transform, const_cast<quint8 *>(src), dst, numPixels);
         // Lcms does nothing to the destination alpha channel so we must convert that manually.
         while (numPixels > 0) {
             qreal alpha = srcColorSpace()->opacityF(src);
             dstColorSpace()->setOpacity(dst, alpha, 1);
 
             src += srcPixelSize;
             dst += dstPixelSize;
             numPixels--;
         }
 
     }
 private:
     mutable cmsHTRANSFORM m_transform;
 };
 
 class KoLcmsColorProofingConversionTransformation : public KoColorProofingConversionTransformation
 {
 public:
     KoLcmsColorProofingConversionTransformation(const KoColorSpace *srcCs, quint32 srcColorSpaceType, LcmsColorProfileContainer *srcProfile,
                                                 const KoColorSpace *dstCs, quint32 dstColorSpaceType, LcmsColorProfileContainer *dstProfile,
                                                 const KoColorSpace *proofingSpace,
                                                 Intent renderingIntent,
                                                 Intent proofingIntent,
                                                 ConversionFlags conversionFlags,
                                                 quint8 *gamutWarning
                                                 )
         : KoColorProofingConversionTransformation(srcCs, dstCs, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning)
         , m_transform(0)
     {
         Q_ASSERT(srcCs);
         Q_ASSERT(dstCs);
         Q_ASSERT(renderingIntent < 4);
 
         if (srcCs->colorDepthId() == Integer8BitsColorDepthID
                 || srcCs->colorDepthId() == Integer16BitsColorDepthID) {
 
             if ((srcProfile->name().contains(QLatin1String("linear"), Qt::CaseInsensitive) ||
                  dstProfile->name().contains(QLatin1String("linear"), Qt::CaseInsensitive)) &&
                     !conversionFlags.testFlag(KoColorConversionTransformation::NoOptimization)) {
                 conversionFlags |= KoColorConversionTransformation::NoOptimization;
             }
         }
 
         quint16 alarm[cmsMAXCHANNELS];//this seems to be bgr???
         alarm[0] = (cmsUInt16Number)gamutWarning[2]*256;
         alarm[1] = (cmsUInt16Number)gamutWarning[1]*256;
         alarm[2] = (cmsUInt16Number)gamutWarning[0]*256;
         cmsSetAlarmCodes(alarm);
 
-        qDebug()<<"Test gamut check";
-        qDebug()<<conversionFlags.testFlag(KoColorConversionTransformation::GamutCheck);
-        qDebug()<<conversionFlags.testFlag(KoColorConversionTransformation::SoftProofing);
-        qDebug()<<alarm[0]<<", "<< alarm[1]<<", "<< alarm[2];
-
         m_transform = cmsCreateProofingTransform(srcProfile->lcmsProfile(),
                                                  srcColorSpaceType,
                                                  dstProfile->lcmsProfile(),
                                                  dstColorSpaceType,
                                                  dynamic_cast<const IccColorProfile *>(proofingSpace->profile())->asLcms()->lcmsProfile(),
                                                  renderingIntent,
                                                  proofingIntent,
                                                  conversionFlags);
 
         Q_ASSERT(m_transform);
     }
 
     ~KoLcmsColorProofingConversionTransformation()
     {
         cmsDeleteTransform(m_transform);
     }
 
 public:
 
     virtual void transform(const quint8 *src, quint8 *dst, qint32 numPixels) const
     {
         Q_ASSERT(m_transform);
 
         qint32 srcPixelSize = srcColorSpace()->pixelSize();
         qint32 dstPixelSize = dstColorSpace()->pixelSize();
 
         cmsDoTransform(m_transform, const_cast<quint8 *>(src), dst, numPixels);
         // Lcms does nothing to the destination alpha channel so we must convert that manually.
         while (numPixels > 0) {
             qreal alpha = srcColorSpace()->opacityF(src);
             dstColorSpace()->setOpacity(dst, alpha, 1);
 
             src += srcPixelSize;
             dst += dstPixelSize;
             numPixels--;
         }
 
     }
 private:
     mutable cmsHTRANSFORM m_transform;
 };
 
 struct IccColorSpaceEngine::Private {
 };
 
 IccColorSpaceEngine::IccColorSpaceEngine() : KoColorSpaceEngine("icc", i18n("ICC Engine")), d(new Private)
 {
 }
 
 IccColorSpaceEngine::~IccColorSpaceEngine()
 {
     delete d;
 }
 
 void IccColorSpaceEngine::addProfile(const QString &filename)
 {
     KoColorSpaceRegistry *registry = KoColorSpaceRegistry::instance();
 
     KoColorProfile *profile = new IccColorProfile(filename);
     Q_CHECK_PTR(profile);
 
     // this our own loading code; sometimes it fails because of an lcms error
     profile->load();
 
     // and then lcms can read the profile from file itself without problems,
     // quite often, and we can initialize it
     if (!profile->valid()) {
         cmsHPROFILE cmsp = cmsOpenProfileFromFile(filename.toLatin1(), "r");
         profile = LcmsColorProfileContainer::createFromLcmsProfile(cmsp);
     }
 
     if (profile->valid()) {
         qDebug() << "Valid profile : " << profile->fileName() << profile->name();
         registry->addProfile(profile);
     } else {
         qDebug() << "Invalid profile : " << profile->fileName() << profile->name();
         delete profile;
     }
 
 }
 
 void IccColorSpaceEngine::removeProfile(const QString &filename)
 {
     KoColorSpaceRegistry *registry = KoColorSpaceRegistry::instance();
 
     KoColorProfile *profile = new IccColorProfile(filename);
     Q_CHECK_PTR(profile);
     profile->load();
 
     if (profile->valid() && registry->profileByName(profile->name())) {
         registry->removeProfile(profile);
     }
 }
 
 KoColorConversionTransformation *IccColorSpaceEngine::createColorTransformation(const KoColorSpace *srcColorSpace,
                                                                                 const KoColorSpace *dstColorSpace,
                                                                                 KoColorConversionTransformation::Intent renderingIntent,
                                                                                 KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     Q_ASSERT(srcColorSpace);
     Q_ASSERT(dstColorSpace);
 
     return new KoLcmsColorConversionTransformation(
                 srcColorSpace, computeColorSpaceType(srcColorSpace),
                 dynamic_cast<const IccColorProfile *>(srcColorSpace->profile())->asLcms(), dstColorSpace, computeColorSpaceType(dstColorSpace),
                 dynamic_cast<const IccColorProfile *>(dstColorSpace->profile())->asLcms(), renderingIntent, conversionFlags);
 
 }
 KoColorProofingConversionTransformation *IccColorSpaceEngine::createColorProofingTransformation(const KoColorSpace *srcColorSpace,
                                                                                                 const KoColorSpace *dstColorSpace,
                                                                                                 const KoColorSpace *proofingSpace,
                                                                                                 KoColorConversionTransformation::Intent renderingIntent,
                                                                                                 KoColorConversionTransformation::Intent proofingIntent,
                                                                                                 KoColorConversionTransformation::ConversionFlags conversionFlags,
                                                                                                 quint8 *gamutWarning) const
 {
     Q_ASSERT(srcColorSpace);
     Q_ASSERT(dstColorSpace);
 
     return new KoLcmsColorProofingConversionTransformation(
                 srcColorSpace, computeColorSpaceType(srcColorSpace),
                 dynamic_cast<const IccColorProfile *>(srcColorSpace->profile())->asLcms(), dstColorSpace, computeColorSpaceType(dstColorSpace),
                 dynamic_cast<const IccColorProfile *>(dstColorSpace->profile())->asLcms(), proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning
                 );
 }
 
 quint32 IccColorSpaceEngine::computeColorSpaceType(const KoColorSpace *cs) const
 {
     Q_ASSERT(cs);
 
     if (const KoLcmsInfo *lcmsInfo = dynamic_cast<const KoLcmsInfo *>(cs)) {
         return lcmsInfo->colorSpaceType();
     } else {
         QString modelId = cs->colorModelId().id();
         QString depthId = cs->colorDepthId().id();
         // Compute the depth part of the type
         quint32 depthType;
 
         if (depthId == Integer8BitsColorDepthID.id()) {
             depthType = BYTES_SH(1);
         } else if (depthId == Integer16BitsColorDepthID.id()) {
             depthType = BYTES_SH(2);
         } else if (depthId == Float16BitsColorDepthID.id()) {
             depthType = BYTES_SH(2);
         } else if (depthId == Float32BitsColorDepthID.id()) {
             depthType = BYTES_SH(4);
         } else if (depthId == Float64BitsColorDepthID.id()) {
             depthType = BYTES_SH(0);
         } else {
             qWarning() << "Unknow bit depth";
             return 0;
         }
         // Compute the model part of the type
         quint32 modelType = 0;
 
         if (modelId == RGBAColorModelID.id()) {
             if (depthId.startsWith(QLatin1Char('U'))) {
                 modelType = (COLORSPACE_SH(PT_RGB) | EXTRA_SH(1) | CHANNELS_SH(3) | DOSWAP_SH(1) | SWAPFIRST_SH(1));
             } else if (depthId.startsWith(QLatin1Char('F'))) {
                 modelType = (COLORSPACE_SH(PT_RGB) | EXTRA_SH(1) | CHANNELS_SH(3));
             }
         } else if (modelId == XYZAColorModelID.id()) {
             modelType = (COLORSPACE_SH(PT_XYZ) | EXTRA_SH(1) | CHANNELS_SH(3));
         } else if (modelId == LABAColorModelID.id()) {
             modelType = (COLORSPACE_SH(PT_Lab) | EXTRA_SH(1) | CHANNELS_SH(3));
         } else if (modelId == CMYKAColorModelID.id()) {
             modelType = (COLORSPACE_SH(PT_CMYK) | EXTRA_SH(1) | CHANNELS_SH(4));
         } else if (modelId == GrayAColorModelID.id()) {
             modelType = (COLORSPACE_SH(PT_GRAY) | EXTRA_SH(1) | CHANNELS_SH(1));
         } else if (modelId == GrayColorModelID.id()) {
             modelType = (COLORSPACE_SH(PT_GRAY) | CHANNELS_SH(1));
         } else if (modelId == YCbCrAColorModelID.id()) {
             modelType = (COLORSPACE_SH(PT_YCbCr) | EXTRA_SH(1) | CHANNELS_SH(3));
         } else {
             qWarning() << "Cannot convert colorspace to lcms modeltype";
             return 0;
         }
         return depthType | modelType;
     }
 }