diff --git a/libs/pigment/KoColorDisplayRendererInterface.cpp b/libs/pigment/KoColorDisplayRendererInterface.cpp
index a0b42b10b7..fb6b0a9165 100644
--- a/libs/pigment/KoColorDisplayRendererInterface.cpp
+++ b/libs/pigment/KoColorDisplayRendererInterface.cpp
@@ -1,80 +1,85 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoColorDisplayRendererInterface.h"
 
 #include <QGlobalStatic>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoChannelInfo.h>
 
 Q_GLOBAL_STATIC(KoDumbColorDisplayRenderer, s_instance)
 
 KoColorDisplayRendererInterface::KoColorDisplayRendererInterface()
 {
 }
 
 KoColorDisplayRendererInterface::~KoColorDisplayRendererInterface()
 {
 }
 
 QColor KoDumbColorDisplayRenderer::toQColor(const KoColor &c) const
 {
     return c.toQColor();
 }
 
 KoColor KoDumbColorDisplayRenderer::approximateFromRenderedQColor(const QColor &c) const
 {
     KoColor color;
     color.fromQColor(c);
     return color;
 }
 
 KoColor KoDumbColorDisplayRenderer::fromHsv(int h, int s, int v, int a) const
 {
     h = qBound(0, h, 359);
     s = qBound(0, s, 255);
     v = qBound(0, v, 255);
     a = qBound(0, a, 255);
     QColor qcolor(QColor::fromHsv(h, s, v, a));
     return KoColor(qcolor, KoColorSpaceRegistry::instance()->rgb8());
 }
 
 void KoDumbColorDisplayRenderer::getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const
 {
     QColor qcolor = toQColor(srcColor);
     qcolor.getHsv(h, s, v, a);
 }
 
 KoColorDisplayRendererInterface* KoDumbColorDisplayRenderer::instance()
 {
     return s_instance;
 }
 
 qreal KoDumbColorDisplayRenderer::minVisibleFloatValue(const KoChannelInfo *chaninfo) const
 {
     Q_ASSERT(chaninfo);
     return chaninfo->getUIMin();
 }
 
 qreal KoDumbColorDisplayRenderer::maxVisibleFloatValue(const KoChannelInfo *chaninfo) const
 {
     Q_ASSERT(chaninfo);
     return chaninfo->getUIMax();
 }
+
+const KoColorSpace* KoDumbColorDisplayRenderer::getPaintingColorSpace() const
+{
+    return KoColorSpaceRegistry::instance()->rgb8();
+}
diff --git a/libs/pigment/KoColorDisplayRendererInterface.h b/libs/pigment/KoColorDisplayRendererInterface.h
index e52e01fd80..2e974767cc 100644
--- a/libs/pigment/KoColorDisplayRendererInterface.h
+++ b/libs/pigment/KoColorDisplayRendererInterface.h
@@ -1,109 +1,117 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KO_COLOR_DISPLAY_RENDERER_INTERFACE_H
 #define __KO_COLOR_DISPLAY_RENDERER_INTERFACE_H
 
 #include <QObject>
 #include <QColor>
 #include <QSharedPointer>
 
 #include "KoColor.h"
 
 class KoChannelInfo;
 
 /**
  * A special interface class provided by pigment to let widgets render
  * a KoColor on screen using custom profiling provided by the user.
  *
  * If you want to provide your own rendering of the KoColor on screen,
  * reimplement this class and provide its instance to a supporting
  * widget.
  */
 class KRITAPIGMENT_EXPORT KoColorDisplayRendererInterface : public QObject
 {
     Q_OBJECT
 
 public:
     KoColorDisplayRendererInterface();
     virtual ~KoColorDisplayRendererInterface();
 
     /**
      * Convert the color \p c to a custom QColor that will be
      * displayed by the widget on screen. Please note, that the
      * reverse conversion may simply not exist.
      */
     virtual QColor toQColor(const KoColor &c) const = 0;
 
     /**
      * This tries to approximate a rendered QColor into the KoColor
      * of the painting color space. Please note, that in most of the
      * cases the exact reverse transformation does not exist, so the
      * resulting color will be only a rough approximation. Never try
      * to do a round trip like that:
      *
      * // r will never be equal to c!
      * r = approximateFromRenderedQColor(toQColor(c));
      */
     virtual KoColor approximateFromRenderedQColor(const QColor &c) const = 0;
 
     virtual KoColor fromHsv(int h, int s, int v, int a = 255) const = 0;
     virtual void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a = 0) const = 0;
 
 
     /**
      * \return the minimum value of a floating point channel that can
      *         be seen on screen
      */
     virtual qreal minVisibleFloatValue(const KoChannelInfo *chaninfo) const = 0;
 
     /**
      * \return the maximum value of a floating point channel that can
      *         be seen on screen. In normal situation it is 1.0. When
      *         the user changes exposure the value varies.
      */
     virtual qreal maxVisibleFloatValue(const KoChannelInfo *chaninfo) const = 0;
 
+    /**
+     * @brief getColorSpace
+     * @return the painting color space, this is useful for determining the transform.
+     */
+    virtual const KoColorSpace* getPaintingColorSpace() const = 0;
+
 Q_SIGNALS:
     void displayConfigurationChanged();
 
 private:
     Q_DISABLE_COPY(KoColorDisplayRendererInterface)
 };
 
 /**
  * The default conversion class that just calls KoColor::toQColor()
  * conversion implementation which efectively renders the color into
  * sRGB color space.
  */
 class KRITAPIGMENT_EXPORT KoDumbColorDisplayRenderer : public KoColorDisplayRendererInterface
 {
 public:
     QColor toQColor(const KoColor &c) const;
     KoColor approximateFromRenderedQColor(const QColor &c) const;
     KoColor fromHsv(int h, int s, int v, int a = 255) const;
     void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a = 0) const;
 
     virtual qreal minVisibleFloatValue(const KoChannelInfo *chaninfo) const;
     virtual qreal maxVisibleFloatValue(const KoChannelInfo *chaninfo) const;
 
+    virtual const KoColorSpace* getPaintingColorSpace() const;
+
     static KoColorDisplayRendererInterface* instance();
 };
 
 #endif /* __KO_COLOR_DISPLAY_RENDERER_INTERFACE_H */
diff --git a/libs/ui/canvas/kis_display_color_converter.cpp b/libs/ui/canvas/kis_display_color_converter.cpp
index 5fd4b32693..a9188d3a66 100644
--- a/libs/ui/canvas/kis_display_color_converter.cpp
+++ b/libs/ui/canvas/kis_display_color_converter.cpp
@@ -1,632 +1,636 @@
 /*
  *  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.
  */
 
 #include "kis_display_color_converter.h"
 
 #include <QGlobalStatic>
 #include <QPointer>
 
 #include <KoColor.h>
 #include <KoColorDisplayRendererInterface.h>
 #include <KoColorSpaceMaths.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorConversions.h>
 
 #include <KoCanvasResourceManager.h>
 #include "kis_config_notifier.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_image.h"
 #include "kis_node.h"
 
 #include "kundo2command.h"
 #include "kis_config.h"
 #include "kis_paint_device.h"
 #include "kis_iterator_ng.h"
 
 Q_GLOBAL_STATIC(KisDisplayColorConverter, s_instance)
 
 
 struct KisDisplayColorConverter::Private
 {
     Private(KisDisplayColorConverter *_q, KoCanvasResourceManager *_resourceManager)
         : q(_q),
           resourceManager(_resourceManager),
           nodeColorSpace(0),
           paintingColorSpace(0),
           monitorColorSpace(0),
           monitorProfile(0),
           renderingIntent(KoColorConversionTransformation::internalRenderingIntent()),
           conversionFlags(KoColorConversionTransformation::internalConversionFlags()),
           displayFilter(0),
           intermediateColorSpace(0),
           displayRenderer(new DisplayRenderer(_q, _resourceManager))
     {
     }
 
     KisDisplayColorConverter *const q;
 
     KoCanvasResourceManager *resourceManager;
 
     const KoColorSpace *nodeColorSpace;
     const KoColorSpace *paintingColorSpace;
     const KoColorSpace *monitorColorSpace;
 
     const KoColorProfile *monitorProfile;
 
     KoColorConversionTransformation::Intent renderingIntent;
     KoColorConversionTransformation::ConversionFlags conversionFlags;
 
     KisDisplayFilter *displayFilter;
     const KoColorSpace *intermediateColorSpace;
 
     KoColor intermediateFgColor;
     KisNodeSP connectedNode;
 
     inline KoColor approximateFromQColor(const QColor &qcolor);
     inline QColor approximateToQColor(const KoColor &color);
 
     void slotCanvasResourceChanged(int key, const QVariant &v);
     void slotUpdateCurrentNodeColorSpace();
     void selectPaintingColorSpace();
 
     void updateIntermediateFgColor(const KoColor &color);
     void setCurrentNode(KisNodeSP node);
     bool useOcio() const;
 
     bool finalIsRgba(const KoColorSpace *cs) const;
 
     template <bool flipToBgra>
     QColor floatArrayToQColor(const float *p);
 
     template <bool flipToBgra>
     QImage convertToQImageDirect(KisPaintDeviceSP device);
 
     class DisplayRenderer : public KoColorDisplayRendererInterface {
     public:
         DisplayRenderer(KisDisplayColorConverter *parent, KoCanvasResourceManager *resourceManager)
             : m_parent(parent),
               m_resourceManager(resourceManager)
         {
             parent->connect(parent, SIGNAL(displayConfigurationChanged()),
                             this, SIGNAL(displayConfigurationChanged()));
         }
 
         QColor toQColor(const KoColor &c) const {
             return m_parent->toQColor(c);
         }
 
         KoColor approximateFromRenderedQColor(const QColor &c) const {
             return m_parent->approximateFromRenderedQColor(c);
         }
 
         KoColor fromHsv(int h, int s, int v, int a) const {
             return m_parent->fromHsv(h, s, v, a);
         }
 
         void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const {
             m_parent->getHsv(srcColor, h, s, v, a);
         }
 
         virtual qreal minVisibleFloatValue(const KoChannelInfo *chaninfo) const {
             return chaninfo->getUIMin();
         }
 
         virtual qreal maxVisibleFloatValue(const KoChannelInfo *chaninfo) const {
             qreal maxValue = chaninfo->getUIMax();
 
             if (m_resourceManager) {
                 qreal exposure = m_resourceManager->resource(KisCanvasResourceProvider::HdrExposure).value<qreal>();
                 // not sure if *= is what we want
                 maxValue *= std::pow(2.0, -exposure);
             }
 
             return maxValue;
         }
 
+        virtual const KoColorSpace* getPaintingColorSpace() const {
+            return m_parent->paintingColorSpace();
+        }
+
     private:
         KisDisplayColorConverter *m_parent;
         QPointer<KoCanvasResourceManager> m_resourceManager;
     };
 
     QScopedPointer<KoColorDisplayRendererInterface> displayRenderer;
 };
 
 KisDisplayColorConverter::KisDisplayColorConverter(KoCanvasResourceManager *resourceManager, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, resourceManager))
 {
 
     connect(m_d->resourceManager, SIGNAL(canvasResourceChanged(int, const QVariant&)),
             SLOT(slotCanvasResourceChanged(int, const QVariant&)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(selectPaintingColorSpace()));
 
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
     setDisplayFilter(0);
 }
 
 KisDisplayColorConverter::KisDisplayColorConverter()
     : m_d(new Private(this, 0))
 {
     setDisplayFilter(0);
     delete m_d->displayFilter;
 
     m_d->paintingColorSpace = KoColorSpaceRegistry::instance()->rgb8();
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
 
 }
 
 KisDisplayColorConverter::~KisDisplayColorConverter()
 {
 }
 
 KisDisplayColorConverter* KisDisplayColorConverter::dumbConverterInstance()
 {
     return s_instance;
 }
 
 KoColorDisplayRendererInterface* KisDisplayColorConverter::displayRendererInterface() const
 {
     return m_d->displayRenderer.data();
 }
 
 bool KisDisplayColorConverter::Private::useOcio() const
 {
     return displayFilter && paintingColorSpace->colorModelId() == RGBAColorModelID;
 }
 
 void KisDisplayColorConverter::Private::updateIntermediateFgColor(const KoColor &srcColor)
 {
     KIS_ASSERT_RECOVER_RETURN(displayFilter);
 
     KoColor color = srcColor;
     color.convertTo(intermediateColorSpace);
     displayFilter->approximateForwardTransformation(color.data(), 1);
     intermediateFgColor = color;
 }
 
 void KisDisplayColorConverter::Private::slotCanvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KisCanvasResourceProvider::CurrentKritaNode) {
         KisNodeSP currentNode = v.value<KisNodeWSP>();
         setCurrentNode(currentNode);
     } else if (useOcio() && key == KoCanvasResourceManager::ForegroundColor) {
         updateIntermediateFgColor(v.value<KoColor>());
     }
 }
 
 void KisDisplayColorConverter::Private::slotUpdateCurrentNodeColorSpace()
 {
     setCurrentNode(connectedNode);
 }
 
 inline KisPaintDeviceSP findValidDevice(KisNodeSP node) {
     return node->paintDevice() ? node->paintDevice() : node->original();
 }
 
 void KisDisplayColorConverter::Private::setCurrentNode(KisNodeSP node)
 {
     if (connectedNode) {
         KisPaintDeviceSP device = findValidDevice(connectedNode);
 
         if (device) {
             q->disconnect(device, 0);
         }
     }
 
     if (node) {
         KisPaintDeviceSP device = findValidDevice(node);
 
         nodeColorSpace = device ?
             device->compositionSourceColorSpace() :
             node->colorSpace();
 
         KIS_ASSERT_RECOVER_NOOP(nodeColorSpace);
 
         if (device) {
             q->connect(device, SIGNAL(profileChanged(const KoColorProfile*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
             q->connect(device, SIGNAL(colorSpaceChanged(const KoColorSpace*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
         }
 
     } else {
         nodeColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     }
 
     connectedNode = node;
     selectPaintingColorSpace();
 }
 
 void KisDisplayColorConverter::Private::selectPaintingColorSpace()
 {
     KisConfig cfg;
     paintingColorSpace = cfg.customColorSelectorColorSpace();
 
     if (!paintingColorSpace || displayFilter) {
         paintingColorSpace = nodeColorSpace;
     }
 
     emit q->displayConfigurationChanged();
 }
 
 const KoColorSpace* KisDisplayColorConverter::paintingColorSpace() const
 {
     KIS_ASSERT_RECOVER(m_d->paintingColorSpace) {
         return KoColorSpaceRegistry::instance()->rgb8();
     }
 
     return m_d->paintingColorSpace;
 }
 
 void KisDisplayColorConverter::setMonitorProfile(const KoColorProfile *monitorProfile)
 {
     m_d->monitorColorSpace = KoColorSpaceRegistry::instance()->rgb8(monitorProfile);
     m_d->monitorProfile = monitorProfile;
 
     m_d->renderingIntent = renderingIntent();
     m_d->conversionFlags = conversionFlags();
 
     emit displayConfigurationChanged();
 }
 
 void KisDisplayColorConverter::setDisplayFilter(KisDisplayFilter *displayFilter)
 {
     if (m_d->displayFilter && displayFilter &&
         displayFilter->lockCurrentColorVisualRepresentation()) {
 
         KoColor color(m_d->intermediateFgColor);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(m_d->paintingColorSpace);
         m_d->resourceManager->setForegroundColor(color);
     }
 
     m_d->displayFilter = displayFilter;
     m_d->intermediateColorSpace = 0;
 
     if (m_d->displayFilter) {
         // choosing default profile, which is scRGB
         const KoColorProfile *intermediateProfile = 0;
         m_d->intermediateColorSpace =
             KoColorSpaceRegistry::instance()->
             colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), intermediateProfile);
 
         KIS_ASSERT_RECOVER(m_d->intermediateColorSpace) {
             m_d->intermediateColorSpace = m_d->monitorColorSpace;
         }
 
         m_d->updateIntermediateFgColor(
             m_d->resourceManager->foregroundColor());
     }
 
 
     { // sanity check
         KisConfig cfg;
         //KIS_ASSERT_RECOVER_NOOP(cfg.useOcio() == (bool) m_d->displayFilter);
     }
 
     m_d->selectPaintingColorSpace();
 }
 
 
 KoColorConversionTransformation::Intent
 KisDisplayColorConverter::renderingIntent()
 {
     KisConfig cfg;
     return (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 }
 
 KoColorConversionTransformation::ConversionFlags
 KisDisplayColorConverter::conversionFlags()
 {
     KoColorConversionTransformation::ConversionFlags conversionFlags =
         KoColorConversionTransformation::HighQuality;
 
     KisConfig cfg;
 
     if (cfg.useBlackPointCompensation()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
 
     return conversionFlags;
 }
 
 KisDisplayFilter *KisDisplayColorConverter::displayFilter() const
 {
     return m_d->displayFilter;
 }
 
 const KoColorProfile* KisDisplayColorConverter::monitorProfile() const
 {
     return m_d->monitorProfile;
 }
 
 bool KisDisplayColorConverter::Private::finalIsRgba(const KoColorSpace *cs) const
 {
     /**
      * In Krita RGB color spaces differ: 8/16bit are BGRA, 16f/32f-bit RGBA
      */
     KoID colorDepthId = cs->colorDepthId();
     return colorDepthId == Float16BitsColorDepthID ||
         colorDepthId == Float32BitsColorDepthID;
 }
 
 template <bool flipToBgra>
 QColor KisDisplayColorConverter::Private::floatArrayToQColor(const float *p) {
     if (flipToBgra) {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     } else {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     }
 }
 
 QColor KisDisplayColorConverter::toQColor(const KoColor &srcColor) const
 {
     KoColor c(srcColor);
     c.convertTo(m_d->paintingColorSpace);
 
     if (!m_d->useOcio()) {
         // we expect the display profile is rgb8, which is BGRA here
         KIS_ASSERT_RECOVER(m_d->monitorColorSpace->pixelSize() == 4) { return Qt::red; };
 
         c.convertTo(m_d->monitorColorSpace, m_d->renderingIntent, m_d->conversionFlags);
 
         const quint8 *p = c.data();
         return QColor(p[2], p[1], p[0], p[3]);
     } else {
         const KoColorSpace *srcCS = c.colorSpace();
 
         if (m_d->displayFilter->useInternalColorManagement()) {
             srcCS = KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Float32BitsColorDepthID.id(),
                 m_d->monitorProfile);
             c.convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
         }
 
         int numChannels = srcCS->channelCount();
         QVector<float> normalizedChannels(numChannels);
         srcCS->normalisedChannelsValue(c.data(), normalizedChannels);
         m_d->displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = (const float *)normalizedChannels.constData();
 
         return m_d->finalIsRgba(srcCS) ?
             m_d->floatArrayToQColor<true>(p) :
             m_d->floatArrayToQColor<false>(p);
     }
 }
 
 KoColor KisDisplayColorConverter::approximateFromRenderedQColor(const QColor &c) const
 {
     return m_d->approximateFromQColor(c);
 }
 
 template <bool flipToBgra>
 QImage
 KisDisplayColorConverter::Private::convertToQImageDirect(KisPaintDeviceSP device)
 {
     QRect bounds = device->exactBounds();
     if (bounds.isEmpty()) return QImage();
 
     QImage image(bounds.size(), QImage::Format_ARGB32);
 
     KisSequentialConstIterator it(device, bounds);
     quint8 *dstPtr = image.bits();
 
     const KoColorSpace *cs = device->colorSpace();
     int numChannels = cs->channelCount();
     QVector<float> normalizedChannels(numChannels);
 
     do {
         cs->normalisedChannelsValue(it.rawDataConst(), normalizedChannels);
         displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = normalizedChannels.constData();
 
         if (flipToBgra) {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         } else {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         }
 
         dstPtr += 4;
     } while (it.nextPixel());
 
     return image;
 }
 
 QImage KisDisplayColorConverter::toQImage(KisPaintDeviceSP srcDevice) const
 {
     KisPaintDeviceSP device = srcDevice;
     if (!(*device->colorSpace() == *m_d->paintingColorSpace)) {
         device = new KisPaintDevice(*srcDevice);
 
         KUndo2Command *cmd = device->convertTo(m_d->paintingColorSpace);
         delete cmd;
     }
 
     if (!m_d->useOcio()) {
         return device->convertToQImage(m_d->monitorProfile, m_d->renderingIntent, m_d->conversionFlags);
     } else {
         if (m_d->displayFilter->useInternalColorManagement()) {
             if (device == srcDevice) {
                 device = new KisPaintDevice(*srcDevice);
             }
 
             const KoColorSpace *srcCS =
                 KoColorSpaceRegistry::instance()->colorSpace(
                     RGBAColorModelID.id(),
                     Float32BitsColorDepthID.id(),
                     m_d->monitorProfile);
 
             KUndo2Command *cmd = device->convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
             delete cmd;
         }
 
         return m_d->finalIsRgba(device->colorSpace()) ?
             m_d->convertToQImageDirect<true>(device) :
             m_d->convertToQImageDirect<false>(device);
     }
 
     return QImage();
 }
 
 KoColor KisDisplayColorConverter::Private::approximateFromQColor(const QColor &qcolor)
 {
     if (!useOcio()) {
         return KoColor(qcolor, paintingColorSpace);
     } else {
         KoColor color(qcolor, intermediateColorSpace);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(paintingColorSpace);
         return color;
     }
 
     qFatal("Must not be reachable");
     return KoColor();
 }
 
 QColor KisDisplayColorConverter::Private::approximateToQColor(const KoColor &srcColor)
 {
     KoColor color(srcColor);
 
     if (useOcio()) {
         color.convertTo(intermediateColorSpace);
         displayFilter->approximateForwardTransformation(color.data(), 1);
     }
 
     return color.toQColor();
 }
 
 
 KoColor KisDisplayColorConverter::fromHsv(int h, int s, int v, int a) const
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsv(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsv(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsvF(qreal h, qreal s, qreal v, qreal a)
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsvF(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsvF(const KoColor &srcColor, qreal *h, qreal *s, qreal *v, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsvF(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHslF(qreal h, qreal s, qreal l, qreal a)
 {
     // generate HSL from sRGB!
     QColor qcolor(QColor::fromHslF(h, s, l, a));
     if (!qcolor.isValid()) {
         warnKrita << "Could not construct valid color from h" << h << "s" << s << "l" << l << "a" << a;
         qcolor = Qt::black;
     }
     return m_d->approximateFromQColor(qcolor);
 
 }
 
 void KisDisplayColorConverter::getHslF(const KoColor &srcColor, qreal *h, qreal *s, qreal *l, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHslF(h, s, l, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsiF(qreal h, qreal s, qreal i)
 {
     // generate HSI from sRGB!
     qreal r=0.0;
     qreal g=0.0;
     qreal b=0.0;
     qreal a=1.0;
     HSIToRGB(h, s, i, &r, &g, &b);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,r,1.0), qBound(0.0,g,1.0), qBound(0.0,b,1.0), a);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsiF(const KoColor &srcColor, qreal *h, qreal *s, qreal *i)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     qreal r=color.redF();
     qreal g=color.greenF();
     qreal b=color.blueF();
     RGBToHSI(r, g, b, h, s, i);
 }
 
 KoColor KisDisplayColorConverter::fromHsyF(qreal h, qreal s, qreal y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // generate HSL from sRGB!
     QVector <qreal> channelValues(3);
     y = pow(y, gamma);
     HSYToRGB(h, s, y, &channelValues[0], &channelValues[1], &channelValues[2], R, G, B);
     KoColorSpaceRegistry::instance()->rgb8()->profile()->delinearizeFloatValueFast(channelValues);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,channelValues[0],1.0), qBound(0.0,channelValues[1],1.0), qBound(0.0,channelValues[2],1.0), 1.0);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsyF(const KoColor &srcColor, qreal *h, qreal *s, qreal *y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     QVector <qreal> channelValues(3);
     channelValues[0]=color.redF();
     channelValues[1]=color.greenF();
     channelValues[2]=color.blueF();
     //TODO: if we're going to have KoColor here, remember to check whether the TRC of the profile exists...
     KoColorSpaceRegistry::instance()->rgb8()->profile()->linearizeFloatValueFast(channelValues);
     RGBToHSY(channelValues[0], channelValues[1], channelValues[2], h, s, y, R, G, B);
     *y = pow(*y, 1/gamma);
 }
 
 #include "moc_kis_display_color_converter.cpp"
diff --git a/libs/ui/widgets/kis_visual_color_selector.cpp b/libs/ui/widgets/kis_visual_color_selector.cpp
index 083e536473..5121332e71 100644
--- a/libs/ui/widgets/kis_visual_color_selector.cpp
+++ b/libs/ui/widgets/kis_visual_color_selector.cpp
@@ -1,657 +1,659 @@
 /*
  * Copyright (C) Wolthera van Hovell tot Westerflier <griffinvalley@gmail.com>, (C) 2016
  *
  *  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_visual_color_selector.h"
 
 #include <QColor>
 #include <QPixmap>
 #include <QPainter>
 #include <QPainterPath>
 #include <QRect>
 #include <QVector>
 #include <QVBoxLayout>
 #include <QList>
 
 #include "KoColorConversions.h"
 #include "KoColorDisplayRendererInterface.h"
 #include "KoChannelInfo.h"
 #include <QPointer>
 #include "kis_signal_compressor.h"
 
 struct KisVisualColorSelector::Private
 {
     KoColor currentcolor;
     const KoColorSpace *currentCS;
     QList <KisVisualColorSelectorShape*> widgetlist;
     bool updateSelf = false;
     const KoColorDisplayRendererInterface *displayRenderer = 0;
     //Current coordinates.
     QVector <float> currentCoordinates;
 };
 
 KisVisualColorSelector::KisVisualColorSelector(QWidget *parent) : QWidget(parent), m_d(new Private)
 {
 
     QVBoxLayout *layout = new QVBoxLayout;
     this->setLayout(layout);
     //m_d->updateSelf = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this);
 }
 
 KisVisualColorSelector::~KisVisualColorSelector()
 {
 
 }
 
 void KisVisualColorSelector::slotSetColor(KoColor c)
 {
     if (m_d->updateSelf==false) {
         m_d->currentcolor = c;
         if (m_d->currentCS != c.colorSpace()) {
             slotsetColorSpace(c.colorSpace());
         }
     }
     updateSelectorElements();
 }
 
 void KisVisualColorSelector::slotsetColorSpace(const KoColorSpace *cs)
 {
     if (m_d->currentCS != cs)
     {
         m_d->currentCS = cs;
         if (this->layout()) {
             qDeleteAll(this->children());
         }
         m_d->widgetlist.clear();
         QHBoxLayout *layout = new QHBoxLayout;
         //redraw all the widgets.
         if (m_d->currentCS->colorChannelCount() == 1) {
             KisVisualRectangleSelectorShape *bar =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::onedimensional,KisVisualColorSelectorShape::Channel, cs, 0, 0);
             bar->setMaximumWidth(width()*0.1);
             bar->setMaximumHeight(height());
             connect (bar, SIGNAL(sigNewColor(KoColor)), this, SLOT(updateFromWidgets(KoColor)));
             layout->addWidget(bar);
             m_d->widgetlist.append(bar);
         } else if (m_d->currentCS->colorChannelCount() == 3) {
             KisVisualRectangleSelectorShape *bar =  new KisVisualRectangleSelectorShape(this,
                                                                                         KisVisualRectangleSelectorShape::onedimensional,
                                                                                         KisVisualColorSelectorShape::HSL,
                                                                                         cs, 0, 0,
                                                                                         m_d->displayRenderer);
             KisVisualRectangleSelectorShape *block =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional,
                                                                                           KisVisualColorSelectorShape::HSL,
                                                                                           cs, 1, 2,
                                                                                           m_d->displayRenderer);
             bar->setMaximumWidth(width()*0.1);
             bar->setMaximumHeight(height());
             block->setMaximumWidth(width()*0.9);
             block->setMaximumHeight(height());
             bar->setColor(m_d->currentcolor);
             block->setColor(m_d->currentcolor);
             connect (bar, SIGNAL(sigNewColor(KoColor)), block, SLOT(setColorFromSibling(KoColor)));
             connect (block, SIGNAL(sigNewColor(KoColor)), SLOT(updateFromWidgets(KoColor)));
             layout->addWidget(bar);
             layout->addWidget(block);
             m_d->widgetlist.append(bar);
             m_d->widgetlist.append(block);
         } else if (m_d->currentCS->colorChannelCount() == 4) {
             KisVisualRectangleSelectorShape *block =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional,KisVisualColorSelectorShape::Channel, cs, 0, 1);
             KisVisualRectangleSelectorShape *block2 =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional,KisVisualColorSelectorShape::Channel, cs, 2, 3);
             block->setMaximumWidth(width()*0.5);
             block->setMaximumHeight(height());
             block2->setMaximumWidth(width()*0.5);
             block2->setMaximumHeight(height());
             block->setColor(m_d->currentcolor);
             block2->setColor(m_d->currentcolor);
             connect (block, SIGNAL(sigNewColor(KoColor)), block2, SLOT(setColorFromSibling(KoColor)));
             connect (block2, SIGNAL(sigNewColor(KoColor)), SLOT(updateFromWidgets(KoColor)));
             layout->addWidget(block);
             layout->addWidget(block2);
             m_d->widgetlist.append(block);
             m_d->widgetlist.append(block2);
         }
         this->setLayout(layout);
     }
 
 }
 
 
 void KisVisualColorSelector::setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer) {
     m_d->displayRenderer = displayRenderer;
     if (m_d->widgetlist.size()>0) {
         Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
             shape->setDisplayRenderer(displayRenderer);
         }
     }
 }
 
 void KisVisualColorSelector::updateSelectorElements()
 {
     //first lock all elements from sending updates, then update all elements.
     Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
         shape->blockSignals(true);
     }
 
     Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
         if (m_d->updateSelf==false) {
             shape->setColor(m_d->currentcolor);
         } else {
             shape->setColorFromSibling(m_d->currentcolor);
         }
     }
     Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
         shape->blockSignals(false);
     }
 
 }
 
 void KisVisualColorSelector::updateFromWidgets(KoColor c)
 {
     m_d->currentcolor = c;
     Q_EMIT sigNewColor(c);
     m_d->updateSelf = true;
 }
 
 void KisVisualColorSelector::leaveEvent(QEvent *)
 {
     m_d->updateSelf = false;
 }
 
 /*------------Selector shape------------*/
 struct KisVisualColorSelectorShape::Private
 {
     QPixmap gradient;
     QPixmap fullSelector;
     bool pixmapsNeedUpdate = true;
     QPointF currentCoordinates;
     Dimensions dimension;
     ColorModel model;
     const KoColorSpace *cs;
     KoColor currentColor;
     int channel1;
     int channel2;
     KisSignalCompressor *updateTimer;
     bool mousePressActive = false;
     const KoColorDisplayRendererInterface *displayRenderer = 0;
 };
 
 KisVisualColorSelectorShape::KisVisualColorSelectorShape(QWidget *parent,
                                                          KisVisualColorSelectorShape::Dimensions dimension,
                                                          KisVisualColorSelectorShape::ColorModel model,
                                                          const KoColorSpace *cs,
                                                          int channel1,
                                                          int channel2,
                                                          const KoColorDisplayRendererInterface *displayRenderer): QWidget(parent), m_d(new Private)
 {
     m_d->dimension = dimension;
     m_d->model = model;
     m_d->cs = cs;
     m_d->currentColor = KoColor();
     m_d->currentColor.setOpacity(1.0);
     m_d->currentColor.convertTo(cs);
     int maxchannel = m_d->cs->colorChannelCount()-1;
     m_d->channel1 = qBound(0, channel1, maxchannel);
     m_d->channel2 = qBound(0, channel2, maxchannel);
     this->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     m_d->updateTimer = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this);
     if (displayRenderer) {
         m_d->displayRenderer = displayRenderer;
         connect(m_d->displayRenderer, SIGNAL(displayConfigurationChanged()), this, SLOT(update()), Qt::UniqueConnection);
     } else {
         KoDumbColorDisplayRenderer::instance();
     }
 
 }
 
 KisVisualColorSelectorShape::~KisVisualColorSelectorShape()
 {
 
 }
 
 void KisVisualColorSelectorShape::updateCursor()
 {
     QPointF point1 = convertKoColorToShapeCoordinate(m_d->currentColor);
     if (point1 != m_d->currentCoordinates) {
         m_d->currentCoordinates = point1;
     }
 }
 
 QPointF KisVisualColorSelectorShape::getCursorPosition() {
     return m_d->currentCoordinates;
 }
 
 void KisVisualColorSelectorShape::setColor(KoColor c)
 {
     if (c.colorSpace() != m_d->cs) {
         c.convertTo(m_d->cs);
     }
     m_d->currentColor = c;
     updateCursor();
     m_d->pixmapsNeedUpdate = true;
     update();
 }
 
 void KisVisualColorSelectorShape::setColorFromSibling(KoColor c)
 {
     if (c.colorSpace() != m_d->cs) {
         c.convertTo(m_d->cs);
     }
     m_d->currentColor = c;
     Q_EMIT sigNewColor(c);
     m_d->pixmapsNeedUpdate = true;
     update();
 }
 
 void KisVisualColorSelectorShape::setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer)
 {
     if (displayRenderer) {
         if (m_d->displayRenderer) {
             m_d->displayRenderer->disconnect(this);
         }
         m_d->displayRenderer = displayRenderer;
-        connect(m_d->displayRenderer, SIGNAL(displayConfigurationChanged()),
-                SLOT(updateFromChangedDisplayRenderer()), Qt::UniqueConnection);
     } else {
         m_d->displayRenderer = KoDumbColorDisplayRenderer::instance();
     }
+    connect(m_d->displayRenderer, SIGNAL(displayConfigurationChanged()),
+            SLOT(updateFromChangedDisplayRenderer()), Qt::UniqueConnection);
 }
 
 void KisVisualColorSelectorShape::updateFromChangedDisplayRenderer()
 {
     m_d->pixmapsNeedUpdate = true;
-    repaint();
+    updateCursor();
+    update();
 }
 
 QColor KisVisualColorSelectorShape::getColorFromConverter(KoColor c){
     QColor col;
-    if (m_d->displayRenderer) {
+    if (m_d->displayRenderer && m_d->displayRenderer->getPaintingColorSpace()==m_d->cs) {
         col = m_d->displayRenderer->toQColor(c);
     } else {
         col = c.toQColor();
     }
     return col;
 }
 
 void KisVisualColorSelectorShape::slotSetActiveChannels(int channel1, int channel2)
 {
     int maxchannel = m_d->cs->colorChannelCount()-1;
     m_d->channel1 = qBound(0, channel1, maxchannel);
     m_d->channel2 = qBound(0, channel2, maxchannel);
     m_d->pixmapsNeedUpdate = true;
     update();
 }
 
 QPixmap KisVisualColorSelectorShape::getPixmap()
 {
     if (m_d->pixmapsNeedUpdate == true) {
         m_d->pixmapsNeedUpdate = false;
         m_d->gradient = QPixmap(width(), height());
         m_d->gradient.fill(Qt::black);
         QImage img(width(), height(), QImage::Format_RGB32);
         img.fill(Qt::black);
 
         for (int y = 0; y<img.height(); y++) {
             for (int x=0; x<img.width(); x++) {
                 QPoint widgetPoint(x,y);
                 QPointF newcoordinate = convertWidgetCoordinateToShapeCoordinate(widgetPoint);
                 KoColor c = convertShapeCoordinateToKoColor(newcoordinate);
                 QColor col = getColorFromConverter(c);
                 img.setPixel(widgetPoint, col.rgb());
             }
         }
 
         m_d->gradient = QPixmap::fromImage(img, Qt::AvoidDither);
     }
     return m_d->gradient;
 }
 
 KoColor KisVisualColorSelectorShape::convertShapeCoordinateToKoColor(QPointF coordinates)
 {
     KoColor c = m_d->currentColor;
     QVector <float> channelValues (c.colorSpace()->channelCount());
     channelValues.fill(1.0);
     c.colorSpace()->normalisedChannelsValue(c.data(), channelValues);
     QVector <qreal> maxvalue(c.colorSpace()->channelCount());
     maxvalue.fill(1.0);
-    if (m_d->displayRenderer) {
+    if (m_d->displayRenderer && m_d->displayRenderer->getPaintingColorSpace()==m_d->cs) {
         for (int ch = 0; ch<maxvalue.size(); ch++) {
             KoChannelInfo *channel = m_d->cs->channels()[ch];
             maxvalue[ch] = m_d->displayRenderer->maxVisibleFloatValue(channel);
             channelValues[ch] = channelValues[ch]/(maxvalue[ch]);
         }
     }
     qreal huedivider = 1.0;
     qreal huedivider2 = 1.0;
 
     if (m_d->channel1==0) {
         huedivider = 360.0;
     }
     if (m_d->channel2==0) {
         huedivider2 = 360.0;
     }
     if (m_d->model != ColorModel::Channel && c.colorSpace()->colorModelId().id() == "RGBA") {
         if (c.colorSpace()->colorModelId().id() == "RGBA") {
             if (m_d->model == ColorModel::HSV){
                 QVector <float> inbetween(3);
                 RGBToHSV(channelValues[2],channelValues[1], channelValues[0], &inbetween[0], &inbetween[1], &inbetween[2]);
                 inbetween[m_d->channel1] = coordinates.x()*huedivider;
                 if (m_d->dimension == Dimensions::twodimensional) {
                     inbetween[m_d->channel2] = coordinates.y()*huedivider2;
                 }
                 HSVToRGB(inbetween[0], inbetween[1], inbetween[2], &channelValues[2], &channelValues[1], &channelValues[0]);
             } else if (m_d->model == ColorModel::HSL) {
                 QVector <float> inbetween(3);
                 RGBToHSL(channelValues[2],channelValues[1], channelValues[0], &inbetween[0], &inbetween[1], &inbetween[2]);
                 inbetween[m_d->channel1] = coordinates.x()*huedivider;
                 if (m_d->dimension == Dimensions::twodimensional) {
                     inbetween[m_d->channel2] = coordinates.y()*huedivider2;
                 }
                 HSLToRGB(inbetween[0], inbetween[1], inbetween[2],&channelValues[2],&channelValues[1], &channelValues[0]);
             } else if (m_d->model == ColorModel::HSI) {
                 QVector <qreal> chan2 = convertvectorfloatToqreal(channelValues);
                 QVector <qreal> inbetween(3);
                 RGBToHSI(chan2[2],chan2[1], chan2[0], &inbetween[0], &inbetween[1], &inbetween[2]);
                 inbetween[m_d->channel1] = coordinates.x();
                 if (m_d->dimension == Dimensions::twodimensional) {
                     inbetween[m_d->channel2] = coordinates.y();
                 }
                 HSIToRGB(inbetween[0], inbetween[1], inbetween[2],&chan2[2],&chan2[1], &chan2[0]);
                 channelValues = convertvectorqrealTofloat(chan2);
             } else /*if (m_d->model == ColorModel::HSY)*/ {
                 QVector <qreal> luma= m_d->cs->lumaCoefficients();
                 QVector <qreal> chan2 = convertvectorfloatToqreal(channelValues);
                 QVector <qreal> inbetween(3);
                 RGBToHSY(chan2[2],chan2[1], chan2[0], &inbetween[0], &inbetween[1], &inbetween[2],
                         luma[0], luma[1], luma[2]);
                 inbetween[m_d->channel1] = coordinates.x();
                 if (m_d->dimension == Dimensions::twodimensional) {
                     inbetween[m_d->channel2] = coordinates.y();
                 }
                 HSYToRGB(inbetween[0], inbetween[1], inbetween[2],&chan2[2],&chan2[1], &chan2[0],
                         luma[0], luma[1], luma[2]);
                 channelValues = convertvectorqrealTofloat(chan2);
             }
         }
     } else {
         channelValues[m_d->channel1] = coordinates.x();
         if (m_d->dimension == Dimensions::twodimensional) {
             channelValues[m_d->channel2] = coordinates.y();
         }
     }
     for (int i=0; i<channelValues.size();i++) {
         channelValues[i] = channelValues[i]*(maxvalue[i]);
     }
     c.colorSpace()->fromNormalisedChannelsValue(c.data(), channelValues);
     return c;
 }
 
 QPointF KisVisualColorSelectorShape::convertKoColorToShapeCoordinate(KoColor c)
 {
     if (c.colorSpace() != m_d->cs) {
         c.convertTo(m_d->cs);
     }
     QVector <float> channelValues (m_d->currentColor.colorSpace()->channelCount());
     channelValues.fill(1.0);
     m_d->cs->normalisedChannelsValue(c.data(), channelValues);
     QVector <qreal> maxvalue(c.colorSpace()->channelCount());
     maxvalue.fill(1.0);
-    if (m_d->displayRenderer) {
+    if (m_d->displayRenderer && m_d->displayRenderer->getPaintingColorSpace()==m_d->cs) {
         for (int ch = 0; ch<maxvalue.size(); ch++) {
             KoChannelInfo *channel = m_d->cs->channels()[ch];
             maxvalue[ch] = m_d->displayRenderer->maxVisibleFloatValue(channel);
             channelValues[ch] = channelValues[ch]/(maxvalue[ch]);
         }
     }
     QPointF coordinates(0.0,0.0);
     qreal huedivider = 1.0;
     qreal huedivider2 = 1.0;
     if (m_d->channel1==0) {
         huedivider = 360.0;
     }
     if (m_d->channel2==0) {
         huedivider2 = 360.0;
     }
     if (m_d->model != ColorModel::Channel && c.colorSpace()->colorModelId().id() == "RGBA") {
         if (c.colorSpace()->colorModelId().id() == "RGBA") {
             if (m_d->model == ColorModel::HSV){
                 QVector <float> inbetween(3);
                 RGBToHSV(channelValues[2],channelValues[1], channelValues[0], &inbetween[0], &inbetween[1], &inbetween[2]);
                 coordinates.setX(inbetween[m_d->channel1]/huedivider);
                 if (m_d->dimension == Dimensions::twodimensional) {
                     coordinates.setY(inbetween[m_d->channel2]/huedivider2);
                 }
             } else if (m_d->model == ColorModel::HSL) {
                 QVector <float> inbetween(3);
                 RGBToHSL(channelValues[2],channelValues[1], channelValues[0], &inbetween[0], &inbetween[1], &inbetween[2]);
                 coordinates.setX(inbetween[m_d->channel1]/huedivider);
                 if (m_d->dimension == Dimensions::twodimensional) {
                     coordinates.setY(inbetween[m_d->channel2]/huedivider2);
                 }
             } else if (m_d->model == ColorModel::HSI) {
                 QVector <qreal> chan2 = convertvectorfloatToqreal(channelValues);
                 QVector <qreal> inbetween(3);
                 RGBToHSI(chan2[2],chan2[1], chan2[0], &inbetween[0], &inbetween[1], &inbetween[2]);
                 coordinates.setX(inbetween[m_d->channel1]);
                 if (m_d->dimension == Dimensions::twodimensional) {
                     coordinates.setY(inbetween[m_d->channel2]);
                 }
             } else /*if (m_d->model == ColorModel::HSY)*/ {
                 QVector <qreal> luma = m_d->cs->lumaCoefficients();
                 QVector <qreal> chan2 = convertvectorfloatToqreal(channelValues);
                 QVector <qreal> inbetween(3);
                 RGBToHSY(chan2[2],chan2[1], chan2[0], &inbetween[0], &inbetween[1], &inbetween[2], luma[0], luma[1], luma[2]);
                 coordinates.setX(inbetween[m_d->channel1]);
                 if (m_d->dimension == Dimensions::twodimensional) {
                     coordinates.setY(inbetween[m_d->channel2]);
                 }
             }
         }
     } else {
         coordinates.setX(channelValues[m_d->channel1]);
         if (m_d->dimension == Dimensions::twodimensional) {
             coordinates.setY(channelValues[m_d->channel2]);
         }
     }
     return coordinates;
 }
 
 QVector<float> KisVisualColorSelectorShape::convertvectorqrealTofloat(QVector<qreal> real)
 {
     QVector <float> vloat(real.size());
     for (int i=0; i<real.size(); i++) {
         vloat[i] = real[i];
     }
     return vloat;
 }
 
 QVector<qreal> KisVisualColorSelectorShape::convertvectorfloatToqreal(QVector <float> vloat)
 {
     QVector <qreal> real(vloat.size());
     for (int i=0; i<vloat.size(); i++) {
         real[i] = vloat[i];
     }
     return real;
 }
 
 void KisVisualColorSelectorShape::mousePressEvent(QMouseEvent *e)
 {
     m_d->mousePressActive = true;
 }
 
 void KisVisualColorSelectorShape::mouseMoveEvent(QMouseEvent *e)
 {
     if (m_d->mousePressActive==true && this->mask().contains(e->pos())) {
         QPointF coordinates = convertWidgetCoordinateToShapeCoordinate(e->pos());
         KoColor col = convertShapeCoordinateToKoColor(coordinates);
         setColor(col);
         if (!m_d->updateTimer->isActive()) {
             Q_EMIT sigNewColor(col);
             m_d->updateTimer->start();
         }
     } else {
         e->ignore();
     }
 }
 
 void KisVisualColorSelectorShape::mouseReleaseEvent(QMouseEvent *)
 {
     m_d->mousePressActive = false;
 }
 void KisVisualColorSelectorShape::paintEvent(QPaintEvent*)
 {
     QPainter painter(this);
 
+    //check if old and new colors differ.
+
     if (m_d->pixmapsNeedUpdate) {
-        getPixmap();
         setMask(getMaskMap());
     }
     drawCursor();
     painter.drawPixmap(0,0,m_d->fullSelector);
 }
 
 void KisVisualColorSelectorShape::resizeEvent(QResizeEvent *)
 {
     m_d->pixmapsNeedUpdate = true;
 }
 
 KisVisualColorSelectorShape::Dimensions KisVisualColorSelectorShape::getDimensions()
 {
     return m_d->dimension;
 }
 
 KisVisualColorSelectorShape::ColorModel KisVisualColorSelectorShape::getColorModel()
 {
     return m_d->model;
 }
 
 void KisVisualColorSelectorShape::setFullImage(QPixmap full)
 {
     m_d->fullSelector = full;
 }
 KoColor KisVisualColorSelectorShape::getCurrentColor()
 {
     return m_d->currentColor;
 }
 
 /*-----------Rectangle Shape------------*/
 
 KisVisualRectangleSelectorShape::KisVisualRectangleSelectorShape(QWidget *parent,
                                                                  Dimensions dimension,
                                                                  ColorModel model,
                                                                  const KoColorSpace *cs,
                                                                  int channel1, int channel2,
                                                                  const KoColorDisplayRendererInterface *displayRenderer,
                                                                  singelDTypes d)
     : KisVisualColorSelectorShape(parent, dimension, model, cs, channel1, channel2, displayRenderer)
 {
     m_type = d;
 }
 
 KisVisualRectangleSelectorShape::~KisVisualRectangleSelectorShape()
 {
 
 }
 
 QPointF KisVisualRectangleSelectorShape::convertShapeCoordinateToWidgetCoordinate(QPointF coordinate)
 {
     qreal x = width()/2;
     qreal y = height()/2;
     KisVisualColorSelectorShape::Dimensions dimension = getDimensions();
     if (dimension == KisVisualColorSelectorShape::onedimensional && m_type == KisVisualRectangleSelectorShape::vertical) {
         y = coordinate.x()*height();
     } else if (dimension == KisVisualColorSelectorShape::onedimensional && m_type == KisVisualRectangleSelectorShape::horizontal) {
         x = coordinate.x()*width();
     } else {
         x = coordinate.x()*width();
         y = coordinate.y()*height();
     }
     return QPointF(x,y);
 }
 
 QPointF KisVisualRectangleSelectorShape::convertWidgetCoordinateToShapeCoordinate(QPoint coordinate)
 {
     //default implementation:
     qreal x = 0.5;
     qreal y = 0.5;
     KisVisualColorSelectorShape::Dimensions dimension = getDimensions();
     if (dimension == KisVisualColorSelectorShape::onedimensional && m_type == KisVisualRectangleSelectorShape::vertical) {
         x = (qreal)coordinate.y()/(qreal)height();
     } else if (dimension == KisVisualColorSelectorShape::onedimensional && m_type == KisVisualRectangleSelectorShape::horizontal) {
         x = (qreal)coordinate.x()/(qreal)width();
     } else {
         x = (qreal)coordinate.x()/(qreal)width();
         y = (qreal)coordinate.y()/(qreal)height();
     }
     return QPointF(x, y);
 }
 
 QRegion KisVisualRectangleSelectorShape::getMaskMap()
 {
     QRegion mask = QRegion(0,0,width(),height());
     return mask;
 }
 
 void KisVisualRectangleSelectorShape::drawCursor()
 {
     QPointF cursorPoint = convertShapeCoordinateToWidgetCoordinate(getCursorPosition());
     QPixmap fullSelector = getPixmap();
     QColor col = getColorFromConverter(getCurrentColor());
     QPainter painter;
     painter.begin(&fullSelector);
     painter.setRenderHint(QPainter::Antialiasing);
     //QPainterPath path;
     QBrush fill;
     fill.setStyle(Qt::SolidPattern);
 
     int cursorwidth = 5;
     QRect rect(cursorPoint.toPoint().x()-cursorwidth,cursorPoint.toPoint().y()-cursorwidth,
                cursorwidth*2,cursorwidth*2);
     if (m_type==KisVisualRectangleSelectorShape::vertical){
         int x = ( cursorPoint.x()-(width()/2)+1 );
         int y = ( cursorPoint.y()-cursorwidth );
         rect.setCoords(x, y, x+width()-2, y+(cursorwidth*2));
     } else {
         int x = cursorPoint.x()-cursorwidth;
         int y = cursorPoint.y()-(height()/2)+1;
         rect.setCoords(x, y, x+(cursorwidth*2), y+cursorwidth-2);
     }
 
     if (getDimensions() == KisVisualColorSelectorShape::onedimensional) {
         painter.setPen(Qt::white);
         fill.setColor(Qt::white);
         painter.setBrush(fill);
         painter.drawRect(rect);
         //set filter conversion!
         fill.setColor(col);
         painter.setPen(Qt::black);
         painter.setBrush(fill);
         rect.setCoords(rect.topLeft().x()+1, rect.topLeft().y()+1,
                        rect.topLeft().x()+rect.width()-2, rect.topLeft().y()+rect.height()-2);
         painter.drawRect(rect);
 
     } else {
         painter.setPen(Qt::white);
         fill.setColor(Qt::white);
         painter.setBrush(fill);
         painter.drawEllipse(cursorPoint, cursorwidth, cursorwidth);
         fill.setColor(col);
         painter.setPen(Qt::black);
         painter.setBrush(fill);
         painter.drawEllipse(cursorPoint, cursorwidth-1.0, cursorwidth-1.0);
     }
     painter.end();
     setFullImage(fullSelector);
 }