diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -408,16 +408,16 @@
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(slotSelectorSettingsChanged()));
 
-        m_selectorUI->colorSelector->setColorConverter(m_canvas->displayColorConverter());
+        m_selectorUI->colorSelector->setCanvas(m_canvas);
         setEnabled(true);
     }
 }
 
 void ArtisticColorSelectorDock::unsetCanvas()
 {
     setEnabled(false);
     m_canvas = nullptr;
-    m_selectorUI->colorSelector->setColorConverter(KisDisplayColorConverter::dumbConverterInstance());
+    m_selectorUI->colorSelector->setCanvas(nullptr);
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskSet(KoGamutMask *mask)
@@ -455,5 +455,5 @@
 
 void ArtisticColorSelectorDock::slotSelectorSettingsChanged()
 {
-    m_selectorUI->colorSelector->update();
+    m_selectorUI->colorSelector->setDirty();
 }
diff --git a/plugins/dockers/artisticcolorselector/kis_color.h b/plugins/dockers/artisticcolorselector/kis_color.h
--- a/plugins/dockers/artisticcolorselector/kis_color.h
+++ b/plugins/dockers/artisticcolorselector/kis_color.h
@@ -26,34 +26,34 @@
 #include <kis_display_color_converter.h>
 #include <kis_arcs_constants.h>
 
+class KisCanvas2;
+
 class KisColor
 {
 public:
     enum Type { HSY, HSV, HSL, HSI };
     
-    KisColor(KisDisplayColorConverter *converter = KisDisplayColorConverter::dumbConverterInstance(),
-             Type type=HSY, qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
+    KisColor(KisCanvas2* canvas = nullptr, Type type=HSY,
+             qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
              qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
 
-    KisColor(qreal hue, KisDisplayColorConverter *converter, Type type,
+    KisColor(qreal hue, KisCanvas2* canvas = nullptr, Type type = HSY,
              qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
              qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
 
-    KisColor(const QColor& color, KisDisplayColorConverter* converter, Type type=HSY,
+    KisColor(const QColor& color, KisCanvas2* canvas = nullptr, Type type=HSY,
              qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
              qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
 
-    KisColor(Qt::GlobalColor color, KisDisplayColorConverter* converter, Type type=HSY,
+    KisColor(Qt::GlobalColor color, KisCanvas2* canvas = nullptr, Type type=HSY,
              qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
              qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
 
-    KisColor(const KisColor& color);
-
-    KisColor(const KisColor& color, Type type,
+    KisColor(const KisColor& color, KisCanvas2* canvas = nullptr, Type type = HSY,
              qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
              qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
 
-    KisColor(const KoColor &color, KisDisplayColorConverter* converter, Type type=HSY,
+    KisColor(const KoColor &color, KisCanvas2* canvas = nullptr, Type type=HSY,
              qreal lR = DEFAULT_LUMA_R, qreal lG = DEFAULT_LUMA_G,
              qreal lB = DEFAULT_LUMA_B, qreal lGamma = DEFAULT_LUMA_GAMMA);
 
@@ -82,7 +82,7 @@
         m_value = x;
     }
 
-    inline KisDisplayColorConverter* colorConverter() const { return m_colorConverter; }
+    KisDisplayColorConverter* colorConverter() const;
     
 private:
     void initHSX(Type type, qreal h, qreal s, qreal x);
@@ -96,7 +96,7 @@
     qreal m_lumaB;
     qreal m_lumaGamma;
     KisColor::Type m_type;
-    KisDisplayColorConverter* m_colorConverter;
+    KisCanvas2* m_canvas;
 };
 
 #endif // H_KIS_COLOR_H
diff --git a/plugins/dockers/artisticcolorselector/kis_color.cpp b/plugins/dockers/artisticcolorselector/kis_color.cpp
--- a/plugins/dockers/artisticcolorselector/kis_color.cpp
+++ b/plugins/dockers/artisticcolorselector/kis_color.cpp
@@ -19,12 +19,13 @@
 #include <KoColor.h>
 #include "kis_color.h"
 #include <kis_arcs_constants.h>
+#include <kis_canvas2.h>
 
 
-KisColor::KisColor(KisDisplayColorConverter* converter, Type type,
+KisColor::KisColor(KisCanvas2* canvas, Type type,
                    qreal lR, qreal lG, qreal lB, qreal lGamma)
 {
-    m_colorConverter = converter;
+    m_canvas = canvas;
     m_type = type;
     m_lumaR = lR;
     m_lumaG = lG;
@@ -34,10 +35,10 @@
     initHSX(type, 0.0, 0.0, 0.0);
 }
 
-KisColor::KisColor(qreal hue, KisDisplayColorConverter* converter, Type type,
+KisColor::KisColor(qreal hue, KisCanvas2* canvas, Type type,
                    qreal lR, qreal lG, qreal lB, qreal lGamma)
 {
-    m_colorConverter = converter;
+    m_canvas = canvas;
     m_type = type;
     m_lumaR = lR;
     m_lumaG = lG;
@@ -47,61 +48,51 @@
     initHSX(type, hue, 0.0, 0.0);
 }
 
-KisColor::KisColor(const QColor& color, KisDisplayColorConverter* converter, Type type,
+KisColor::KisColor(const QColor& color, KisCanvas2* canvas, Type type,
                    qreal lR, qreal lG, qreal lB, qreal lGamma)
 {
-    m_colorConverter = converter;
+    m_canvas = canvas;
     m_type = type;
     m_lumaR = lR;
     m_lumaG = lG;
     m_lumaB = lB;
     m_lumaGamma = lGamma;
 
-    KoColor koColor = m_colorConverter->approximateFromRenderedQColor(color);
+    KoColor koColor = colorConverter()->approximateFromRenderedQColor(color);
     fromKoColor(koColor);
 }
 
-KisColor::KisColor(Qt::GlobalColor color, KisDisplayColorConverter* converter,
+KisColor::KisColor(Qt::GlobalColor color, KisCanvas2* canvas,
                    Type type, qreal lR, qreal lG, qreal lB, qreal lGamma)
 {
     QColor c(color);
-    m_colorConverter = converter;
+    m_canvas = canvas;
     m_type = type;
     m_lumaR = lR;
     m_lumaG = lG;
     m_lumaB = lB;
     m_lumaGamma = lGamma;
 
-    KoColor koColor = m_colorConverter->approximateFromRenderedQColor(c);
+    KoColor koColor = colorConverter()->approximateFromRenderedQColor(c);
     fromKoColor(koColor);
 }
 
-KisColor::KisColor(const KisColor& color)
-{
-    m_colorConverter = color.colorConverter();
-    m_lumaR = color.lumaR();
-    m_lumaG = color.lumaG();
-    m_lumaB = color.lumaB();
-    m_lumaGamma = color.lumaGamma();
-    initHSX(color.getType(), color.getH(), color.getS(), color.getX());
-}
-
-KisColor::KisColor(const KoColor &color, KisDisplayColorConverter* converter, KisColor::Type type,
+KisColor::KisColor(const KoColor &color, KisCanvas2* canvas, KisColor::Type type,
                    qreal lR, qreal lG, qreal lB, qreal lGamma)
 {
-    m_colorConverter = converter;
+    m_canvas = canvas;
     m_type = type;
     m_lumaR = lR;
     m_lumaG = lG;
     m_lumaB = lB;
     m_lumaGamma = lGamma;
     fromKoColor(color);
 }
 
-KisColor::KisColor(const KisColor& color, KisColor::Type type,
+KisColor::KisColor(const KisColor& color, KisCanvas2 *canvas, KisColor::Type type,
                    qreal lR, qreal lG, qreal lB, qreal lGamma)
 {
-    m_colorConverter = color.colorConverter();
+    m_canvas = canvas;
     m_type = type;
     m_lumaR = lR;
     m_lumaG = lG;
@@ -116,25 +107,25 @@
 
 QColor KisColor::toQColor() const
 {
-    return m_colorConverter->toQColor(toKoColor());
+    return colorConverter()->toQColor(toKoColor());
 }
 
 KoColor KisColor::toKoColor() const
 {
-    KoColor color;
+    KoColor color(Qt::transparent, colorConverter()->paintingColorSpace());
 
     switch (m_type) {
     case HSV:
-        color = m_colorConverter->fromHsvF(m_hue, m_saturation, m_value);
+        color = colorConverter()->fromHsvF(m_hue, m_saturation, m_value);
         break;
     case HSI:
-        color = m_colorConverter->fromHsiF(m_hue, m_saturation, m_value);
+        color = colorConverter()->fromHsiF(m_hue, m_saturation, m_value);
         break;
     case HSL:
-        color = m_colorConverter->fromHslF(m_hue, m_saturation, m_value);
+        color = colorConverter()->fromHslF(m_hue, m_saturation, m_value);
         break;
     case HSY:
-        color = m_colorConverter->fromHsyF(m_hue, m_saturation, m_value, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+        color = colorConverter()->fromHsyF(m_hue, m_saturation, m_value, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
         break;
     }
 
@@ -145,20 +136,27 @@
 {
     switch (m_type) {
     case HSV:
-        m_colorConverter->getHsvF(color, &m_hue, &m_saturation, &m_value);
+        colorConverter()->getHsvF(color, &m_hue, &m_saturation, &m_value);
         break;
     case HSI:
-        m_colorConverter->getHsiF(color, &m_hue, &m_saturation, &m_value);
+        colorConverter()->getHsiF(color, &m_hue, &m_saturation, &m_value);
         break;
     case HSL:
-        m_colorConverter->getHsvF(color, &m_hue, &m_saturation, &m_value);
+        colorConverter()->getHsvF(color, &m_hue, &m_saturation, &m_value);
         break;
     case HSY:
-        m_colorConverter->getHsyF(color, &m_hue, &m_saturation, &m_value, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+        colorConverter()->getHsyF(color, &m_hue, &m_saturation, &m_value, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
         break;
     }
 }
 
+KisDisplayColorConverter* KisColor::colorConverter() const
+{
+    return m_canvas ?
+        m_canvas->displayColorConverter() :
+                KisDisplayColorConverter::dumbConverterInstance();
+}
+
 void KisColor::initHSX(Type type, qreal h, qreal s, qreal x)
 {
     m_type = type;
diff --git a/plugins/dockers/artisticcolorselector/kis_color_selector.h b/plugins/dockers/artisticcolorselector/kis_color_selector.h
--- a/plugins/dockers/artisticcolorselector/kis_color_selector.h
+++ b/plugins/dockers/artisticcolorselector/kis_color_selector.h
@@ -31,6 +31,7 @@
 
 #include <resources/KoGamutMask.h>
 #include <KisGamutMaskViewConverter.h>
+#include <kis_canvas2.h>
 
 class QPainter;
 class KisDisplayColorConverter;
@@ -59,7 +60,8 @@
     KisColorSelector(QWidget* parent, KisColor::Type type=KisColor::HSL);
 
     void setColorSpace(KisColor::Type type);
-    void setColorConverter(KisDisplayColorConverter* colorConverter);
+//    void setColorConverter(KisDisplayColorConverter* colorConverter);
+    void setCanvas(KisCanvas2* canvas);
     void setNumPieces(int num);
     void setNumLightPieces(int num) __attribute__((optimize(0)));
     void setNumRings(int num);
@@ -83,13 +85,12 @@
     void setShowBgColor(bool value);
     void setShowValueScaleNumbers(bool value);
     void setGamutMask(KoGamutMask* gamutMask);
+    void setDirty();
     bool gamutMaskOn();
     void setGamutMaskOn(bool gamutMaskOn);
     void setEnforceGamutMask(bool enforce);
     KoGamutMask* gamutMask();
 
-    bool saturationIsInvertible();
-
     void saveSettings();
     void loadSettings();
 
@@ -131,6 +132,7 @@
     void drawBlip(QPainter& painter, const QRect& rect);
     void drawLightStrip(QPainter& painter, const QRect& rect);
     void drawGamutMaskShape(QPainter& painter, const QRect& rect);
+    void drawColorPreview(QPainter& painter, const QRect& rect);
 
     qint8 getHueIndex(Radian hue) const;
     qreal getHue(int hueIdx, Radian shift=0.0f) const;
@@ -153,7 +155,7 @@
     void slotUpdateColorAndPreview(QPair<KisColor, Acs::ColorRole> color);
 
 private:
-    KisDisplayColorConverter* m_colorConverter;
+    KisCanvas2*        m_canvas;
     KisColor::Type     m_colorSpace;
     quint8             m_numPieces;
     quint8             m_numLightPieces;
@@ -166,6 +168,9 @@
     KisColor           m_bgColor;
     QImage             m_renderBuffer;
     QImage             m_maskBuffer;
+    QImage             m_lightStripBuffer;
+    QImage             m_colorPreviewBuffer;
+    QRect              m_widgetArea;
     QRect              m_renderArea;
     QRect              m_lightStripArea;
     bool               m_mouseMoved;
@@ -189,6 +194,10 @@
     KisGamutMaskViewConverter* m_viewConverter;
 
     bool m_widgetUpdatesSelf;
+    bool m_isDirtyWheel;
+    bool m_isDirtyLightStrip;
+    bool m_isDirtyGamutMask;
+    bool m_isDirtyColorPreview;
 
     qreal m_lumaR;
     qreal m_lumaG;
diff --git a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
--- a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
@@ -40,25 +40,29 @@
 
 KisColorSelector::KisColorSelector(QWidget* parent, KisColor::Type type)
     : QWidget(parent)
-    , m_colorConverter(KisDisplayColorConverter::dumbConverterInstance())
+    , m_canvas(nullptr)
     , m_colorSpace(type)
     , m_inverseSaturation(false)
-    , m_selectedColor(m_colorConverter)
-    , m_fgColor(m_colorConverter)
-    , m_bgColor(m_colorConverter)
+    , m_selectedColor(m_canvas)
+    , m_fgColor(m_canvas)
+    , m_bgColor(m_canvas)
     , m_clickedRing(-1)
     , m_gamutMaskOn(false)
     , m_currentGamutMask(nullptr)
     , m_maskPreviewActive(true)
     , m_widgetUpdatesSelf(false)
+    , m_isDirtyWheel(false)
+    , m_isDirtyLightStrip(false)
+    , m_isDirtyGamutMask(false)
+    , m_isDirtyColorPreview(false)
 {
     m_viewConverter = new KisGamutMaskViewConverter();
 
     setLumaCoefficients(DEFAULT_LUMA_R, DEFAULT_LUMA_G, DEFAULT_LUMA_B,DEFAULT_LUMA_GAMMA);
 
     recalculateRings(DEFAULT_SATURATION_STEPS, DEFAULT_HUE_STEPS);
     recalculateAreas(DEFAULT_VALUE_SCALE_STEPS);
-    selectColor(KisColor(Qt::red, m_colorConverter, KisColor::HSY, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma));
+    selectColor(KisColor(Qt::red, m_canvas, KisColor::HSY, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma));
 
     using namespace std::placeholders; // For _1 placeholder
     auto function = std::bind(&KisColorSelector::slotUpdateColorAndPreview, this, _1);
@@ -68,18 +72,21 @@
 void KisColorSelector::setColorSpace(KisColor::Type type)
 {
     m_colorSpace    = type;
-    m_selectedColor = KisColor(m_selectedColor, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+    m_selectedColor = KisColor(m_selectedColor, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+
+    m_isDirtyLightStrip = true;
+    m_isDirtyWheel = true;
 
 #ifdef DEBUG_ARC_SELECTOR
         dbgPlugins << "KisColorSelector::setColorSpace: set to:" << m_colorSpace;
 #endif
 
         update();
 }
 
-void KisColorSelector::setColorConverter(KisDisplayColorConverter *colorConverter)
+void KisColorSelector::setCanvas(KisCanvas2 *canvas)
 {
-    m_colorConverter = colorConverter;
+    m_canvas = canvas;
     update();
 }
 
@@ -121,7 +128,7 @@
 
 void KisColorSelector::selectColor(const KisColor& color)
 {
-    m_selectedColor      = KisColor(color, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+    m_selectedColor      = KisColor(color, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
     m_selectedPiece      = getHueIndex(m_selectedColor.getH() * PI2);
     m_selectedRing       = getSaturationIndex(m_selectedColor.getS());
     m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
@@ -131,9 +138,12 @@
 void KisColorSelector::setFgColor(const KoColor& fgColor)
 {
     if (!m_widgetUpdatesSelf) {
-        m_fgColor = KisColor(fgColor, m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
-        m_selectedColor = KisColor(fgColor, m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+        m_fgColor = KisColor(fgColor, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+        m_selectedColor = KisColor(fgColor, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
 
+        m_isDirtyWheel = true;
+        m_isDirtyLightStrip = true;
+        m_isDirtyColorPreview = true;
 #ifdef DEBUG_ARC_SELECTOR
         dbgPlugins << "KisColorSelector::setFgColor: m_fgColor set to:"
                    << "H:" << m_fgColor.getH()
@@ -152,7 +162,9 @@
 void KisColorSelector::setBgColor(const KoColor& bgColor)
 {
     if (!m_widgetUpdatesSelf) {
-        m_bgColor = KisColor(bgColor, m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+        m_bgColor = KisColor(bgColor, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+
+        m_isDirtyColorPreview = true;
 #ifdef DEBUG_ARC_SELECTOR
         dbgPlugins << "KisColorSelector::setBgColor: m_bgColor set to:"
                    << "H:" << m_bgColor.getH()
@@ -167,6 +179,7 @@
 {
     m_selectedColor.setX(qBound(0.0, light, 1.0));
     m_selectedLightPiece = getLightIndex(m_selectedColor.getX());
+    m_isDirtyLightStrip = true;
     update();
 }
 
@@ -177,7 +190,10 @@
     m_lumaB = lB;
     m_lumaGamma = lGamma;
 
-    m_selectedColor = KisColor(m_selectedColor, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+    m_selectedColor = KisColor(m_selectedColor, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+
+    m_isDirtyLightStrip = true;
+    m_isDirtyWheel = true;
 
 #ifdef DEBUG_ARC_SELECTOR
         dbgPlugins << "KisColorSelector::setLumaCoefficients: " << m_lumaR
@@ -206,6 +222,23 @@
     m_currentGamutMask = gamutMask;
     m_viewConverter->setViewSize(m_renderAreaSize);
     m_viewConverter->setMaskSize(m_currentGamutMask->maskSize());
+
+    if (m_enforceGamutMask) {
+        m_isDirtyWheel = true;
+    } else {
+        m_isDirtyGamutMask = true;
+    }
+
+    update();
+}
+
+void KisColorSelector::setDirty()
+{
+    m_isDirtyWheel = true;
+    m_isDirtyLightStrip = true;
+    m_isDirtyGamutMask = true;
+    m_isDirtyColorPreview = true;
+
     update();
 }
 
@@ -224,13 +257,16 @@
 {
     if (m_currentGamutMask) {
         m_gamutMaskOn = gamutMaskOn;
+        m_isDirtyGamutMask = true;
         update();
     }
 }
 
 void KisColorSelector::setEnforceGamutMask(bool enforce)
 {
     m_enforceGamutMask = enforce;
+    m_isDirtyGamutMask = true;
+    m_isDirtyWheel = true;
     update();
 }
 
@@ -366,7 +402,6 @@
 
 void KisColorSelector::recalculateAreas(quint8 numLightPieces)
 {
-
     qreal LIGHT_STRIP_RATIO = 0.075;
     if (m_showValueScaleNumbers) {
         LIGHT_STRIP_RATIO = 0.25;
@@ -387,12 +422,21 @@
     m_renderAreaSize = QSize(size,size);
     m_viewConverter->setViewSize(m_renderAreaSize);
 
+    m_widgetArea     = QRect(0, 0, QWidget::width(), QWidget::height());
     m_renderArea     = QRect(x+stripThick, y, size, size);
     m_lightStripArea = QRect(0, 0, stripThick, QWidget::height());
 
     m_renderBuffer   = QImage(size, size, QImage::Format_ARGB32_Premultiplied);
+    m_colorPreviewBuffer   = QImage(QWidget::width(), QWidget::height(), QImage::Format_ARGB32_Premultiplied);
     m_maskBuffer   = QImage(size, size, QImage::Format_ARGB32_Premultiplied);
+    m_lightStripBuffer = QImage(stripThick, QWidget::height(), QImage::Format_ARGB32_Premultiplied);
+
     m_numLightPieces = numLightPieces;
+
+    m_isDirtyGamutMask = true;
+    m_isDirtyLightStrip = true;
+    m_isDirtyWheel = true;
+    m_isDirtyColorPreview = true;
 }
 
 void KisColorSelector::recalculateRings(quint8 numRings, quint8 numPieces)
@@ -408,6 +452,8 @@
         createRing(m_colorRings[i], numPieces, innerRadius, outerRadius+0.001);
         m_colorRings[i].saturation = m_inverseSaturation ? (1.0 - saturation) : saturation;
     }
+
+    m_isDirtyWheel = true;
 }
 
 void KisColorSelector::createRing(ColorRing& ring, quint8 numPieces, qreal innerRadius, qreal outerRadius)
@@ -465,6 +511,11 @@
                << "S:" << color.getS()
                << "X:" << color.getX();
 #endif
+
+    m_isDirtyLightStrip = true;
+    m_isDirtyColorPreview = true;
+    m_isDirtyWheel = true;
+
     m_updateColorCompressor->start(qMakePair(color, role));
 }
 
@@ -509,7 +560,7 @@
             hue = (hue >= 1.0) ? (hue - 1.0) : hue;
             hue = (hue <  0.0) ? (hue + 1.0) : hue;
 
-            KisColor color(hue, m_colorConverter, m_colorSpace);
+            KisColor color(hue, m_canvas, m_colorSpace);
             color.setS(ring.saturation);
             color.setX(m_selectedColor.getX());
 
@@ -531,13 +582,13 @@
     }
     else {
         KisColor colors[7] = {
-            KisColor(Qt::cyan   , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
-            KisColor(Qt::green  , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
-            KisColor(Qt::yellow , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
-            KisColor(Qt::red    , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
-            KisColor(Qt::magenta, m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
-            KisColor(Qt::blue   , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
-            KisColor(Qt::cyan   , m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma)
+            KisColor(Qt::cyan   , m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
+            KisColor(Qt::green  , m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
+            KisColor(Qt::yellow , m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
+            KisColor(Qt::red    , m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
+            KisColor(Qt::magenta, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
+            KisColor(Qt::blue   , m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma),
+            KisColor(Qt::cyan   , m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma)
         };
 
         QConicalGradient gradient(0, 0, 0);
@@ -558,6 +609,8 @@
 
 void KisColorSelector::drawOutline(QPainter& painter, const QRect& rect)
 {
+    painter.save();
+
     painter.setRenderHint(QPainter::Antialiasing, true);
     painter.resetTransform();
     painter.translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
@@ -611,20 +664,22 @@
             painter.drawLine(QPointF(lineCoords.x()*iRad, lineCoords.y()*iRad), QPointF(lineCoords.x()*oRad, lineCoords.y()*oRad));
         }
     }
+
+    painter.restore();
 }
 
 void KisColorSelector::drawLightStrip(QPainter& painter, const QRect& rect)
 {
     qreal    penSize    = qreal(qMin(QWidget::width(), QWidget::height())) / 200.0;
     qreal    penSizeSmall = penSize / 1.2;
     QPen selectedPen;
 
-    KisColor valueScaleColor(m_selectedColor, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
-    KisColor grayScaleColor(Qt::gray, m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+    KisColor valueScaleColor(m_selectedColor, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
+    KisColor grayScaleColor(Qt::gray, m_canvas, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
     int rectSize = rect.height();
 
-    painter.resetTransform();
     painter.save();
+    painter.resetTransform();
     painter.setRenderHint(QPainter::Antialiasing, true);
 
     QTransform matrix;
@@ -741,6 +796,8 @@
 
 void KisColorSelector::drawBlip(QPainter& painter, const QRect& rect)
 {
+    painter.save();
+
     painter.setRenderHint(QPainter::Antialiasing, true);
     painter.resetTransform();
     painter.translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
@@ -758,8 +815,9 @@
     painter.drawEllipse(fgColorPos, 0.05, 0.05);
 
     painter.setPen(QPen(QBrush(COLOR_SELECTED_LIGHT), 0.01));
-    painter.setBrush(m_fgColor.toQColor());
     painter.drawEllipse(fgColorPos, 0.04, 0.04);
+
+    painter.restore();
 }
 
 void KisColorSelector::drawGamutMaskShape(QPainter &painter, const QRect &rect)
@@ -787,66 +845,89 @@
     painter.restore();
 }
 
-void KisColorSelector::paintEvent(QPaintEvent* /*event*/)
+void KisColorSelector::drawColorPreview(QPainter &painter, const QRect &rect)
 {
-    // 0 red    -> (1,0,0)
-    // 1 yellow -> (1,1,0)
-    // 2 green  -> (0,1,0)
-    // 3 cyan   -> (0,1,1)
-    // 4 blue   -> (0,0,1)
-    // 5 maenta -> (1,0,1)
-    // 6 red    -> (1,0,0)
-
-    m_renderBuffer.fill(0);
-
-    QPainter imgPainter(&m_renderBuffer);
-    QPainter wdgPainter(this);
-
-    // draw the fg and bg color previews
-    // QPainter settings must be saved and restored afterwards, otherwise the wheel drawing is totally broken
-    wdgPainter.save();
-    wdgPainter.setRenderHint(QPainter::Antialiasing, true);
+    painter.save();
+    painter.setRenderHint(QPainter::Antialiasing, true);
 
-    QRect fgRect(0, 0, QWidget::width(), QWidget::height());
-    wdgPainter.fillRect(fgRect, m_fgColor.toQColor());
+    painter.fillRect(rect, m_fgColor.toQColor());
 
-    int bgSide = qMin(QWidget::width()*0.15,QWidget::height()*0.15);
+    int bgSide = qMin(rect.width()*0.15,rect.height()*0.15);
 
     if (m_showBgColor) {
         QPointF bgPolyPoints[3] = {
-            QPointF(QWidget::width(), QWidget::height()),
-            QPointF(QWidget::width()-bgSide, QWidget::height()),
-            QPointF(QWidget::width(), QWidget::height()-bgSide)
+            QPointF(rect.width(), rect.height()),
+            QPointF(rect.width()-bgSide, rect.height()),
+            QPointF(rect.width(), rect.height()-bgSide)
         };
 
-        wdgPainter.setBrush(m_bgColor.toQColor());
-        wdgPainter.setPen(m_bgColor.toQColor());
-        wdgPainter.drawPolygon(bgPolyPoints, 3);
+        painter.setBrush(m_bgColor.toQColor());
+        painter.setPen(m_bgColor.toQColor());
+        painter.drawPolygon(bgPolyPoints, 3);
+    }
+
+    painter.restore();
+}
+
+void KisColorSelector::paintEvent(QPaintEvent* /*event*/)
+{
+    QPainter wdgPainter(this);
+
+    // draw the fg and bg color previews
+    if (m_isDirtyColorPreview) {
+        m_colorPreviewBuffer.fill(Qt::transparent);
+        QPainter colorPreviewPainter(&m_colorPreviewBuffer);
+        drawColorPreview(colorPreviewPainter, m_widgetArea);
+
+        m_isDirtyColorPreview = false;
     }
+    wdgPainter.drawImage(m_widgetArea, m_colorPreviewBuffer);
+    // draw the fg and bg color previews
 
-    wdgPainter.restore();
+    // draw the wheel
+    if (m_isDirtyWheel) {
+        m_renderBuffer.fill(Qt::transparent);
+        QPainter wheelPainter(&m_renderBuffer);
 
-    for(int i=0; i<m_colorRings.size(); ++i)
-        drawRing(imgPainter, m_colorRings[i], m_renderArea);
+        for(int i=0; i<m_colorRings.size(); ++i)
+            drawRing(wheelPainter, m_colorRings[i], m_renderArea);
 
+        m_isDirtyWheel = false;
+    }
     wdgPainter.drawImage(m_renderArea, m_renderBuffer);
+    // draw the wheel
 
     // draw the mask either in continuous mode or in discrete mode when enforcing is turned off
     // if enforcing is turned on in discrete mode,
     // drawRing function takes care of delineating the mask swatches
     if (m_gamutMaskOn
             && ((getNumPieces() == 1) || (!m_enforceGamutMask))) {
 
-        m_maskBuffer.fill(0);
-        QPainter maskPainter(&m_maskBuffer);
-        drawGamutMaskShape(maskPainter, m_renderArea);
+        if (m_isDirtyGamutMask) {
+            m_maskBuffer.fill(Qt::transparent);
+            QPainter maskPainter(&m_maskBuffer);
+            drawGamutMaskShape(maskPainter, m_renderArea);
 
+            m_isDirtyGamutMask = false;
+        }
         wdgPainter.drawImage(m_renderArea, m_maskBuffer);
     }
+    // draw gamut mask
 
-    drawOutline   (wdgPainter, m_renderArea);
-    drawLightStrip(wdgPainter, m_lightStripArea);
-    drawBlip (wdgPainter, m_renderArea);
+    drawOutline(wdgPainter, m_renderArea);
+
+    // draw light strip
+    if (m_isDirtyLightStrip) {
+        m_lightStripBuffer.fill(Qt::transparent);
+        QPainter lightStripPainter(&m_lightStripBuffer);
+
+        drawLightStrip(lightStripPainter, m_lightStripArea);
+        m_isDirtyLightStrip = false;
+    }
+    wdgPainter.drawImage(m_lightStripArea, m_lightStripBuffer);
+    // draw light strip
+
+    drawBlip(wdgPainter, m_renderArea);
 }
 
 void KisColorSelector::mousePressEvent(QMouseEvent* event)
@@ -874,7 +955,7 @@
         if (getNumPieces() == 1) {
             Radian angle = mapCoordToAngle(m_clickPos.x(), m_clickPos.y());
 
-            KisColor color(m_colorConverter, m_colorSpace);
+            KisColor color(m_canvas, m_colorSpace);
             color.setHSX(angle.scaled(0.0, 1.0)
                          , getSaturation(m_clickedRing)
                          , m_selectedColor.getX()
@@ -915,7 +996,7 @@
 
     if (getNumPieces() == 1) {
         Radian angle = mapCoordToAngle(dragPos.x(), dragPos.y());
-        KisColor color(m_colorConverter, m_colorSpace);
+        KisColor color(m_canvas, m_colorSpace);
         color.setHSX(angle.scaled(0.0, 1.0)
                      , getSaturation(m_clickedRing)
                      , m_selectedColor.getX()
@@ -936,7 +1017,7 @@
 
     if (!m_mouseMoved && m_clickedRing >= 0) {
         Radian angle = mapCoordToAngle(m_clickPos.x(), m_clickPos.y());
-        KisColor color(m_colorConverter, m_colorSpace);
+        KisColor color(m_canvas, m_colorSpace);
 
         qint8 hueIndex = getHueIndex(angle);
 
@@ -1070,6 +1151,7 @@
 void KisColorSelector::setShowBgColor(bool value)
 {
     m_showBgColor = value;
+    m_isDirtyColorPreview = true;
     update();
 }
 
@@ -1080,10 +1162,3 @@
     update();
 }
 
-bool KisColorSelector::saturationIsInvertible()
-{
-    if (!m_gamutMaskOn) return true;
-    bool b = (m_enforceGamutMask && getNumPieces() == 1) ? false : true;
-    return b;
-}
-