diff --git a/krita/data/templates/animation/.directory b/krita/data/templates/animation/.directory
index e97c8024d7..2faab82dfc 100644
--- a/krita/data/templates/animation/.directory
+++ b/krita/data/templates/animation/.directory
@@ -1,15 +1,16 @@
 [Desktop Entry]
 Name=Animation Templates
 Name[ca]=Plantilles d'animació
 Name[ca@valencia]=Plantilles d'animació
 Name[cs]=Šablony animací:
 Name[en_GB]=Animation Templates
+Name[es]=Plantillas de animación
 Name[it]=Modelli di animazioni
 Name[nl]=Animatiesjablonen
 Name[pl]=Szablony animacji
 Name[pt]=Modelos de Animações
 Name[pt_BR]=Modelos de animação
 Name[sv]=Animeringsmallar
 Name[uk]=Шаблони анімацій
 Name[x-test]=xxAnimation Templatesxx
 X-KDE-DefaultTab=true
diff --git a/libs/image/commands/kis_image_set_projection_color_space_command.cpp b/libs/image/commands/kis_image_set_projection_color_space_command.cpp
index 3eb9b8dfd7..e4d2a3293f 100644
--- a/libs/image/commands/kis_image_set_projection_color_space_command.cpp
+++ b/libs/image/commands/kis_image_set_projection_color_space_command.cpp
@@ -1,53 +1,52 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image_commands.h"
 
 #include "KoColorSpace.h"
 #include "kis_image.h"
 
 #include <klocalizedstring.h>
 
 
 KisImageSetProjectionColorSpaceCommand::KisImageSetProjectionColorSpaceCommand(KisImageWSP image, const KoColorSpace * afterColorSpace)
     : KisImageCommand(kundo2_i18n("Convert Image Type"), image)
 {
     KisImageSP imageSP = image.toStrongRef();
     if (imageSP) {
         m_beforeColorSpace = imageSP->colorSpace();
         m_afterColorSpace = afterColorSpace;
-        imageSP->setProjectionColorSpace(m_afterColorSpace);
     }
 }
 
 void KisImageSetProjectionColorSpaceCommand::redo()
 {
     KisImageSP image = m_image.toStrongRef();
     if (image) {
         image->setProjectionColorSpace(m_afterColorSpace);
     }
 }
 
 void KisImageSetProjectionColorSpaceCommand::undo()
 {
     KisImageSP image = m_image.toStrongRef();
     if (image) {
         image->setProjectionColorSpace(m_beforeColorSpace);
     }
 }
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index 81477d2842..cc45b10e66 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,1695 +1,1694 @@
 /*
  *  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
 
 
 struct KisImageSPStaticRegistrar {
     KisImageSPStaticRegistrar() {
         qRegisterMetaType<KisImageSP>("KisImageSP");
     }
 };
 static KisImageSPStaticRegistrar __registrar;
 
 class KisImage::KisImagePrivate
 {
 public:
     KisImagePrivate(KisImage *_q, qint32 w, qint32 h,
                     const KoColorSpace *c,
                     KisUndoStore *undo,
                     KisImageAnimationInterface *_animationInterface)
         : q(_q)
         , lockedForReadOnly(false)
         , width(w)
         , height(h)
         , colorSpace(c ? c : KoColorSpaceRegistry::instance()->rgb8())
         , nserver(1)
         , undoStore(undo ? undo : new KisDumbUndoStore())
         , legacyUndoAdapter(undoStore.data(), _q)
         , postExecutionUndoAdapter(undoStore.data(), _q)
         , recorder(_q)
         , signalRouter(_q)
         , animationInterface(_animationInterface)
         , scheduler(_q)
         , axesCenter(QPointF(0.5, 0.5))
     {
         {
             KisImageConfig cfg;
             if (cfg.enableProgressReporting()) {
                 scheduler.setProgressProxy(&compositeProgressProxy);
             }
 
             // Each of these lambdas defines a new factory function.
             scheduler.setLod0ToNStrokeStrategyFactory(
                 [=](bool forgettable) {
                     return KisLodSyncPair(
                         new KisSyncLodCacheStrokeStrategy(KisImageWSP(q), forgettable),
                         KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setSuspendUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), true),
                         KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setResumeUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), false),
                         KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP(q)));
                 });
         }
 
         connect(q, SIGNAL(sigImageModified()), KisMemoryStatisticsServer::instance(), SLOT(notifyImageChanged()));
     }
 
     ~KisImagePrivate() {
         /**
          * Stop animation interface. It may use the rootLayer.
          */
         delete animationInterface;
 
         /**
          * First delete the nodes, while strokes
          * and undo are still alive
          */
         rootLayer.clear();
     }
 
     KisImage *q;
 
     quint32 lockCount = 0;
     bool lockedForReadOnly;
 
     qint32 width;
     qint32 height;
 
     double xres = 1.0;
     double yres = 1.0;
 
     const KoColorSpace * colorSpace;
     KisProofingConfigurationSP proofingConfig;
 
     KisSelectionSP deselectedGlobalSelection;
     KisGroupLayerSP rootLayer; // The layers are contained in here
     QList<KisLayerCompositionSP> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted = false;
 
     KisNameServer nserver;
 
     QScopedPointer<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;
 
     QPointF axesCenter;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc);
 };
 
 KisImage::KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name)
         : QObject(0)
         , KisShared()
         , m_d(new KisImagePrivate(this, width, height,
                                   colorSpace, undoStore,
                                   new KisImageAnimationInterface(this)))
 {
     setObjectName(name);
     setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
 }
 
 KisImage::~KisImage()
 {
     qDebug() << "deleting kisimage" << objectName();
 
     /**
      * Request the tools to end currently running strokes
      */
     waitForDone();
 
     delete m_d;
     disconnect(); // in case Qt gets confused
 }
 
 KisImage *KisImage::clone(bool exactCopy)
 {
     return new KisImage(*this, 0, exactCopy);
 }
 
 KisImage::KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy)
     : KisNodeFacade(),
       KisNodeGraphListener(),
       KisShared(),
       m_d(new KisImagePrivate(this,
                               rhs.width(), rhs.height(),
                               rhs.colorSpace(),
                               undoStore ? undoStore : new KisDumbUndoStore(),
                               new KisImageAnimationInterface(*rhs.animationInterface(), this)))
 {
     setObjectName(rhs.objectName());
 
     m_d->xres = rhs.m_d->xres;
     m_d->yres = rhs.m_d->yres;
 
 
     if (rhs.m_d->proofingConfig) {
         m_d->proofingConfig = toQShared(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
     }
 
     KisNodeSP newRoot = rhs.root()->clone();
     newRoot->setGraphListener(this);
     newRoot->setImage(this);
     m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
     setRoot(newRoot);
 
     if (exactCopy) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.root(),
             [&linearizedNodes](KisNodeSP node) {
                 linearizedNodes.enqueue(node);
             });
         KisLayerUtils::recursiveApplyNodes(newRoot,
             [&linearizedNodes](KisNodeSP node) {
                 KisNodeSP refNode = linearizedNodes.dequeue();
                 node->setUuid(refNode->uuid());
             });
     }
 
     Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
         m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
     }
 
     rhs.m_d->nserver = KisNameServer(rhs.m_d->nserver);
 
     vKisAnnotationSP newAnnotations;
     Q_FOREACH (KisAnnotationSP annotation, rhs.m_d->annotations) {
         newAnnotations << annotation->clone();
     }
     m_d->annotations = newAnnotations;
 
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->projectionUpdatesFilter);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableUIUpdateSignals);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableDirtyRequests);
 
     m_d->blockLevelOfDetail = rhs.m_d->blockLevelOfDetail;
 }
 
 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(bool allowLocked)
 {
     return (allowLocked || !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 = qobject_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);
     bool retval = m_d->rootLayer->accept(visitor);
     m_d->signalRouter.emitNotification(ProfileChangedSignal);
     return retval;
 
 }
 
 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;
-    assignImageProfile(colorSpace->profile());
     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
 {
     const int lod = currentLevelOfDetail();
     return lod > 0 ?
         m_d->scheduler.lodNPostExecutionUndoAdapter() :
         &m_d->postExecutionUndoAdapter;
 }
 
 void KisImage::setUndoStore(KisUndoStore *undoStore)
 {
 
     m_d->legacyUndoAdapter.setUndoStore(undoStore);
     m_d->postExecutionUndoAdapter.setUndoStore(undoStore);
     m_d->undoStore.reset(undoStore);
 }
 
 KisUndoStore* KisImage::undoStore()
 {
     return m_d->undoStore.data();
 }
 
 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 = original->defaultPixel();
     }
 
     m_d->rootLayer = rootLayer;
     m_d->rootLayer->disconnect();
     m_d->rootLayer->setGraphListener(this);
     m_d->rootLayer->setImage(this);
 
     KisPaintDeviceSP newOriginal = m_d->rootLayer->original();
     newOriginal->setDefaultPixel(defaultProjectionColor);
 
     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();
     }
 }
 
 UndoResult KisImage::tryUndoUnfinishedLod0Stroke()
 {
     return m_d->scheduler.tryUndoLastStrokeAsync();
 }
 
 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<KisLayerCompositionSP> KisImage::compositions()
 {
     return m_d->compositions;
 }
 
 void KisImage::addComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.append(composition);
 }
 
 void KisImage::removeComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.removeAll(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(KisProofingConfigurationSP proofingConfig)
 {
     m_d->proofingConfig = proofingConfig;
     emit sigProofingConfigChanged();
 }
 
 KisProofingConfigurationSP KisImage::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
         KisImageConfig cfg;
         m_d->proofingConfig = cfg.defaultProofingconfiguration();
     }
     return m_d->proofingConfig;
 }
 
 QPointF KisImage::mirrorAxesCenter() const
 {
     return m_d->axesCenter;
 }
 
 void KisImage::setMirrorAxesCenter(const QPointF &value) const
 {
     m_d->axesCenter = value;
 }
diff --git a/libs/image/kis_raster_keyframe_channel.cpp b/libs/image/kis_raster_keyframe_channel.cpp
index bacf6cfe4b..2c18f15de1 100644
--- a/libs/image/kis_raster_keyframe_channel.cpp
+++ b/libs/image/kis_raster_keyframe_channel.cpp
@@ -1,287 +1,296 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_raster_keyframe_channel.h"
 #include "kis_node.h"
 #include "kis_dom_utils.h"
 
 #include "kis_global.h"
 #include "kis_paint_device.h"
 #include "kis_paint_device_frames_interface.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 #include "kis_onion_skin_compositor.h"
 
 struct KisRasterKeyframe : public KisKeyframe
 {
     KisRasterKeyframe(KisRasterKeyframeChannel *channel, int time, int frameId)
         : KisKeyframe(channel, time)
         , frameId(frameId)
     {}
 
-    KisRasterKeyframe(const KisRasterKeyframe *rhs, KisRasterKeyframeChannel *channel)
+    KisRasterKeyframe(const KisRasterKeyframe *rhs, KisKeyframeChannel *channel)
         : KisKeyframe(rhs, channel)
         , frameId(rhs->frameId)
     {}
 
     int frameId;
 
     KisKeyframeSP cloneFor(KisKeyframeChannel *channel) const
     {
-        KisRasterKeyframeChannel *rasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(channel);
-        Q_ASSERT(rasterChannel);
-        return toQShared(new KisRasterKeyframe(this, rasterChannel));
+        return toQShared(new KisRasterKeyframe(this, channel));
     }
 
 };
 
 struct KisRasterKeyframeChannel::Private
 {
   Private(KisPaintDeviceWSP paintDevice, const QString filenameSuffix)
       : paintDevice(paintDevice),
         filenameSuffix(filenameSuffix),
         onionSkinsEnabled(false)
   {}
 
   KisPaintDeviceWSP paintDevice;
   QMap<int, QString> frameFilenames;
   QString filenameSuffix;
   bool onionSkinsEnabled;
 };
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KoID &id, const KisPaintDeviceWSP paintDevice, KisDefaultBoundsBaseSP defaultBounds)
     : KisKeyframeChannel(id, defaultBounds),
       m_d(new Private(paintDevice, QString()))
 {
 }
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KisRasterKeyframeChannel &rhs, const KisNodeWSP newParentNode, const KisPaintDeviceWSP newPaintDevice)
     : KisKeyframeChannel(rhs, newParentNode),
       m_d(new Private(newPaintDevice, rhs.m_d->filenameSuffix))
 {
     KIS_ASSERT_RECOVER_NOOP(&rhs != this);
 
     m_d->frameFilenames = rhs.m_d->frameFilenames;
     m_d->onionSkinsEnabled = rhs.m_d->onionSkinsEnabled;
 }
 
 KisRasterKeyframeChannel::~KisRasterKeyframeChannel()
 {
 }
 
 int KisRasterKeyframeChannel::frameId(KisKeyframeSP keyframe) const
 {
     KisRasterKeyframe *key = dynamic_cast<KisRasterKeyframe*>(keyframe.data());
     Q_ASSERT(key != 0);
     return key->frameId;
 }
 
 int KisRasterKeyframeChannel::frameIdAt(int time) const
 {
     KisKeyframeSP activeKey = activeKeyframeAt(time);
     if (activeKey.isNull()) return -1;
     return frameId(activeKey);
 }
 
 void KisRasterKeyframeChannel::fetchFrame(KisKeyframeSP keyframe, KisPaintDeviceSP targetDevice)
 {
     m_d->paintDevice->framesInterface()->fetchFrame(frameId(keyframe), targetDevice);
 }
 
 void KisRasterKeyframeChannel::importFrame(int time, KisPaintDeviceSP sourceDevice, KUndo2Command *parentCommand)
 {
     KisKeyframeSP keyframe = addKeyframe(time, parentCommand);
 
     const int frame = frameId(keyframe);
 
     m_d->paintDevice->framesInterface()->uploadFrame(frame, sourceDevice);
 }
 
 QRect KisRasterKeyframeChannel::frameExtents(KisKeyframeSP keyframe)
 {
     return m_d->paintDevice->framesInterface()->frameBounds(frameId(keyframe));
 }
 
 QString KisRasterKeyframeChannel::frameFilename(int frameId) const
 {
     return m_d->frameFilenames.value(frameId, QString());
 }
 
 void KisRasterKeyframeChannel::setFilenameSuffix(const QString &suffix)
 {
     m_d->filenameSuffix = suffix;
 }
 
 void KisRasterKeyframeChannel::setFrameFilename(int frameId, const QString &filename)
 {
     Q_ASSERT(!m_d->frameFilenames.contains(frameId));
     m_d->frameFilenames.insert(frameId, filename);
 }
 
 QString KisRasterKeyframeChannel::chooseFrameFilename(int frameId, const QString &layerFilename)
 {
     QString filename;
 
     if (m_d->frameFilenames.isEmpty()) {
         // Use legacy naming convention for first keyframe
         filename = layerFilename + m_d->filenameSuffix;
     } else {
         filename = layerFilename + m_d->filenameSuffix + ".f" + QString::number(frameId);
     }
 
     setFrameFilename(frameId, filename);
 
     return filename;
 }
 
 KisKeyframeSP KisRasterKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
-    int srcFrame = (copySrc != 0) ? frameId(copySrc) : 0;
+    KisRasterKeyframe *keyframe;
 
-    int frameId = m_d->paintDevice->framesInterface()->createFrame((copySrc != 0), srcFrame, QPoint(), parentCommand);
+    if (!copySrc) {
+        int frameId = m_d->paintDevice->framesInterface()->createFrame(false, 0, QPoint(), parentCommand);
+        keyframe = new KisRasterKeyframe(this, time, frameId);
+    } else {
+        int srcFrame = frameId(copySrc);
+        int frameId = m_d->paintDevice->framesInterface()->createFrame(true, srcFrame, QPoint(), parentCommand);
 
-    KisKeyframeSP keyframe(new KisRasterKeyframe(this, time, frameId));
+        KisRasterKeyframe *srcKeyframe = dynamic_cast<KisRasterKeyframe*>(copySrc.data());
+        Q_ASSERT(srcKeyframe);
+        keyframe = new KisRasterKeyframe(srcKeyframe, this);
 
-    return keyframe;
+        keyframe->setTime(time);
+        keyframe->frameId = frameId;
+    }
+
+    return toQShared(keyframe);
 }
 
 void KisRasterKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
 {
     m_d->paintDevice->framesInterface()->deleteFrame(frameId(key), parentCommand);
 }
 
 void KisRasterKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     KisRasterKeyframeChannel *srcRasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(srcChannel);
     KIS_ASSERT_RECOVER_RETURN(srcRasterChannel);
 
     const int srcId = srcRasterChannel->frameIdAt(srcTime);
     const int dstId = frameId(dstFrame);
 
     m_d->paintDevice->framesInterface()->
         uploadFrame(srcId,
                     dstId,
                     srcRasterChannel->m_d->paintDevice);
 }
 
 QRect KisRasterKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     KeyframesMap::iterator it = keys().find(key->time());
     QRect rect;
 
     // Calculate changed area as the union of the current and previous keyframe.
     // This makes sure there are no artifacts left over from the previous frame
     // where the new one doesn't cover the area.
 
     if (it == keys().begin()) {
         // Using the *next* keyframe at the start of the timeline avoids artifacts
         // when deleting or moving the first key
         it++;
     } else {
         it--;
     }
 
     if (it != keys().end()) {
         rect = m_d->paintDevice->framesInterface()->frameBounds(frameId(it.value()));
     }
 
     rect |= m_d->paintDevice->framesInterface()->frameBounds(frameId(key));
 
     if (m_d->onionSkinsEnabled) {
         const QRect dirtyOnionSkinsRect =
             KisOnionSkinCompositor::instance()->calculateFullExtent(m_d->paintDevice);
         rect |= dirtyOnionSkinsRect;
     }
 
     return rect;
 }
 
 QDomElement KisRasterKeyframeChannel::toXML(QDomDocument doc, const QString &layerFilename)
 {
     m_d->frameFilenames.clear();
 
     return KisKeyframeChannel::toXML(doc, layerFilename);
 }
 
 void KisRasterKeyframeChannel::loadXML(const QDomElement &channelNode)
 {
     m_d->frameFilenames.clear();
 
     KisKeyframeChannel::loadXML(channelNode);
 }
 
 void KisRasterKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     int frame = frameId(keyframe);
 
     QString filename = frameFilename(frame);
     if (filename.isEmpty()) {
         filename = chooseFrameFilename(frame, layerFilename);
     }
     keyframeElement.setAttribute("frame", filename);
 
     QPoint offset = m_d->paintDevice->framesInterface()->frameOffset(frame);
     KisDomUtils::saveValue(&keyframeElement, "offset", offset);
 }
 
 KisKeyframeSP KisRasterKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
     int time = keyframeNode.attribute("time").toUInt();
 
     QPoint offset;
     KisDomUtils::loadValue(keyframeNode, "offset", &offset);
     QString frameFilename = keyframeNode.attribute("frame");
 
     KisKeyframeSP keyframe;
 
     if (m_d->frameFilenames.isEmpty()) {
         // First keyframe loaded: use the existing frame
 
         Q_ASSERT(keyframeCount() == 1);
         keyframe = constKeys().begin().value();
 
         // Remove from keys. It will get reinserted with new time once we return
         keys().remove(keyframe->time());
 
         keyframe->setTime(time);
         m_d->paintDevice->framesInterface()->setFrameOffset(frameId(keyframe), offset);
     } else {
         KUndo2Command tempCommand;
         int frameId = m_d->paintDevice->framesInterface()->createFrame(false, 0, offset, &tempCommand);
 
         keyframe = toQShared(new KisRasterKeyframe(this, time, frameId));
     }
 
     setFrameFilename(frameId(keyframe), frameFilename);
 
     return keyframe;
 }
 
 bool KisRasterKeyframeChannel::hasScalarValue() const
 {
     return false;
 }
 
 void KisRasterKeyframeChannel::setOnionSkinsEnabled(bool value)
 {
     m_d->onionSkinsEnabled = value;
 }
 
 bool KisRasterKeyframeChannel::onionSkinsEnabled() const
 {
     return m_d->onionSkinsEnabled;
 }
diff --git a/libs/image/kis_scalar_keyframe_channel.cpp b/libs/image/kis_scalar_keyframe_channel.cpp
index f00ba5741d..00d6c912a5 100644
--- a/libs/image/kis_scalar_keyframe_channel.cpp
+++ b/libs/image/kis_scalar_keyframe_channel.cpp
@@ -1,465 +1,472 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_node.h"
 #include "kundo2command.h"
 #include "kis_time_range.h"
 
 #include <kis_global.h>
 #include <kis_dom_utils.h>
 
 struct KisScalarKeyframe : public KisKeyframe
 {
     KisScalarKeyframe(KisKeyframeChannel *channel, int time, qreal value)
         : KisKeyframe(channel, time)
         , value(value)
     {}
 
     KisScalarKeyframe(const KisScalarKeyframe *rhs, KisKeyframeChannel *channel)
         : KisKeyframe(rhs, channel)
         , value(rhs->value)
     {}
 
     qreal value;
 
     KisKeyframeSP cloneFor(KisKeyframeChannel *channel) const
     {
         return toQShared(new KisScalarKeyframe(this, channel));
     }
 };
 
 
 KisScalarKeyframeChannel::AddKeyframeCommand::AddKeyframeCommand(KisScalarKeyframeChannel *channel, int time, qreal value, KUndo2Command *parentCommand)
     : KisReplaceKeyframeCommand(channel, time, channel->createKeyframe(time, value, parentCommand), parentCommand)
 {}
 
 struct KisScalarKeyframeChannel::Private
 {
 public:
     Private(qreal min, qreal max, KisKeyframe::InterpolationMode defaultInterpolation)
         : minValue(min), maxValue(max), firstFreeIndex(0), defaultInterpolation(defaultInterpolation)
     {}
 
     qreal minValue;
     qreal maxValue;
     int firstFreeIndex;
 
     KisKeyframe::InterpolationMode defaultInterpolation;
 
     struct SetValueCommand;
     struct SetTangentsCommand;
     struct SetInterpolationModeCommand;
 };
 
 KisScalarKeyframeChannel::KisScalarKeyframeChannel(const KoID &id, qreal minValue, qreal maxValue, KisDefaultBoundsBaseSP defaultBounds, KisKeyframe::InterpolationMode defaultInterpolation)
     : KisKeyframeChannel(id, defaultBounds),
       m_d(new Private(minValue, maxValue, defaultInterpolation))
 {
 }
 
 KisScalarKeyframeChannel::~KisScalarKeyframeChannel()
 {}
 
 bool KisScalarKeyframeChannel::hasScalarValue() const
 {
     return true;
 }
 
 qreal KisScalarKeyframeChannel::minScalarValue() const
 {
     return m_d->minValue;
 }
 
 qreal KisScalarKeyframeChannel::maxScalarValue() const
 {
     return m_d->maxValue;
 }
 
 qreal KisScalarKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
 {
     KisScalarKeyframe *key = dynamic_cast<KisScalarKeyframe*>(keyframe.data());
     Q_ASSERT(key != 0);
     return key->value;
 }
 
 struct KisScalarKeyframeChannel::Private::SetValueCommand : public KUndo2Command
 {
     SetValueCommand(KisScalarKeyframeChannel *channel, KisKeyframeSP keyframe, qreal oldValue, qreal newValue, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldValue(oldValue),
           m_newValue(newValue)
     {
     }
 
     void redo() override {
         setValue(m_newValue);
     }
 
     void undo() override {
         setValue(m_oldValue);
     }
 
     void setValue(qreal value) {
         KisScalarKeyframe *key = dynamic_cast<KisScalarKeyframe*>(m_keyframe.data());
         Q_ASSERT(key != 0);
         key->value = value;
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
 private:
     KisScalarKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     qreal m_oldValue;
     qreal m_newValue;
 };
 
 struct KisScalarKeyframeChannel::Private::SetTangentsCommand : public KUndo2Command
 {
     SetTangentsCommand(KisScalarKeyframeChannel *channel, KisKeyframeSP keyframe,
                        KisKeyframe::InterpolationTangentsMode oldMode, QPointF oldLeftTangent, QPointF oldRightTangent,
                        KisKeyframe::InterpolationTangentsMode newMode, QPointF newLeftTangent, QPointF newRightTangent,
                        KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldMode(oldMode),
           m_oldLeftTangent(oldLeftTangent),
           m_oldRightTangent(oldRightTangent),
           m_newMode(newMode),
           m_newLeftTangent(newLeftTangent),
           m_newRightTangent(newRightTangent)
     {
     }
 
     void redo() override {
         m_keyframe->setTangentsMode(m_newMode);
         m_keyframe->setInterpolationTangents(m_newLeftTangent, m_newRightTangent);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
     void undo() override {
         m_keyframe->setTangentsMode(m_oldMode);
         m_keyframe->setInterpolationTangents(m_oldLeftTangent, m_oldRightTangent);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
 private:
     KisScalarKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     KisKeyframe::InterpolationTangentsMode m_oldMode;
     QPointF m_oldLeftTangent;
     QPointF m_oldRightTangent;
     KisKeyframe::InterpolationTangentsMode m_newMode;
     QPointF m_newLeftTangent;
     QPointF m_newRightTangent;
 };
 
 struct KisScalarKeyframeChannel::Private::SetInterpolationModeCommand : public KUndo2Command
 {
     SetInterpolationModeCommand(KisScalarKeyframeChannel *channel, KisKeyframeSP keyframe, KisKeyframe::InterpolationMode oldMode, KisKeyframe::InterpolationMode newMode, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldMode(oldMode),
           m_newMode(newMode)
     {
     }
 
     void redo() override {
         m_keyframe->setInterpolationMode(m_newMode);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
     void undo() override {
         m_keyframe->setInterpolationMode(m_oldMode);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
 private:
     KisScalarKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     KisKeyframe::InterpolationMode m_oldMode;
     KisKeyframe::InterpolationMode m_newMode;
 };
 
 void KisScalarKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     qreal oldValue = scalarValue(keyframe);
     KUndo2Command *cmd = new Private::SetValueCommand(this, keyframe, oldValue, value, parentCommand);
     cmd->redo();
 }
 
 void KisScalarKeyframeChannel::setInterpolationMode(KisKeyframeSP keyframe, KisKeyframe::InterpolationMode mode, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     KisKeyframe::InterpolationMode oldMode = keyframe->interpolationMode();
 
     KUndo2Command *cmd = new Private::SetInterpolationModeCommand(this, keyframe, oldMode, mode, parentCommand);
     cmd->redo();
 }
 
 void KisScalarKeyframeChannel::setInterpolationTangents(KisKeyframeSP keyframe, KisKeyframe::InterpolationTangentsMode mode, QPointF leftTangent, QPointF rightTangent, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     KisKeyframe::InterpolationTangentsMode oldMode = keyframe->tangentsMode();
     QPointF oldLeftTangent = keyframe->leftTangent();
     QPointF oldRightTangent = keyframe->rightTangent();
 
     KUndo2Command *cmd = new Private::SetTangentsCommand(this, keyframe, oldMode, oldLeftTangent, oldRightTangent, mode, leftTangent, rightTangent, parentCommand);
     cmd->redo();
 }
 
 qreal cubicBezier(qreal p0, qreal delta1, qreal delta2, qreal p3, qreal t) {
     qreal p1 = p0 + delta1;
     qreal p2 = p3 + delta2;
 
     qreal c = 1-t;
     return c*c*c * p0 + 3*c*c*t * p1 + 3*c*t*t * p2 + t*t*t * p3;
 }
 
 void normalizeTangents(const QPointF point1, QPointF &rightTangent, QPointF &leftTangent, const QPointF point2)
 {
     // To ensure that the curve is monotonic wrt time,
     // check that control points lie between the endpoints.
     // If not, force them into range by scaling down the tangents
 
     float interval = point2.x() - point1.x();
     if (rightTangent.x() < 0) rightTangent *= 0;
     if (leftTangent.x() > 0) leftTangent *= 0;
 
     if (rightTangent.x() > interval) {
         rightTangent *= interval / rightTangent.x();
     }
     if (leftTangent.x() < -interval) {
         leftTangent *= interval / -leftTangent.x();
     }
 }
 
 QPointF KisScalarKeyframeChannel::interpolate(QPointF point1, QPointF rightTangent, QPointF leftTangent, QPointF point2, qreal t)
 {
     normalizeTangents(point1, rightTangent, leftTangent, point2);
 
     qreal x = cubicBezier(point1.x(), rightTangent.x(), leftTangent.x(), point2.x(), t);
     qreal y = cubicBezier(point1.y(), rightTangent.y(), leftTangent.y(), point2.y(), t);
 
     return QPointF(x,y);
 }
 
 qreal findCubicCurveParameter(int time0, qreal delta0, qreal delta1, int time1, int time)
 {
     if (time == time0) return 0.0;
     if (time == time1) return 1.0;
 
     qreal min_t = 0.0;
     qreal max_t = 1.0;
 
     while (true) {
         qreal t = (max_t + min_t) / 2;
         qreal time_t = cubicBezier(time0, delta0, delta1, time1, t);
 
         if (time_t < time - 0.05) {
             min_t = t;
         } else if (time_t > time + 0.05) {
             max_t = t;
         } else {
             // Close enough
             return t;
         }
     }
 }
 
 qreal KisScalarKeyframeChannel::interpolatedValue(int time) const
 {
     KisKeyframeSP activeKey = activeKeyframeAt(time);
     if (activeKey.isNull()) return qQNaN();
 
     KisKeyframeSP nextKey = nextKeyframe(activeKey);
 
     qreal result = qQNaN();
     if (time == activeKey->time() || nextKey.isNull()) {
         result = scalarValue(activeKey);
     } else {
         switch (activeKey->interpolationMode()) {
         case KisKeyframe::Constant:
             result = scalarValue(activeKey);
             break;
         case KisKeyframe::Linear:
         {
             int time0 = activeKey->time();
             int time1 = nextKey->time();
             qreal value0 = scalarValue(activeKey);
             qreal value1 = scalarValue(nextKey);
             result = value0 + (value1 - value0) * (time - time0) / (time1 - time0);
         }
             break;
         case KisKeyframe::Bezier:
         {
             QPointF point0 = QPointF(activeKey->time(), scalarValue(activeKey));
             QPointF point1 = QPointF(nextKey->time(), scalarValue(nextKey));
 
             QPointF tangent0 = activeKey->rightTangent();
             QPointF tangent1 = nextKey->leftTangent();
 
             normalizeTangents(point0, tangent0, tangent1, point1);
             qreal t = findCubicCurveParameter(point0.x(), tangent0.x(), tangent1.x(), point1.x(), time);
             result = interpolate(point0, tangent0, tangent1, point1, t).y();
         }
             break;
         default:
             KIS_ASSERT_RECOVER_BREAK(false);
             break;
         }
     }
 
     if (result > m_d->maxValue) return m_d->maxValue;
     if (result < m_d->minValue) return m_d->minValue;
 
     return result;
 }
 
 qreal KisScalarKeyframeChannel::currentValue() const
 {
     return interpolatedValue(currentTime());
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
-    qreal value = (copySrc.isNull() ? 0 : scalarValue(copySrc));
-    return createKeyframe(time, value, parentCommand);
+    if (copySrc) {
+        KisScalarKeyframe *srcKeyframe = dynamic_cast<KisScalarKeyframe*>(copySrc.data());
+        Q_ASSERT(srcKeyframe);
+        KisScalarKeyframe *keyframe = new KisScalarKeyframe(srcKeyframe, this);
+        keyframe->setTime(time);
+        return toQShared(keyframe);
+    } else {
+        return createKeyframe(time, 0, parentCommand);
+    }
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::createKeyframe(int time, qreal value, KUndo2Command *parentCommand)
 {
     Q_UNUSED(parentCommand);
     KisScalarKeyframe *keyframe = new KisScalarKeyframe(this, time, value);
     keyframe->setInterpolationMode(m_d->defaultInterpolation);
     return toQShared(keyframe);
 }
 
 void KisScalarKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
 {
     Q_UNUSED(parentCommand);
     Q_UNUSED(key);
 }
 
 void KisScalarKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     KisScalarKeyframeChannel *srcScalarChannel = dynamic_cast<KisScalarKeyframeChannel*>(srcChannel);
     KIS_ASSERT_RECOVER_RETURN(srcScalarChannel);
 
     KisKeyframeSP srcFrame = srcScalarChannel->keyframeAt(srcTime);
     KIS_ASSERT_RECOVER_RETURN(srcFrame);
 
     KisScalarKeyframe *dstKey = dynamic_cast<KisScalarKeyframe*>(dstFrame.data());
     dstKey->value = srcChannel->scalarValue(srcFrame);
     notifyKeyframeChanged(dstFrame);
 }
 
 QRect KisScalarKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     Q_UNUSED(key);
 
     if (node()) {
         return node()->extent();
     } else {
         return QRect();
     }
 }
 
 void KisScalarKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     Q_UNUSED(layerFilename);
     keyframeElement.setAttribute("value", KisDomUtils::toString(scalarValue(keyframe)));
 
     QString interpolationMode;
     if (keyframe->interpolationMode() == KisKeyframe::Constant) interpolationMode = "constant";
     if (keyframe->interpolationMode() == KisKeyframe::Linear) interpolationMode = "linear";
     if (keyframe->interpolationMode() == KisKeyframe::Bezier) interpolationMode = "bezier";
 
     QString tangentsMode;
     if (keyframe->tangentsMode() == KisKeyframe::Smooth) tangentsMode = "smooth";
     if (keyframe->tangentsMode() == KisKeyframe::Sharp) tangentsMode = "sharp";
 
     keyframeElement.setAttribute("interpolation", interpolationMode);
     keyframeElement.setAttribute("tangents", tangentsMode);
     KisDomUtils::saveValue(&keyframeElement, "leftTangent", keyframe->leftTangent());
     KisDomUtils::saveValue(&keyframeElement, "rightTangent", keyframe->rightTangent());
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
     int time = keyframeNode.toElement().attribute("time").toUInt();
     qreal value = KisDomUtils::toDouble(keyframeNode.toElement().attribute("value"));
 
     KUndo2Command tempParentCommand;
     KisKeyframeSP keyframe = createKeyframe(time, KisKeyframeSP(), &tempParentCommand);
     setScalarValue(keyframe, value);
 
     QString interpolationMode = keyframeNode.toElement().attribute("interpolation");
     if (interpolationMode == "constant") {
         keyframe->setInterpolationMode(KisKeyframe::Constant);
     } else if (interpolationMode == "linear") {
         keyframe->setInterpolationMode(KisKeyframe::Linear);
     } else if (interpolationMode == "bezier") {
         keyframe->setInterpolationMode(KisKeyframe::Bezier);
     }
 
     QString tangentsMode = keyframeNode.toElement().attribute("tangents");
     if (tangentsMode == "smooth") {
         keyframe->setTangentsMode(KisKeyframe::Smooth);
     } else if (tangentsMode == "sharp") {
         keyframe->setTangentsMode(KisKeyframe::Sharp);
     }
 
     QPointF leftTangent;
     QPointF rightTangent;
     KisDomUtils::loadValue(keyframeNode, "leftTangent", &leftTangent);
     KisDomUtils::loadValue(keyframeNode, "rightTangent", &rightTangent);
     keyframe->setInterpolationTangents(leftTangent, rightTangent);
 
     return keyframe;
 }
 
 void KisScalarKeyframeChannel::notifyKeyframeChanged(KisKeyframeSP keyframe)
 {
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(keyframe->time());
 
     requestUpdate(range, rect);
 
     emit sigKeyframeChanged(keyframe);
 }
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index 34acaa8eae..6c59f0371e 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1717 +1,1721 @@
 /* This file is part of the Krita project
  *
  * Copyright (C) 2014 Boudewijn Rempt <boud@kogmbh.com>
  *
  * 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 "KisMainWindow.h" // XXX: remove
 #include <QMessageBox> // XXX: remove
 
 #include <KisMimeDatabase.h>
 
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfoDlg.h>
 #include <KoDocumentInfo.h>
 #include <KoDpi.h>
 #include <KoUnit.h>
 #include <KoFileDialog.h>
 #include <KoID.h>
 #include <KoOdfReadStore.h>
 #include <KoProgressProxy.h>
 #include <KoProgressUpdater.h>
 #include <KoSelection.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoStore.h>
 #include <KoUpdater.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <QTemporaryFile>
 #include <kbackup.h>
 
 #include <QApplication>
 #include <QBuffer>
 #include <QDesktopServices>
 #include <QDir>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFileInfo>
 #include <QImage>
 #include <QList>
 #include <QPainter>
 #include <QRect>
 #include <QScopedPointer>
 #include <QSize>
 #include <QStringList>
 #include <QtGlobal>
 #include <QTimer>
 #include <QWidget>
 
 // Krita Image
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_debug.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_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_painting_assistants_decoration.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_debug.h>
 #include <kis_canvas_widget_base.h>
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_resource_server_provider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisPart.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include <mutex>
 
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 namespace {
 
 class DocumentProgressProxy : public KoProgressProxy {
 public:
     KisMainWindow *m_mainWindow;
     DocumentProgressProxy(KisMainWindow *mainWindow)
         : m_mainWindow(mainWindow)
     {
     }
 
     ~DocumentProgressProxy() override {
         // signal that the job is done
         setValue(-1);
     }
 
     int maximum() const override {
         return 100;
     }
 
     void setValue(int value) override {
         if (m_mainWindow) {
             m_mainWindow->slotProgress(value);
         }
     }
 
     void setRange(int /*minimum*/, int /*maximum*/) override {
 
     }
 
     void setFormat(const QString &/*format*/) override {
 
     }
 };
 }
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private() :
         docInfo(0),
         progressUpdater(0),
         progressProxy(0),
         importExportManager(0),
         isImporting(false),
         isExporting(false),
         password(QString()),
         modifiedAfterAutosave(false),
         isAutosaving(false),
         backupFile(true),
         doNotSaveExtDoc(false),
         undoStack(0),
         m_saveOk(false),
         m_waitForSave(false),
         m_duringSaveAs(false),
         m_bAutoDetectedMime(false),
         modified(false),
         readwrite(true),
         disregardAutosaveFailure(false),
         nserver(0),
         macroNestDepth(0),
         imageIdleWatcher(2000 /*ms*/),
         suppressProgress(false),
         fileProgressProxy(0),
         savingLock(&savingMutex)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KoDocumentInfo *docInfo;
 
     KoProgressUpdater *progressUpdater;
     KoProgressProxy *progressProxy;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     bool isImporting;
     bool isExporting; // File --> Import/Export vs File --> Open/Save
     QString password; // The password used to encrypt an encrypted document
 
     QTimer autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     int autoSaveDelay {300}; // in seconds, 0 to disable.
     bool modifiedAfterAutosave;
     bool isAutosaving;
     bool backupFile;
     bool doNotSaveExtDoc; // makes it possible to save only internally stored child documents
 
     KUndo2Stack *undoStack;
 
     KisGuidesConfig guidesConfig;
 
     QUrl m_originalURL; // for saveAs
     QString m_originalFilePath; // for saveAs
     bool m_saveOk;
     bool m_waitForSave;
     bool m_duringSaveAs;
     bool m_bAutoDetectedMime; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
     QEventLoop m_eventLoop;
     QMutex savingMutex;
 
     bool modified;
     bool readwrite;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     bool disregardAutosaveFailure;
 
     KisNameServer *nserver;
     qint32 macroNestDepth;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeSP preActivatedNode;
     KisShapeController* shapeController;
     KoShapeController* koShapeController;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     bool suppressProgress;
     KoProgressProxy* fileProgressProxy;
 
     QList<KisPaintingAssistantSP> assistants;
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     class SafeSavingLocker;
 };
 
 class KisDocument::Private::SafeSavingLocker {
 public:
     SafeSavingLocker(KisDocument::Private *_d, KisDocument *document)
         : d(_d)
         , m_document(document)
         , m_locked(false)
         , m_imageLock(d->image, true)
     {
         const int realAutoSaveInterval = KisConfig().autoSaveInterval();
         const int emergencyAutoSaveInterval = 10; // sec
 
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, d->savingLock) < 0;
 
         if (!m_locked) {
             if (d->isAutosaving) {
                 d->disregardAutosaveFailure = true;
                 if (realAutoSaveInterval) {
                     m_document->setAutoSaveDelay(emergencyAutoSaveInterval);
                 }
             } else {
                 d->image->requestStrokeEnd();
                 QApplication::processEvents();
 
                 // one more try...
                 m_locked = std::try_lock(m_imageLock, d->savingLock) < 0;
             }
         }
 
         if (m_locked) {
             d->disregardAutosaveFailure = false;
         }
     }
 
     ~SafeSavingLocker() {
          if (m_locked) {
              m_imageLock.unlock();
              d->savingLock.unlock();
 
              const int realAutoSaveInterval = KisConfig().autoSaveInterval();
              m_document->setAutoSaveDelay(realAutoSaveInterval);
          }
      }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     KisDocument::Private *d;
     KisDocument *m_document;
     bool m_locked;
 
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument()
     : d(new Private())
 {
     d->undoStack = new UndoStack(this);
     d->undoStack->setParent(this);
 
     d->importExportManager = new KisImportExportManager(this);
     d->importExportManager->setProgresUpdater(d->progressUpdater);
 
     connect(&d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     KisConfig cfg;
     setAutoSaveDelay(cfg.autoSaveInterval());
 
     setObjectName(newObjectName());
 
     d->docInfo = new KoDocumentInfo(this);
 
     d->firstMod = QDateTime::currentDateTime();
     d->lastMod = QDateTime::currentDateTime();
 
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->nserver = new KisNameServer(1);
 
     d->shapeController = new KisShapeController(this, d->nserver);
     d->koShapeController = new KoShapeController(0, d->shapeController);
 
     undoStack()->setUndoLimit(KisConfig().undoStackLimit());
     connect(d->undoStack, SIGNAL(indexChanged(int)), this, SLOT(slotUndoStackIndexChanged(int)));
     setBackupFile(KisConfig().backupFile());
 }
 
 KisDocument::~KisDocument()
 {
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer.disconnect(this);
     d->autoSaveTimer.stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
 
 
     delete d;
 }
 
 bool KisDocument::reload()
 {
     // XXX: reimplement!
     return false;
 }
 
 bool KisDocument::exportDocument(const QUrl &_url, KisPropertiesConfigurationSP exportConfiguration)
 {
     //qDebug() << "exportDocument" << _url.toDisplayString() << "is autosaving" << d->isAutosaving;
     bool ret;
 
     d->isExporting = true;
 
     //
     // Preserve a lot of state here because we need to restore it in order to
     // be able to fake a File --> Export.  Can't do this in saveFile() because,
     // for a start, KParts has already set url and m_file and because we need
     // to restore the modified flag etc. and don't want to put a load on anyone
     // reimplementing saveFile() (Note: importDocument() and exportDocument()
     // will remain non-virtual).
     //
     QUrl oldURL = url();
     QString oldFile = localFilePath();
 
     //qDebug() << "\toldUrl" << oldURL << "oldFile" << oldFile << "export url" << _url;
 
     bool wasModified = isModified();
 
     // save...
     ret = saveAs(_url, exportConfiguration);
 
     //
     // This is sooooo hacky :(
     // Hopefully we will restore enough state.
     //
     dbgUI << "Restoring KisDocument state to before export";
 
     // always restore url & m_file regardless of failure or success
     //qDebug() << "\tafter saveAs: url" << url() << "local file path" << localFilePath();
     setUrl(oldURL);
     setLocalFilePath(oldFile);
     //qDebug() << "\tafter restoring: url" << url() << "local file path" << localFilePath();
 
 
     // on successful export we need to restore modified etc. too
     // on failed export, mimetype/modified hasn't changed anyway
     if (ret) {
         setModified(wasModified);
    }
 
     d->isExporting = false;
 
     return ret;
 }
 
 bool KisDocument::saveAs(const QUrl &url, KisPropertiesConfigurationSP exportConfiguration)
 {
     //qDebug() << "saveAs" << url;
     if (!url.isValid() || !url.isLocalFile()) {
         errKrita << "saveAs: Malformed URL " << url.url() << endl;
         return false;
     }
     d->m_duringSaveAs = true;
     d->m_originalURL = d->m_url;
     d->m_originalFilePath = d->m_file;
     d->m_url = url; // Store where to upload in saveToURL
     d->m_file = d->m_url.toLocalFile();
 
     bool result = save(exportConfiguration); // Save local file and upload local file
 
     if (!result) {
         d->m_url = d->m_originalURL;
         d->m_file = d->m_originalFilePath;
         d->m_duringSaveAs = false;
         d->m_originalURL = QUrl();
         d->m_originalFilePath.clear();
     }
 
     return result;
 }
 
 bool KisDocument::save(KisPropertiesConfigurationSP exportConfiguration)
 {
     //qDebug() << "save" << d->m_file << d->m_url << url() << localFilePath();
 
     d->m_saveOk = false;
     if (d->m_file.isEmpty()) { // document was created empty
         d->m_file = d->m_url.toLocalFile();
     }
 
     updateEditingTime(true);
 
     setFileProgressProxy();
     setUrl(url());
 
     bool ok = saveFile(localFilePath(), exportConfiguration);
 
     clearFileProgressProxy();
 
     if (ok) {
         setModified( false );
         emit completed();
         d->m_saveOk = true;
         d->m_duringSaveAs = false;
         d->m_originalURL = QUrl();
         d->m_originalFilePath.clear();
         return true; // Nothing to do
     }
     else {
         emit canceled(QString());
     }
     return false;
 }
 
 bool KisDocument::saveFile(const QString &filePath, KisPropertiesConfigurationSP exportConfiguration)
 {
     if (!prepareLocksForSaving()) {
         return false;
     }
 
     // Unset the error message
     setErrorMessage("");
 
     // Save it to be able to restore it after a failed save
     const bool wasModified = isModified();
 
     // The output format is set by KisMainWindow, and by openFile
     QByteArray outputMimeType = d->outputMimeType;
 
     if (outputMimeType.isEmpty()) {
         outputMimeType = d->outputMimeType = nativeFormatMimeType();
     }
 
     //qDebug() << "saveFile. Is Autosaving?" << isAutosaving() << "url" << filePath << d->outputMimeType;
 
 
     if (d->backupFile) {
         Q_ASSERT(url().isLocalFile());
         KBackup::backupFile(url().toLocalFile());
     }
 
     qApp->processEvents();
 
     bool ret = false;
     bool suppressErrorDialog = false;
     KisImportExportFilter::ConversionStatus status = KisImportExportFilter::OK;
 
     setFileProgressUpdater(i18n("Saving Document"));
 
     QFileInfo fi(filePath);
     QString tempororaryFileName;
     {
         QTemporaryFile tf(QDir::tempPath() + "/XXXXXX" + fi.baseName() + "." + fi.completeSuffix());
         tf.open();
         tempororaryFileName = tf.fileName();
     }
     Q_ASSERT(!tempororaryFileName.isEmpty());
 
     //qDebug() << "saving to tempory file" << tempororaryFileName;
     status = d->importExportManager->exportDocument(tempororaryFileName, filePath, outputMimeType, !d->isExporting , exportConfiguration);
 
     ret = (status == KisImportExportFilter::OK);
     suppressErrorDialog = (isAutosaving() || status == KisImportExportFilter::UserCancelled || status == KisImportExportFilter::BadConversionGraph);
     //qDebug() << "Export status was" << status;
 
     if (ret) {
 
         //qDebug() << "copying temporary file" << tempororaryFileName << "to" << filePath;
 
         if (!d->isAutosaving && !d->suppressProgress) {
             QPointer<KoUpdater> updater = d->progressUpdater->startSubtask(1, "clear undo stack");
             updater->setProgress(0);
             d->undoStack->setClean();
             updater->setProgress(100);
         } else {
             d->undoStack->setClean();
         }
 
         QFile tempFile(tempororaryFileName);
         QString s = filePath;
         QFile dstFile(s);
         while (QFileInfo(s).exists()) {
             s.append("_");
         }
         bool r;
         if (s != filePath) {
             r = dstFile.rename(s);
             if (!r) {
                setErrorMessage(i18n("Could not rename original file to %1: %2", dstFile.fileName(), dstFile. errorString()));
                 ret = false;
             }
          }
 
         if (tempFile.exists()) {
             r = tempFile.copy(filePath);
             if (!r) {
                 setErrorMessage(i18n("Copying the temporary file failed: %1 to %2: %3", tempFile.fileName(), dstFile.fileName(), tempFile.errorString()));
                 ret = false;
             }
             else {
                 r = tempFile.remove();
                 if (!r) {
                     setErrorMessage(i18n("Could not remove temporary file %1: %2", tempFile.fileName(), tempFile.errorString()));
                     ret = false;
                 }
                 else if (s != filePath) {
                     r = dstFile.remove();
                     if (!r) {
                         setErrorMessage(i18n("Could not remove saved original file: %1", dstFile.errorString()));
                         ret = false;
                     }
                 }
             }
         }
         else {
             setErrorMessage(i18n("The temporary file %1 is gone before we could copy it!", tempFile.fileName()));
             ret = false;
         }
 
         if (errorMessage().isEmpty()) {
             if (!isAutosaving()) {
                 removeAutoSaveFiles();
             }
         }
         else {
             ret = false;
             qWarning() << "Error while saving:" << errorMessage();
         }
         // Restart the autosave timer
         // (we don't want to autosave again 2 seconds after a real save)
         if (!isAutosaving()) {
             setAutoSaveDelay(d->autoSaveDelay);
         }
 
         d->mimeType = outputMimeType;
     }
     if (!ret) {
         if (!suppressErrorDialog) {
 
             if (errorMessage().isEmpty()) {
                 setErrorMessage(KisImportExportFilter::conversionStatusString(status));
             }
 
             if (errorMessage().isEmpty()) {
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save\n%1", filePath));
             } else {
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, errorMessage()));
             }
 
         }
 
         // couldn't save file so this new URL is invalid
         // FIXME: we should restore the current document's true URL instead of
         // setting it to nothing otherwise anything that depends on the URL
         // being correct will not work (i.e. the document will be called
         // "Untitled" which may not be true)
         //
         // Update: now the URL is restored in KisMainWindow but really, this
         // should still be fixed in KisDocument/KParts (ditto for file).
         // We still resetURL() here since we may or may not have been called
         // by KisMainWindow - Clarence
         resetURL();
 
         // As we did not save, restore the "was modified" status
         setModified(wasModified);
     }
 
     emit sigSavingFinished();
     clearFileProgressUpdater();
 
     unlockAfterSaving();
     return ret;
 }
 
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 void KisDocument::setOutputMimeType(const QByteArray & mimeType)
 {
     d->outputMimeType = mimeType;
 }
 
 QByteArray KisDocument::outputMimeType() const
 {
     return d->outputMimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->importExportManager->batchMode();
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->importExportManager->setBatchMode(batchMode);
 }
 
 bool KisDocument::isImporting() const
 {
     return d->isImporting;
 }
 
 bool KisDocument::isExporting() const
 {
     return d->isExporting;
 }
 
 void KisDocument::slotAutoSave()
 {
     //qDebug() << "slotAutoSave. Modified:"  << d->modified << "modifiedAfterAutosave" << d->modified << "url" << url() << localFilePath();
 
     if (!d->isAutosaving && d->modified && d->modifiedAfterAutosave) {
 
         connect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
         emit statusBarMessage(i18n("Autosaving..."));
         d->isAutosaving = true;
         QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
         QByteArray mimetype = d->outputMimeType;
         d->outputMimeType = nativeFormatMimeType();
         bool ret = exportDocument(QUrl::fromLocalFile(autoSaveFileName));
         d->outputMimeType = mimetype;
 
         if (ret) {
             d->modifiedAfterAutosave = false;
             d->autoSaveTimer.stop(); // until the next change
         }
         d->isAutosaving = false;
 
         emit clearStatusBarMessage();
         disconnect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
 
         if (!ret && !d->disregardAutosaveFailure) {
             emit statusBarMessage(i18n("Error during autosave! Partition full?"));
         }
     }
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setAutoSaveDelay(d->autoSaveDelay);
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     //qDebug() << "setting autosave delay from" << d->autoSaveDelay << "to" << delay;
     d->autoSaveDelay = delay;
     if (isReadWrite() && d->autoSaveDelay > 0) {
         d->autoSaveTimer.start(d->autoSaveDelay * 1000);
     }
     else {
         d->autoSaveTimer.stop();
     }
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
 
     if (path.isEmpty()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #endif
     } else {
         QFileInfo fi(path);
         QString dir = fi.absolutePath();
         QString filename = fi.fileName();
         retval = QString("%1%2.%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
     d->isImporting = true;
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     d->isImporting = false;
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, KisDocument::OpenUrlFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //dbgUI <<"asf=" << asf;
             // ## TODO compare timestamps ?
             int res = QMessageBox::warning(0,
                                            i18nc("@title:window", "Krita"),
                                            i18n("An autosaved file exists for this document.\nDo you want to open it instead?"),
                                            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
             switch (res) {
             case QMessageBox::Yes :
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case QMessageBox::No :
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened) {
         resetURL(); // Force save to act like 'Save As'
         setReadWrite(true); // enable save button
         setModified(true);
     }
     else {
         if( !(flags & OPEN_URL_FLAG_DO_NOT_ADD_TO_RECENT_FILES) ) {
             KisPart::instance()->addRecentURLToAllMainWindows(_url);
         }
 
         if (ret) {
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
     }
     return ret;
 }
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath())) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     setFileProgressUpdater(i18n("Opening Document"));
 
     KisImportExportFilter::ConversionStatus status;
 
     status = d->importExportManager->importDocument(localFilePath(), typeName);
     if (status != KisImportExportFilter::OK) {
         QString msg = KisImportExportFilter::conversionStatusString(status);
         if (!msg.isEmpty()) {
             QString errorMsg(i18n("Could not open %2.\nReason: %1.\n%3", msg, prettyPathOrUrl(), errorMessage()));
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), errorMsg);
         }
         clearFileProgressUpdater();
         return false;
     }
 
     setMimeTypeAfterLoading(typeName);
     emit sigLoadingFinished();
 
     if (!d->suppressProgress && d->progressUpdater) {
         QPointer<KoUpdater> updater = d->progressUpdater->startSubtask(1, "clear undo stack");
         updater->setProgress(0);
         undoStack()->clear();
         updater->setProgress(100);
 
         clearFileProgressUpdater();
     } else {
         undoStack()->clear();
     }
 
     return true;
 }
 
 KoProgressUpdater *KisDocument::progressUpdater() const
 {
     return d->progressUpdater;
 }
 
 void KisDocument::setProgressProxy(KoProgressProxy *progressProxy)
 {
     d->progressProxy = progressProxy;
 }
 
 KoProgressProxy* KisDocument::progressProxy() const
 {
     if (!d->progressProxy) {
         KisMainWindow *mainWindow = 0;
         if (KisPart::instance()->mainwindowCount() > 0) {
             mainWindow = KisPart::instance()->mainWindows()[0];
         }
         d->progressProxy = new DocumentProgressProxy(mainWindow);
     }
     return d->progressProxy;
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified()
 {
     d->modified = true;
 }
 
 void KisDocument::setModified(bool mod)
 {
     if (mod) {
         updateEditingTime(false);
     }
 
     if (d->isAutosaving)   // ignore setModified calls due to autosaving
         return;
 
     if ( !d->readwrite && d->modified ) {
         errKrita << "Can't set a read-only document to 'modified' !" << endl;
         return;
     }
 
     //dbgUI<<" url:" << url.path();
     //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
     if (mod && !d->modifiedAfterAutosave) {
         // First change since last autosave -> start the autosave timer
         setAutoSaveDelay(d->autoSaveDelay);
     }
     d->modifiedAfterAutosave = mod;
 
     if (mod == isModified())
         return;
 
     d->modified = mod;
 
     if (mod) {
         documentInfo()->updateParameters();
     }
 
     // This influences the title
     setTitleModified();
     emit modified(mod);
 }
 
 void KisDocument::updateEditingTime(bool forceStoreElapsed)
 {
     QDateTime now = QDateTime::currentDateTime();
     int firstModDelta = d->firstMod.secsTo(now);
     int lastModDelta = d->lastMod.secsTo(now);
 
     if (lastModDelta > 30) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
         d->firstMod = now;
     } else if (firstModDelta > 60 || forceStoreElapsed) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
         d->firstMod = now;
     }
 
     d->lastMod = now;
 }
 
 QString KisDocument::prettyPathOrUrl() const
 {
     QString _url(url().toDisplayString());
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         _url = QDir::toNativeSeparators(_url);
     }
 #endif
     return _url;
 }
 
 // Get caption from document info (title(), in about page)
 QString KisDocument::caption() const
 {
     QString c;
     if (documentInfo()) {
         c = documentInfo()->aboutInfo("title");
     }
     const QString _url(url().fileName());
     if (!c.isEmpty() && !_url.isEmpty()) {
         c = QString("%1 - %2").arg(c).arg(_url);
     }
     else if (c.isEmpty()) {
         c = _url; // Fall back to document URL
     }
     return c;
 }
 
 void KisDocument::setTitleModified()
 {
     emit titleModified(caption(), isModified());
 }
 
 QDomDocument KisDocument::createDomDocument(const QString& tagName, const QString& version) const
 {
     return createDomDocument("krita", tagName, version);
 }
 
 //static
 QDomDocument KisDocument::createDomDocument(const QString& appName, const QString& tagName, const QString& version)
 {
     QDomImplementation impl;
     QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
     QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                      QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                      url);
     // The namespace URN doesn't need to include the version number.
     QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
     QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
     doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
     return doc;
 }
 
 bool KisDocument::isNativeFormat(const QByteArray& mimetype) const
 {
     if (mimetype == nativeFormatMimeType())
         return true;
     return extraNativeMimeTypes().contains(mimetype);
 }
 
 void KisDocument::setErrorMessage(const QString& errMsg)
 {
     d->lastErrorMessage = errMsg;
 }
 
 QString KisDocument::errorMessage() const
 {
     return d->lastErrorMessage;
 }
 
 void KisDocument::removeAutoSaveFiles()
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(localFilePath());   // the one in the current dir
     //qDebug() << "\tfilename:" << asf << "exists:" << QFile::exists(asf);
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autosavefile" << asf;
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
     //qDebug() << "Autsavefile in $home" << asf;
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autsavefile 2" << asf;
         QFile::remove(asf);
     }
 }
 
 void KisDocument::setBackupFile(bool saveBackup)
 {
     d->backupFile = saveBackup;
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackIndexChanged(int idx)
 {
     // even if the document was already modified, call setModified to re-start autosave timer
     setModified(idx != d->undoStack->cleanIndex());
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     d->gridConfig = config;
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() )
         return false;
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() )
         return false;
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
         setFileProgressProxy();
         setUrl(d->m_url);
         ret = openFile();
         clearFileProgressProxy();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, bool backgroundAsLayer,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisConfig cfg;
 
     KisImageSP image;
     KisPaintLayerSP layer;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
     documentInfo()->setAboutInfo("title", name);
     if (name != i18n("Unnamed") && !name.isEmpty()) {
         setUrl(QUrl::fromLocalFile(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation) + '/' + name + ".kra"));
     }
     documentInfo()->setAboutInfo("abstract", description);
 
     layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     Q_CHECK_PTR(layer);
 
     if (backgroundAsLayer) {
         image->setDefaultProjectionColor(KoColor(cs));
 
         if (bgColor.opacityU8() == OPACITY_OPAQUE_U8) {
             layer->paintDevice()->setDefaultPixel(bgColor);
         } else {
             // Hack: with a semi-transparent background color, the projection isn't composited right if we just set the default pixel
             KisFillPainter painter;
             painter.begin(layer->paintDevice());
             painter.fillRect(0, 0, width, height, bgColor, bgColor.opacityU8());
         }
     } else {
         image->setDefaultProjectionColor(bgColor);
     }
     layer->setDirty(QRect(0, 0, width, height));
 
     image->addNode(layer.data(), image->rootLayer().data());
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
     cfg.defColorModel(image->colorSpace()->colorModelId().id());
     cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 KoShapeBasedDocumentBase *KisDocument::shapeController() const
 {
     return d->shapeController;
 }
 
 KoShapeLayer* KisDocument::shapeForNode(KisNodeSP layer) const
 {
     return d->shapeController->shapeForNode(layer);
 }
 
 vKisNodeSP KisDocument::activeNodes() const
 {
     vKisNodeSP nodes;
     Q_FOREACH (KisView *v, KisPart::instance()->views()) {
         if (v->document() == this && v->viewManager()) {
             KisNodeSP activeNode = v->viewManager()->activeNode();
             if (activeNode && !nodes.contains(activeNode)) {
                 if (activeNode->inherits("KisMask")) {
                     activeNode = activeNode->parent();
                 }
                 nodes.append(activeNode);
             }
         }
     }
     return nodes;
 }
 
 QList<KisPaintingAssistantSP> KisDocument::assistants() const
 {
     return d->assistants;
 }
 
 void KisDocument::setAssistants(const QList<KisPaintingAssistantSP> value)
 {
     d->assistants = value;
 }
 
 void KisDocument::setPreActivatedNode(KisNodeSP activatedNode)
 {
     d->preActivatedNode = activatedNode;
 }
 
 KisNodeSP KisDocument::preActivatedNode() const
 {
     return d->preActivatedNode;
 }
 
 void KisDocument::setFileProgressUpdater(const QString &text)
 {
     d->suppressProgress = d->importExportManager->batchMode();
 
     if (!d->suppressProgress) {
         d->progressUpdater = new KoProgressUpdater(d->progressProxy, KoProgressUpdater::Unthreaded);
         d->progressUpdater->start(100, text);
         d->importExportManager->setProgresUpdater(d->progressUpdater);
         if (KisPart::instance()->currentMainwindow()) {
             connect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
             connect(KisPart::instance()->currentMainwindow(), SIGNAL(sigProgressCanceled()), this, SIGNAL(sigProgressCanceled()));
         }
     }
 }
 
 void KisDocument::clearFileProgressUpdater()
 {
     if (!d->suppressProgress && d->progressUpdater) {
         if (KisPart::instance()->currentMainwindow()) {
             disconnect(KisPart::instance()->currentMainwindow(), SIGNAL(sigProgressCanceled()), this, SIGNAL(sigProgressCanceled()));
             disconnect(this, SIGNAL(sigProgress(int)), KisPart::instance()->currentMainwindow(), SLOT(slotProgress(int)));
         }
         delete d->progressUpdater;
         d->importExportManager->setProgresUpdater(0);
         d->progressUpdater = 0;
     }
 }
 
 void KisDocument::setFileProgressProxy()
 {
     if (!d->progressProxy && !d->importExportManager->batchMode()) {
         d->fileProgressProxy = progressProxy();
     } else {
         d->fileProgressProxy = 0;
     }
 }
 
 void KisDocument::clearFileProgressProxy()
 {
     if (d->fileProgressProxy) {
         setProgressProxy(0);
         delete d->fileProgressProxy;
         d->fileProgressProxy = 0;
     }
 }
 
 KisImageWSP KisDocument::image() const
 {
     return d->image;
 }
 
 KisImageSP KisDocument::savingImage() const
 {
     return d->savingImage;
 }
 
 
 void KisDocument::setCurrentImage(KisImageSP image)
 {
     if (d->image) {
         // Disconnect existing sig/slot connections
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     d->image->initialRefreshGraph();
     setAutoSaveDelay(KisConfig().autoSaveInterval());
 }
 
 void KisDocument::setImageModified()
 {
     setModified(true);
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 bool KisDocument::prepareLocksForSaving()
 {
     KisImageSP copiedImage;
-
+    // XXX: Restore this when
+    // a) cloning works correctly and
+    // b) doesn't take ages because it needs to refresh its entire graph and finally,
+    // c) we do use the saving image to save in the background.
     {
         Private::SafeSavingLocker locker(d, this);
         if (locker.successfullyLocked()) {
-            copiedImage = d->image->clone(true);
+
+            copiedImage = d->image; //->clone(true);
         }
         else if (!isAutosaving()) {
             // even though it is a recovery operation, we should ensure we do not enter saving twice!
             std::unique_lock<StdLockableWrapper<QMutex>> l(d->savingLock, std::try_to_lock);
 
             if (l.owns_lock()) {
                 d->lastErrorMessage = i18n("The image was still busy while saving. Your saved image might be incomplete.");
                 d->image->lock();
-                copiedImage = d->image->clone(true);
-                copiedImage->initialRefreshGraph();
+                copiedImage = d->image; //->clone(true);
+                //copiedImage->initialRefreshGraph();
                 d->image->unlock();
             }
         }
     }
 
     bool result = false;
 
     // ensure we do not enter saving twice
     if (copiedImage && d->savingMutex.tryLock()) {
         d->savingImage = copiedImage;
         result = true;
     } else {
         qWarning() << "Could not lock the document for saving!";
         d->lastErrorMessage = i18n("Could not lock the image for saving.");
     }
 
     return result;
 }
 
 void KisDocument::unlockAfterSaving()
 {
     d->savingImage = 0;
     d->savingMutex.unlock();
 }
 
diff --git a/libs/ui/KisImportExportFilter.cpp b/libs/ui/KisImportExportFilter.cpp
index dd4f62d995..58cac657db 100644
--- a/libs/ui/KisImportExportFilter.cpp
+++ b/libs/ui/KisImportExportFilter.cpp
@@ -1,279 +1,278 @@
 /* This file is part of the KDE libraries
    Copyright (C) 2001 Werner Trobin <trobin@kde.org>
                  2002 Werner Trobin <trobin@kde.org>
 
 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 "KisImportExportFilter.h"
 
 #include <QFile>
 #include <kis_debug.h>
 #include <QStack>
 #include "KisImportExportManager.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KisExportCheckBase.h>
 #include <KisExportCheckRegistry.h>
 #include "KoUpdater.h"
 #include <klocalizedstring.h>
 
 class Q_DECL_HIDDEN KisImportExportFilter::Private
 {
 public:
     QPointer<KoUpdater> updater;
     QByteArray mime;
     QString filename;
     QString realFilename;
     bool batchmode;
 
     QMap<QString, KisExportCheckBase*> capabilities;
 
     Private()
         : updater(0)
         , batchmode(false)
     {}
 
     ~Private()
     {
         qDeleteAll(capabilities);
     }
 
 };
 
 
 KisImportExportFilter::KisImportExportFilter(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
 }
 
 KisImportExportFilter::~KisImportExportFilter()
 {
-    Q_ASSERT(d->updater);
     if (d->updater) {
         d->updater->setProgress(100);
     }
     delete d;
 }
 
 QString KisImportExportFilter::filename() const
 {
     return d->filename;
 }
 
 QString KisImportExportFilter::realFilename() const
 {
     return d->realFilename;
 }
 
 bool KisImportExportFilter::batchMode() const
 {
     return d->batchmode;
 }
 
 
 void KisImportExportFilter::setBatchMode(bool batchmode)
 {
     d->batchmode = batchmode;
 }
 
 void KisImportExportFilter::setFilename(const QString &filename)
 {
     d->filename = filename;
 }
 
 void KisImportExportFilter::setRealFilename(const QString &filename)
 {
     d->realFilename = filename;
 }
 
 
 void KisImportExportFilter::setMimeType(const QString &mime)
 {
     d->mime = mime.toLatin1();
 }
 
 QByteArray KisImportExportFilter::mimeType() const
 {
     return d->mime;
 }
 
 QString KisImportExportFilter::conversionStatusString(ConversionStatus status)
 {
     QString msg;
     switch (status) {
     case OK: break;
 
     case FilterCreationError:
         msg = i18n("Could not create the filter plugin"); break;
 
     case CreationError:
         msg = i18n("Could not create the output document"); break;
 
     case FileNotFound:
         msg = i18n("File not found"); break;
 
     case StorageCreationError:
         msg = i18n("Cannot create storage"); break;
 
     case BadMimeType:
         msg = i18n("Bad MIME type"); break;
 
     case WrongFormat:
         msg = i18n("Format not recognized"); break;
 
     case NotImplemented:
         msg = i18n("Not implemented"); break;
 
     case ParsingError:
         msg = i18n("Parsing error"); break;
 
     case InvalidFormat:
         msg = i18n("Invalid file format"); break;
 
     case InternalError:
     case UsageError:
         msg = i18n("Internal error"); break;
 
     case ProgressCancelled:
         msg = i18n("Cancelled by user"); break;
 
     case BadConversionGraph:
 
         msg = i18n("Unknown file type"); break;
 
     case UnsupportedVersion:
 
         msg = i18n("Unsupported file version"); break;
 
     case UserCancelled:
 
         // intentionally we do not prompt the error message here
         break;
 
 
     default: msg = i18n("Unknown error"); break;
     }
     return msg;
 }
 
 KisPropertiesConfigurationSP KisImportExportFilter::defaultConfiguration(const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     Q_UNUSED(to);
     return 0;
 }
 
 KisPropertiesConfigurationSP KisImportExportFilter::lastSavedConfiguration(const QByteArray &from, const QByteArray &to) const
 {
     return defaultConfiguration(from, to);
 }
 
 KisConfigWidget *KisImportExportFilter::createConfigurationWidget(QWidget *, const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     Q_UNUSED(to);
     return 0;
 }
 
 QMap<QString, KisExportCheckBase *> KisImportExportFilter::exportChecks()
 {
     qDeleteAll(d->capabilities);
     initializeCapabilities();
     return d->capabilities;
 }
 
 void KisImportExportFilter::setUpdater(QPointer<KoUpdater> updater)
 {
     d->updater = updater;
 }
 
 void KisImportExportFilter::setProgress(int value)
 {
     if (d->updater) {
         d->updater->setValue(value);
     }
 }
 
 void KisImportExportFilter::initializeCapabilities()
 {
     // XXX: Initialize everything to fully supported?
 }
 
 void KisImportExportFilter::addCapability(KisExportCheckBase *capability)
 {
     d->capabilities[capability->id()] = capability;
 }
 
 
 
 void KisImportExportFilter::addSupportedColorModels(QList<QPair<KoID, KoID> > supportedColorModels, const QString &name, KisExportCheckBase::Level level)
 {
     Q_ASSERT(level != KisExportCheckBase::SUPPORTED);
     QString layerMessage;
     QString imageMessage;
     QList<KoID> allColorModels = KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(const KoID &colorModelID, allColorModels) {
         QList<KoID> allColorDepths = KoColorSpaceRegistry::instance()->colorDepthList(colorModelID.id(), KoColorSpaceRegistry::AllColorSpaces);
         Q_FOREACH(const KoID &colorDepthID, allColorDepths) {
 
             KisExportCheckFactory *colorModelCheckFactory =
                     KisExportCheckRegistry::instance()->get("ColorModelCheck/" + colorModelID.id() + "/" + colorDepthID.id());
             KisExportCheckFactory *colorModelPerLayerCheckFactory =
                     KisExportCheckRegistry::instance()->get("ColorModelPerLayerCheck/" + colorModelID.id() + "/" + colorDepthID.id());
 
             if(!colorModelCheckFactory || !colorModelPerLayerCheckFactory) {
                 qDebug() << "No factory for" << colorModelID << colorDepthID;
                 continue;
             }
 
             if (supportedColorModels.contains(QPair<KoID, KoID>(colorModelID, colorDepthID))) {
                 addCapability(colorModelCheckFactory->create(KisExportCheckBase::SUPPORTED));
                 addCapability(colorModelPerLayerCheckFactory->create(KisExportCheckBase::SUPPORTED));
             }
             else {
 
 
                 if (level == KisExportCheckBase::PARTIALLY) {
                     imageMessage = i18nc("image conversion warning",
                                          "%1 cannot save images with color model <b>%2</b> and depth <b>%3</b>. The image will be converted."
                                          ,name, colorModelID.name(), colorDepthID.name());
 
                     layerMessage =
                             i18nc("image conversion warning",
                                   "%1 cannot save layers with color model <b>%2</b> and depth <b>%3</b>. The layers will be converted or skipped."
                                   ,name, colorModelID.name(), colorDepthID.name());
                 }
                 else {
                     imageMessage = i18nc("image conversion warning",
                                          "%1 cannot save images with color model <b>%2</b> and depth <b>%3</b>. The image will not be saved."
                                          ,name, colorModelID.name(), colorDepthID.name());
 
                     layerMessage =
                             i18nc("image conversion warning",
                                   "%1 cannot save layers with color model <b>%2</b> and depth <b>%3</b>. The layers will be skipped."
                                   , name, colorModelID.name(), colorDepthID.name());
                  }
 
 
 
                 addCapability(colorModelCheckFactory->create(level, imageMessage));
                 addCapability(colorModelPerLayerCheckFactory->create(level, layerMessage));
             }
         }
     }
 }
diff --git a/libs/ui/kis_animation_exporter.cpp b/libs/ui/kis_animation_exporter.cpp
index 3d536e0cda..bf35d690c4 100644
--- a/libs/ui/kis_animation_exporter.cpp
+++ b/libs/ui/kis_animation_exporter.cpp
@@ -1,378 +1,378 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_exporter.h"
 
 #include <QDesktopServices>
 #include <QProgressDialog>
 #include <KisMimeDatabase.h>
 #include <QEventLoop>
 #include <QMessageBox>
 
 #include "KoFileDialog.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "KisImportExportManager.h"
 #include "kis_image_animation_interface.h"
 #include "KisPart.h"
 #include "KisMainWindow.h"
 
 #include "kis_paint_layer.h"
 #include "kis_group_layer.h"
 #include "kis_time_range.h"
 #include "kis_painter.h"
 
 #include "kis_image_lock_hijacker.h"
 
 
 struct KisAnimationExporterUI::Private
 {
     QWidget *parentWidget;
     KisAnimationExportSaver *exporter;
 
     Private(QWidget *parent)
         : parentWidget(parent),
           exporter(0)
     {}
 };
 
 KisAnimationExporterUI::KisAnimationExporterUI(QWidget *parent)
     : m_d(new Private(parent))
 {
 }
 
 KisAnimationExporterUI::~KisAnimationExporterUI()
 {
     if (m_d->exporter) {
         delete m_d->exporter;
     }
 }
 
 struct KisAnimationExporter::Private
 {
     Private(KisDocument *document, int fromTime, int toTime)
         : document(document)
         , image(document->image())
         , firstFrame(fromTime)
         , lastFrame(toTime)
         , currentFrame(-1)
         , batchMode(document->fileBatchMode())
         , isCancelled(false)
         , status(KisImportExportFilter::OK)
         , tmpDevice(new KisPaintDevice(image->colorSpace()))
     {
     }
 
     KisDocument *document;
     KisImageWSP image;
 
     int firstFrame;
     int lastFrame;
     int currentFrame;
 
     bool batchMode;
     bool isCancelled;
 
     KisImportExportFilter::ConversionStatus status;
 
     SaveFrameCallback saveFrameCallback;
 
     KisPaintDeviceSP tmpDevice;
 
     KisPropertiesConfigurationSP exportConfiguration;
     QProgressDialog progress;
 
 };
 
 KisAnimationExporter::KisAnimationExporter(KisDocument *document, int fromTime, int toTime)
     : m_d(new Private(document, fromTime, toTime))
 {
     connect(m_d->image->animationInterface(), SIGNAL(sigFrameReady(int)),
             this, SLOT(frameReadyToCopy(int)), Qt::DirectConnection);
 
     connect(this, SIGNAL(sigFrameReadyToSave()),
             this, SLOT(frameReadyToSave()), Qt::QueuedConnection);
 }
 
 KisAnimationExporter::~KisAnimationExporter()
 {
 }
 
 void KisAnimationExporter::setExportConfiguration(KisPropertiesConfigurationSP exportConfiguration)
 {
     m_d->exportConfiguration = exportConfiguration;
 }
 
 void KisAnimationExporter::setSaveFrameCallback(SaveFrameCallback func)
 {
     m_d->saveFrameCallback = func;
 }
 
 KisImportExportFilter::ConversionStatus KisAnimationExporter::exportAnimation()
 {
 
     if (!m_d->batchMode) {
         QString message = i18n("Preparing to export frames...");
 
         m_d->progress.reset();
         m_d->progress.setLabelText(message);
         m_d->progress.setWindowModality(Qt::ApplicationModal);
         m_d->progress.setCancelButton(0);
         m_d->progress.setMinimumDuration(0);
         m_d->progress.setValue(0);
         m_d->progress.setMinimum(0);
         m_d->progress.setMaximum(100);
 
         emit m_d->document->statusBarMessage(message);
         emit m_d->document->sigProgress(0);
         connect(m_d->document, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
     }
 
     /**
      * HACK ALERT: Here we remove the image lock! We do it in a GUI
      *             thread under the barrier lock held, so it is
      *             guaranteed no other stroke will accidentally be
      *             started by this. And showing an app-modal dialog to
      *             the user will prevent him from doing anything
      *             nasty.
      */
     KisImageLockHijacker badGuy(m_d->image);
     Q_UNUSED(badGuy);
 
     KIS_ASSERT_RECOVER(!m_d->image->locked()) { return KisImportExportFilter::InternalError; }
 
     m_d->status = KisImportExportFilter::OK;
     m_d->currentFrame = m_d->firstFrame;
     m_d->image->animationInterface()->requestFrameRegeneration(m_d->currentFrame, m_d->image->bounds());
 
     QEventLoop loop;
     loop.connect(this, SIGNAL(sigFinished()), SLOT(quit()));
     loop.exec();
 
     if (!m_d->batchMode) {
         disconnect(m_d->document, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
         emit m_d->document->sigProgress(100);
         emit m_d->document->clearStatusBarMessage();
         m_d->progress.reset();
     }
 
     return m_d->status;
 }
 
 void KisAnimationExporter::cancel()
 {
     m_d->isCancelled = true;
 }
 
 void KisAnimationExporter::frameReadyToCopy(int time)
 {
     if (time != m_d->currentFrame) return;
 
     QRect rc = m_d->image->bounds();
     KisPainter::copyAreaOptimized(rc.topLeft(), m_d->image->projection(), m_d->tmpDevice, rc);
 
     emit sigFrameReadyToSave();
 }
 
 void KisAnimationExporter::frameReadyToSave()
 {
     KIS_ASSERT_RECOVER(m_d->saveFrameCallback) {
         m_d->status = KisImportExportFilter::InternalError;
         emit sigFinished();
         return;
     }
 
     if (m_d->isCancelled) {
         m_d->status = KisImportExportFilter::UserCancelled;
         emit sigFinished();
         return;
     }
 
     KisImportExportFilter::ConversionStatus result =
         KisImportExportFilter::OK;
     int time = m_d->currentFrame;
 
     result = m_d->saveFrameCallback(time, m_d->tmpDevice, m_d->exportConfiguration);
 
     if (!m_d->batchMode) {
-        emit m_d->document->sigProgress((time - m_d->firstFrame) * 100 /
-                                        (m_d->lastFrame - m_d->firstFrame));
+        int length = m_d->lastFrame - m_d->firstFrame + 1;
+        emit m_d->document->sigProgress((time - m_d->firstFrame) * 100 / length);
     }
 
     qDebug() << result << time << m_d->lastFrame;
 
     QString dialogText = QString("Exporting Frame ").append(QString::number(time)).append(" of ").append(QString::number(m_d->lastFrame));
     int percentageProcessed = (float(time) / float(m_d->lastFrame) * 100);
 
     m_d->progress.setLabelText(dialogText);
     m_d->progress.setValue(int(percentageProcessed));
 
     if (result == KisImportExportFilter::OK && time < m_d->lastFrame) {
         m_d->currentFrame = time + 1;
         m_d->image->animationInterface()->requestFrameRegeneration(m_d->currentFrame, m_d->image->bounds());
     } else {
         emit sigFinished();
     }
 }
 
 struct KisAnimationExportSaver::Private
 {
     Private(KisDocument *document, int fromTime, int toTime, int _sequenceNumberingOffset)
         : document(document)
         , image(document->image())
         , firstFrame(fromTime)
         , lastFrame(toTime)
         , sequenceNumberingOffset(_sequenceNumberingOffset)
         , tmpDoc(KisPart::instance()->createDocument())
         , exporter(document, fromTime, toTime)
     {
         tmpDoc->setAutoSaveDelay(0);
 
         tmpImage = new KisImage(tmpDoc->createUndoStore(),
                                 image->bounds().width(),
                                 image->bounds().height(),
                                 image->colorSpace(),
                                 QString());
 
         tmpImage->setResolution(image->xRes(), image->yRes());
         tmpDoc->setCurrentImage(tmpImage);
 
         KisPaintLayer* paintLayer = new KisPaintLayer(tmpImage, "paint device", 255);
         tmpImage->addNode(paintLayer, tmpImage->rootLayer(), KisLayerSP(0));
 
         tmpDevice = paintLayer->paintDevice();
     }
 
     KisDocument *document;
     KisImageWSP image;
     int firstFrame;
     int lastFrame;
     int sequenceNumberingOffset;
 
     QScopedPointer<KisDocument> tmpDoc;
     KisImageSP tmpImage;
     KisPaintDeviceSP tmpDevice;
 
     KisAnimationExporter exporter;
 
     QString filenamePrefix;
     QString filenameSuffix;
 };
 
 KisAnimationExportSaver::KisAnimationExportSaver(KisDocument *document, const QString &baseFilename, int fromTime, int toTime, int sequenceNumberingOffset)
     : m_d(new Private(document, fromTime, toTime, sequenceNumberingOffset))
 {
     int baseLength = baseFilename.lastIndexOf(".");
     if (baseLength > -1) {
         m_d->filenamePrefix = baseFilename.left(baseLength);
         m_d->filenameSuffix = baseFilename.right(baseFilename.length() - baseLength);
     } else {
         m_d->filenamePrefix = baseFilename;
     }
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(baseFilename);
     m_d->tmpDoc->setOutputMimeType(mimefilter.toLatin1());
     m_d->tmpDoc->setFileBatchMode(true);
 
     using namespace std::placeholders; // For _1 placeholder
     m_d->exporter.setSaveFrameCallback(std::bind(&KisAnimationExportSaver::saveFrameCallback, this, _1, _2, _3));
     
    
     
 }
 
 KisAnimationExportSaver::~KisAnimationExportSaver()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisAnimationExportSaver::exportAnimation(KisPropertiesConfigurationSP cfg)
 {
     QFileInfo info(savedFilesMask());
 
     QDir dir(info.absolutePath());
     QStringList filesList = dir.entryList({ info.fileName() });
 
     if (!filesList.isEmpty()) {
         if (m_d->document->fileBatchMode()) {
             return KisImportExportFilter::CreationError;
         }
 
         QStringList truncatedList = filesList;
 
         while (truncatedList.size() > 3) {
             truncatedList.takeLast();
         }
 
         QString exampleFiles = truncatedList.join(", ");
         if (truncatedList.size() != filesList.size()) {
             exampleFiles += QString(", ...");
         }
 
         QMessageBox::StandardButton result =
                 QMessageBox::warning(0,
                                      i18n("Delete old frames?"),
                                      i18n("Frames with the same naming "
                                           "scheme exist in the destination "
                                           "directory. They are going to be "
                                           "deleted, continue?\n\n"
                                           "Directory: %1\n"
                                           "Files: %2",
                                           info.absolutePath(), exampleFiles),
                                      QMessageBox::Yes | QMessageBox::No,
                                      QMessageBox::No);
 
         if (result == QMessageBox::Yes) {
             Q_FOREACH (const QString &file, filesList) {
                 if (!dir.remove(file)) {
                     QMessageBox::critical(0,
                                           i18n("Failed to delete"),
                                           i18n("Failed to delete an old frame file:\n\n"
                                                "%1\n\n"
                                                "Rendering cancelled.", dir.absoluteFilePath(file)));
                     return KisImportExportFilter::CreationError;
                 }
             }
         } else {
             return KisImportExportFilter::UserCancelled;
         }
     }
 
     m_d->exporter.setExportConfiguration(cfg);
     return m_d->exporter.exportAnimation();
 }
 
 KisImportExportFilter::ConversionStatus KisAnimationExportSaver::saveFrameCallback(int time, KisPaintDeviceSP frame, KisPropertiesConfigurationSP exportConfiguration)
 {
     KisImportExportFilter::ConversionStatus status = KisImportExportFilter::OK;
 
     QString frameNumber = QString("%1").arg(time - m_d->firstFrame + m_d->sequenceNumberingOffset, 4, 10, QChar('0'));
     QString filename = m_d->filenamePrefix + frameNumber + m_d->filenameSuffix;
 
     QRect rc = m_d->image->bounds();
     KisPainter::copyAreaOptimized(rc.topLeft(), frame, m_d->tmpDevice, rc);
     if (!m_d->tmpDoc->exportDocument(QUrl::fromLocalFile(filename), exportConfiguration)) {
         status = KisImportExportFilter::InternalError;
     }
 
     return status;
 }
 
 QString KisAnimationExportSaver::savedFilesMask() const
 {
     return m_d->filenamePrefix + "%04d" + m_d->filenameSuffix;
 }
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index 5aff453d39..e7431a55ff 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1314 +1,1317 @@
 /*
  *  kis_paintop_box.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2009-2011 Sven Langkamp (sven.langkamp@gmail.com)
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_box.h"
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QPixmap>
 #include <QWidgetAction>
 #include <QApplication>
 #include <QMenu>
 
 #include <kis_debug.h>
 
 #include <kactioncollection.h>
 #include <kacceleratormanager.h>
 #include <QKeySequence>
 
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceSelector.h>
 #include <KoResourceServerAdapter.h>
 #include <KoToolManager.h>
 #include <QTemporaryFile>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_paint_device.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_settings_update_proxy.h>
 #include <kis_config_widget.h>
 #include <kis_image.h>
 #include <kis_node.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_action.h>
 
 #include "kis_canvas2.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_resource_server_provider.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_config.h"
 
 #include "widgets/kis_popup_button.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_popup.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_chooser_popup.h"
 #include "widgets/kis_workspace_chooser.h"
 #include "widgets/kis_paintop_list_widget.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_widget_chooser.h"
 #include "tool/kis_tool.h"
 #include "kis_signals_blocker.h"
 #include "kis_action_manager.h"
 #include "kis_highlighted_button.h"
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisPaintopBox::KisPaintopBox(KisViewManager *view, QWidget *parent, const char *name)
     : QWidget(parent)
     , m_resourceProvider(view->resourceProvider())
     , m_optionWidget(0)
     , m_toolOptionsPopupButton(0)
     , m_brushEditorPopupButton(0)
     , m_presetSelectorPopupButton(0)
     , m_toolOptionsPopup(0)
     , m_viewManager(view)
     , m_previousNode(0)
     , m_currTabletToolID(KoInputDevice::invalid())
     , m_presetsEnabled(true)
     , m_blockUpdate(false)
     , m_dirtyPresetsEnabled(false)
     , m_eraserBrushSizeEnabled(false)
     , m_eraserBrushOpacityEnabled(false)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
     KisConfig cfg;
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
     m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
     int iconsize = grp.readEntry("IconSize", 32);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopupButton = new KisPopupButton(this);
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
         m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
         m_toolOptionsPopupButton->setFixedSize(iconsize, iconsize);
     }
 
     m_brushEditorPopupButton = new KisPopupButton(this);
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
     m_brushEditorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_presetSelectorPopupButton = new KisPopupButton(this);
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
     m_presetSelectorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_eraseModeButton = new KisHighlightedToolButton(this);
     m_eraseModeButton->setFixedSize(iconsize, iconsize);
     m_eraseModeButton->setCheckable(true);
 
     m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
     m_eraseModeButton->setDefaultAction(m_eraseAction);
 
     m_reloadButton = new QToolButton(this);
     m_reloadButton->setFixedSize(iconsize, iconsize);
 
     m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
     m_reloadButton->setDefaultAction(m_reloadAction);
 
     m_alphaLockButton = new KisHighlightedToolButton(this);
     m_alphaLockButton->setFixedSize(iconsize, iconsize);
     m_alphaLockButton->setCheckable(true);
 
     KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
     m_alphaLockButton->setDefaultAction(alphaLockAction);
 
 
     // pen pressure
     m_disablePressureButton = new KisHighlightedToolButton(this);
     m_disablePressureButton->setFixedSize(iconsize, iconsize);
     m_disablePressureButton->setCheckable(true);
 
     m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
     m_disablePressureButton->setDefaultAction(m_disablePressureAction);
 
     // horizontal and vertical mirror toolbar buttons
 
     // mirror tool options for the X Mirror
     QMenu *toolbarMenuXMirror = new QMenu();
 
     KisAction* hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     hideCanvasDecorationsX->setCheckable(true);
     hideCanvasDecorationsX->setText(i18n("Hide Mirror Line"));
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     KisAction* lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     lockActionX->setText(i18n("Lock"));
     lockActionX->setCheckable(true);
     toolbarMenuXMirror->addAction(lockActionX);
 
     KisAction* moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     moveToCenterActionX->setCheckable(false);
     moveToCenterActionX->setText(i18n("Move to Canvas Center"));
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     KisAction* hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     hideCanvasDecorationsY->setCheckable(true);
     hideCanvasDecorationsY->setText(i18n("Hide Mirror Line"));
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     KisAction* lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     lockActionY->setText(i18n("Lock"));
     lockActionY->setCheckable(true);
     toolbarMenuYMirror->addAction(lockActionY);
 
     KisAction* moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     moveToCenterActionY->setCheckable(false);
     moveToCenterActionY->setText(i18n("Move to Canvas Center"));
     toolbarMenuYMirror->addAction(moveToCenterActionY);
 
 
 
 
     // create horizontal and vertical mirror buttons
 
     m_hMirrorButton = new KisHighlightedToolButton(this);
     int menuPadding = 10;
     m_hMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_hMirrorButton->setCheckable(true);
     m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
     m_hMirrorButton->setDefaultAction(m_hMirrorAction);
     m_hMirrorButton->setMenu(toolbarMenuXMirror);
     m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_vMirrorButton = new KisHighlightedToolButton(this);
     m_vMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_vMirrorButton->setCheckable(true);
     m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
     m_vMirrorButton->setDefaultAction(m_vMirrorAction);
     m_vMirrorButton->setMenu(toolbarMenuYMirror);
     m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     // add connections for horizontal and mirrror buttons
     connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
     connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
     connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
     connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
     connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
     connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
     const bool sliderLabels = cfg.sliderLabels();
     int sliderWidth;
 
     if (sliderLabels) {
         sliderWidth = 150 * logicalDpiX() / 96;
     }
     else {
         sliderWidth = 120 * logicalDpiX() / 96;
     }
 
     for (int i = 0; i < 3; ++i) {
         m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
         KisDoubleSliderSpinBox* slOpacity;
         KisDoubleSliderSpinBox* slFlow;
         KisDoubleSliderSpinBox* slSize;
         if (sliderLabels) {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
             slOpacity->setPrefix(QString("%1  ").arg(i18n("Opacity:")));
             slFlow->setPrefix(QString("%1  ").arg(i18n("Flow:")));
             slSize->setPrefix(QString("%1  ").arg(i18n("Size:")));
         }
         else {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
         }
 
         slOpacity->setRange(0.0, 1.0, 2);
         slOpacity->setValue(1.0);
         slOpacity->setSingleStep(0.05);
         slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
         slOpacity->setFixedHeight(iconsize);
         slOpacity->setBlockUpdateSignalOnDrag(true);
 
         slFlow->setRange(0.0, 1.0, 2);
         slFlow->setValue(1.0);
         slFlow->setSingleStep(0.05);
         slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
         slFlow->setFixedHeight(iconsize);
         slFlow->setBlockUpdateSignalOnDrag(true);
 
         slSize->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         slSize->setValue(100);
 
         slSize->setSingleStep(1);
         slSize->setExponentRatio(3.0);
         slSize->setSuffix(i18n(" px"));
         slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
         slSize->setFixedHeight(iconsize);
         slSize->setBlockUpdateSignalOnDrag(true);
 
         m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
     }
 
     m_cmbCompositeOp = new KisCompositeOpComboBox();
     m_cmbCompositeOp->setFixedHeight(iconsize);
     Q_FOREACH (KisAction * a, m_cmbCompositeOp->blendmodeActions()) {
         m_viewManager->actionManager()->addAction(a->text(), a);
     }
 
     m_workspaceWidget = new KisPopupButton(this);
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_workspaceWidget->setToolTip(i18n("Choose workspace"));
     m_workspaceWidget->setFixedSize(iconsize, iconsize);
     m_workspaceWidget->setPopupWidget(new KisWorkspaceChooser(view));
 
     QHBoxLayout* baseLayout = new QHBoxLayout(this);
     m_paintopWidget = new QWidget(this);
     baseLayout->addWidget(m_paintopWidget);
     baseLayout->setSpacing(4);
     baseLayout->setContentsMargins(0, 0, 0, 0);
 
     m_layout = new QHBoxLayout(m_paintopWidget);
     if (!cfg.toolOptionsInDocker()) {
         m_layout->addWidget(m_toolOptionsPopupButton);
     }
     m_layout->addWidget(m_brushEditorPopupButton);
     m_layout->addWidget(m_presetSelectorPopupButton);
     m_layout->setSpacing(4);
     m_layout->setContentsMargins(0, 0, 0, 0);
 
     QWidget* compositeActions = new QWidget(this);
     QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
     compositeLayout->addWidget(m_cmbCompositeOp);
     compositeLayout->addWidget(m_eraseModeButton);
     compositeLayout->addWidget(m_alphaLockButton);
 
     compositeLayout->setSpacing(4);
     compositeLayout->setContentsMargins(0, 0, 0, 0);
 
     compositeLayout->addWidget(m_reloadButton);
 
     QWidgetAction * action;
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("composite_actions", action);
     action->setText(i18n("Brush composite"));
     action->setDefaultWidget(compositeActions);
 
     QWidget* compositePressure = new QWidget(this);
     QHBoxLayout* pressureLayout = new QHBoxLayout(compositePressure);
     pressureLayout->addWidget(m_disablePressureButton);
     pressureLayout->setSpacing(4);
     pressureLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("pressure_action", action);
     action->setText(i18n("Pressure usage (small button)"));
     action->setDefaultWidget(compositePressure);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider1", action);
     view->actionCollection()->addAction("brushslider1", action);
     action->setDefaultWidget(m_sliderChooser[0]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider2", action);
     view->actionCollection()->addAction("brushslider2", action);
     action->setDefaultWidget(m_sliderChooser[1]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider3", action);
     view->actionCollection()->addAction("brushslider3", action);
     action->setDefaultWidget(m_sliderChooser[2]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
         connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
     view->actionCollection()->addAction("next_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
     view->actionCollection()->addAction("previous_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_preset", action);
     view->actionCollection()->addAction("previous_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
     if (!cfg.toolOptionsInDocker()) {
         action = new QWidgetAction(this);
         KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
         view->actionCollection()->addAction("show_tool_options", action);
         connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
     }
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
     view->actionCollection()->addAction("show_brush_editor", action);
     connect(action, SIGNAL(triggered()), m_brushEditorPopupButton, SLOT(showPopupWidget()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
     view->actionCollection()->addAction("show_brush_presets", action);
     connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
 
     QWidget* mirrorActions = new QWidget(this);
     QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
     mirrorLayout->addWidget(m_hMirrorButton);
     mirrorLayout->addWidget(m_vMirrorButton);
     mirrorLayout->setSpacing(4);
     mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
     action->setDefaultWidget(mirrorActions);
     view->actionCollection()->addAction("mirror_actions", action);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("workspaces", action);
     view->actionCollection()->addAction("workspaces", action);
     action->setDefaultWidget(m_workspaceWidget);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopup = new KisToolOptionsPopup();
         m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
         m_toolOptionsPopup->switchDetached(false);
     }
 
     m_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->parentWidget()->setWindowTitle(i18n("Brush Editor"));
 
     connect(m_presetsPopup, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     slotNodeChanged(view->activeNode());
     // Get all the paintops
     QList<QString> keys = KisPaintOpRegistry::instance()->keys();
     QList<KisPaintOpFactory*> factoryList;
 
     Q_FOREACH (const QString & paintopId, keys) {
         factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
     }
     m_presetsPopup->setPaintOpList(factoryList);
 
     connect(m_presetsPopup       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
     connect(m_presetsPopup       , SIGNAL(savePresetClicked())                , SLOT(slotSaveActivePreset()));
     connect(m_presetsPopup       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
     connect(m_presetsPopup       , SIGNAL(signalResourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
     connect(m_presetsPopup       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
     connect(m_presetsPopup       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
     connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResource*))      , SLOT(resourceSelected(KoResource*)));
     connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResource*))      , SLOT(resourceSelected(KoResource*)));
 
     connect(m_resourceProvider   , SIGNAL(sigNodeChanged(const KisNodeSP))    , SLOT(slotNodeChanged(const KisNodeSP)));
     connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
     connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
     connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
     connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
 
     m_disablePressureAction->setChecked(true);
 
     connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
     connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
     connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
 
     //Needed to connect canvas to favorite resource manager
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
     connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
     connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
     // cold initialization
     m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
     m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
     connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigEnableChangeColor(bool)), m_resourceProvider, SLOT(slotResetEnableFGChange(bool)));
 
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
 
     slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
     KisConfig cfg;
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         //qDebug() << "Writing last used preset for" << iter.key().pointer << iter.key().uniqueID << iter.value().preset->name();
         if ((iter.key().pointer) == QTabletEvent::Eraser) {
             cfg.writeEntry(QString("LastEraser_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
         else {
             cfg.writeEntry(QString("LastPreset_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
     }
     // Do not delete the widget, since it it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     //qDebug() << "restoreResource" << resource << preset;
     if (preset) {
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     if (m_toolOptionsPopup) {
         m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisPaintopBox::resourceSelected(KoResource* resource)
 {
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset && preset != m_resourceProvider->currentPreset()) {
         if (!preset->settings()->isLoadable())
             return;
 
         if (!m_dirtyPresetsEnabled) {
             KisSignalsBlocker blocker(m_optionWidget);
             if (!preset->load()) {
                 warnKrita << "failed to load the preset.";
             }
         }
         //qDebug() << "resourceSelected" << resource->name();
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop)
 {
     KisPaintOpPresetSP preset = activePreset(paintop);
     Q_ASSERT(preset && preset->settings());
     //qDebug() << "setCurrentPaintop();" << paintop << preset;
     setCurrentPaintop(preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(KisPaintOpPresetSP preset)
 {
 
     //qDebug() << "setCurrentPaintop(); " << preset->name();
 
     if (preset == m_resourceProvider->currentPreset()) {
-        return;
+
+        if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
+            return;
+        }
     }
     Q_ASSERT(preset);
     const KoID& paintop = preset->paintOp();
     m_presetConnections.clear();
 
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->hide();
         }
 
     }
 
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
     KisSignalsBlocker b(m_optionWidget);
 
     preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
     m_resourceProvider->setPaintOpPreset(preset);
 
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
     KisPaintOpFactory* paintOp = KisPaintOpRegistry::instance()->get(paintop.id());
     QString pixFilename = KoResourcePaths::findResource("kis_images", paintOp->pixmap());
 
     m_brushEditorPopupButton->setIcon(QIcon(pixFilename));
     m_presetsPopup->setCurrentPaintOpId(paintop.id());
 
 
     ////qDebug() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
     m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
     m_tabletToolMap[m_currTabletToolID].preset = preset;
     m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
     if (m_presetsPopup->currentPaintOpId() != paintop.id()) {
         // Must change the paintop as the current one is not supported
         // by the new colorspace.
         dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
     }
 }
 
 void KisPaintopBox::slotUpdateOptionsWidgetPopup()
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
     KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_optionWidget->setConfigurationSafe(preset->settings());
 
     m_presetsPopup->resourceSelected(preset.data());
     m_presetsPopup->updateViewSettings();
 
     // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
     // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
     m_optionWidget->setImage(m_viewManager->image());
 }
 
 KisPaintOpPresetSP KisPaintopBox::defaultPreset(const KoID& paintOp)
 {
     QString defaultName = paintOp.id() + ".kpp";
     QString path = KoResourcePaths::findResource("kis_defaultpresets", defaultName);
 
     KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
 
     if (!preset->load()) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
     }
 
     Q_ASSERT(preset);
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 
 KisPaintOpPresetSP KisPaintopBox::activePreset(const KoID& paintOp)
 {
     if (m_paintOpPresetMap[paintOp] == 0) {
         m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
     }
 
     return m_paintOpPresetMap[paintOp];
 }
 
 void KisPaintopBox::updateCompositeOp(QString compositeOpID)
 {
     if (!m_optionWidget) return;
     KisSignalsBlocker blocker(m_optionWidget);
 
     KisNodeSP node = m_resourceProvider->currentNode();
 
     if (node && node->paintDevice()) {
         if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
             compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
         {
             KisSignalsBlocker b1(m_cmbCompositeOp);
             m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         }
         if (compositeOpID != m_currCompositeOpID) {
             m_currCompositeOpID = compositeOpID;
         }
         if (compositeOpID == COMPOSITE_ERASE) {
             m_eraseModeButton->setChecked(true);
         }
         else {
             m_eraseModeButton->setChecked(false);
         }
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
         slider->setValue(value);
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         //qDebug() << "slotsetpaintop" << id;
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
     //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
+    m_currTabletToolID = TabletToolID(inputDevice);
+
     if (toolData == m_tabletToolMap.end()) {
         KisConfig cfg;
         KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer(false);
         KisPaintOpPresetSP preset;
         if (inputDevice.pointer() == QTabletEvent::Eraser) {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), "Eraser_circle"));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), "Basic_tip_default"));
             //if (preset)
                 //qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
             //else
                 //qDebug() << "no preset fcound for" << inputDevice.uniqueTabletId();
         }
         if (!preset) {
             preset = rserver->resourceByName("Basic_tip_default");
         }
         if (preset) {
             //qDebug() << "inputdevicechanged 1" << preset;
             setCurrentPaintop(preset);
         }
     }
     else {
         if (toolData->preset) {
             //qDebug() << "inputdevicechanged 2" << toolData->preset;
             setCurrentPaintop(toolData->preset);
         }
         else {
             //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
             setCurrentPaintop(toolData->paintOpID);
         }
     }
-
-    m_currTabletToolID = TabletToolID(inputDevice);
 }
 
 void KisPaintopBox::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if (m_viewManager) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_viewManager->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
             QString compositeOp = preset->settings()->getString("CompositeOp");
             updateCompositeOp(compositeOp);
             resourceSelected(preset.data());
         }
 
         /**
          * Update currently selected preset in both the popup widgets
          */
         m_presetsChooserPopup->canvasResourceChanged(preset);
 
         m_presetsPopup->currentPresetChanged(preset);
 
         if (key == KisCanvasResourceProvider::CurrentCompositeOp) {
             if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                 updateCompositeOp(m_resourceProvider->currentCompositeOp());
             }
         }
 
         if (key == KisCanvasResourceProvider::Size) {
             setSliderValue("size", m_resourceProvider->size());
         }
 
         if (key == KisCanvasResourceProvider::Opacity) {
             setSliderValue("opacity", m_resourceProvider->opacity());
         }
 
         if (key == KisCanvasResourceProvider::Flow) {
             setSliderValue("flow", m_resourceProvider->flow());
         }
 
         if (key == KisCanvasResourceProvider::EraserMode) {
             m_eraseAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::DisablePressure) {
             m_disablePressureAction->setChecked(value.toBool());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotSaveActivePreset()
 {
     KisPaintOpPresetSP curPreset = m_resourceProvider->currentPreset();
 
     if (!curPreset)
         return;
 
     m_favoriteResourceManager->setBlockUpdates(true);
 
     KisPaintOpPresetSP newPreset = curPreset->clone();
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString saveLocation = rServer->saveLocation();
     QString presetName = m_presetsPopup->getPresetName();
     QString presetFilename = saveLocation + presetName + newPreset->defaultFileExtension();
 
     QStringList tags;
     KisPaintOpPresetSP resource = rServer->resourceByName(presetName);
     if (resource) {
 
         tags = rServer->assignedTagsList(resource.data());
         rServer->removeResourceAndBlacklist(resource);
 
     }
 
     newPreset->setImage(m_presetsPopup->cutOutOverlay());
     newPreset->setFilename(presetFilename);
     newPreset->setName(presetName);
     newPreset->setPresetDirty(false);
 
     rServer->addResource(newPreset);
     Q_FOREACH (const QString & tag, tags) {
         rServer->addTag(newPreset.data(), tag);
     }
 
     // HACK ALERT! the server does not notify the observers
     // automatically, so we need to call theupdate manually!
     rServer->tagCategoryMembersChanged();
 
     restoreResource(newPreset.data());
 
     m_favoriteResourceManager->setBlockUpdates(false);
 }
 
 void KisPaintopBox::slotUpdatePreset()
 {
     if (!m_resourceProvider->currentPreset()) return;
 
     // block updates of avoid some over updating of the option widget
     m_blockUpdate = true;
 
     setSliderValue("size", m_resourceProvider->size());
 
     {
         qreal opacity = m_resourceProvider->currentPreset()->settings()->paintOpOpacity();
         m_resourceProvider->setOpacity(opacity);
         setSliderValue("opacity", opacity);
         setWidgetState(ENABLE_OPACITY);
     }
 
     {
         setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
         setWidgetState(ENABLE_FLOW);
     }
 
     {
         updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
         setWidgetState(ENABLE_COMPOSITEOP);
     }
 
     m_blockUpdate = false;
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
     preset->setOptionsWidget(m_optionWidget);
     m_resourceProvider->setPaintOpPreset(preset);
 }
 
 void KisPaintopBox::slotNodeChanged(const KisNodeSP node)
 {
     if (m_previousNode.isValid() && m_previousNode->paintDevice())
         disconnect(m_previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
     // Reconnect colorspace change of node
     if (node && node->paintDevice()) {
         connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
         m_previousNode = node;
         slotColorSpaceChanged(node->colorSpace());
     }
 
     if (m_optionWidget) {
         m_optionWidget->setNode(node);
     }
 }
 
 void KisPaintopBox::slotColorSpaceChanged(const KoColorSpace* colorSpace)
 {
     m_cmbCompositeOp->validate(colorSpace);
 }
 
 void KisPaintopBox::slotToggleEraseMode(bool checked)
 {
     const bool oldEraserMode = m_resourceProvider->eraserMode();
     m_resourceProvider->setEraserMode(checked);
 
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
         const qreal currentSize = m_resourceProvider->size();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush size. set the eraser size to the normal brush size if not set
         if (checked) {
             settings->setSavedBrushSize(currentSize);
             if (qFuzzyIsNull(settings->savedEraserSize())) {
                 settings->setSavedEraserSize(currentSize);
             }
         } else {
             settings->setSavedEraserSize(currentSize);
             if (qFuzzyIsNull(settings->savedBrushSize())) {
                 settings->setSavedBrushSize(currentSize);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
         m_resourceProvider->setSize(newSize);
     }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
         const qreal currentOpacity = m_resourceProvider->opacity();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
         if (checked) {
             settings->setSavedBrushOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                 settings->setSavedEraserOpacity(currentOpacity);
             }
         } else {
             settings->setSavedEraserOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                 settings->setSavedBrushOpacity(currentOpacity);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
         m_resourceProvider->setOpacity(newOpacity);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
     QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
     m_resourceProvider->setCurrentCompositeOp(compositeOp);
 }
 
 void KisPaintopBox::slotHorizontalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorHorizontal(value);
 }
 
 void KisPaintopBox::slotVerticalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorVertical(value);
 }
 
 void KisPaintopBox::sliderChanged(int n)
 {
     if (!m_optionWidget) // widget will not exist if the are no documents open
         return;
 
 
     KisSignalsBlocker blocker(m_optionWidget);
 
     qreal opacity = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value();
     qreal flow    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value();
     qreal size    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
 
 
     setSliderValue("opacity", opacity);
     setSliderValue("flow"   , flow);
     setSliderValue("size"   , size);
 
     if (m_presetsEnabled) {
         // IMPORTANT: set the PaintOp size before setting the other properties
         //            it wont work the other way
         // TODO: why?!
 
         m_resourceProvider->setSize(size);
         m_resourceProvider->setOpacity(opacity);
         m_resourceProvider->setFlow(flow);
 
 
         KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         m_optionWidget->setConfigurationSafe(m_resourceProvider->currentPreset()->settings().data());
     } else {
         m_resourceProvider->setOpacity(opacity);
     }
 
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 }
 
 void KisPaintopBox::slotSlider1Changed()
 {
     sliderChanged(0);
 }
 
 void KisPaintopBox::slotSlider2Changed()
 {
     sliderChanged(1);
 }
 
 void KisPaintopBox::slotSlider3Changed()
 {
     sliderChanged(2);
 }
 
 void KisPaintopBox::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!m_viewManager->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             setWidgetState(ENABLE_COMPOSITEOP | ENABLE_OPACITY);
         } else                                              {
             setWidgetState(DISABLE_COMPOSITEOP | DISABLE_OPACITY);
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             setWidgetState(ENABLE_PRESETS | ENABLE_SIZE | ENABLE_FLOW);
             slotUpdatePreset();
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS | DISABLE_SIZE | DISABLE_FLOW);
             m_presetsEnabled = false;
         }
     } else setWidgetState(DISABLE_ALL);
 }
 
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     int i = 0;
     Q_FOREACH (KisPaintOpPresetSP preset, m_favoriteResourceManager->favoritePresetList()) {
         if (m_resourceProvider->currentPreset() && m_resourceProvider->currentPreset()->name() == preset->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             return;
         }
         i++;
     }
 
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     int i = 0;
     Q_FOREACH (KisPaintOpPresetSP preset, m_favoriteResourceManager->favoritePresetList()) {
         if (m_resourceProvider->currentPreset()->name() == preset->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             return;
         }
         i++;
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         //qDebug() << "slotSwitchToPreviousPreset();" << m_resourceProvider->previousPreset();
         setCurrentPaintop(m_resourceProvider->previousPreset());
     }
 }
 
 void KisPaintopBox::slotUnsetEraseMode()
 {
     m_eraseAction->setChecked(false);
 }
 
 void KisPaintopBox::slotToggleAlphaLockMode(bool checked)
 {
     if (checked) {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-locked"));
     } else {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-unlocked"));
     }
     m_resourceProvider->setGlobalAlphaLock(checked);
 }
 
 void KisPaintopBox::slotDisablePressureMode(bool checked)
 {
     if (checked) {
         m_disablePressureButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 
     m_resourceProvider->setDisablePressure(checked);
 }
 
 void KisPaintopBox::slotReloadPreset()
 {
     KisSignalsBlocker blocker(m_optionWidget);
 
     //Here using the name and fetching the preset from the server was the only way the load was working. Otherwise it was not loading.
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP preset = rserver->resourceByName(m_resourceProvider->currentPreset()->name());
     if (preset) {
         preset->load();
     }
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         /**
          * Here we postpone all the settings updates events until thye entire writing
          * operation will be finished. As soon as it is finished, the updates will be
          * emitted happily (if there were any).
          */
 
         KisPaintOpPreset::UpdatedPostponer postponer(preset.data());
         m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(preset->settings().data()));
     }
 
     // we should also update the preset strip to update the status of the "dirty" mark
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 
     // TODO!!!!!!!!
     //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p)
 {
 
     QMapIterator<QString, QVariant> i(p->getProperties());
     while (i.hasNext()) {
         i.next();
         m_resourceProvider->currentPreset()->settings()->setProperty(i.key(), QVariant(i.value()));
         if (m_resourceProvider->currentPreset()->settings()->hasProperty(i.key() + "_previous")) {
             m_resourceProvider->currentPreset()->settings()->removeProperty(i.key() + "_previous");
         }
 
     }
     slotGuiChangedCurrentPreset();
 
 }
 
 void KisPaintopBox::slotDropLockedOption(KisPropertiesConfigurationSP p)
 {
     KisSignalsBlocker blocker(m_optionWidget);
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         KisPaintOpPreset::DirtyStateSaver dirtySaver(preset.data());
 
         QMapIterator<QString, QVariant> i(p->getProperties());
         while (i.hasNext()) {
             i.next();
             if (preset->settings()->hasProperty(i.key() + "_previous")) {
                 preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                 preset->settings()->removeProperty(i.key() + "_previous");
             }
 
         }
     }
 
     //slotUpdatePreset();
 }
 void KisPaintopBox::slotDirtyPresetToggled(bool value)
 {
     if (!value) {
         slotReloadPreset();
         m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
         m_presetsPopup->updateViewSettings();
     }
     m_dirtyPresetsEnabled = value;
     KisConfig cfg;
     cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
 
 }
 void KisPaintopBox::slotEraserBrushSizeToggled(bool value)
 {
     m_eraserBrushSizeEnabled = value;
     KisConfig cfg;
     cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
 }
 
 void KisPaintopBox::slotEraserBrushOpacityToggled(bool value)
 {
     m_eraserBrushOpacityEnabled = value;
     KisConfig cfg;
     cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
 }
 
 void KisPaintopBox::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
     KisConfig cfg;
     if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
     }
 
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
 
     m_eraseAction->setIcon(KisIconUtils::loadIcon("draw-eraser"));
     m_reloadAction->setIcon(KisIconUtils::loadIcon("view-refresh"));
 
     if (m_disablePressureAction->isChecked()) {
         m_disablePressureButton->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureButton->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 }
 
 void KisPaintopBox::slotLockXMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorHorizontalLock(toggleLock);
 }
 
 void KisPaintopBox::slotLockYMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorVerticalLock(toggleLock);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorX(bool toggled) {
     m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorY(bool toggled) {
     m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
 }
 
 
 
 void KisPaintopBox::slotMoveToCenterMirrorX() {
   m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorY() {
   m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
 }
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index 4a4975281b..726d0a6f02 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1276 +1,1287 @@
 /*
  *  Copyright (c) 2005-2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_png_converter.h"
 // A big thank to Glenn Randers-Pehrson for his wonderful
 // documentation of libpng available at
 // http://www.libpng.org/pub/png/libpng-1.2.5-manual.html
 
 #ifndef PNG_MAX_UINT // Removed in libpng 1.4
 #define PNG_MAX_UINT PNG_UINT_31_MAX
 #endif
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 
 #include <limits.h>
 #include <stdio.h>
 #include <zlib.h>
 
 #include <QBuffer>
 #include <QFile>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <QUrl>
 
 #include <KoColorSpace.h>
 #include <KoDocumentInfo.h>
 #include <KoID.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 
 #include <kis_config.h>
 #include <kis_painter.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include <metadata/kis_meta_data_store.h>
 #include <KoColorModelStandardIds.h>
 #include "dialogs/kis_dlg_png_import.h"
 #include "kis_clipboard.h"
 
 namespace
 {
 
 
 int getColorTypeforColorSpace(const KoColorSpace * cs , bool alpha)
 {
 
     QString id = cs->id();
 
     if (id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16") {
         return alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY;
     }
     if (id == "RGBA" || id == "RGBA16") {
         return alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
     }
 
     return -1;
 
 }
 
 bool colorSpaceIdSupported(const QString &id)
 {
     return id == "RGBA" || id == "RGBA16" ||
         id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16";
 }
 
 QPair<QString, QString> getColorSpaceForColorType(int color_type, int color_nb_bits)
 {
     QPair<QString, QString> r;
 
     if (color_type ==  PNG_COLOR_TYPE_PALETTE) {
         r.first = RGBAColorModelID.id();
         r.second = Integer8BitsColorDepthID.id();
     } else {
         if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
             r.first = GrayAColorModelID.id();
         } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_RGB) {
             r.first = RGBAColorModelID.id();
         }
         if (color_nb_bits == 16) {
             r.second = Integer16BitsColorDepthID.id();
         } else if (color_nb_bits <= 8) {
             r.second = Integer8BitsColorDepthID.id();
         }
     }
     return r;
 }
 
 
 void fillText(png_text* p_text, const char* key, QString& text)
 {
     p_text->compression = PNG_TEXT_COMPRESSION_zTXt;
     p_text->key = const_cast<char *>(key);
     char* textc = new char[text.length()+1];
     strcpy(textc, text.toLatin1());
     p_text->text = textc;
     p_text->text_length = text.length() + 1;
 }
 
 long formatStringList(char *string, const size_t length, const char *format, va_list operands)
 {
     int n = vsnprintf(string, length, format, operands);
 
     if (n < 0)
         string[length-1] = '\0';
 
     return((long) n);
 }
 
 long formatString(char *string, const size_t length, const char *format, ...)
 {
     long n;
 
     va_list operands;
 
     va_start(operands, format);
     n = (long) formatStringList(string, length, format, operands);
     va_end(operands);
     return(n);
 }
 
 void writeRawProfile(png_struct *ping, png_info *ping_info, QString profile_type, QByteArray profile_data)
 {
 
     png_textp      text;
 
     png_uint_32    allocated_length, description_length;
 
     const uchar hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     dbgFile << "Writing Raw profile: type=" << profile_type << ", length=" << profile_data.length() << endl;
 
     text               = (png_textp) png_malloc(ping, (png_uint_32) sizeof(png_text));
     description_length = profile_type.length();
     allocated_length   = (png_uint_32)(profile_data.length() * 2 + (profile_data.length() >> 5) + 20 + description_length);
 
     text[0].text   = (png_charp) png_malloc(ping, allocated_length);
 
     QString key = QLatin1Literal("Raw profile type ") + profile_type.toLatin1();
     QByteArray keyData = key.toLatin1();
     text[0].key = keyData.data();
 
     uchar* sp = (uchar*)profile_data.data();
     png_charp dp = text[0].text;
     *dp++ = '\n';
 
     memcpy(dp, profile_type.toLatin1().constData(), profile_type.length());
 
     dp += description_length;
     *dp++ = '\n';
 
     formatString(dp, allocated_length - strlen(text[0].text), "%8lu ", profile_data.length());
 
     dp += 8;
 
     for (long i = 0; i < (long) profile_data.length(); i++) {
         if (i % 36 == 0)
             *dp++ = '\n';
 
         *(dp++) = (char) hex[((*sp >> 4) & 0x0f)];
         *(dp++) = (char) hex[((*sp++) & 0x0f)];
     }
 
     *dp++ = '\n';
     *dp = '\0';
     text[0].text_length = (png_size_t)(dp - text[0].text);
     text[0].compression = -1;
 
     if (text[0].text_length <= allocated_length)
         png_set_text(ping, ping_info, text, 1);
 
     png_free(ping, text[0].text);
     png_free(ping, text);
 }
 
 QByteArray png_read_raw_profile(png_textp text)
 {
     QByteArray profile;
 
     static const unsigned char unhex[103] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
         13, 14, 15
     };
 
     png_charp sp = text[0].text + 1;
     /* look for newline */
     while (*sp != '\n')
         sp++;
     /* look for length */
     while (*sp == '\0' || *sp == ' ' || *sp == '\n')
         sp++;
     png_uint_32 length = (png_uint_32) atol(sp);
     while (*sp != ' ' && *sp != '\n')
         sp++;
     if (length == 0) {
         return profile;
     }
     profile.resize(length);
     /* copy profile, skipping white space and column 1 "=" signs */
     unsigned char *dp = (unsigned char*)profile.data();
     png_uint_32 nibbles = length * 2;
     for (png_uint_32 i = 0; i < nibbles; i++) {
         while (*sp < '0' || (*sp > '9' && *sp < 'a') || *sp > 'f') {
             if (*sp == '\0') {
                 return QByteArray();
             }
             sp++;
         }
         if (i % 2 == 0)
             *dp = (unsigned char)(16 * unhex[(int) *sp++]);
         else
             (*dp++) += unhex[(int) *sp++];
     }
     return profile;
 }
 
 void decode_meta_data(png_textp text, KisMetaData::Store* store, QString type, int headerSize)
 {
     dbgFile << "Decoding " << type << " " << text[0].key;
     KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value(type);
     Q_ASSERT(exifIO);
 
     QByteArray rawProfile = png_read_raw_profile(text);
     if (headerSize > 0) {
         rawProfile.remove(0, headerSize);
     }
     if (rawProfile.size() > 0) {
         QBuffer buffer;
         buffer.setData(rawProfile);
         exifIO->loadFrom(store, &buffer);
     } else {
         dbgFile << "Decoding failed";
     }
 }
 }
 
 KisPNGConverter::KisPNGConverter(KisDocument *doc, bool batchMode)
 {
     //     Q_ASSERT(doc);
     //     Q_ASSERT(adapter);
 
     m_doc = doc;
     m_stop = false;
     m_max_row = 0;
     m_image = 0;
     m_batchMode = batchMode;
 }
 
 KisPNGConverter::~KisPNGConverter()
 {
 }
 
 class KisPNGReadStream
 {
 public:
     KisPNGReadStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
     }
     int nextValue() {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
         }
         m_posinc -= m_depth;
         return (((*m_buf) >> (m_posinc)) & ((1 << m_depth) - 1));
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGWriteStream
 {
 public:
     KisPNGWriteStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
         *m_buf = 0;
     }
     void setNextValue(int v) {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
             *m_buf = 0;
         }
         m_posinc -= m_depth;
         *m_buf = (v << m_posinc) | *m_buf;
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGReaderAbstract
 {
 public:
     KisPNGReaderAbstract(png_structp _png_ptr, int _width, int _height) : png_ptr(_png_ptr), width(_width), height(_height) {}
     virtual ~KisPNGReaderAbstract() {}
     virtual png_bytep readLine() = 0;
 protected:
     png_structp png_ptr;
     int width, height;
 };
 
 class KisPNGReaderLineByLine : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderLineByLine(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height) {
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         row_pointer = new png_byte[rowbytes];
     }
     ~KisPNGReaderLineByLine() override {
         delete[] row_pointer;
     }
     png_bytep readLine() override {
         png_read_row(png_ptr, row_pointer, 0);
         return row_pointer;
     }
 private:
     png_bytep row_pointer;
 };
 
 class KisPNGReaderFullImage : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderFullImage(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height), y(0) {
         row_pointers = new png_bytep[height];
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         for (int i = 0; i < height; i++) {
             row_pointers[i] = new png_byte[rowbytes];
         }
         png_read_image(png_ptr, row_pointers);
     }
     ~KisPNGReaderFullImage() override {
         for (int i = 0; i < height; i++) {
             delete[] row_pointers[i];
         }
         delete[] row_pointers;
     }
     png_bytep readLine() override {
         return row_pointers[y++];
     }
 private:
     png_bytepp row_pointers;
     int y;
 };
 
 
 static
 void _read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);
 
     while (length) {
         int nr = in->read((char*)data, length);
         if (nr <= 0) {
             png_error(png_ptr, "Read Error");
             return;
         }
         length -= nr;
     }
 }
 
 static
 void _write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice* out = (QIODevice*)png_get_io_ptr(png_ptr);
 
     uint nr = out->write((char*)data, length);
     if (nr != length) {
         png_error(png_ptr, "Write Error");
         return;
     }
 }
 
 static
 void _flush_fn(png_structp png_ptr)
 {
     Q_UNUSED(png_ptr);
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildImage(QIODevice* iod)
 {
     dbgFile << "Start decoding PNG File";
 
     png_byte signature[8];
     iod->peek((char*)signature, 8);
 
 #if PNG_LIBPNG_VER < 10400
     if (!png_check_sig(signature, 8)) {
 #else
     if (png_sig_cmp(signature, 0, 8) != 0) {
 #endif
         iod->close();
         return (KisImageBuilder_RESULT_BAD_FETCH);
     }
 
     // Initialize the internal structures
     png_structp png_ptr =  png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         iod->close();
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_read_struct(&png_ptr, (png_infopp)0, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
         png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Initialize the special
     png_set_read_fn(png_ptr, iod, _read_fn);
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
     // read all PNG info up to image data
     png_read_info(png_ptr, info_ptr);
 
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_expand(png_ptr);
     }
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_packing(png_ptr);
     }
 
 
     if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE &&
             (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) {
         png_set_expand(png_ptr);
     }
     png_read_update_info(png_ptr, info_ptr);
 
     // Read information about the png
     png_uint_32 width, height;
     int color_nb_bits, color_type, interlace_type;
     png_get_IHDR(png_ptr, info_ptr, &width, &height, &color_nb_bits, &color_type, &interlace_type, 0, 0);
     dbgFile << "width = " << width << " height = " << height << " color_nb_bits = " << color_nb_bits << " color_type = " << color_type << " interlace_type = " << interlace_type << endl;
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Determine the colorspace
     QPair<QString, QString> csName = getColorSpaceForColorType(color_type, color_nb_bits);
     if (csName.first.isEmpty()) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     bool hasalpha = (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_GRAY_ALPHA);
 
     // Read image profile
     png_charp profile_name;
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
     png_bytep profile_data;
 #else
     png_charp profile_data;
 #endif
     int compression_type;
     png_uint_32 proflen;
 
     // Get the various optional chunks
 
     // https://www.w3.org/TR/PNG/#11cHRM
 #if defined(PNG_cHRM_SUPPORTED)
     double whitePointX, whitePointY;
     double redX, redY;
     double greenX, greenY;
     double blueX, blueY;
     png_get_cHRM(png_ptr,info_ptr, &whitePointX, &whitePointY, &redX, &redY, &greenX, &greenY, &blueX, &blueY);
     qDebug() << "cHRM:" << whitePointX << whitePointY << redX << redY << greenX << greenY << blueX << blueY;
 #endif
 
     // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
     double gamma;
     png_get_gAMA(png_ptr, info_ptr, &gamma);
     qDebug() << "gAMA" << gamma;
 #endif
 
     // https://www.w3.org/TR/PNG/#11sRGB
 #if defined(PNG_sRGB_SUPPORTED)
     int sRGBIntent;
     png_get_sRGB(png_ptr, info_ptr, &sRGBIntent);
     qDebug() << "sRGB" << sRGBIntent;
 #endif
 
 bool fromBlender = false;
 
 png_text* text_ptr;
     int num_comments;
 png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
 
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             if (key == "file") {
                 QString relatedFile = text_ptr[i].text;
                 if (relatedFile.contains(".blend", Qt::CaseInsensitive)){
                     fromBlender=true;
                 }
             }
         }
 
     const KoColorProfile* profile = 0;
     if (png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &proflen)) {
         QByteArray profile_rawdata;
         // XXX: Hardcoded for icc type -- is that correct for us?
         profile_rawdata.resize(proflen);
         memcpy(profile_rawdata.data(), profile_data, proflen);
         profile = KoColorSpaceRegistry::instance()->createColorProfile(csName.first, csName.second, profile_rawdata);
         Q_CHECK_PTR(profile);
         if (profile) {
             //                 dbgFile << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo();
             if (!profile->isSuitableForOutput()) {
                 dbgFile << "the profile is not suitable for output and therefore cannot be used in krita, we need to convert the image to a standard profile"; // TODO: in ko2 popup a selection menu to inform the user
             }
         }
     }
     else {
         dbgFile << "no embedded profile, will use the default profile";
         if (color_nb_bits == 16 && !fromBlender && !qAppName().toLower().contains("test") && !m_batchMode) {
             KisConfig cfg;
             quint32 behaviour = cfg.pasteBehaviour();
             if (behaviour == PASTE_ASK) {
                 KisDlgPngImport dlg(m_path, csName.first, csName.second);
                 QApplication::restoreOverrideCursor();
                 dlg.exec();
                 if (!dlg.profile().isEmpty()) {
 
                     QString s = KoColorSpaceRegistry::instance()->colorSpaceId(csName.first, csName.second);
 
                     const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s);
                     if (csf) {
                         QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
                         Q_FOREACH (const KoColorProfile *p, profileList) {
                             if (p->name() == dlg.profile()) {
                                 profile = p;
                                 break;
                             }
                         }
                     }
                 }
                 QApplication::setOverrideCursor(Qt::WaitCursor);
 
             }
         }
         dbgFile << "no embedded profile, will use the default profile";
     }
 
     // Check that the profile is used by the color space
     if (profile && !KoColorSpaceRegistry::instance()->colorSpaceFactory(
                 KoColorSpaceRegistry::instance()->colorSpaceId(
                     csName.first, csName.second))->profileIsCompatible(profile)) {
         warnFile << "The profile " << profile->name() << " is not compatible with the color space model " << csName.first << " " << csName.second;
         profile = 0;
     }
 
     // Retrieve a pointer to the colorspace
     const KoColorSpace* cs;
     if (profile && profile->isSuitableForOutput()) {
         dbgFile << "image has embedded profile: " << profile->name() << "\n";
         cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile);
     }
     else {
         if (csName.first == RGBAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "sRGB-elle-V2-srgbtrc.icc");
         }
         else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     //TODO: two fixes : one tell the user about the problem and ask for a solution, and two once the kocolorspace include KoColorTransformation, use that instead of hacking a lcms transformation
     // Create the cmsTransform if needed
     KoColorTransformation* transform = 0;
     if (profile && !profile->isSuitableForOutput()) {
         transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     }
 
     // Creating the KisImageWSP
     if (m_image == 0) {
         m_image = new KisImage(m_doc->createUndoStore(), width, height, cs, "built image");
         Q_CHECK_PTR(m_image);
     }
 
     // Read resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 
     png_get_pHYs(png_ptr, info_ptr, &x_resolution, &y_resolution, &unit_type);
     if (x_resolution > 0 && y_resolution > 0 && unit_type == PNG_RESOLUTION_METER) {
         m_image->setResolution((double) POINT_TO_CM(x_resolution) / 100.0, (double) POINT_TO_CM(y_resolution) / 100.0); // It is the "invert" macro because we convert from pointer-per-inchs to points
     }
 
     double coeff = quint8_MAX / (double)(pow((double)2, color_nb_bits) - 1);
     KisPaintLayerSP layer = new KisPaintLayer(m_image.data(), m_image -> nextLayerName(), UCHAR_MAX);
 
     // Read comments/texts...
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
     if (m_doc) {
         KoDocumentInfo * info = m_doc->documentInfo();
         dbgFile << "There are " << num_comments << " comments in the text";
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             dbgFile << "key is |" << text_ptr[i].key << "| containing " << text_ptr[i].text << " " << (key ==  "Raw profile type exif ");
             if (key == "title") {
                 info->setAboutInfo("title", text_ptr[i].text);
             } else if (key == "description") {
                 info->setAboutInfo("comment", text_ptr[i].text);
             } else if (key == "author") {
         qDebug()<<"Author:"<<text_ptr[i].text;
                 info->setAuthorInfo("creator", text_ptr[i].text);
             } else if (key.contains("Raw profile type exif")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "exif", 6);
             } else if (key.contains("Raw profile type iptc")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "iptc", 14);
             } else if (key.contains("Raw profile type xmp")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "xmp", 0);
             } else if (key == "version") {
                 m_image->addAnnotation(new KisAnnotation("kpp_version", "version", QByteArray(text_ptr[i].text)));
             } else if (key == "preset") {
                 m_image->addAnnotation(new KisAnnotation("kpp_preset", "preset", QByteArray(text_ptr[i].text)));
             }
         }
     }
 
     // Read image data
     KisPNGReaderAbstract* reader = 0;
     try {
         if (interlace_type == PNG_INTERLACE_ADAM7) {
             reader = new KisPNGReaderFullImage(png_ptr, info_ptr, width, height);
         } else {
             reader = new KisPNGReaderLineByLine(png_ptr, info_ptr, width, height);
         }
     } catch (std::bad_alloc& e) {
         // new png_byte[] may raise such an exception if the image
         // is invalid / to large.
         dbgFile << "bad alloc: " << e.what();
         // Free only the already allocated png_byte instances.
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Read the palette if the file is indexed
     png_colorp palette ;
     int num_palette;
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
     }
 
     // Read the transparency palette
     quint8 palette_alpha[256];
     memset(palette_alpha, 255, 256);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         if (color_type == PNG_COLOR_TYPE_PALETTE) {
             png_bytep alpha_ptr;
             int num_alpha;
             png_get_tRNS(png_ptr, info_ptr, &alpha_ptr, &num_alpha, 0);
             for (int i = 0; i < num_alpha; ++i) {
                 palette_alpha[i] = alpha_ptr[i];
             }
         }
     }
 
     for (png_uint_32 y = 0; y < height; y++) {
         KisHLineIteratorSP it = layer -> paintDevice() -> createHLineIteratorNG(0, y, width);
 
         png_bytep row_pointer = reader->readLine();
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                 } while (it->nextPixel());
             }
             // FIXME:should be able to read 1 and 4 bits depth and scale them to 8 bits"
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[2] = *(src++);
                     d[1] = *(src++);
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                 } while (it->nextPixel());
             } else {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[2] = (quint8)(stream.nextValue() * coeff);
                     d[1] = (quint8)(stream.nextValue() * coeff);
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             KisPNGReadStream stream(row_pointer, color_nb_bits);
             do {
                 quint8 *d = it->rawData();
                 quint8 index = stream.nextValue();
                 quint8 alpha = palette_alpha[ index ];
                 if (alpha == 0) {
                     memset(d, 0, 4);
                 } else {
                     png_color c = palette[ index ];
                     d[2] = c.red;
                     d[1] = c.green;
                     d[0] = c.blue;
                     d[3] = alpha;
                 }
             } while (it->nextPixel());
         }
             break;
         default:
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
     m_image->addNode(layer.data(), m_image->rootLayer().data());
 
     png_read_end(png_ptr, end_info);
     iod->close();
 
     // Freeing memory
     png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
 
     delete reader;
     return KisImageBuilder_RESULT_OK;
 
 }
 
 KisImageBuilder_Result KisPNGConverter::buildImage(const QString &filename)
 {
     m_path = filename;
 
     QFile fp(filename);
     if (fp.exists()) {
         if (!fp.open(QIODevice::ReadOnly)) {
             dbgFile << "Failed to open PNG File";
             return (KisImageBuilder_RESULT_FAILURE);
         }
 
         return buildImage(&fp);
     }
     return (KisImageBuilder_RESULT_NOT_EXIST);
 
 }
 
 
 KisImageSP KisPNGConverter::image()
 {
     return m_image;
 }
 
 bool KisPNGConverter::saveDeviceToStore(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP dev, KoStore *store, KisMetaData::Store* metaData)
 {
     if (store->open(filename)) {
         KoStoreDevice io(store);
         if (!io.open(QIODevice::WriteOnly)) {
             dbgFile << "Could not open for writing:" << filename;
             return false;
         }
         KisPNGConverter pngconv(0);
         vKisAnnotationSP_it annotIt = 0;
         KisMetaData::Store* metaDataStore = 0;
         if (metaData) {
             metaDataStore = new KisMetaData::Store(*metaData);
         }
         KisPNGOptions options;
         options.compression = 0;
         options.interlace = false;
         options.tryToSaveAsIndexed = false;
         options.alpha = true;
         options.saveSRGBProfile = false;
 
         if (dev->colorSpace()->id() != "RGBA") {
             dev = new KisPaintDevice(*dev.data());
             KUndo2Command *cmd = dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
             delete cmd;
         }
 
         bool success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (success != KisImageBuilder_RESULT_OK) {
             dbgFile << "Saving PNG failed:" << filename;
             delete metaDataStore;
             return false;
         }
         delete metaDataStore;
         io.close();
         if (!store->close()) {
             return false;
         }
     } else {
         dbgFile << "Opening of data file failed :" << filename;
         return false;
     }
     return true;
 
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildFile(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     dbgFile << "Start writing PNG File " << filename;
     // Open a QIODevice for writing
     QFile fp (filename);
     if (!fp.open(QIODevice::WriteOnly)) {
         dbgFile << "Failed to open PNG File for writing";
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     KisImageBuilder_Result result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImageBuilder_Result KisPNGConverter::buildFile(QIODevice* iodevice, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     if (!device)
         return KisImageBuilder_RESULT_INVALID_ARG;
 
     if (!options.alpha) {
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         KoColor c(options.transparencyFillColor, device->colorSpace());
         tmp->fill(imageRect, c);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
+    if (device->colorSpace()->colorDepthId() == Float16BitsColorDepthID
+            || device->colorSpace()->colorDepthId() == Float32BitsColorDepthID
+            || device->colorSpace()->colorDepthId() == Float64BitsColorDepthID) {
+        const KoColorSpace *dstcs = KoColorSpaceRegistry::instance()->colorSpace(device->colorSpace()->colorModelId().id(), Integer8BitsColorDepthID.id(), "");
+        KisPaintDeviceSP tmp = new KisPaintDevice(dstcs);
+        KisPainter gc(tmp);
+        gc.bitBlt(imageRect.topLeft(), device, imageRect);
+        gc.end();
+        device = tmp;
+    }
+
     if (options.forceSRGB) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         device->convertTo(cs);
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
     png_set_check_for_invalid_index(png_ptr, 0);
 #endif
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_write_struct(&png_ptr, (png_infopp)0);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // If an error occurs during writing, libpng will jump here
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
         return (KisImageBuilder_RESULT_FAILURE);
     }
     // Initialize the writing
     //     png_init_io(png_ptr, fp);
     // Setup the progress function
     // XXX: Implement progress updating -- png_set_write_status_fn(png_ptr, progress);"
     //     setProgressTotalSteps(100/*height*/);
 
     /* set the zlib compression level */
     png_set_compression_level(png_ptr, options.compression);
 
     png_set_write_fn(png_ptr, (void*)iodevice, _write_fn, _flush_fn);
 
     /* set other zlib parameters */
     png_set_compression_mem_level(png_ptr, 8);
     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
     png_set_compression_window_bits(png_ptr, 15);
     png_set_compression_method(png_ptr, 8);
     png_set_compression_buffer_size(png_ptr, 8192);
 
     int color_nb_bits = 8 * device->pixelSize() / device->channelCount();
     int color_type = getColorTypeforColorSpace(device->colorSpace(), options.alpha);
 
     Q_ASSERT(color_type > -1);
 
     // Try to compute a table of color if the colorspace is RGB8f
     png_colorp palette = 0;
     int num_palette = 0;
     if (!options.alpha && options.tryToSaveAsIndexed && KoID(device->colorSpace()->id()) == KoID("RGBA")) { // png doesn't handle indexed images and alpha, and only have indexed for RGB8
         palette = new png_color[255];
 
         KisSequentialIterator it(device, imageRect);
 
         bool toomuchcolor = false;
         do {
             const quint8* c = it.oldRawData();
             bool findit = false;
             for (int i = 0; i < num_palette; i++) {
                 if (palette[i].red == c[2] &&
                         palette[i].green == c[1] &&
                         palette[i].blue == c[0]) {
                     findit = true;
                     break;
                 }
             }
             if (!findit) {
                 if (num_palette == 255) {
                     toomuchcolor = true;
                     break;
                 }
                 palette[num_palette].red = c[2];
                 palette[num_palette].green = c[1];
                 palette[num_palette].blue = c[0];
                 num_palette++;
             }
         }  while (it.nextPixel());
 
         if (!toomuchcolor) {
             dbgFile << "Found a palette of " << num_palette << " colors";
             color_type = PNG_COLOR_TYPE_PALETTE;
             if (num_palette <= 2) {
                 color_nb_bits = 1;
             } else if (num_palette <= 4) {
                 color_nb_bits = 2;
             } else if (num_palette <= 16) {
                 color_nb_bits = 4;
             } else {
                 color_nb_bits = 8;
             }
         } else {
             delete [] palette;
         }
     }
 
     int interlacetype = options.interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
 
     png_set_IHDR(png_ptr, info_ptr,
                  imageRect.width(),
                  imageRect.height(),
                  color_nb_bits,
                  color_type, interlacetype,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
     // set sRGB only if the profile is sRGB  -- http://www.w3.org/TR/PNG/#11sRGB says sRGB and iCCP should not both be present
 
     bool sRGB = device->colorSpace()->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
     /*
      * This automatically writes the correct gamma and chroma chunks along with the sRGB chunk, but firefox's
      * color management is bugged, so once you give it any incentive to start color managing an sRGB image it
      * will turn, for example, a nice desaturated rusty red into bright poppy red. So this is disabled for now.
      */
     /*if (!options.saveSRGBProfile && sRGB) {
         png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
     }*/
     // set the palette
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
     }
     // Save annotation
     vKisAnnotationSP_it it = annotationsStart;
     while (it != annotationsEnd) {
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         dbgFile << "Trying to store annotation of type " << (*it) -> type() << " of size " << (*it) -> annotation() . size();
 
         if ((*it) -> type().startsWith(QString("krita_attribute:"))) { //
             // Attribute
             // XXX: it should be possible to save krita_attributes in the \"CHUNKs\""
             dbgFile << "cannot save this annotation : " << (*it) -> type();
         } else if ((*it)->type() == "kpp_version" || (*it)->type() == "kpp_preset" ) {
             dbgFile << "Saving preset information " << (*it)->description();
             png_textp      text = (png_textp) png_malloc(png_ptr, (png_uint_32) sizeof(png_text));
 
             QByteArray keyData = (*it)->description().toLatin1();
             text[0].key = keyData.data();
             text[0].text = (char*)(*it)->annotation().data();
             text[0].text_length = (*it)->annotation().size();
             text[0].compression = -1;
 
             png_set_text(png_ptr, info_ptr, text, 1);
             png_free(png_ptr, text);
         }
         it++;
     }
 
     // Save the color profile
     const KoColorProfile* colorProfile = device->colorSpace()->profile();
     QByteArray colorProfileData = colorProfile->rawData();
     if (!sRGB || options.saveSRGBProfile) {
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (const png_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
         png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (char*)colorProfileData.constData(), colorProfileData . size());
 #endif
     }
 
     // read comments from the document information
     // warning: according to the official png spec, the keys need to be capitalised!
     if (m_doc) {
         png_text texts[3];
         int nbtexts = 0;
         KoDocumentInfo * info = m_doc->documentInfo();
         QString title = info->aboutInfo("title");
         if (!title.isEmpty()) {
             fillText(texts + nbtexts, "Title", title);
             nbtexts++;
         }
         QString abstract = info->aboutInfo("comment");
         if (!abstract.isEmpty()) {
             fillText(texts + nbtexts, "Description", abstract);
             nbtexts++;
         }
         QString author = info->authorInfo("creator");
         if (!author.isEmpty()) {
             fillText(texts + nbtexts, "Author", author);
             nbtexts++;
         }
 
         png_set_text(png_ptr, info_ptr, texts, nbtexts);
     }
 
     // Save metadata following imagemagick way
 
     // Save exif
     if (metaData && !metaData->empty()) {
         if (options.exif) {
             dbgFile << "Trying to save exif information";
 
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
 
             QBuffer buffer;
             exifIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
             writeRawProfile(png_ptr, info_ptr, "exif", buffer.data());
         }
         // Save IPTC
         if (options.iptc) {
             dbgFile << "Trying to save exif information";
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
 
             QBuffer buffer;
             iptcIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "IPTC information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "iptc", buffer.data());
         }
         // Save XMP
         if (options.xmp) {
             dbgFile << "Trying to save XMP information";
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
 
             QBuffer buffer;
             xmpIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::NoHeader);
 
             dbgFile << "XMP information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "xmp", buffer.data());
         }
     }
 #if 0 // Unimplemented?
     // Save resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 #endif
     png_set_pHYs(png_ptr, info_ptr, CM_TO_POINT(xRes) * 100.0, CM_TO_POINT(yRes) * 100.0, PNG_RESOLUTION_METER); // It is the "invert" macro because we convert from pointer-per-inchs to points
 
     // Save the information to the file
     png_write_info(png_ptr, info_ptr);
     png_write_flush(png_ptr);
 
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Write the PNG
     //     png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
 
     // Fill the data structure
     png_byte** row_pointers = new png_byte*[imageRect.height()];
     int row = 0;
     for (int y = imageRect.y(); y < imageRect.y() + imageRect.height(); y++, row++) {
         KisHLineConstIteratorSP it = device->createHLineConstIteratorNG(imageRect.x(), y, imageRect.width());
 
         row_pointers[row] = new png_byte[imageRect.width() * device->pixelSize()];
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(row_pointers[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = row_pointers[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(row_pointers[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = row_pointers[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             quint8 *dst = row_pointers[row];
             KisPNGWriteStream writestream(dst, color_nb_bits);
             do {
                 const quint8 *d = it->oldRawData();
                 int i;
                 for (i = 0; i < num_palette; i++) {
                     if (palette[i].red == d[2] &&
                             palette[i].green == d[1] &&
                             palette[i].blue == d[0]) {
                         break;
                     }
                 }
                 writestream.setNextValue(i);
             } while (it->nextPixel());
         }
             break;
         default:
             delete[] row_pointers;
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
 
     png_write_image(png_ptr, row_pointers);
 
     // Writing is over
     png_write_end(png_ptr, info_ptr);
 
     // Free memory
     png_destroy_write_struct(&png_ptr, &info_ptr);
     for (int y = 0; y < imageRect.height(); y++) {
         delete[] row_pointers[y];
     }
     delete[] row_pointers;
 
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         delete [] palette;
     }
     iodevice->close();
     return KisImageBuilder_RESULT_OK;
 }
 
 
 void KisPNGConverter::cancel()
 {
     m_stop = true;
 }
 
 void KisPNGConverter::progress(png_structp png_ptr, png_uint_32 row_number, int pass)
 {
     if (png_ptr == 0 || row_number > PNG_MAX_UINT || pass > 7) return;
     //     setProgress(row_number);
 }
 
 bool KisPNGConverter::isColorSpaceSupported(const KoColorSpace *cs)
 {
     return colorSpaceIdSupported(cs->id());
 }
 
 
diff --git a/libs/ui/opengl/kis_opengl.cpp b/libs/ui/opengl/kis_opengl.cpp
index 9932779cb6..8819ee25d7 100644
--- a/libs/ui/opengl/kis_opengl.cpp
+++ b/libs/ui/opengl/kis_opengl.cpp
@@ -1,227 +1,225 @@
 /*
  *  Copyright (c) 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.h"
 
 #include <QOpenGLContext>
 #include <QOpenGLFunctions>
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QPixmapCache>
 
 #include <QDir>
 #include <QFile>
 #include <QDesktopServices>
 #include <QMessageBox>
 #include <QWindow>
 
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 namespace
 {
     bool initialized = false;
     bool NeedsFenceWorkaround = false;
     bool NeedsPixmapCacheWorkaround = false;
     int glMajorVersion = 0;
     int glMinorVersion = 0;
     bool supportsDeprecatedFunctions = false;
 
     QString Renderer;
 }
 
 void KisOpenGL::initialize()
 {
     if (initialized) return;
 
     setDefaultFormat();
 
     // we need a QSurface active to get our GL functions from the context
     QWindow  surface;
     surface.setSurfaceType( QSurface::OpenGLSurface );
     surface.create();
 
     QOpenGLContext context;
     context.create();
     if (!context.isValid()) return;
 
     context.makeCurrent( &surface );
 
     QOpenGLFunctions  *funcs = context.functions();
     funcs->initializeOpenGLFunctions();
 
     qDebug() << "OpenGL Info";
     qDebug() << "  Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR));
     qDebug() << "  Renderer: " << reinterpret_cast<const char *>(funcs->glGetString(GL_RENDERER));
     qDebug() << "  Version: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VERSION));
     qDebug() << "  Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION));
     qDebug() << "  Requested format: " << QSurfaceFormat::defaultFormat();
     qDebug() << "  Current format:   " << context.format();
 
     glMajorVersion = context.format().majorVersion();
     glMinorVersion = context.format().minorVersion();
     supportsDeprecatedFunctions = (context.format().options() & QSurfaceFormat::DeprecatedFunctions);
 
     qDebug() << "     Version:" << glMajorVersion << "." << glMinorVersion;
     qDebug() << "     Supports deprecated functions" << supportsDeprecatedFunctions;
 
     initialized = true;
 }
 
 void KisOpenGL::initializeContext(QOpenGLContext *ctx)
 {
     initialize();
 
     dbgUI << "OpenGL: Opening new context";
 
     // Double check we were given the version we requested
     QSurfaceFormat format = ctx->format();
     QOpenGLFunctions *f = ctx->functions();
     f->initializeOpenGLFunctions();
 
 #ifndef GL_RENDERER
 #  define GL_RENDERER 0x1F01
 #endif
     Renderer = QString((const char*)f->glGetString(GL_RENDERER));
 
     QFile log(QDesktopServices::storageLocation(QDesktopServices::TempLocation) + "/krita-opengl.txt");
     log.open(QFile::WriteOnly);
     QString vendor((const char*)f->glGetString(GL_VENDOR));
     log.write(vendor.toLatin1());
     log.write(", ");
     log.write(Renderer.toLatin1());
     log.write(", ");
     QString version((const char*)f->glGetString(GL_VERSION));
     log.write(version.toLatin1());
     log.close();
 
     // Check if we have a bugged driver that needs fence workaround
     bool isOnX11 = false;
 #ifdef HAVE_X11
     isOnX11 = true;
 #endif
     KisConfig cfg;
     if ((isOnX11 && Renderer.startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) {
         NeedsFenceWorkaround = true;
     }
 
 
     /**
      * NVidia + Qt's openGL don't play well together and one cannot
      * draw a pixmap on a widget more than once in one rendering cycle.
      *
      * It can be workarounded by drawing strictly via QPixmapCache and
      * only when the pixmap size in bigger than doubled size of the
      * display framebuffer. That is for 8-bit HD display, you should have
      * a cache bigger than 16 MiB. Don't ask me why. (DK)
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=361709
      *
      * TODO: check if this workaround is still needed after merging
      *       Qt5+openGL3 branch.
      */
 
     if (vendor.toUpper().contains("NVIDIA")) {
         NeedsPixmapCacheWorkaround = true;
 
         const QRect screenSize = QApplication::desktop()->screenGeometry();
         const int minCacheSize = 20 * 1024;
         const int cacheSize = 2048 + 2 * 4 * screenSize.width() * screenSize.height() / 1024; //KiB
 
         QPixmapCache::setCacheLimit(qMax(minCacheSize, cacheSize));
     }
 
 
     /**
      * Warn about Intel's broken video drivers
      */
 #if defined Q_OS_WIN
-    KisConfig cfg;
-    QString renderer = KisOpenGL::renderer();
-    if (cfg.useOpenGL() && renderer.startsWith("Intel") && !cfg.readEntry("WarnedAboutIntel", false)) {
+    if (cfg.useOpenGL() && Renderer.startsWith("Intel") && !cfg.readEntry("WarnedAboutIntel", false)) {
         QMessageBox::information(0,
                                  i18nc("@title:window", "Krita: Warning"),
                                  i18n("You have an Intel(R) HD Graphics video adapter.\n"
                                       "If you experience problems like a crash, a black or blank screen,"
                                       "please update your display driver to the latest version.\n\n"
                                       "If Krita crashes, it will disable OpenGL rendering. Please restart Krita in that case.\n After updating your drivers you can re-enable OpenGL in Krita's Settings.\n"));
         cfg.writeEntry("WarnedAboutIntel", true);
     }
 #endif
 
 }
 
 // XXX Temporary function to allow LoD on OpenGL3 without triggering
 // all of the other 3.2 functionality, can be removed once we move to Qt5.7
 bool KisOpenGL::supportsLoD()
 {
     initialize();
     return (glMajorVersion * 100 + glMinorVersion) >= 300;
 }
 
 bool KisOpenGL::hasOpenGL3()
 {
     initialize();
     return (glMajorVersion * 100 + glMinorVersion) >= 302;
 }
 
 bool KisOpenGL::supportsFenceSync()
 {
     initialize();
     return glMajorVersion >= 3;
 }
 
 bool KisOpenGL::needsFenceWorkaround()
 {
     initialize();
     return NeedsFenceWorkaround;
 }
 
 bool KisOpenGL::needsPixmapCacheWorkaround()
 {
     initialize();
     return NeedsPixmapCacheWorkaround;
 }
 
 void KisOpenGL::setDefaultFormat()
 {
     QSurfaceFormat format;
 #ifdef Q_OS_OSX
     format.setVersion(3, 2);
     format.setProfile(QSurfaceFormat::CoreProfile);
 #else
     // XXX This can be removed once we move to Qt5.7
     format.setVersion(3, 0);
     format.setProfile(QSurfaceFormat::CompatibilityProfile);
     format.setOptions(QSurfaceFormat::DeprecatedFunctions);
 #endif
     format.setDepthBufferSize(24);
     format.setStencilBufferSize(8);
     format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
     format.setSwapInterval(0); // Disable vertical refresh syncing
     QSurfaceFormat::setDefaultFormat(format);
 }
 
 bool KisOpenGL::hasOpenGL()
 {
     return ((glMajorVersion * 100 + glMinorVersion) >= 201);
     //return (glMajorVersion >= 3 && supportsDeprecatedFunctions);
 }
diff --git a/libs/ui/opengl/kis_opengl_canvas2.h b/libs/ui/opengl/kis_opengl_canvas2.h
index dd7939f5a4..283162d618 100644
--- a/libs/ui/opengl/kis_opengl_canvas2.h
+++ b/libs/ui/opengl/kis_opengl_canvas2.h
@@ -1,110 +1,121 @@
 /*
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  * Copyright (C) Michael Abrahams <miabraha@gmail.com>, (C) 2015
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_OPENGL_CANVAS_2_H
 #define KIS_OPENGL_CANVAS_2_H
 
 #include <QOpenGLWidget>
 #include <QOpenGLFunctions_3_0>
-
+#include <QOpenGLFunctions_3_2_Core>
 #include "canvas/kis_canvas_widget_base.h"
 #include "opengl/kis_opengl_image_textures.h"
 
 #include "kritaui_export.h"
 #include "kis_ui_types.h"
 
 class KisCanvas2;
 class KisDisplayColorConverter;
 class QOpenGLShaderProgram;
 class QPainterPath;
 
+#ifndef Q_MOC_RUN
+#ifndef Q_OS_MAC
+#define GLFunctions QOpenGLFunctions_3_0
+#else
+#define GLFunctions QOpenGLFunctions_3_2_Core
+#endif
 
+#endif
 /**
  * KisOpenGLCanvas is the widget that shows the actual image using OpenGL
  *
  * NOTE: if you change something in the event handling here, also change it
  * in the qpainter canvas.
  *
  */
-class KRITAUI_EXPORT KisOpenGLCanvas2 : public QOpenGLWidget, protected QOpenGLFunctions_3_0, public KisCanvasWidgetBase
+class KRITAUI_EXPORT KisOpenGLCanvas2
+        : public QOpenGLWidget
+#ifndef Q_MOC_RUN
+        , protected GLFunctions
+#endif
+        , public KisCanvasWidgetBase
 {
-
     Q_OBJECT
 
 public:
 
     KisOpenGLCanvas2(KisCanvas2 *canvas, KisCoordinatesConverter *coordinatesConverter, QWidget *parent, KisImageWSP image, KisDisplayColorConverter *colorConverter);
 
     virtual ~KisOpenGLCanvas2();
 
 public: // QOpenGLWidget
 
     void resizeGL(int width, int height);
     void initializeGL();
     void paintGL();
 
     virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
     virtual void inputMethodEvent(QInputMethodEvent *event);
 
 public:
     void renderCanvasGL();
     void renderDecorations(QPainter *painter);
     void paintToolOutline(const QPainterPath &path);
 
     bool needsFpsDebugging() const;
 
 public: // Implement kis_abstract_canvas_widget interface
     void initializeShaders();
     void setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter);
     void setWrapAroundViewingMode(bool value);
     void channelSelectionChanged(const QBitArray &channelFlags);
     void setDisplayProfile(KisDisplayColorConverter *colorConverter);
     void finishResizingImage(qint32 w, qint32 h);
     KisUpdateInfoSP startUpdateCanvasProjection(const QRect & rc, const QBitArray &channelFlags);
     QRect updateCanvasProjection(KisUpdateInfoSP info);
 
     QWidget *widget() {
         return this;
     }
 
     bool isBusy() const;
 
     void setDisplayFilterImpl(QSharedPointer<KisDisplayFilter> displayFilter, bool initializing);
 
     KisOpenGLImageTexturesSP openGLImageTextures() const;
 
 private Q_SLOTS:
     void slotConfigChanged();
 
 protected: // KisCanvasWidgetBase
     virtual bool callFocusNextPrevChild(bool next);
 
 private:
     void reportFailedShaderCompilation(const QString &context);
     void drawImage();
     void drawCheckers();
 
 private:
 
     struct Private;
     Private * const d;
 
 };
 
 #endif // KIS_OPENGL_CANVAS_2_H
diff --git a/libs/ui/opengl/kis_opengl_image_textures.h b/libs/ui/opengl/kis_opengl_image_textures.h
index 55f48458ef..f54c74c84c 100644
--- a/libs/ui/opengl/kis_opengl_image_textures.h
+++ b/libs/ui/opengl/kis_opengl_image_textures.h
@@ -1,210 +1,211 @@
 /*
  *  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.
  */
 #ifndef KIS_OPENGL_IMAGE_TEXTURES_H_
 #define KIS_OPENGL_IMAGE_TEXTURES_H_
 
 #include <QVector>
 #include <QMap>
+#include <QOpenGLFunctions>
 
 #include "kritaui_export.h"
 
 #include "kis_shared.h"
 
 #include "canvas/kis_update_info.h"
 #include "opengl/kis_texture_tile.h"
 #include "KisProofingConfiguration.h"
 #include <KoColorProofingConversionTransformation.h>
 
 class KisOpenGLImageTextures;
-class QOpenGLFunctions;
+
 typedef KisSharedPtr<KisOpenGLImageTextures> KisOpenGLImageTexturesSP;
 
 class KoColorProfile;
 class KisTextureTileUpdateInfoPoolCollection;
 typedef QSharedPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolSP;
 
 /**
  * A set of OpenGL textures that contains the projection of a KisImage.
  */
 class KRITAUI_EXPORT KisOpenGLImageTextures : public KisShared
 {
 public:
     /**
      * Obtain a KisOpenGLImageTextures object for the given image.
      * @param image The image
      * @param monitorProfile The profile of the display device
      */
     static KisOpenGLImageTexturesSP getImageTextures(KisImageWSP image,
                                                      const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent,
                                                      KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Default constructor.
      */
     KisOpenGLImageTextures();
 
     /**
      * Destructor.
      */
     virtual ~KisOpenGLImageTextures();
 
     /**
      * \return the image associated with the textures
      */
     KisImageSP image() const;
 
     /**
      * Set the color profile of the display device.
      * @param profile The color profile of the display device
      */
     void setMonitorProfile(const KoColorProfile *monitorProfile,
                            KoColorConversionTransformation::Intent renderingIntent,
                            KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Complete initialization can only happen once an OpenGL context has been created.
      * @param f Pointer to OpenGL functions. They must already be ininitialized.
      */
     void initGL(QOpenGLFunctions *f);
 
     void setChannelFlags(const QBitArray &channelFlags);
     void setProofingConfig(KisProofingConfigurationSP);
 
     bool internalColorManagementActive() const;
     bool setInternalColorManagementActive(bool value);
 
     /**
      * The background checkers texture.
      */
     static const int BACKGROUND_TEXTURE_CHECK_SIZE = 32;
     static const int BACKGROUND_TEXTURE_SIZE = BACKGROUND_TEXTURE_CHECK_SIZE * 2;
 
     /**
      * Generate a background texture from the given QImage. This is used for the checker
      * pattern on which the image is rendered.
      */
     void generateCheckerTexture(const QImage & checkImage);
     GLuint checkerTexture();
 
     void updateConfig(bool useBuffer, int NumMipmapLevels);
 
 public:
     inline QRect storedImageBounds() {
         return m_storedImageBounds;
     }
 
     inline int xToCol(int x) {
         return x / m_texturesInfo.effectiveWidth;
     }
 
     inline int yToRow(int y) {
         return y / m_texturesInfo.effectiveHeight;
     }
 
     inline KisTextureTile* getTextureTileCR(int col, int row) {
         if (m_initialized) {
             int tile = row * m_numCols + col;
             KIS_ASSERT_RECOVER_RETURN_VALUE(m_textureTiles.size() > tile, 0);
             return m_textureTiles[tile];
         }
         return 0;
     }
 
     inline qreal texelSize() const {
         Q_ASSERT(m_texturesInfo.width == m_texturesInfo.height);
         return 1.0 / m_texturesInfo.width;
     }
 
     KisOpenGLUpdateInfoSP updateCache(const QRect& rect);
     KisOpenGLUpdateInfoSP updateCacheNoConversion(const QRect& rect);
 
     void recalculateCache(KisUpdateInfoSP info);
 
     void slotImageSizeChanged(qint32 w, qint32 h);
 
 protected:
 
     KisOpenGLImageTextures(KisImageWSP image, const KoColorProfile *monitorProfile,
                            KoColorConversionTransformation::Intent renderingIntent,
                            KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     void createImageTextureTiles();
 
     void destroyImageTextureTiles();
 
     static bool imageCanShareTextures();
 
 private:
 
     QRect calculateTileRect(int col, int row) const;
 
     void getTextureSize(KisGLTexturesInfo *texturesInfo);
 
     void updateTextureFormat();
     KisOpenGLUpdateInfoSP updateCacheImpl(const QRect& rect, bool convertColorSpace);
 
 private:
     KisImageWSP m_image;
     QRect m_storedImageBounds;
     const KoColorProfile *m_monitorProfile;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
 
     KisProofingConfigurationSP m_proofingConfig;
     QScopedPointer<KoColorConversionTransformation> m_proofingTransform;
     bool m_createNewProofingTransform;
 
     /**
      * If the destination color space coincides with the one of the image,
      * then effectively, there is no conversion happens. That is used
      * for working with OCIO.
      */
     const KoColorSpace *m_tilesDestinationColorSpace;
 
     /**
      * Shows whether the internal color management should be enabled or not.
      * Please note that if you disable color management, *but* your image color
      * space will not be supported (non-RGB), then it will be enabled anyway.
      * And this valiable will hold the real state of affairs!
      */
     bool m_internalColorManagementActive;
 
     GLuint m_checkerTexture;
 
     KisGLTexturesInfo m_texturesInfo;
     int m_numCols;
     QVector<KisTextureTile*> m_textureTiles;
 
     QOpenGLFunctions *m_glFuncs;
     QBitArray m_channelFlags;
     bool m_allChannelsSelected;
     bool m_onlyOneChannelSelected;
     int m_selectedChannelIndex;
 
     bool m_useOcio;
     bool m_initialized;
 
     KisTextureTileInfoPoolSP m_infoChunksPool;
 
 private:
     typedef QMap<KisImageWSP, KisOpenGLImageTextures*> ImageTexturesMap;
     static ImageTexturesMap imageTexturesMap;
 };
 
 #endif // KIS_OPENGL_IMAGE_TEXTURES_H_
 
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
index f1eb9fc074..8d8a57e00e 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
@@ -1,188 +1,188 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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
  */
 
 #include "kis_color_selector_container.h"
 
 #include "kis_color_selector.h"
 #include "kis_my_paint_shade_selector.h"
 #include "kis_minimal_shade_selector.h"
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QAction>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <kactioncollection.h>
 
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node_manager.h"
 #include "kis_node.h"
 #include "kis_paint_device.h"
 
 #include "kis_action_registry.h"
 
 KisColorSelectorContainer::KisColorSelectorContainer(QWidget *parent) :
     QWidget(parent),
     m_colorSelector(new KisColorSelector(this)),
     m_myPaintShadeSelector(new KisMyPaintShadeSelector(this)),
     m_minimalShadeSelector(new KisMinimalShadeSelector(this)),
     m_shadeSelector(m_myPaintShadeSelector),
     m_canvas(0)
 {
     m_widgetLayout = new QBoxLayout(QBoxLayout::TopToBottom, this);
     m_widgetLayout->setSpacing(0);
     m_widgetLayout->setMargin(0);
 
     m_widgetLayout->addWidget(m_colorSelector);
     m_widgetLayout->addWidget(m_myPaintShadeSelector);
     m_widgetLayout->addWidget(m_minimalShadeSelector);
 
     m_myPaintShadeSelector->hide();
     m_minimalShadeSelector->hide();
 
     connect(m_colorSelector,SIGNAL(settingsButtonClicked()), SIGNAL(openSettings()));
 
     connect(this, SIGNAL(settingsChanged()), m_colorSelector,        SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), m_myPaintShadeSelector, SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), this,                   SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), m_minimalShadeSelector, SLOT(updateSettings()));
 
 
     m_colorSelAction = KisActionRegistry::instance()->makeQAction("show_color_selector", this);
     connect(m_colorSelAction, SIGNAL(triggered()), m_colorSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
     m_mypaintAction = KisActionRegistry::instance()->makeQAction("show_mypaint_shade_selector", this);
     connect(m_mypaintAction, SIGNAL(triggered()), m_myPaintShadeSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
     m_minimalAction = KisActionRegistry::instance()->makeQAction("show_minimal_shade_selector", this);
     connect(m_minimalAction, SIGNAL(triggered()), m_minimalShadeSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
 }
 
 void KisColorSelectorContainer::unsetCanvas()
 {
     m_colorSelector->unsetCanvas();
     m_myPaintShadeSelector->unsetCanvas();
     m_minimalShadeSelector->unsetCanvas();
     m_canvas = 0;
 }
 
 void KisColorSelectorContainer::setCanvas(KisCanvas2* canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_canvas->viewManager()->nodeManager()->disconnect(this);
         KActionCollection *ac = m_canvas->viewManager()->actionCollection();
         ac->takeAction(ac->action("show_color_selector"));
         ac->takeAction(ac->action("show_mypaint_shade_selector"));
         ac->takeAction(ac->action("show_minimal_shade_selector"));
     }
 
     m_canvas = canvas;
 
     m_colorSelector->setCanvas(canvas);
     m_myPaintShadeSelector->setCanvas(canvas);
     m_minimalShadeSelector->setCanvas(canvas);
 
     if (m_canvas && m_canvas->viewManager()) {
         if (m_canvas->viewManager()->nodeManager()) {
             connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigLayerActivated(KisLayerSP)), SLOT(reactOnLayerChange()), Qt::UniqueConnection);
         }
 
         KActionCollection* actionCollection = canvas->viewManager()->actionCollection();
         actionCollection->addAction("show_color_selector", m_colorSelAction);
         actionCollection->addAction("show_mypaint_shade_selector", m_mypaintAction);
         actionCollection->addAction("show_minimal_shade_selector", m_minimalAction);
     }
 }
 
 void KisColorSelectorContainer::updateSettings()
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     m_onDockerResizeSetting =  (int)cfg.readEntry("onDockerResize", 0);
 
-    QString type = cfg.readEntry("shadeSelectorType", "MyPaint");
+    QString type = cfg.readEntry("shadeSelectorType", "Minimal");
 
     QWidget* newShadeSelector;
     if(type=="MyPaint")
         newShadeSelector = m_myPaintShadeSelector;
     else if (type=="Minimal")
         newShadeSelector = m_minimalShadeSelector;
     else
         newShadeSelector = 0;
 
 
 
     if(m_shadeSelector!=newShadeSelector && m_shadeSelector!=0) {
         m_shadeSelector->hide();
     }
     m_shadeSelector=newShadeSelector;
 
     if(m_shadeSelector!=0)
         m_shadeSelector->show();
 
 }
 
 void KisColorSelectorContainer::reactOnLayerChange()
 {
     if (m_canvas) {
         KisNodeSP node = m_canvas->viewManager()->resourceProvider()->currentNode();
         if (node) {
             KisPaintDeviceSP device = node->paintDevice();
             if (device) {
                 m_colorSelAction->setEnabled(true);
                 m_mypaintAction->setEnabled(true);
                 m_minimalAction->setEnabled(true);
             }
             else {
                 //            m_colorSelAction->setEnabled(false);
                 //            m_mypaintAction->setEnabled(false);
                 //            m_minimalAction->setEnabled(false);
             }
         }
     }
 }
 
 void KisColorSelectorContainer::resizeEvent(QResizeEvent * e)
 {
     if(m_shadeSelector!=0) {
         int minimumHeightForBothWidgets = m_colorSelector->minimumHeight()+m_shadeSelector->minimumHeight()+30; //+30 for the buttons (temporarily)
 
         if(height()<minimumHeightForBothWidgets && m_onDockerResizeSetting== 1) {  // 1 option is hide shade selector
             m_shadeSelector->hide();
         }
         else {
             m_shadeSelector->show();
         }
 
         // m_onDockerResizeSetting==0 is allow horizontal layout
         if(height() < width() && m_onDockerResizeSetting==0 && m_shadeSelector!=m_minimalShadeSelector) {
             m_widgetLayout->setDirection(QBoxLayout::LeftToRight);
         }
         else {
             m_widgetLayout->setDirection(QBoxLayout::TopToBottom);
         }
     }
 
     QWidget::resizeEvent(e);
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
index e1458d2c92..e5f0e1f4d8 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
@@ -1,634 +1,634 @@
 /*
  *  Copyright (C) 2010 Celarek Adam <kdedev at xibo dot at>
  *
  *  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_color_selector_settings.h"
 #include "ui_wdg_color_selector_settings.h"
 
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QComboBox>
 
 #include <kconfiggroup.h>
 
 
 #include <kis_icon.h>
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 
 #include "kis_color_selector_combo_box.h"
 #include "kis_color_selector.h"
 #include "kis_config.h"
 
 
 KisColorSelectorSettings::KisColorSelectorSettings(QWidget *parent) :
     KisPreferenceSet(parent),
     ui(new Ui::KisColorSelectorSettings)
 {
     ui->setupUi(this);
 
     resize(minimumSize());
 
     ui->colorSelectorConfiguration->setColorSpace(ui->colorSpace->currentColorSpace());
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
 
     connect(ui->useDifferentColorSpaceCheckbox, SIGNAL(clicked(bool)), this, SLOT(useDifferentColorSpaceChecked(bool)));
 
     /* color docker selector drop down */
     ui->dockerColorSettingsComboBox->addItem(i18n("Advanced Color Selector"));
     ui->dockerColorSettingsComboBox->addItem(i18n("Color Sliders"));
     ui->dockerColorSettingsComboBox->addItem(i18n("Color Hotkeys"));
     ui->dockerColorSettingsComboBox->setCurrentIndex(0); // start off seeing advanced color selector properties
 
     connect( ui->dockerColorSettingsComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedColorDocker(int)));
     changedColorDocker(0);
 
 
     /* advanced color docker options */
     ui->dockerResizeOptionsComboBox->addItem(i18n("Change to a Horizontal Layout"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Hide Shade Selector"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Do Nothing"));
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
 
 
     ui->zoomSelectorOptionComboBox->addItem(i18n("When Pressing Middle Mouse Button"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("On Mouse Over"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("Never"));
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
 
 
     ui->colorSelectorTypeComboBox->addItem(i18n("HSV"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSL"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSI"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSY'"));
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
     connect( ui->colorSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSColorSelectorType(int)));
     changedACSColorSelectorType(0); // initialize everything to HSV at the start
 
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSV"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSL"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSI"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSY'"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
 
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("MyPaint"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Minimal"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Do Not Show"));
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     changedACSShadeSelectorType(0); // show/hide UI elements for MyPaint settings
     connect( ui->ACSShadeSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSShadeSelectorType(int)));
 
 
     ui->commonColorsAlignVertical->setChecked(true);
     ui->commonColorsAlignHorizontal->setChecked(true);
     connect( ui->commonColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSColorAlignment(bool)));
     connect( ui->lastUsedColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSLastUsedColorAlignment(bool)));
 
     changedACSColorAlignment(ui->commonColorsAlignHorizontal->isChecked());
     changedACSLastUsedColorAlignment(ui->lastUsedColorsAlignHorizontal->isChecked());
 
 
     connect(ui->colorSpace,                 SIGNAL(colorSpaceChanged(const KoColorSpace*)),
             ui->colorSelectorConfiguration, SLOT(setColorSpace(const KoColorSpace*)));
 
 
     connect(this, SIGNAL(hsxchanged(int)),
             ui->colorSelectorConfiguration, SLOT(setList(int)));
 
     connect(ui->minimalShadeSelectorLineCount,      SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SLOT(setLineCount(int)));
 
     connect(ui->minimalShadeSelectorLineSettings,   SIGNAL(lineCountChanged(int)),
             ui->minimalShadeSelectorLineCount,      SLOT(setValue(int)));
 
     connect(ui->minimalShadeSelectorAsGradient,     SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setGradient(bool)));
 
     connect(ui->minimalShadeSelectorAsColorPatches, SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatches(bool)));
 
     connect(ui->minimalShadeSelectorLineHeight,     SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setLineHeight(int)));
 
     connect(ui->minimalShadeSelectorPatchesPerLine, SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatchCount(int)));
 }
 
 KisColorSelectorSettings::~KisColorSelectorSettings()
 {
     delete ui;
 }
 
 QString KisColorSelectorSettings::id()
 {
     return QString("advancedColorSelector");
 }
 
 QString KisColorSelectorSettings::name()
 {
     return header();
 }
 
 QString KisColorSelectorSettings::header()
 {
     return QString(i18n("Color Selector Settings"));
 }
 
 
 QIcon KisColorSelectorSettings::icon()
 {
     return KisIconUtils::loadIcon("extended_color_selector");
 }
 
 
 void KisColorSelectorSettings::savePreferences() const
 {
     // write cfg
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
     //  advanced color selector
     cfg.writeEntry("onDockerResize", ui->dockerResizeOptionsComboBox->currentIndex());
     cfg.writeEntry("zoomSelectorOptions", ui->zoomSelectorOptionComboBox->currentIndex() );
     cfg.writeEntry("zoomSize", ui->popupSize->value());
 
 
 
     bool useCustomColorSpace =  ui->useDifferentColorSpaceCheckbox->isChecked();
     const KoColorSpace* colorSpace = useCustomColorSpace ? ui->colorSpace->currentColorSpace() : 0;
 
 
     KisConfig kisconfig;
     kisconfig.setCustomColorSelectorColorSpace(colorSpace);
 
     //color patches
     cfg.writeEntry("lastUsedColorsShow", ui->lastUsedColorsShow->isChecked());
     cfg.writeEntry("lastUsedColorsAlignment", ui->lastUsedColorsAlignVertical->isChecked());
     cfg.writeEntry("lastUsedColorsScrolling", ui->lastUsedColorsAllowScrolling->isChecked());
     cfg.writeEntry("lastUsedColorsNumCols", ui->lastUsedColorsNumCols->value());
     cfg.writeEntry("lastUsedColorsNumRows", ui->lastUsedColorsNumRows->value());
     cfg.writeEntry("lastUsedColorsCount", ui->lastUsedColorsPatchCount->value());
     cfg.writeEntry("lastUsedColorsWidth", ui->lastUsedColorsWidth->value());
     cfg.writeEntry("lastUsedColorsHeight", ui->lastUsedColorsHeight->value());
 
     cfg.writeEntry("commonColorsShow", ui->commonColorsShow->isChecked());
     cfg.writeEntry("commonColorsAlignment", ui->commonColorsAlignVertical->isChecked());
     cfg.writeEntry("commonColorsScrolling", ui->commonColorsAllowScrolling->isChecked());
     cfg.writeEntry("commonColorsNumCols", ui->commonColorsNumCols->value());
     cfg.writeEntry("commonColorsNumRows", ui->commonColorsNumRows->value());
     cfg.writeEntry("commonColorsCount", ui->commonColorsPatchCount->value());
     cfg.writeEntry("commonColorsWidth", ui->commonColorsWidth->value());
     cfg.writeEntry("commonColorsHeight", ui->commonColorsHeight->value());
     cfg.writeEntry("commonColorsAutoUpdate", ui->commonColorsAutoUpdate->isChecked());
 
     //shade selector
 
 
 
     int shadeSelectorTypeIndex =  ui->ACSShadeSelectorTypeComboBox->currentIndex();
 
     if(shadeSelectorTypeIndex == 0) {
         cfg.writeEntry("shadeSelectorType", "MyPaint");
     } else if (shadeSelectorTypeIndex == 1) {
         cfg.writeEntry("shadeSelectorType", "Minimal");
     } else {
         cfg.writeEntry("shadeSelectorType", "Hidden");
     }
 
     cfg.writeEntry("shadeSelectorUpdateOnRightClick", ui->shadeSelectorUpdateOnRightClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnForeground", ui->shadeSelectorUpdateOnForeground->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnLeftClick", ui->shadeSelectorUpdateOnLeftClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnBackground", ui->shadeSelectorUpdateOnBackground->isChecked());
     cfg.writeEntry("hidePopupOnClickCheck", ui->hidePopupOnClickCheck->isChecked());
-    
+
     //mypaint model
 
     int shadeMyPaintComboBoxIndex  = ui->ACSshadeSelectorMyPaintColorModelComboBox->currentIndex();
     if (shadeMyPaintComboBoxIndex == 0 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSV");
     } else  if (shadeMyPaintComboBoxIndex == 1 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSL");
     } else  if (shadeMyPaintComboBoxIndex == 2 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSI");
     } else {   // HSY
         cfg.writeEntry("shadeMyPaintType",   "HSY");
     }
 
 
 
     cfg.writeEntry("minimalShadeSelectorAsGradient", ui->minimalShadeSelectorAsGradient->isChecked());
     cfg.writeEntry("minimalShadeSelectorPatchCount", ui->minimalShadeSelectorPatchesPerLine->value());
     cfg.writeEntry("minimalShadeSelectorLineConfig",  ui->minimalShadeSelectorLineSettings->toString());
     cfg.writeEntry("minimalShadeSelectorLineHeight", ui->minimalShadeSelectorLineHeight->value());
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cfg.writeEntry("colorSelectorConfiguration", cstw->configuration().toString());
-    
+
     cfg.writeEntry("hsxSettingType", ui->colorSelectorTypeComboBox->currentIndex());
-    
+
     //luma//
     cfg.writeEntry("lumaR", ui->l_lumaR->value());
     cfg.writeEntry("lumaG", ui->l_lumaG->value());
     cfg.writeEntry("lumaB", ui->l_lumaB->value());
     cfg.writeEntry("gamma", ui->SP_Gamma->value());
-    
+
     //slider//
     hsxcfg.writeEntry("hsvH", ui->csl_hsvH->isChecked());
     hsxcfg.writeEntry("hsvS", ui->csl_hsvS->isChecked());
     hsxcfg.writeEntry("hsvV", ui->csl_hsvV->isChecked());
     hsxcfg.writeEntry("hslH", ui->csl_hslH->isChecked());
     hsxcfg.writeEntry("hslS", ui->csl_hslS->isChecked());
     hsxcfg.writeEntry("hslL", ui->csl_hslL->isChecked());
     hsxcfg.writeEntry("hsiH", ui->csl_hsiH->isChecked());
     hsxcfg.writeEntry("hsiS", ui->csl_hsiS->isChecked());
     hsxcfg.writeEntry("hsiI", ui->csl_hsiI->isChecked());
     hsxcfg.writeEntry("hsyH", ui->csl_hsyH->isChecked());
     hsxcfg.writeEntry("hsyS", ui->csl_hsyS->isChecked());
     hsxcfg.writeEntry("hsyY", ui->csl_hsyY->isChecked());
 
     //hotkeys//
     hotkeycfg.writeEntry("steps_lightness", ui->sb_lightness->value());
     hotkeycfg.writeEntry("steps_saturation", ui->sb_saturation->value());
     hotkeycfg.writeEntry("steps_hue", ui->sb_hue->value());
     hotkeycfg.writeEntry("steps_redgreen", ui->sb_rg->value());
     hotkeycfg.writeEntry("steps_blueyellow", ui->sb_by->value());
 
     emit settingsChanged();
 }
 
 //void KisColorSelectorSettings::changeEvent(QEvent *e)
 //{
 //    QDialog::changeEvent(e);
 //    switch (e->type()) {
 //    case QEvent::LanguageChange:
 //        ui->retranslateUi(this);
 //        break;
 //    default:
 //        break;
 //    }
 //}
 
 
 void KisColorSelectorSettings::changedColorDocker(int index)
 {
     // having a situation where too many sections are visible makes the window too large. turn all off before turning more on
     ui->colorSliderOptions->hide();
     ui->advancedColorSelectorOptions->hide();
     ui->hotKeyOptions->hide();
 
     if (index == 0)     { // advanced color selector options selected
         ui->advancedColorSelectorOptions->show();
         ui->colorSliderOptions->hide();
         ui->hotKeyOptions->hide();
     }
     else if (index == 1) {  // color slider options selected
         ui->advancedColorSelectorOptions->hide();
         ui->hotKeyOptions->hide();
         ui->colorSliderOptions->show();
-    } else { 
+    } else {
        ui->colorSliderOptions->hide();
        ui->advancedColorSelectorOptions->hide();
        ui->hotKeyOptions->show();
     }
 }
 
 void KisColorSelectorSettings::changedACSColorSelectorType(int index)
 {
     ui->lumaCoefficientGroupbox->setVisible(false);
 
     if (index == 0)     {  // HSV
         ui->ACSTypeDescriptionLabel->setText(i18n("Values goes from black to white, or black to the most saturated colour. Saturation, in turn, goes from the most saturated colour to white, grey or black."));
     }
     else if (index == 1)     {  // HSL
         ui->ACSTypeDescriptionLabel->setText(i18n("Lightness goes from black to white, with middle grey being equal to the most saturated colour."));
     }
     else if (index == 2)     {  // HSI
         ui->ACSTypeDescriptionLabel->setText(i18n("Intensity maps to the sum of rgb components"));
     }
     else {  // HSY'
         ui->ACSTypeDescriptionLabel->setText(i18n("Luma(Y') is weighted by its coefficients which are configurable. Default values are set to 'rec 709'."));
         ui->lumaCoefficientGroupbox->setVisible(true);
     }
 
     ui->colorSelectorConfiguration->update();
     emit hsxchanged(index);
 
 }
 
 
 void KisColorSelectorSettings::changedACSColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_commonColorsNumCols->setDisabled(toggled);
     ui->commonColorsNumCols->setDisabled(toggled);
 
     ui->lbl_commonColorsNumRows->setEnabled(toggled);
     ui->commonColorsNumRows->setEnabled(toggled);
 }
 
 void KisColorSelectorSettings::changedACSLastUsedColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_lastUsedNumCols->setDisabled(toggled);
     ui->lastUsedColorsNumCols->setDisabled(toggled);
 
     ui->lbl_lastUsedNumRows->setEnabled(toggled);
     ui->lastUsedColorsNumRows->setEnabled(toggled);
 }
 
 
 
 void KisColorSelectorSettings::changedACSShadeSelectorType(int index)
 {
 
     if (index == 0)     {  // MyPaint
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->show();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->show();
 
     } else if (index == 1) { // Minimal
         ui->minimalShadeSelectorGroup->show();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
 
     }else { // do not show
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
     }
 }
 
 void KisColorSelectorSettings::useDifferentColorSpaceChecked(bool enabled)
 {
     ui->colorSpace->setEnabled(enabled);
 }
 
 void KisColorSelectorSettings::loadPreferences()
 {
     //read cfg
     //don't forget to also add a new entry to the default preferences
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
 
     // Advanced color selector
     ui->dockerResizeOptionsComboBox->setCurrentIndex(  (int)cfg.readEntry("onDockerResize", 0) );
     ui->zoomSelectorOptionComboBox->setCurrentIndex(   (int) cfg.readEntry("zoomSelectorOptions", 0) );
     ui->popupSize->setValue(cfg.readEntry("zoomSize", 280));
 
 
     {
         KisConfig kisconfig;
         const KoColorSpace *cs = kisconfig.customColorSelectorColorSpace();
 
         if(cs) {
             ui->useDifferentColorSpaceCheckbox->setChecked(true);
             ui->colorSpace->setEnabled(true);
             ui->colorSpace->setCurrentColorSpace(cs);
         } else {
             ui->useDifferentColorSpaceCheckbox->setChecked(false);
             ui->colorSpace->setEnabled(false);
         }
     }
 
 
     //color patches
     ui->lastUsedColorsShow->setChecked(cfg.readEntry("lastUsedColorsShow", true));
     bool a = cfg.readEntry("lastUsedColorsAlignment", true);
     ui->lastUsedColorsAlignVertical->setChecked(a);
     ui->lastUsedColorsAlignHorizontal->setChecked(!a);
     ui->lastUsedColorsAllowScrolling->setChecked(cfg.readEntry("lastUsedColorsScrolling", true));
     ui->lastUsedColorsNumCols->setValue(cfg.readEntry("lastUsedColorsNumCols", 1));
     ui->lastUsedColorsNumRows->setValue(cfg.readEntry("lastUsedColorsNumRows", 1));
     ui->lastUsedColorsPatchCount->setValue(cfg.readEntry("lastUsedColorsCount", 20));
     ui->lastUsedColorsWidth->setValue(cfg.readEntry("lastUsedColorsWidth", 16));
     ui->lastUsedColorsHeight->setValue(cfg.readEntry("lastUsedColorsHeight", 16));
 
     ui->commonColorsShow->setChecked(cfg.readEntry("commonColorsShow", true));
     a = cfg.readEntry("commonColorsAlignment", false);
     ui->commonColorsAlignVertical->setChecked(a);
     ui->commonColorsAlignHorizontal->setChecked(!a);
     ui->commonColorsAllowScrolling->setChecked(cfg.readEntry("commonColorsScrolling", false));
     ui->commonColorsNumCols->setValue(cfg.readEntry("commonColorsNumCols", 1));
     ui->commonColorsNumRows->setValue(cfg.readEntry("commonColorsNumRows", 1));
     ui->commonColorsPatchCount->setValue(cfg.readEntry("commonColorsCount", 12));
     ui->commonColorsWidth->setValue(cfg.readEntry("commonColorsWidth", 16));
     ui->commonColorsHeight->setValue(cfg.readEntry("commonColorsHeight", 16));
     ui->commonColorsAutoUpdate->setChecked(cfg.readEntry("commonColorsAutoUpdate", false));
 
     //shade selector
-    QString shadeSelectorType=cfg.readEntry("shadeSelectorType", "MyPaint");
+    QString shadeSelectorType=cfg.readEntry("shadeSelectorType", "Minimal");
 
     if ( shadeSelectorType == "MyPaint") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     } else if (shadeSelectorType == "Minimal") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1);
     } else {   // Hidden
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(2);
     }
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnRightClick", false));
     ui->shadeSelectorUpdateOnLeftClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnLeftClick", false));
     ui->shadeSelectorUpdateOnForeground->setChecked(cfg.readEntry("shadeSelectorUpdateOnForeground", true));
     ui->shadeSelectorUpdateOnBackground->setChecked(cfg.readEntry("shadeSelectorUpdateOnBackground", true));
     ui->hidePopupOnClickCheck->setChecked(cfg.readEntry("hidePopupOnClickCheck", false));
 
     QString shadeMyPaintType = cfg.readEntry("shadeMyPaintType", "HSV");
 
     if (shadeMyPaintType == "HSV" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
     } else  if (shadeMyPaintType == "HSL" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(1);
     } else  if (shadeMyPaintType == "HSI" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(2);
     } else {   // HSY
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(3);
     }
 
 
     bool asGradient = cfg.readEntry("minimalShadeSelectorAsGradient", true);
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(cfg.readEntry("minimalShadeSelectorPatchCount", 10));
     ui->minimalShadeSelectorLineSettings->fromString(cfg.readEntry("minimalShadeSelectorLineConfig", "0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;"));
     ui->minimalShadeSelectorLineHeight->setValue(cfg.readEntry("minimalShadeSelectorLineHeight", 10));
 
     int hsxSettingType= (int)cfg.readEntry("hsxSettingType", 0);
     ui->colorSelectorTypeComboBox->setCurrentIndex(hsxSettingType);
 
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", "3|0|5|0"))); // triangle selector
-    
+
     //luma values//
     ui->l_lumaR->setValue(cfg.readEntry("lumaR", 0.2126));
     ui->l_lumaG->setValue(cfg.readEntry("lumaG", 0.7152));
     ui->l_lumaB->setValue(cfg.readEntry("lumaB", 0.0722));
     ui->SP_Gamma->setValue(cfg.readEntry("gamma", 2.2));
-    
+
     //color sliders//
     ui->csl_hsvH->setChecked(hsxcfg.readEntry("hsvH", false));
     ui->csl_hsvS->setChecked(hsxcfg.readEntry("hsvS", false));
     ui->csl_hsvV->setChecked(hsxcfg.readEntry("hsvV", false));
     ui->csl_hslH->setChecked(hsxcfg.readEntry("hslH", true));
     ui->csl_hslS->setChecked(hsxcfg.readEntry("hslS", true));
     ui->csl_hslL->setChecked(hsxcfg.readEntry("hslL", true));
     ui->csl_hsiH->setChecked(hsxcfg.readEntry("hsiH", false));
     ui->csl_hsiS->setChecked(hsxcfg.readEntry("hsiS", false));
     ui->csl_hsiI->setChecked(hsxcfg.readEntry("hsiI", false));
     ui->csl_hsyH->setChecked(hsxcfg.readEntry("hsyH", false));
     ui->csl_hsyS->setChecked(hsxcfg.readEntry("hsyS", false));
     ui->csl_hsyY->setChecked(hsxcfg.readEntry("hsyY", false));
 
     //hotkeys//
     ui->sb_lightness->setValue(hotkeycfg.readEntry("steps_lightness", 10));
     ui->sb_saturation->setValue(hotkeycfg.readEntry("steps_saturation", 10));
     ui->sb_hue->setValue(hotkeycfg.readEntry("steps_hue", 36));
     ui->sb_rg->setValue(hotkeycfg.readEntry("steps_redgreen", 10));
     ui->sb_by->setValue(hotkeycfg.readEntry("steps_blueyellow", 10));
 
-    
+
 }
 
 void KisColorSelectorSettings::loadDefaultPreferences()
 {
     //set defaults
     //if you change something, don't forget that loadPreferences should be kept in sync
 
     // advanced color selector docker
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
     ui->popupSize->setValue(280);
 
 
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
     ui->colorSpace->setCurrentColorModel(KoID("RGBA"));
     ui->colorSpace->setCurrentColorDepth(KoID("U8"));
     ui->colorSpace->setCurrentProfile(KoColorSpaceRegistry::instance()->rgb8()->profile()->name());
 
     //color patches
     ui->lastUsedColorsShow->setChecked(true);
     ui->lastUsedColorsAlignVertical->setChecked(true);
     ui->lastUsedColorsAlignHorizontal->setChecked(false);
     ui->lastUsedColorsAllowScrolling->setChecked(true);
     ui->lastUsedColorsNumCols->setValue(1);
     ui->lastUsedColorsNumRows->setValue(1);
     ui->lastUsedColorsPatchCount->setValue(20);
     ui->lastUsedColorsWidth->setValue(16);
     ui->lastUsedColorsHeight->setValue(16);
 
     ui->commonColorsShow->setChecked(true);
     ui->commonColorsAlignVertical->setChecked(false);
     ui->commonColorsAlignHorizontal->setChecked(true);
     ui->commonColorsAllowScrolling->setChecked(false);
     ui->commonColorsNumCols->setValue(1);
     ui->commonColorsNumRows->setValue(1);
     ui->commonColorsPatchCount->setValue(12);
     ui->commonColorsWidth->setValue(16);
     ui->commonColorsHeight->setValue(16);
     ui->commonColorsAutoUpdate->setChecked(false);
 
     //shade selector
-    ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0); // MyPaint
+    ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1); // Minimal
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(false);
     ui->shadeSelectorUpdateOnLeftClick->setChecked(false);
     ui->shadeSelectorUpdateOnForeground->setChecked(true);
     ui->shadeSelectorUpdateOnBackground->setChecked(true);
 
     bool asGradient = true;
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(10);
     ui->minimalShadeSelectorLineSettings->fromString("0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;");
     ui->minimalShadeSelectorLineHeight->setValue(10);
 
     // set advanced color selector to use HSV
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
-    
+
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration("3|0|5|0")); // triangle selector
-    
+
     //luma//
     ui->l_lumaR->setValue(0.2126);
     ui->l_lumaG->setValue(0.7152);
     ui->l_lumaB->setValue(0.0722);
     ui->SP_Gamma->setValue(2.2);
-    
+
     //color sliders//
     ui->csl_hsvH->setChecked(false);
     ui->csl_hsvS->setChecked(false);
     ui->csl_hsvV->setChecked(false);
     ui->csl_hslH->setChecked(true);
     ui->csl_hslS->setChecked(true);
     ui->csl_hslL->setChecked(true);
     ui->csl_hsiH->setChecked(false);
     ui->csl_hsiS->setChecked(false);
     ui->csl_hsiI->setChecked(false);
     ui->csl_hsyH->setChecked(false);
     ui->csl_hsyS->setChecked(false);
     ui->csl_hsyY->setChecked(false);
 
     //hotkeys//
     ui->sb_lightness->setValue(10);
     ui->sb_saturation->setValue(10);
     ui->sb_hue->setValue(36);
     ui->sb_rg->setValue(10);
     ui->sb_by->setValue(10);
 
 }
 
 KisColorSelectorSettingsDialog::KisColorSelectorSettingsDialog(QWidget *parent) :
     QDialog(parent),
     m_widget(new KisColorSelectorSettings(this))
 {
     QLayout* l = new QVBoxLayout(this);
     l->addWidget(m_widget);
 
     m_widget->loadPreferences();
 
     QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::RestoreDefaults,
                                                        Qt::Horizontal,
                                                        this);
     l->addWidget(buttonBox);
 
     connect(buttonBox, SIGNAL(accepted()), m_widget, SLOT(savePreferences()));
     connect(buttonBox, SIGNAL(accepted()), this,     SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), this,     SLOT(reject()));
     connect(buttonBox->button(QDialogButtonBox::RestoreDefaults),
             SIGNAL(clicked()),  m_widget, SLOT(loadDefaultPreferences()));
 }
 
 
 
diff --git a/plugins/dockers/animation/kis_custom_modifiers_catcher.h b/plugins/dockers/animation/kis_custom_modifiers_catcher.h
index 9b63d44951..03e3538eca 100644
--- a/plugins/dockers/animation/kis_custom_modifiers_catcher.h
+++ b/plugins/dockers/animation/kis_custom_modifiers_catcher.h
@@ -1,42 +1,74 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_CUSTOM_MODIFIERS_CATCHER_H
 #define __KIS_CUSTOM_MODIFIERS_CATCHER_H
 
 #include <QScopedPointer>
 #include <QObject>
 
+/**
+ * @brief The KisCustomModifiersCatcher class is a special utility class that
+ * tracks custom modifiers pressed. Its main purpose is to avoid manual tracking
+ * of KeyPress/KeyRelease/FocusIn events in the class and reuse the common code in
+ * multiple widgets.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~{.cpp}
+ * // in the c-tor of your widget create the catcher, it will automatically
+ * // connect to the passed parent
+ * KisCustomModifiersCatcher *catcher = new KisCustomModifiersCatcher(parent);
+ *
+ * // Register a tracked modifier
+ * catcher->addModifier("pan-zoom", Qt::Key_Space);
+ *
+ * // in the pointer tracking event handlers just check
+ * // if the modifier is pressed or not
+ * bool isPressed = catcher->modifierPressed("pan-zoom");
+ * ~~~~~~~~~~~~~~~~~~~~
+ */
 
 class KisCustomModifiersCatcher : public QObject
 {
 public:
+    /**
+     * Create the catcher and connect to the passed widget/object to
+     * track its key events
+     */
     KisCustomModifiersCatcher(QObject *parent);
     ~KisCustomModifiersCatcher();
 
     bool eventFilter(QObject* object, QEvent* event);
 
+    /**
+     * @brief addModifier registers a custom modifier
+     * @param id a unique id string associated with the modifier. Later, you will use this string to fetch the modifier state.
+     * @param modifier the key to track
+     */
     void addModifier(const QString &id, Qt::Key modifier);
+
+    /**
+     * @brief modifierPressed returns the state of the tracked modifier
+     */
     bool modifierPressed(const QString &id);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_CUSTOM_MODIFIERS_CATCHER_H */
diff --git a/plugins/dockers/lut/ocio_display_filter.cpp b/plugins/dockers/lut/ocio_display_filter.cpp
index 3a621896e8..87339c4ee4 100644
--- a/plugins/dockers/lut/ocio_display_filter.cpp
+++ b/plugins/dockers/lut/ocio_display_filter.cpp
@@ -1,365 +1,369 @@
 /*
  *  Copyright (c) 2012 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 "ocio_display_filter.h"
 #include <math.h>
 #include <cstdlib>
 #include <cmath>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <fstream>
 #include <sstream>
 
 #include <kis_config.h>
 
 #include <opengl/kis_opengl.h>
 #include <QOpenGLContext>
 #include <QOpenGLFunctions_3_2_Core>
 #include <QOpenGLFunctions_3_0>
 #include <QOpenGLFunctions_2_0>
 
 
 OcioDisplayFilter::OcioDisplayFilter(KisExposureGammaCorrectionInterface *interface, QObject *parent)
     : KisDisplayFilter(parent)
     , inputColorSpaceName(0)
     , displayDevice(0)
     , view(0)
     , look(0)
     , swizzle(RGBA)
     , m_interface(interface)
     , m_lut3dTexID(0)
     , m_shaderDirty(true)
 {
 }
 
 OcioDisplayFilter::~OcioDisplayFilter()
 {
 }
 
 KisExposureGammaCorrectionInterface* OcioDisplayFilter::correctionInterface() const
 {
     return m_interface;
 }
 
 void OcioDisplayFilter::filter(quint8 *pixels, quint32 numPixels)
 {
     // processes that data _in_ place
     if (m_processor) {
         OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
         m_processor->apply(img);
     }
 }
 
 void OcioDisplayFilter::approximateInverseTransformation(quint8 *pixels, quint32 numPixels)
 {
     // processes that data _in_ place
     if (m_revereseApproximationProcessor) {
         OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
         m_revereseApproximationProcessor->apply(img);
     }
 }
 
 void OcioDisplayFilter::approximateForwardTransformation(quint8 *pixels, quint32 numPixels)
 {
     // processes that data _in_ place
     if (m_forwardApproximationProcessor) {
         OCIO::PackedImageDesc img(reinterpret_cast<float*>(pixels), numPixels, 1, 4);
         m_forwardApproximationProcessor->apply(img);
     }
 }
 
 bool OcioDisplayFilter::useInternalColorManagement() const
 {
     return forceInternalColorManagement;
 }
 
 bool OcioDisplayFilter::lockCurrentColorVisualRepresentation() const
 {
     return m_lockCurrentColorVisualRepresentation;
 }
 
 void OcioDisplayFilter::setLockCurrentColorVisualRepresentation(bool value)
 {
     m_lockCurrentColorVisualRepresentation = value;
 }
 
 QString OcioDisplayFilter::program() const
 {
     return m_program;
 }
 
 GLuint OcioDisplayFilter::lutTexture() const
 {
     return m_lut3dTexID;
 }
 
 void OcioDisplayFilter::updateProcessor()
 {
     if (!config) {
         return;
     }
 
     if (!displayDevice) {
         displayDevice = config->getDefaultDisplay();
     }
 
     if (!view) {
         view = config->getDefaultView(displayDevice);
     }
 
     if (!inputColorSpaceName) {
         inputColorSpaceName = config->getColorSpaceNameByIndex(0);
     }
     if (!look) {
 	look = config->getLookNameByIndex(0);
     }
 
     if (!displayDevice || !view || !inputColorSpaceName) {
         return;
     }
 
     OCIO::DisplayTransformRcPtr transform = OCIO::DisplayTransform::Create();
     transform->setInputColorSpaceName(inputColorSpaceName);
     transform->setDisplay(displayDevice);
     transform->setView(view);
 
     /**
      * Look support:
      * As the OCIO docs will tell you, looks are a aesthetic transform that is
      * added onto the mix.
      * A view+display can have it's own assigned Look, or list of looks, and these
      * can be overriden optionally.
      * What the OCIO docs won't tell you is that a display transform won't use the
      * looks attached to it unless "skipColorSpaceConversions" is false...
      * I have no idea what "skipColorSpaceConversions" is beyond what it says on the
      * tin. It is not mentioned in the documentation anywhere. Or on the website.
      * Or how to set it. Or unset it. Why it is apparantly set true to begin with.
      * Only that, apparantly, this was done with non-color data in mind...
      *
      * Until there's clear documentation on how to use this feature, I am afraid the
      * override is all we can offer.
      */
     if (config->getLook(look)) {
        transform->setLooksOverride(look);
        transform->setLooksOverrideEnabled(true);
     }
 
     OCIO::GroupTransformRcPtr approximateTransform = OCIO::GroupTransform::Create();
 
     // fstop exposure control -- not sure how that translates to our exposure
     {
         float exposureGain = powf(2.0f, exposure);
 
         const qreal minRange = 0.001;
         if (qAbs(blackPoint - whitePoint) < minRange) {
             whitePoint = blackPoint + minRange;
         }
 
         const float oldMin[] = { blackPoint, blackPoint, blackPoint, 0.0f };
         const float oldMax[] = { whitePoint, whitePoint, whitePoint, 1.0f };
 
         const float newMin[] = { 0.0f, 0.0f, 0.0f, 0.0f };
         const float newMax[] = { exposureGain, exposureGain, exposureGain, 1.0f };
 
         float m44[16];
         float offset4[4];
         OCIO::MatrixTransform::Fit(m44, offset4, oldMin, oldMax, newMin, newMax);
         OCIO::MatrixTransformRcPtr mtx =  OCIO::MatrixTransform::Create();
         mtx->setValue(m44, offset4);
         transform->setLinearCC(mtx);
 
         // approximation (no color correction);
         approximateTransform->push_back(mtx);
     }
 
     // channel swizzle
     {
         int channelHot[4];
         switch (swizzle) {
         case LUMINANCE:
             channelHot[0] = 1;
             channelHot[1] = 1;
             channelHot[2] = 1;
             channelHot[3] = 0;
             break;
         case RGBA:
             channelHot[0] = 1;
             channelHot[1] = 1;
             channelHot[2] = 1;
             channelHot[3] = 1;
             break;
         case R:
             channelHot[0] = 1;
             channelHot[1] = 0;
             channelHot[2] = 0;
             channelHot[3] = 0;
             break;
         case G:
             channelHot[0] = 0;
             channelHot[1] = 1;
             channelHot[2] = 0;
             channelHot[3] = 0;
             break;
         case B:
             channelHot[0] = 0;
             channelHot[1] = 0;
             channelHot[2] = 1;
             channelHot[3] = 0;
             break;
         case A:
             channelHot[0] = 0;
             channelHot[1] = 0;
             channelHot[2] = 0;
             channelHot[3] = 1;
         default:
             ;
         }
         float lumacoef[3];
         config->getDefaultLumaCoefs(lumacoef);
         float m44[16];
         float offset[4];
         OCIO::MatrixTransform::View(m44, offset, channelHot, lumacoef);
         OCIO::MatrixTransformRcPtr swizzle = OCIO::MatrixTransform::Create();
         swizzle->setValue(m44, offset);
         transform->setChannelView(swizzle);
     }
 
     // Post-display transform gamma
     {
         float exponent = 1.0f/std::max(1e-6f, static_cast<float>(gamma));
         const float exponent4f[] = { exponent, exponent, exponent, exponent };
         OCIO::ExponentTransformRcPtr expTransform =  OCIO::ExponentTransform::Create();
         expTransform->setValue(exponent4f);
         transform->setDisplayCC(expTransform);
 
         // approximation (no color correction);
         approximateTransform->push_back(expTransform);
     }
 
     m_processor = config->getProcessor(transform);
 
     m_forwardApproximationProcessor = config->getProcessor(approximateTransform, OCIO::TRANSFORM_DIR_FORWARD);
 
     try {
         m_revereseApproximationProcessor = config->getProcessor(approximateTransform, OCIO::TRANSFORM_DIR_INVERSE);
     } catch (...) {
         warnKrita << "OCIO inverted matrix does not exist!";
         //m_revereseApproximationProcessor;
     }
 
     m_shaderDirty = true;
 }
 
 void OcioDisplayFilter::updateShader()
 {
     if (KisOpenGL::hasOpenGL3()) {
         QOpenGLFunctions_3_2_Core *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_2_Core>();
         updateShaderImpl(f);
     }
     // XXX This option can be removed once we move to Qt 5.7+
     else if (KisOpenGL::supportsLoD()) {
+#ifdef Q_OS_MAC
+        QOpenGLFunctions_3_2_Core *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_2_Core>();
+#else
         QOpenGLFunctions_3_0 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_0>();
+#endif
         updateShaderImpl(f);
     } else {
         QOpenGLFunctions_2_0 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_2_0>();
         updateShaderImpl(f);
     }
 }
 
 template <class F>
 void OcioDisplayFilter::updateShaderImpl(F *f) {
     // check whether we are allowed to use shaders -- though that should
     // work for everyone these days
     KisConfig cfg;
     if (!cfg.useOpenGL()) return;
 
     if (!m_shaderDirty) return;
 
     if (!f) {
         qWarning() << "Failed to get valid OpenGL functions for OcioDisplayFilter!";
         return;
     }
 
     f->initializeOpenGLFunctions();
 
     const int lut3DEdgeSize = cfg.ocioLutEdgeSize();
 
     if (m_lut3d.size() == 0) {
         //dbgKrita << "generating lut";
         f->glGenTextures(1, &m_lut3dTexID);
 
         int num3Dentries = 3 * lut3DEdgeSize * lut3DEdgeSize * lut3DEdgeSize;
         m_lut3d.fill(0.0, num3Dentries);
 
         f->glActiveTexture(GL_TEXTURE1);
         f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);
 
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         f->glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
         f->glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB16F_ARB,
                         lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,
                         0, GL_RGB, GL_FLOAT, &m_lut3d.constData()[0]);
     }
 
     // Step 1: Create a GPU Shader Description
     OCIO::GpuShaderDesc shaderDesc;
 
     if (KisOpenGL::supportsLoD()) {
         shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_3);
     }
     else {
         shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_0);
     }
 
 
     shaderDesc.setFunctionName("OCIODisplay");
     shaderDesc.setLut3DEdgeLen(lut3DEdgeSize);
 
 
     // Step 2: Compute the 3D LUT
     QString lut3dCacheID = QString::fromLatin1(m_processor->getGpuLut3DCacheID(shaderDesc));
     if (lut3dCacheID != m_lut3dcacheid) {
         //dbgKrita << "Computing 3DLut " << m_lut3dcacheid;
         m_lut3dcacheid = lut3dCacheID;
         m_processor->getGpuLut3D(&m_lut3d[0], shaderDesc);
 
         f->glBindTexture(GL_TEXTURE_3D, m_lut3dTexID);
         f->glTexSubImage3D(GL_TEXTURE_3D, 0,
                                   0, 0, 0,
                                   lut3DEdgeSize, lut3DEdgeSize, lut3DEdgeSize,
                                   GL_RGB, GL_FLOAT, &m_lut3d[0]);
     }
 
     // Step 3: Generate the shader text
     QString shaderCacheID = QString::fromLatin1(m_processor->getGpuShaderTextCacheID(shaderDesc));
     if (m_program.isEmpty() || shaderCacheID != m_shadercacheid) {
         //dbgKrita << "Computing Shader " << m_shadercacheid;
 
         m_shadercacheid = shaderCacheID;
 
         std::ostringstream os;
         os << m_processor->getGpuShaderText(shaderDesc) << "\n";
 
         m_program = QString::fromLatin1(os.str().c_str());
     }
 
     m_shaderDirty = false;
 }
diff --git a/plugins/tools/tool_transform2/kis_liquify_properties.h b/plugins/tools/tool_transform2/kis_liquify_properties.h
index 734b8ffd4e..aab45b2e13 100644
--- a/plugins/tools/tool_transform2/kis_liquify_properties.h
+++ b/plugins/tools/tool_transform2/kis_liquify_properties.h
@@ -1,148 +1,148 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_LIQUIFY_PROPERTIES_H
 #define __KIS_LIQUIFY_PROPERTIES_H
 
 #include <QtGlobal>
 #include <boost/operators.hpp>
 
 class QDomElement;
 
 
 class KisLiquifyProperties : boost::equality_comparable<KisLiquifyProperties>
 {
 public:
     enum LiquifyMode {
         MOVE,
         SCALE,
         ROTATE,
         OFFSET,
         UNDO,
 
         N_MODES
     };
 
     KisLiquifyProperties()
         : m_mode(MOVE),
-          m_size(50),
-          m_amount(0.2),
+          m_size(60),
+          m_amount(0.05),
           m_spacing(0.2),
           m_sizeHasPressure(false),
           m_amountHasPressure(false),
           m_reverseDirection(false),
           m_useWashMode(false),
           m_flow(0.2)
     {
     }
 
     bool operator==(const KisLiquifyProperties &other) const;
 
     LiquifyMode mode() const {
         return m_mode;
     }
     void setMode(LiquifyMode value) {
         m_mode = value;
     }
 
     qreal size() const {
         return m_size;
     }
     void setSize(qreal value) {
         m_size = value;
     }
 
     static qreal minSize() {
         return 5.0;
     }
 
     static qreal maxSize() {
         return 1000.0;
     }
 
     qreal amount() const {
         return m_amount;
     }
     void setAmount(qreal value) {
         m_amount = value;
     }
 
     qreal spacing() const {
         return m_spacing;
     }
     void setSpacing(qreal value) {
         m_spacing = value;
     }
 
     bool sizeHasPressure() const {
         return m_sizeHasPressure;
     }
     void setSizeHasPressure(bool value) {
         m_sizeHasPressure = value;
     }
 
     bool amountHasPressure() const {
         return m_amountHasPressure;
     }
     void setAmountHasPressure(bool value) {
         m_amountHasPressure = value;
     }
 
     bool reverseDirection() const {
         return m_reverseDirection;
     }
     void setReverseDirection(bool value) {
         m_reverseDirection = value;
     }
 
     bool useWashMode() const {
         return m_useWashMode;
     }
     void setUseWashMode(bool value) {
         m_useWashMode = value;
     }
 
     qreal flow() const {
         return m_flow;
     }
     void setFlow(qreal value) {
         m_flow = value;
     }
 
     void saveMode() const;
     void loadMode();
 
     void loadAndResetMode();
 
     void toXML(QDomElement *e) const;
     static KisLiquifyProperties fromXML(const QDomElement &e);
 
 private:
     LiquifyMode m_mode;
     qreal m_size;
     qreal m_amount;
     qreal m_spacing;
     bool m_sizeHasPressure;
     bool m_amountHasPressure;
     bool m_reverseDirection;
 
     bool m_useWashMode;
     qreal m_flow;
 };
 
 #endif /* __KIS_LIQUIFY_PROPERTIES_H */
diff --git a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
index 34b1e7cf1a..96b1c93024 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
@@ -1,1285 +1,1283 @@
 /*
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_transform_config_widget.h"
 
 #include <kis_icon.h>
 #include "rotation_icons.h"
 #include "kis_canvas2.h"
 #include <QSignalMapper>
 #include "kis_liquify_properties.h"
 
 #include "KisMainWindow.h"
 #include "KisViewManager.h"
 #include "kis_transform_utils.h"
 
 
 template<typename T> inline T sign(T x) {
     return x > 0 ? 1 : x == (T)0 ? 0 : -1;
 }
 
 const int KisToolTransformConfigWidget::DEFAULT_POINTS_PER_LINE = 3;
 
 
 KisToolTransformConfigWidget::KisToolTransformConfigWidget(TransformTransactionProperties *transaction, KisCanvas2 *canvas, bool workRecursively, QWidget *parent)
     : QWidget(parent),
       m_transaction(transaction),
       m_notificationsBlocked(0),
       m_uiSlotsBlocked(0),
       m_configChanged(false)
 {
     setupUi(this);
     showDecorationsBox->setIcon(KisIconUtils::loadIcon("krita_tool_transform"));
     chkWorkRecursively->setIcon(KisIconUtils::loadIcon("krita_tool_transform_recursive"));
     flipXButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_x"));
     flipYButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_y"));
     rotateCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_cw"));
     rotateCCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_ccw"));
 
     chkWorkRecursively->setChecked(workRecursively);
     connect(chkWorkRecursively, SIGNAL(toggled(bool)), this, SIGNAL(sigRestartTransform()));
 
     // Init Filter  combo
     cmbFilter->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     cmbFilter->setCurrent("Bicubic");
     cmbFilter->setToolTip(i18nc("@info:tooltip",
                                 "<p>Select filtering mode:\n"
                                 "<ul>"
                                 "<li><b>Bilinear</b> for areas with uniform color to avoid artifacts</li>"
                                 "<li><b>Bicubic</b> for smoother results</li>"
                                 "<li><b>Lanczos3</b> for sharp results. May produce aerials.</li>"
                                 "</ul></p>"));
     connect(cmbFilter, SIGNAL(activated(const KoID &)),
             this, SLOT(slotFilterChanged(const KoID &)));
 
     // Init Warp Type combo
     cmbWarpType->insertItem(KisWarpTransformWorker::AFFINE_TRANSFORM,i18n("Default (Affine)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::RIGID_TRANSFORM,i18n("Strong (Rigid)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::SIMILITUDE_TRANSFORM,i18n("Strongest (Similitude)"));
     cmbWarpType->setCurrentIndex(KisWarpTransformWorker::AFFINE_TRANSFORM);
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotWarpTypeChanged(int)));
 
     // Init Rotation Center buttons
     m_handleDir[0] = QPointF(1, 0);
     m_handleDir[1] = QPointF(1, -1);
     m_handleDir[2] = QPointF(0, -1);
     m_handleDir[3] = QPointF(-1, -1);
     m_handleDir[4] = QPointF(-1, 0);
     m_handleDir[5] = QPointF(-1, 1);
     m_handleDir[6] = QPointF(0, 1);
     m_handleDir[7] = QPointF(1, 1);
     m_handleDir[8] = QPointF(0, 0); // also add the center
 
     m_rotationCenterButtons = new QButtonGroup(0);
     // we set the ids to match m_handleDir
     m_rotationCenterButtons->addButton(middleRightButton, 0);
     m_rotationCenterButtons->addButton(topRightButton, 1);
     m_rotationCenterButtons->addButton(middleTopButton, 2);
     m_rotationCenterButtons->addButton(topLeftButton, 3);
     m_rotationCenterButtons->addButton(middleLeftButton, 4);
     m_rotationCenterButtons->addButton(bottomLeftButton, 5);
     m_rotationCenterButtons->addButton(middleBottomButton, 6);
     m_rotationCenterButtons->addButton(bottomRightButton, 7);
     m_rotationCenterButtons->addButton(centerButton, 8);
 
     QToolButton *nothingSelected = new QToolButton(0);
     nothingSelected->setCheckable(true);
     nothingSelected->setAutoExclusive(true);
     nothingSelected->hide(); // a convenient button for when no button is checked in the group
     m_rotationCenterButtons->addButton(nothingSelected, 9);
 
 
     // initialize values for free transform sliders
     shearXBox->setSuffix(i18n(" px"));
     shearYBox->setSuffix(i18n(" px"));
     shearXBox->setRange(-5.0, 5.0, 2);
     shearYBox->setRange(-5.0, 5.0, 2);
     shearXBox->setSingleStep(0.01);
     shearYBox->setSingleStep(0.01);
     shearXBox->setValue(0.0);
     shearYBox->setValue(0.0);
 
 
     translateXBox->setSuffix(i18n(" px"));
     translateYBox->setSuffix(i18n(" px"));
     translateXBox->setRange(-10000, 10000);
     translateYBox->setRange(-10000, 10000);
 
 
     scaleXBox->setSuffix("%");
     scaleYBox->setSuffix("%");
     scaleXBox->setRange(-10000, 10000);
     scaleYBox->setRange(-10000, 10000);
     scaleXBox->setValue(100.0);
     scaleYBox->setValue(100.0);
 
     m_scaleRatio = 1.0;
 
     aXBox->setSuffix(QChar(Qt::Key_degree));
     aYBox->setSuffix(QChar(Qt::Key_degree));
     aZBox->setSuffix(QChar(Qt::Key_degree));
     aXBox->setRange(0.0, 360.0, 2);
     aYBox->setRange(0.0, 360.0, 2);
     aZBox->setRange(0.0, 360.0, 2);
     aXBox->setValue(0.0);
     aYBox->setValue(0.0);
     aZBox->setValue(0.0);
     aXBox->setSingleStep(1.0);
     aYBox->setSingleStep(1.0);
     aZBox->setSingleStep(1.0);
 
 
 
 
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(slotRotationCenterChanged(int)));
     connect(btnTransformAroundPivotPoint, SIGNAL(clicked(bool)), this, SLOT(slotTransformAroundRotationCenter(bool)));
 
     // Init Free Transform Values
     connect(scaleXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleX(int)));
     connect(scaleYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleY(int)));
     connect(shearXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearX(qreal)));
     connect(shearYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearY(qreal)));
     connect(translateXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateX(int)));
     connect(translateYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateY(int)));
     connect(aXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAX(qreal)));
     connect(aYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAY(qreal)));
     connect(aZBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAZ(qreal)));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotSetKeepAspectRatio(bool)));
     connect(flipXButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipX()));
     connect(flipYButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipY()));
     connect(rotateCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCW()));
     connect(rotateCCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCCW()));
 
     // toggle visibility of different free buttons
     connect(freeMoveRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeRotationRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeScaleRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeShearRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
 
     // only first group for free transform
     rotationGroup->hide();
     moveGroup->show();
     scaleGroup->hide();
     shearGroup->hide();
 
 
 
     // Init Warp Transform Values
     alphaBox->setSingleStep(0.1);
     alphaBox->setRange(0, 10, 1);
 
     connect(alphaBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetWarpAlpha(qreal)));
     connect(densityBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetWarpDensity(int)));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpDefaultPointsButtonClicked(bool)));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpCustomPointsButtonClicked(bool)));
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpLockPointsButtonClicked()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpResetPointsButtonClicked()));
 
     // Init Cage Transform Values
     cageTransformButtonGroup->setId(cageAddEditRadio, 0); // we need to set manually since Qt Designer generates negative by default
     cageTransformButtonGroup->setId(cageDeformRadio, 1);
     connect(cageTransformButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(slotCageOptionsChanged(int)));
 
     // Init Liquify Transform Values
     liquifySizeSlider->setRange(KisLiquifyProperties::minSize(),
                                 KisLiquifyProperties::maxSize(), 2);
     liquifySizeSlider->setExponentRatio(4);
-    liquifySizeSlider->setValue(50.0);
+    liquifySizeSlider->setValue(60.0);
     connect(liquifySizeSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySizeChanged(qreal)));
     liquifySizeSlider->setToolTip(i18nc("@info:tooltip", "Size of the deformation brush"));
 
     liquifyAmountSlider->setRange(0.0, 1.0, 2);
-    liquifyAmountSlider->setValue(1.0);
+    liquifyAmountSlider->setValue(0.05);
     connect(liquifyAmountSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyAmountChanged(qreal)));
     liquifyAmountSlider->setToolTip(i18nc("@info:tooltip", "Amount of the deformation you get"));
 
     liquifyFlowSlider->setRange(0.0, 1.0, 2);
     liquifyFlowSlider->setValue(1.0);
     connect(liquifyFlowSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyFlowChanged(qreal)));
     liquifyFlowSlider->setToolTip(i18nc("@info:tooltip", "When in non-buildup mode, shows how fast the deformation limit is reached."));
 
-
     buidupModeComboBox->setCurrentIndex(0); // set to build-up mode by default
     connect(buidupModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(liquifyBuildUpChanged(int)));
     buidupModeComboBox->setToolTip(i18nc("@info:tooltip", "Switch between Build Up and Wash mode of painting. Build Up mode adds deformations one on top of the other without any limits. Wash mode gradually deforms the piece to the selected deformation level."));
 
-
     liquifySpacingSlider->setRange(0.0, 3.0, 2);
     liquifySizeSlider->setExponentRatio(3);
     liquifySpacingSlider->setSingleStep(0.01);
     liquifySpacingSlider->setValue(0.2);
     connect(liquifySpacingSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySpacingChanged(qreal)));
     liquifySpacingSlider->setToolTip(i18nc("@info:tooltip", "Space between two sequential applications of the deformation"));
 
     liquifySizePressureBox->setChecked(true);
     connect(liquifySizePressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifySizePressureChanged(bool)));
     liquifySizePressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Size</b> value according to current stylus pressure"));
 
     liquifyAmountPressureBox->setChecked(true);
     connect(liquifyAmountPressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifyAmountPressureChanged(bool)));
     liquifyAmountPressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Amount</b> value according to current stylus pressure"));
 
     liquifyReverseDirectionChk->setChecked(false);
     connect(liquifyReverseDirectionChk, SIGNAL(toggled(bool)), this, SLOT(liquifyReverseDirectionChanged(bool)));
     liquifyReverseDirectionChk->setToolTip(i18nc("@info:tooltip", "Reverse direction of the current deformation tool"));
 
     QSignalMapper *liquifyModeMapper = new QSignalMapper(this);
     connect(liquifyMove, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyScale, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyRotate, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyOffset, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyUndo, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     liquifyModeMapper->setMapping(liquifyMove, (int)KisLiquifyProperties::MOVE);
     liquifyModeMapper->setMapping(liquifyScale, (int)KisLiquifyProperties::SCALE);
     liquifyModeMapper->setMapping(liquifyRotate, (int)KisLiquifyProperties::ROTATE);
     liquifyModeMapper->setMapping(liquifyOffset, (int)KisLiquifyProperties::OFFSET);
     liquifyModeMapper->setMapping(liquifyUndo, (int)KisLiquifyProperties::UNDO);
     connect(liquifyModeMapper, SIGNAL(mapped(int)), SLOT(slotLiquifyModeChanged(int)));
 
     liquifyMove->setToolTip(i18nc("@info:tooltip", "Move: drag the image along the brush stroke"));
     liquifyScale->setToolTip(i18nc("@info:tooltip", "Scale: grow/shrink image under cursor"));
     liquifyRotate->setToolTip(i18nc("@info:tooltip", "Rotate: twirl image under cursor"));
     liquifyOffset->setToolTip(i18nc("@info:tooltip", "Offset: shift the image to the right of the stroke direction"));
     liquifyUndo->setToolTip(i18nc("@info:tooltip", "Undo: erase actions of other tools"));
 
     // Connect all edit boxes to the Editing Finished signal
     connect(densityBox, SIGNAL(editingFinished()), this, SLOT(notifyEditingFinished()));
 
 
 
     // Connect other widget (not having editingFinished signal) to
     // the same slot. From Qt 4.6 onwards the sequence of the signal
     // delivery is definite.
     connect(cmbFilter, SIGNAL(activated(const KoID &)), this, SLOT(notifyEditingFinished()));
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(notifyEditingFinished()));
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(notifyEditingFinished()));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(notifyEditingFinished()));
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
 
     // Liquify
     //
     // liquify brush options do not affect the image directly and are not
     // saved to undo, so we don't emit notifyEditingFinished() for them
 
     // Connect Apply/Reset buttons
     connect(buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(slotButtonBoxClicked(QAbstractButton *)));
 
     // Mode switch buttons
     connect(freeTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetFreeTransformModeButtonClicked(bool)));
     connect(warpButton, SIGNAL(clicked(bool)), this, SLOT(slotSetWarpModeButtonClicked(bool)));
     connect(cageButton, SIGNAL(clicked(bool)), this, SLOT(slotSetCageModeButtonClicked(bool)));
     connect(perspectiveTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetPerspectiveModeButtonClicked(bool)));
     connect(liquifyButton, SIGNAL(clicked(bool)), this, SLOT(slotSetLiquifyModeButtonClicked(bool)));
 
     // Connect Decorations switcher
     connect(showDecorationsBox, SIGNAL(toggled(bool)), canvas, SLOT(updateCanvas()));
 
     tooBigLabelWidget->hide();
 
     connect(canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), SLOT(slotUpdateIcons()), Qt::UniqueConnection);
     slotUpdateIcons();
 }
 
 void KisToolTransformConfigWidget::slotUpdateIcons()
 {
     freeTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_main"));
     warpButton->setIcon(KisIconUtils::loadIcon("transform_icons_warp"));
     cageButton->setIcon(KisIconUtils::loadIcon("transform_icons_cage"));
     perspectiveTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_perspective"));
     liquifyButton->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_main"));
 
     liquifyMove->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_move"));
     liquifyScale->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_resize"));
     liquifyRotate->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_rotate"));
     liquifyOffset->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_offset"));
     liquifyUndo->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_erase"));
 
 
 
     middleRightButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     topRightButton->setIcon(KisIconUtils::loadIcon("arrow-topright"));
     middleTopButton->setIcon(KisIconUtils::loadIcon("arrow-up"));
     topLeftButton->setIcon(KisIconUtils::loadIcon("arrow-topleft"));
     middleLeftButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     bottomLeftButton->setIcon(KisIconUtils::loadIcon("arrow-downleft"));
     middleBottomButton->setIcon(KisIconUtils::loadIcon("arrow-down"));
     bottomRightButton->setIcon(KisIconUtils::loadIcon("arrow-downright"));
 
     btnTransformAroundPivotPoint->setIcon(KisIconUtils::loadIcon("pivot-point"));
 
 
     // pressure icons
     liquifySizePressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     liquifyAmountPressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
 }
 
 double KisToolTransformConfigWidget::radianToDegree(double rad)
 {
     double piX2 = 2 * M_PI;
 
     if (rad < 0 || rad >= piX2) {
         rad = fmod(rad, piX2);
         if (rad < 0) {
             rad += piX2;
         }
     }
 
     return (rad * 360. / piX2);
 }
 
 double KisToolTransformConfigWidget::degreeToRadian(double degree)
 {
     if (degree < 0. || degree >= 360.) {
         degree = fmod(degree, 360.);
         if (degree < 0)
             degree += 360.;
     }
 
     return (degree * M_PI / 180.);
 }
 
 void KisToolTransformConfigWidget::updateLiquifyControls()
 {
     blockUiSlots();
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     const bool useWashMode = props->useWashMode();
 
     liquifySizeSlider->setValue(props->size());
     liquifyAmountSlider->setValue(props->amount());
     liquifyFlowSlider->setValue(props->flow());
     buidupModeComboBox->setCurrentIndex(useWashMode);
 
     liquifySpacingSlider->setValue(props->spacing());
     liquifySizePressureBox->setChecked(props->sizeHasPressure());
     liquifyAmountPressureBox->setChecked(props->amountHasPressure());
     liquifyReverseDirectionChk->setChecked(props->reverseDirection());
 
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(props->mode());
 
     bool canInverseDirection =
         mode != KisLiquifyProperties::UNDO;
 
     bool canUseWashMode = mode != KisLiquifyProperties::UNDO;
 
     liquifyReverseDirectionChk->setEnabled(canInverseDirection);
     liquifyFlowSlider->setEnabled(canUseWashMode && useWashMode);
     buidupModeComboBox->setEnabled(canUseWashMode);
 
     const qreal maxAmount = canUseWashMode ? 5.0 : 1.0;
     liquifyAmountSlider->setRange(0.0, maxAmount, 2);
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::slotLiquifyModeChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(value);
 
     if (mode == props->mode()) return;
 
     props->setMode(mode);
     props->loadMode();
 
     updateLiquifyControls();
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizeChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSize(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmount(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyFlowChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setFlow(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyBuildUpChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setUseWashMode(value); // 0 == build up mode / 1 == wash mode
 
     notifyConfigChanged();
 
     // we need to enable/disable flow slider
     updateLiquifyControls();
 }
 
 void KisToolTransformConfigWidget::liquifySpacingChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSpacing(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizePressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSizeHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountPressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmountHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyReverseDirectionChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setReverseDirection(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::updateConfig(const ToolTransformArgs &config)
 {
     blockUiSlots();
 
     if (config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
         config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) {
 
         quickTransformGroup->setEnabled(config.mode() == ToolTransformArgs::FREE_TRANSFORM);
 
         stackedWidget->setCurrentIndex(0);
 
         bool freeTransformIsActive = config.mode() == ToolTransformArgs::FREE_TRANSFORM;
 
         if (freeTransformIsActive)
         {
             freeTransformButton->setChecked(true);
         }
         else
         {
             perspectiveTransformButton->setChecked(true);
         }
 
         aXBox->setEnabled(freeTransformIsActive);
         aYBox->setEnabled(freeTransformIsActive);
         aZBox->setEnabled(freeTransformIsActive);
         freeRotationRadioButton->setEnabled(freeTransformIsActive);
 
         scaleXBox->setValue(config.scaleX() * 100.);
         scaleYBox->setValue(config.scaleY() * 100.);
         shearXBox->setValue(config.shearX());
         shearYBox->setValue(config.shearY());
 
         const QPointF anchorPoint = config.originalCenter() + config.rotationCenterOffset();
         const KisTransformUtils::MatricesPack m(config);
         const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
 
         translateXBox->setValue(anchorPointView.x());
         translateYBox->setValue(anchorPointView.y());
 
         aXBox->setValue(radianToDegree(config.aX()));
         aYBox->setValue(radianToDegree(config.aY()));
         aZBox->setValue(radianToDegree(config.aZ()));
         aspectButton->setKeepAspectRatio(config.keepAspectRatio());
         cmbFilter->setCurrent(config.filterId());
 
         QPointF pt = m_transaction->currentConfig()->rotationCenterOffset();
         pt.rx() /= m_transaction->originalHalfWidth();
         pt.ry() /= m_transaction->originalHalfHeight();
 
         for (int i = 0; i < 9; i++) {
             if (qFuzzyCompare(m_handleDir[i].x(), pt.x()) &&
                 qFuzzyCompare(m_handleDir[i].y(), pt.y())) {
 
                 m_rotationCenterButtons->button(i)->setChecked(true);
                 break;
             }
         }
 
         btnTransformAroundPivotPoint->setChecked(config.transformAroundRotationCenter());
 
     } else if (config.mode() == ToolTransformArgs::WARP) {
 
         stackedWidget->setCurrentIndex(1);
         warpButton->setChecked(true);
 
         if (config.defaultPoints()) {
             densityBox->setValue(std::sqrt(config.numPoints()));
         }
 
         cmbWarpType->setCurrentIndex((int)config.warpType());
         defaultRadioButton->setChecked(config.defaultPoints());
         customRadioButton->setChecked(!config.defaultPoints());
         densityBox->setEnabled(config.defaultPoints());
         customWarpWidget->setEnabled(!config.defaultPoints());
 
         updateLockPointsButtonCaption();
 
     } else if (config.mode() == ToolTransformArgs::CAGE) {
 
         // default UI options
         resetUIOptions();
 
         // we need at least 3 point before we can start actively deforming
         if (config.origPoints().size() >= 3)
         {
             cageTransformDirections->setText(i18n("Switch between editing and deforming cage"));
             cageAddEditRadio->setVisible(true);
             cageDeformRadio->setVisible(true);
 
             // update to correct radio button
             if (config.isEditingTransformPoints())
                 cageAddEditRadio->setChecked(true);
             else
                  cageDeformRadio->setChecked(true);
 
         }
 
     } else if (config.mode() == ToolTransformArgs::LIQUIFY) {
 
         stackedWidget->setCurrentIndex(3);
         liquifyButton->setChecked(true);
 
         const KisLiquifyProperties *props =
             config.liquifyProperties();
 
         switch (props->mode()) {
         case KisLiquifyProperties::MOVE:
             liquifyMove->setChecked(true);
             break;
         case KisLiquifyProperties::SCALE:
             liquifyScale->setChecked(true);
             break;
         case KisLiquifyProperties::ROTATE:
             liquifyRotate->setChecked(true);
             break;
         case KisLiquifyProperties::OFFSET:
             liquifyOffset->setChecked(true);
             break;
         case KisLiquifyProperties::UNDO:
             liquifyUndo->setChecked(true);
             break;
         case KisLiquifyProperties::N_MODES:
             qFatal("Unsupported mode");
         }
 
         updateLiquifyControls();
     }
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::updateLockPointsButtonCaption()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     if (config->isEditingTransformPoints()) {
         lockUnlockPointsButton->setText(i18n("Lock Points"));
     } else {
         lockUnlockPointsButton->setText(i18n("Unlock Points"));
     }
 }
 
 void KisToolTransformConfigWidget::setApplyResetDisabled(bool disabled)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     Q_ASSERT(applyButton);
     Q_ASSERT(resetButton);
 
     applyButton->setDisabled(disabled);
     resetButton->setDisabled(disabled);
 }
 
 void KisToolTransformConfigWidget::resetRotationCenterButtons()
 {
     int checkedId = m_rotationCenterButtons->checkedId();
 
     if (checkedId >= 0 && checkedId <= 8) {
         // uncheck the current checked button
         m_rotationCenterButtons->button(9)->setChecked(true);
     }
 }
 
 bool KisToolTransformConfigWidget::workRecursively() const
 {
     return chkWorkRecursively->isChecked();
 }
 
 void KisToolTransformConfigWidget::setTooBigLabelVisible(bool value)
 {
     tooBigLabelWidget->setVisible(value);
 }
 
 bool KisToolTransformConfigWidget::showDecorations() const
 {
     return showDecorationsBox->isChecked();
 }
 
 void KisToolTransformConfigWidget::blockNotifications()
 {
     m_notificationsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockNotifications()
 {
     m_notificationsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyConfigChanged()
 {
     if (!m_notificationsBlocked) {
         emit sigConfigChanged();
     }
     m_configChanged = true;
 }
 
 void KisToolTransformConfigWidget::blockUiSlots()
 {
     m_uiSlotsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockUiSlots()
 {
     m_uiSlotsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyEditingFinished()
 {
     if (m_uiSlotsBlocked || m_notificationsBlocked || !m_configChanged) return;
 
     emit sigEditingFinished();
     m_configChanged = false;
 }
 
 
 void KisToolTransformConfigWidget::resetUIOptions()
 {
     // reset tool states since we are done (probably can encapsulate this later)
     ToolTransformArgs *config = m_transaction->currentConfig();
     if (config->mode() == ToolTransformArgs::CAGE)
     {
         cageAddEditRadio->setVisible(false);
         cageAddEditRadio->setChecked(true);
         cageDeformRadio->setVisible(false);
         cageTransformDirections->setText(i18n("Create 3 points on the canvas to begin"));
 
         // ensure we are on the right options view
         stackedWidget->setCurrentIndex(2);
     }
 
 
 
 }
 
 void KisToolTransformConfigWidget::slotButtonBoxClicked(QAbstractButton *button)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     resetUIOptions();
 
     if (button == applyButton) {
         emit sigApplyTransform();
     }
     else if (button == resetButton) {
         emit sigResetTransform();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetFreeTransformModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(freeTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::FREE_TRANSFORM);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(warpButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::WARP);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetCageModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(cageButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::CAGE);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetLiquifyModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(liquifyButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::LIQUIFY);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetPerspectiveModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(perspectiveTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::PERSPECTIVE_4POINT);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotFilterChanged(const KoID &filterId)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setFilterId(filterId.id());
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotRotationCenterChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     if (index >= 0 && index <= 8) {
         ToolTransformArgs *config = m_transaction->currentConfig();
 
         double i = m_handleDir[index].x();
         double j = m_handleDir[index].y();
 
         config->setRotationCenterOffset(QPointF(i * m_transaction->originalHalfWidth(),
                                                 j * m_transaction->originalHalfHeight()));
 
         notifyConfigChanged();
         updateConfig(*config);
     }
 }
 
 void KisToolTransformConfigWidget::slotTransformAroundRotationCenter(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setTransformAroundRotationCenter(value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
 
         blockNotifications();
          int calculatedValue = int( value/ m_scaleRatio );
 
         scaleYBox->blockSignals(true);
         scaleYBox->setValue(calculatedValue);
         config->setScaleY(calculatedValue / 100.);
         scaleYBox->blockSignals(false);
 
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
         blockNotifications();
         int calculatedValue = int(m_scaleRatio * value);
         scaleXBox->blockSignals(true);
         scaleXBox->setValue(calculatedValue);
         config->setScaleX(calculatedValue / 100.);
         scaleXBox->blockSignals(false);
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearX((double)value);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearY((double)value);
     }
 
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(value, anchorPointView.y());
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(anchorPointView.x(), value);
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetAX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAX(degreeToRadian((double)value));
     }
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAY(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAZ(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipX()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(config->scaleX() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipY()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(config->scaleY() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() + M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() - M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 
 // change free transform setting we want to alter (all radio buttons call this)
 void KisToolTransformConfigWidget::slotTransformAreaVisible(bool value)
 {
     Q_UNUSED(value);
 
     //QCheckBox sender = (QCheckBox)(*)(QObject::sender());
     QString senderName = QObject::sender()->objectName();
 
 
     // only show setting with what we have selected
     rotationGroup->hide();
     shearGroup->hide();
     scaleGroup->hide();
     moveGroup->hide();
 
 
     if ("freeMoveRadioButton" == senderName)
     {
         moveGroup->show();
     }
     else  if ("freeShearRadioButton" == senderName)
     {
         shearGroup->show();
     }
     else if ("freeScaleRadioButton" == senderName)
     {
         scaleGroup->show();
     }
     else
     {
         rotationGroup->show();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetKeepAspectRatio(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setKeepAspectRatio(value);
 
     if (value) {
        blockNotifications();
        int tmpXScaleBox = scaleXBox->value();
        int tmpYScaleBox = scaleYBox->value();
        m_scaleRatio = (tmpXScaleBox / (double) tmpYScaleBox);
        unblockNotifications();
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpAlpha(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setAlpha((double)value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpDensity(int value)
 {
     if (m_uiSlotsBlocked) return;
     setDefaultWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::setDefaultWarpPoints(int pointsPerLine)
 {
     if (pointsPerLine < 0) {
         pointsPerLine = DEFAULT_POINTS_PER_LINE;
     }
 
     int nbPoints = pointsPerLine * pointsPerLine;
     QVector<QPointF> origPoints(nbPoints);
     QVector<QPointF> transfPoints(nbPoints);
     qreal gridSpaceX, gridSpaceY;
 
     if (nbPoints == 1) {
         //there is actually no grid
         origPoints[0] = m_transaction->originalCenterGeometric();
         transfPoints[0] = m_transaction->originalCenterGeometric();
     }
     else if (nbPoints > 1) {
         gridSpaceX = m_transaction->originalRect().width() / (pointsPerLine - 1);
         gridSpaceY = m_transaction->originalRect().height() / (pointsPerLine - 1);
         double y = m_transaction->originalRect().top();
         for (int i = 0; i < pointsPerLine; ++i) {
             double x = m_transaction->originalRect().left();
             for (int j = 0 ; j < pointsPerLine; ++j) {
                 origPoints[i * pointsPerLine + j] = QPointF(x, y);
                 transfPoints[i * pointsPerLine + j] = QPointF(x, y);
                 x += gridSpaceX;
             }
             y += gridSpaceY;
         }
     }
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setDefaultPoints(nbPoints > 0);
     config->setPoints(origPoints, transfPoints);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::activateCustomWarpPoints(bool enabled)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     densityBox->setEnabled(!enabled);
     customWarpWidget->setEnabled(enabled);
 
     if (!enabled) {
         config->setEditingTransformPoints(false);
         setDefaultWarpPoints(densityBox->value());
     } else {
         config->setEditingTransformPoints(true);
         setDefaultWarpPoints(0);
     }
 
     updateLockPointsButtonCaption();
 }
 
 void KisToolTransformConfigWidget::slotWarpDefaultPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(!value);
 }
 
 void KisToolTransformConfigWidget::slotWarpCustomPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::slotWarpResetPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(true);
 }
 
 void KisToolTransformConfigWidget::slotWarpLockPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setEditingTransformPoints(!config->isEditingTransformPoints());
 
     if (config->isEditingTransformPoints()) {
         // reinit the transf points to their original value
         ToolTransformArgs *config = m_transaction->currentConfig();
         int nbPoints = config->origPoints().size();
         for (int i = 0; i < nbPoints; ++i) {
             config->transfPoint(i) = config->origPoint(i);
         }
     }
 
     updateLockPointsButtonCaption();
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotWarpTypeChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     switch (index) {
     case KisWarpTransformWorker::AFFINE_TRANSFORM:
     case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
     case KisWarpTransformWorker::RIGID_TRANSFORM:
         config->setWarpType((KisWarpTransformWorker::WarpType)index);
         break;
     default:
         config->setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
         break;
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotCageOptionsChanged(int value)
 {
     if ( value == 0)
     {
         slotEditCagePoints(true);
     }
     else
     {
         slotEditCagePoints(false);
     }
 
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotEditCagePoints(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->refTransformedPoints() = config->origPoints();
 
     config->setEditingTransformPoints(value);
     notifyConfigChanged();
 }