diff --git a/libs/ui/kis_popup_palette.cpp b/libs/ui/kis_popup_palette.cpp
index 59dc873f00..2706cd7e85 100644
--- a/libs/ui/kis_popup_palette.cpp
+++ b/libs/ui/kis_popup_palette.cpp
@@ -1,988 +1,995 @@
 /* This file is part of the KDE project
    Copyright 2009 Vera Lukman <shicmap@gmail.com>
    Copyright 2011 Sven Langkamp <sven.langkamp@gmail.com>
    Copyright 2016 Scott Petrovic <scottpetrovic@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    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 "kis_canvas2.h"
 #include "kis_config.h"
 #include "kis_popup_palette.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_icon_utils.h"
 #include "KisResourceServerProvider.h"
 #include <kis_canvas_resource_provider.h>
 #include <KoTriangleColorSelector.h>
 #include <KisVisualColorSelector.h>
 #include <kis_config_notifier.h>
 #include <QtGui>
 #include <QMenu>
 #include <QWhatsThis>
 #include <QVBoxLayout>
 #include <QElapsedTimer>
 #include "kis_signal_compressor.h"
 #include "brushhud/kis_brush_hud.h"
 #include "brushhud/kis_round_hud_button.h"
 #include "kis_signals_blocker.h"
 #include "kis_canvas_controller.h"
 #include "kis_acyclic_signal_connector.h"
 #include "KisMouseClickEater.h"
 
 class PopupColorTriangle : public KoTriangleColorSelector
 {
 public:
     PopupColorTriangle(const KoColorDisplayRendererInterface *displayRenderer, QWidget* parent)
         : KoTriangleColorSelector(displayRenderer, parent)
         , m_dragging(false)
     {
     }
 
     ~PopupColorTriangle() override {}
 
     void tabletEvent(QTabletEvent* event) override {
         event->accept();
         QMouseEvent* mouseEvent = 0;
 
         // this will tell the pop-up palette widget to close
         if(event->button() == Qt::RightButton) {
             emit requestCloseContainer();
         }
 
         // ignore any tablet events that are done with the right click
         // Tablet move events don't return a "button", so catch that too
         if(event->button() == Qt::LeftButton || event->type() == QEvent::TabletMove)
         {
             switch (event->type()) {
                 case QEvent::TabletPress:
                     mouseEvent = new QMouseEvent(QEvent::MouseButtonPress, event->pos(),
                                                  Qt::LeftButton, Qt::LeftButton, event->modifiers());
                     m_dragging = true;
                     mousePressEvent(mouseEvent);
                     break;
                 case QEvent::TabletMove:
                     mouseEvent = new QMouseEvent(QEvent::MouseMove, event->pos(),
                                                  (m_dragging) ? Qt::LeftButton : Qt::NoButton,
                                                  (m_dragging) ? Qt::LeftButton : Qt::NoButton, event->modifiers());
                     mouseMoveEvent(mouseEvent);
                     break;
                 case QEvent::TabletRelease:
                     mouseEvent = new QMouseEvent(QEvent::MouseButtonRelease, event->pos(),
                                                  Qt::LeftButton,
                                                  Qt::LeftButton,
                                                  event->modifiers());
                     m_dragging = false;
                     mouseReleaseEvent(mouseEvent);
                     break;
                 default: break;
             }
         }
 
         delete mouseEvent;
     }
 
 private:
     bool m_dragging;
 };
 
 KisPopupPalette::KisPopupPalette(KisViewManager* viewManager, KisCoordinatesConverter* coordinatesConverter ,KisFavoriteResourceManager* manager,
                                  const KoColorDisplayRendererInterface *displayRenderer, KisCanvasResourceProvider *provider, QWidget *parent)
     : QWidget(parent, Qt::FramelessWindowHint)
     , m_coordinatesConverter(coordinatesConverter)
     , m_viewManager(viewManager)
     , m_actionManager(viewManager->actionManager())
     , m_resourceManager(manager)
     , m_displayRenderer(displayRenderer)
     , m_colorChangeCompressor(new KisSignalCompressor(50, KisSignalCompressor::POSTPONE))
     , m_actionCollection(viewManager->actionCollection())
     , m_acyclicConnector(new KisAcyclicSignalConnector(this))
     , m_clicksEater(new KisMouseClickEater(Qt::RightButton, 1, this))
 {
     // some UI controls are defined and created based off these variables
 
     const int borderWidth = 3;
 
     if (KisConfig(true).readEntry<bool>("popuppalette/usevisualcolorselector", false)) {
         KisVisualColorSelector *selector = new KisVisualColorSelector(this);
         selector->setAcceptTabletEvents(true);
         m_triangleColorSelector = selector;
     }
     else {
         m_triangleColorSelector  = new PopupColorTriangle(displayRenderer, this);
         connect(m_triangleColorSelector, SIGNAL(requestCloseContainer()), this, SLOT(slotHide()));
     }
     m_triangleColorSelector->setDisplayRenderer(displayRenderer);
     m_triangleColorSelector->setConfig(true,false);
     m_triangleColorSelector->move(m_popupPaletteSize/2-m_colorHistoryInnerRadius+borderWidth, m_popupPaletteSize/2-m_colorHistoryInnerRadius+borderWidth);
     m_triangleColorSelector->resize(m_popupPaletteSize - 2*m_triangleColorSelector->x(), m_popupPaletteSize - 2*m_triangleColorSelector->y());
     m_triangleColorSelector->setVisible(true);
     KoColor fgcolor(Qt::black, KoColorSpaceRegistry::instance()->rgb8());
     if (m_resourceManager) {
         fgcolor = provider->fgColor();
     }
     m_triangleColorSelector->slotSetColor(fgcolor);
 
 
     /**
      * Tablet support code generates a spurious right-click right after opening
      * the window, so we should ignore it. Next right-click will be used for
      * closing the popup palette
      */
     this->installEventFilter(m_clicksEater);
     m_triangleColorSelector->installEventFilter(m_clicksEater);
 
     QRegion maskedRegion(0, 0, m_triangleColorSelector->width(), m_triangleColorSelector->height(), QRegion::Ellipse );
     m_triangleColorSelector->setMask(maskedRegion);
 
     //setAttribute(Qt::WA_TranslucentBackground, true);
 
     connect(m_triangleColorSelector, SIGNAL(sigNewColor(KoColor)),
             m_colorChangeCompressor.data(), SLOT(start()));
     connect(m_colorChangeCompressor.data(), SIGNAL(timeout()),
             SLOT(slotEmitColorChanged()));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), m_triangleColorSelector, SLOT(configurationChanged()));
+    connect(m_displayRenderer,  SIGNAL(displayConfigurationChanged()), this, SLOT(slotDisplayConfigurationChanged()));
 
     m_acyclicConnector->connectForwardKoColor(m_resourceManager, SIGNAL(sigChangeFGColorSelector(KoColor)),
                                               this, SLOT(slotExternalFgColorChanged(KoColor)));
 
     m_acyclicConnector->connectBackwardKoColor(this, SIGNAL(sigChangefGColor(KoColor)),
                                                m_resourceManager, SIGNAL(sigSetFGColor(KoColor)));
 
     connect(this, SIGNAL(sigChangeActivePaintop(int)), m_resourceManager, SLOT(slotChangeActivePaintop(int)));
     connect(this, SIGNAL(sigUpdateRecentColor(int)), m_resourceManager, SLOT(slotUpdateRecentColor(int)));
 
     connect(m_resourceManager, SIGNAL(setSelectedColor(int)), SLOT(slotSetSelectedColor(int)));
     connect(m_resourceManager, SIGNAL(updatePalettes()), SLOT(slotUpdate()));
     connect(m_resourceManager, SIGNAL(hidePalettes()), SLOT(slotHide()));
 
     // This is used to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     m_timer.setSingleShot(true);
     connect(this, SIGNAL(sigTriggerTimer()), this, SLOT(slotTriggerTimer()));
     connect(&m_timer, SIGNAL(timeout()), this, SLOT(slotEnableChangeFGColor()));
     connect(this, SIGNAL(sigEnableChangeFGColor(bool)), m_resourceManager, SIGNAL(sigEnableChangeColor(bool)));
 
     setCursor(Qt::ArrowCursor);
     setMouseTracking(true);
     setHoveredPreset(-1);
     setHoveredColor(-1);
     setSelectedColor(-1);
 
     m_brushHud = new KisBrushHud(provider, parent);
     m_brushHud->setFixedHeight(int(m_popupPaletteSize));
     m_brushHud->setVisible(false);
 
     const int auxButtonSize = 35;
 
     m_settingsButton = new KisRoundHudButton(this);
 
     m_settingsButton->setGeometry(m_popupPaletteSize - 2.2 * auxButtonSize, m_popupPaletteSize - auxButtonSize,
                                   auxButtonSize, auxButtonSize);
 
     connect(m_settingsButton, SIGNAL(clicked()), SLOT(slotShowTagsPopup()));
 
     KisConfig cfg(true);
     m_brushHudButton = new KisRoundHudButton(this);
     m_brushHudButton->setCheckable(true);
 
     m_brushHudButton->setGeometry(m_popupPaletteSize - 1.0 * auxButtonSize, m_popupPaletteSize - auxButtonSize,
                                   auxButtonSize, auxButtonSize);
     connect(m_brushHudButton, SIGNAL(toggled(bool)), SLOT(showHudWidget(bool)));
     m_brushHudButton->setChecked(cfg.showBrushHud());
 
 
     // add some stuff below the pop-up palette that will make it easier to use for tablet people
     QVBoxLayout* vLayout = new QVBoxLayout(this); // main layout
 
     QSpacerItem* verticalSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
     vLayout->addSpacerItem(verticalSpacer); // this should push the box to the bottom
 
 
     QHBoxLayout* hLayout = new QHBoxLayout();
 
     vLayout->addLayout(hLayout);
 
     mirrorMode = new KisHighlightedToolButton(this);
     mirrorMode->setFixedSize(35, 35);
 
     mirrorMode->setToolTip(i18n("Mirror Canvas"));
     mirrorMode->setDefaultAction(m_actionCollection->action("mirror_canvas"));
 
     canvasOnlyButton = new KisHighlightedToolButton(this);
     canvasOnlyButton->setFixedSize(35, 35);
 
     canvasOnlyButton->setToolTip(i18n("Canvas Only"));
     canvasOnlyButton->setDefaultAction(m_actionCollection->action("view_show_canvas_only"));
 
     zoomToOneHundredPercentButton = new QPushButton(this);
     zoomToOneHundredPercentButton->setText(i18n("100%"));
     zoomToOneHundredPercentButton->setFixedHeight(35);
 
     zoomToOneHundredPercentButton->setToolTip(i18n("Zoom to 100%"));
     connect(zoomToOneHundredPercentButton, SIGNAL(clicked(bool)), this, SLOT(slotZoomToOneHundredPercentClicked()));
 
     zoomCanvasSlider = new QSlider(Qt::Horizontal, this);
     zoomSliderMinValue = 10; // set in %
     zoomSliderMaxValue = 200; // set in %
 
     zoomCanvasSlider->setRange(zoomSliderMinValue, zoomSliderMaxValue);
     zoomCanvasSlider->setFixedHeight(35);
     zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent());
 
     zoomCanvasSlider->setSingleStep(1);
     zoomCanvasSlider->setPageStep(1);
 
     connect(zoomCanvasSlider, SIGNAL(valueChanged(int)), this, SLOT(slotZoomSliderChanged(int)));
     connect(zoomCanvasSlider, SIGNAL(sliderPressed()), this, SLOT(slotZoomSliderPressed()));
     connect(zoomCanvasSlider, SIGNAL(sliderReleased()), this, SLOT(slotZoomSliderReleased()));
 
     slotUpdateIcons();
 
     hLayout->addWidget(mirrorMode);
     hLayout->addWidget(canvasOnlyButton);
     hLayout->addWidget(zoomToOneHundredPercentButton);
     hLayout->addWidget(zoomCanvasSlider);
 
     setVisible(true);
     setVisible(false);
 
     opacityChange = new QGraphicsOpacityEffect(this);
     setGraphicsEffect(opacityChange);
 
     // Prevent tablet events from being captured by the canvas
     setAttribute(Qt::WA_NoMousePropagation, true);
 }
 
-void KisPopupPalette::slotExternalFgColorChanged(const KoColor &color)
+void KisPopupPalette::slotDisplayConfigurationChanged()
 {
+    // Visual Color Selector picks up color space from input
+    KoColor col = m_viewManager->canvasResourceProvider()->fgColor();
+    const KoColorSpace *paintingCS = m_displayRenderer->getPaintingColorSpace();
     //hack to get around cmyk for now.
-    if (color.colorSpace()->colorChannelCount()>3) {
-        KoColor c(KoColorSpaceRegistry::instance()->rgb8());
-        c.fromKoColor(color);
-        m_triangleColorSelector->slotSetColor(c);
-    } else {
-        m_triangleColorSelector->slotSetColor(color);
+    if (paintingCS->colorChannelCount()>3) {
+        paintingCS = KoColorSpaceRegistry::instance()->rgb8();
     }
+    m_triangleColorSelector->slotSetColorSpace(paintingCS);
+    m_triangleColorSelector->slotSetColor(col);
+}
+
+void KisPopupPalette::slotExternalFgColorChanged(const KoColor &color)
+{
+    m_triangleColorSelector->slotSetColor(color);
 }
 
 void KisPopupPalette::slotEmitColorChanged()
 {
     if (isVisible()) {
         update();
         emit sigChangefGColor(m_triangleColorSelector->getCurrentColor());
     }
 }
 
 //setting KisPopupPalette properties
 int KisPopupPalette::hoveredPreset() const
 {
     return m_hoveredPreset;
 }
 
 void KisPopupPalette::setHoveredPreset(int x)
 {
     m_hoveredPreset = x;
 }
 
 int KisPopupPalette::hoveredColor() const
 {
     return m_hoveredColor;
 }
 
 void KisPopupPalette::setHoveredColor(int x)
 {
     m_hoveredColor = x;
 }
 
 int KisPopupPalette::selectedColor() const
 {
     return m_selectedColor;
 }
 
 void KisPopupPalette::setSelectedColor(int x)
 {
     m_selectedColor = x;
 }
 
 void KisPopupPalette::slotTriggerTimer()
 {
     m_timer.start(750);
 }
 
 void KisPopupPalette::slotEnableChangeFGColor()
 {
     emit sigEnableChangeFGColor(true);
 }
 
 void KisPopupPalette::slotZoomSliderChanged(int zoom) {
     emit zoomLevelChanged(zoom);
 }
 
 void KisPopupPalette::slotZoomSliderPressed()
 {
    m_isZoomingCanvas = true;
 }
 
 void KisPopupPalette::slotZoomSliderReleased()
 {
     m_isZoomingCanvas = false;
 }
 
 void KisPopupPalette::adjustLayout(const QPoint &p)
 {
     KIS_ASSERT_RECOVER_RETURN(m_brushHud);
     if (isVisible() && parentWidget())  {
 
         float hudMargin = 30.0;
         const QRect fitRect = kisGrowRect(parentWidget()->rect(), -20.0); // -20 is widget margin
         const QPoint paletteCenterOffset(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
         QRect paletteRect = rect();
         paletteRect.moveTo(p - paletteCenterOffset);
         if (m_brushHudButton->isChecked()) {
             m_brushHud->updateGeometry();
             paletteRect.adjust(0, 0, m_brushHud->width() + hudMargin, 0);
         }
 
         paletteRect = kisEnsureInRect(paletteRect, fitRect);
         move(paletteRect.topLeft());
         m_brushHud->move(paletteRect.topLeft() + QPoint(m_popupPaletteSize + hudMargin, 0));
         m_lastCenterPoint = p;
     }
 }
 
 void KisPopupPalette::slotUpdateIcons()
 {
     this->setPalette(qApp->palette());
 
     for(int i=0; i<this->children().size(); i++) {
         QWidget *w = qobject_cast<QWidget*>(this->children().at(i));
         if (w) {
             w->setPalette(qApp->palette());
         }
     }
     zoomToOneHundredPercentButton->setIcon(m_actionCollection->action("zoom_to_100pct")->icon());
     m_brushHud->updateIcons();
     m_settingsButton->setIcon(KisIconUtils::loadIcon("tag"));
     m_brushHudButton->setOnOffIcons(KisIconUtils::loadIcon("arrow-left"), KisIconUtils::loadIcon("arrow-right"));
 }
 
 void KisPopupPalette::showHudWidget(bool visible)
 {
     KIS_ASSERT_RECOVER_RETURN(m_brushHud);
 
     const bool reallyVisible = visible && m_brushHudButton->isChecked();
 
     if (reallyVisible) {
         m_brushHud->updateProperties();
     }
 
     m_brushHud->setVisible(reallyVisible);
     adjustLayout(m_lastCenterPoint);
 
     KisConfig cfg(false);
     cfg.setShowBrushHud(visible);
 }
 
 void KisPopupPalette::showPopupPalette(const QPoint &p)
 {
     showPopupPalette(!isVisible());
     adjustLayout(p);
 }
 
 void KisPopupPalette::showPopupPalette(bool show)
 {
     if (show) {
         // don't set the zoom slider if we are outside of the zoom slider bounds. It will change the zoom level to within
         // the bounds and cause the canvas to jump between the slider's min and max
         if (m_coordinatesConverter->zoomInPercent() > zoomSliderMinValue &&
                 m_coordinatesConverter->zoomInPercent() < zoomSliderMaxValue  ){
 
             KisSignalsBlocker b(zoomCanvasSlider);
             zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent()); // sync the zoom slider
         }
         emit sigEnableChangeFGColor(!show);
     } else {
         emit sigTriggerTimer();
     }
     setVisible(show);
     m_brushHud->setVisible(show && m_brushHudButton->isChecked());
 }
 
 //redefinition of setVariable function to change the scope to private
 void KisPopupPalette::setVisible(bool b)
 {
     QWidget::setVisible(b);
 }
 
 void KisPopupPalette::setParent(QWidget *parent) {
     m_brushHud->setParent(parent);
     QWidget::setParent(parent);
 }
 
 QSize KisPopupPalette::sizeHint() const
 {
     return QSize(m_popupPaletteSize, m_popupPaletteSize + 50); // last number is the space for the toolbar below
 }
 
 void KisPopupPalette::resizeEvent(QResizeEvent*)
 {
 }
 
 void KisPopupPalette::paintEvent(QPaintEvent* e)
 {
     Q_UNUSED(e);
 
     QPainter painter(this);
 
     QPen pen(palette().color(QPalette::Text));
     pen.setWidth(3);
     painter.setPen(pen);
 
     painter.setRenderHint(QPainter::Antialiasing);
     painter.setRenderHint(QPainter::SmoothPixmapTransform);
 
     // painting background color indicator
     QPainterPath bgColor;
     bgColor.addEllipse(QPoint( 50, 80), 30, 30);
     painter.fillPath(bgColor, m_displayRenderer->toQColor(m_resourceManager->bgColor()));
     painter.drawPath(bgColor);
 
     // painting foreground color indicator
     QPainterPath fgColor;
     fgColor.addEllipse(QPoint( 60, 50), 30, 30);
     painter.fillPath(fgColor, m_displayRenderer->toQColor(m_triangleColorSelector->getCurrentColor()));
     painter.drawPath(fgColor);
 
     // create a circle background that everything else will go into
     QPainterPath backgroundContainer;
     float shrinkCircleAmount = 3;// helps the circle when the stroke is put around it
 
     QRectF circleRect(shrinkCircleAmount, shrinkCircleAmount,
                       m_popupPaletteSize - shrinkCircleAmount*2,m_popupPaletteSize - shrinkCircleAmount*2);
 
 
     backgroundContainer.addEllipse( circleRect );
     painter.fillPath(backgroundContainer,palette().brush(QPalette::Background));
 
     painter.drawPath(backgroundContainer);
 
     // create a path slightly inside the container circle. this will create a 'track' to indicate that we can rotate the canvas
     // with the indicator
     QPainterPath rotationTrackPath;
     shrinkCircleAmount = 18;
     QRectF circleRect2(shrinkCircleAmount, shrinkCircleAmount,
                        m_popupPaletteSize - shrinkCircleAmount*2,m_popupPaletteSize - shrinkCircleAmount*2);
 
     rotationTrackPath.addEllipse( circleRect2 );
     pen.setWidth(1);
     painter.setPen(pen);
     painter.drawPath(rotationTrackPath);
 
     // this thing will help indicate where the starting brush preset is at.
     // also what direction they go to give sor order to the presets populated
     /*
     pen.setWidth(6);
     pen.setCapStyle(Qt::RoundCap);
     painter.setPen(pen);
     painter.drawArc(circleRect, (16*90), (16*-30)); // span angle (last parameter) is in 16th of degrees
 
     QPainterPath brushDir;
     brushDir.arcMoveTo(circleRect, 60);
     brushDir.lineTo(brushDir.currentPosition().x()-5, brushDir.currentPosition().y() - 14);
     painter.drawPath(brushDir);
 
     brushDir.lineTo(brushDir.currentPosition().x()-2, brushDir.currentPosition().y() + 6);
     painter.drawPath(brushDir);
     */
 
     // the following things needs to be based off the center, so let's translate the painter
     painter.translate(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
 
     // create the canvas rotation handle
     QPainterPath rotationIndicator = drawRotationIndicator(m_coordinatesConverter->rotationAngle(), true);
 
     painter.fillPath(rotationIndicator,palette().brush(QPalette::Text));
 
     // hover indicator for the canvas rotation
     if (m_isOverCanvasRotationIndicator == true) {
         painter.save();
 
         QPen pen(palette().color(QPalette::Highlight));
         pen.setWidth(2);
         painter.setPen(pen);
         painter.drawPath(rotationIndicator);
 
         painter.restore();
     }
 
     // create a reset canvas rotation indicator to bring the canvas back to 0 degrees
     QPainterPath resetRotationIndicator = drawRotationIndicator(0, false);
 
     QPen resetPen(palette().color(QPalette::Text));
     resetPen.setWidth(1);
     painter.save();
     painter.setPen(resetPen);
     painter.drawPath(resetRotationIndicator);
 
     painter.restore();
 
     // painting favorite brushes
     QList<QImage> images(m_resourceManager->favoritePresetImages());
 
     // painting favorite brushes pixmap/icon
     QPainterPath presetPath;
     for (int pos = 0; pos < numSlots(); pos++) {
         painter.save();
 
         presetPath = createPathFromPresetIndex(pos);
 
         if (pos < images.size()) {
             painter.setClipPath(presetPath);
 
             QRect bounds = presetPath.boundingRect().toAlignedRect();
             painter.drawImage(bounds.topLeft() , images.at(pos).scaled(bounds.size() , Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation));
         }
         else {
             painter.fillPath(presetPath, palette().brush(QPalette::Window));  // brush slot that has no brush in it
         }
         QPen pen = painter.pen();
         pen.setWidth(1);
         painter.setPen(pen);
         painter.drawPath(presetPath);
 
         painter.restore();
     }
     if (hoveredPreset() > -1) {
         presetPath = createPathFromPresetIndex(hoveredPreset());
         QPen pen(palette().color(QPalette::Highlight));
         pen.setWidth(3);
         painter.setPen(pen);
         painter.drawPath(presetPath);
     }
 
     // paint recent colors area.
     painter.setPen(Qt::NoPen);
     float rotationAngle = -360.0 / m_resourceManager->recentColorsTotal();
 
     // there might be no recent colors at the start, so paint a placeholder
     if (m_resourceManager->recentColorsTotal() == 0) {
         painter.setBrush(Qt::transparent);
 
         QPainterPath emptyRecentColorsPath(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
         painter.setPen(QPen(palette().color(QPalette::Background).lighter(150), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
         painter.drawPath(emptyRecentColorsPath);
     } else {
 
         for (int pos = 0; pos < m_resourceManager->recentColorsTotal(); pos++) {
             QPainterPath recentColorsPath(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
 
             //accessing recent color of index pos
             painter.fillPath(recentColorsPath, m_displayRenderer->toQColor( m_resourceManager->recentColorAt(pos) ));
             painter.drawPath(recentColorsPath);
             painter.rotate(rotationAngle);
         }
 
     }
 
     // painting hovered color
     if (hoveredColor() > -1) {
         painter.setPen(QPen(palette().color(QPalette::Highlight), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
         if (m_resourceManager->recentColorsTotal() == 1) {
             QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
             painter.drawPath(path_ColorDonut);
         } else {
             painter.rotate((m_resourceManager->recentColorsTotal() + hoveredColor()) *rotationAngle);
             QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
             painter.drawPath(path);
             painter.rotate(hoveredColor() * -1 * rotationAngle);
         }
     }
 
     // painting selected color
     if (selectedColor() > -1) {
         painter.setPen(QPen(palette().color(QPalette::Highlight).darker(130), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
         if (m_resourceManager->recentColorsTotal() == 1) {
             QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
             painter.drawPath(path_ColorDonut);
         } else {
             painter.rotate((m_resourceManager->recentColorsTotal() + selectedColor()) *rotationAngle);
             QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
             painter.drawPath(path);
             painter.rotate(selectedColor() * -1 * rotationAngle);
         }
     }
 
 
     // if we are actively rotating the canvas or zooming, make the panel slightly transparent to see the canvas better
     if(m_isRotatingCanvasIndicator || m_isZoomingCanvas) {
         opacityChange->setOpacity(0.4);
     } else {
         opacityChange->setOpacity(1.0);
     }
 
 }
 
 QPainterPath KisPopupPalette::drawDonutPathFull(int x, int y, int inner_radius, int outer_radius)
 {
     QPainterPath path;
     path.addEllipse(QPointF(x, y), outer_radius, outer_radius);
     path.addEllipse(QPointF(x, y), inner_radius, inner_radius);
     path.setFillRule(Qt::OddEvenFill);
 
     return path;
 }
 
 QPainterPath KisPopupPalette::drawDonutPathAngle(int inner_radius, int outer_radius, int limit)
 {
     QPainterPath path;
     path.moveTo(-0.999 * outer_radius * sin(M_PI / limit), 0.999 * outer_radius * cos(M_PI / limit));
     path.arcTo(-1 * outer_radius, -1 * outer_radius, 2 * outer_radius, 2 * outer_radius, -90.0 - 180.0 / limit,
                360.0 / limit);
     path.arcTo(-1 * inner_radius, -1 * inner_radius, 2 * inner_radius, 2 * inner_radius, -90.0 + 180.0 / limit,
                - 360.0 / limit);
     path.closeSubpath();
 
     return path;
 }
 
 QPainterPath KisPopupPalette::drawRotationIndicator(qreal rotationAngle, bool canDrag)
 {
     // used for canvas rotation. This function gets called twice. Once by the canvas rotation indicator,
     // and another time by the reset canvas position
 
     float canvasRotationRadians = qDegreesToRadians(rotationAngle - 90);  // -90 will make 0 degrees be at the top
     float rotationDialXPosition = qCos(canvasRotationRadians) * (m_popupPaletteSize/2 - 10); // m_popupPaletteSize/2  = radius
     float rotationDialYPosition = qSin(canvasRotationRadians) * (m_popupPaletteSize/2 - 10);
 
     QPainterPath canvasRotationIndicator;
     int canvasIndicatorSize = 15;
     int canvasIndicatorMiddle = canvasIndicatorSize / 2;
     QRect indicatorRectangle = QRect( rotationDialXPosition - canvasIndicatorMiddle, rotationDialYPosition - canvasIndicatorMiddle,
                                       canvasIndicatorSize, canvasIndicatorSize );
 
     if (canDrag) {
         m_canvasRotationIndicatorRect = indicatorRectangle;
     } else {
         m_resetCanvasRotationIndicatorRect = indicatorRectangle;
     }
 
     canvasRotationIndicator.addEllipse(indicatorRectangle.x(), indicatorRectangle.y(),
                                        indicatorRectangle.width(), indicatorRectangle.height() );
 
     return canvasRotationIndicator;
 }
 
 
 void KisPopupPalette::mouseMoveEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     setToolTip(QString());
     setHoveredPreset(-1);
     setHoveredColor(-1);
 
     // calculate if we are over the canvas rotation knob
     // before we started painting, we moved the painter to the center of the widget, so the X/Y positions are offset. we need to
     // correct them first before looking for a click event intersection
 
     float rotationCorrectedXPos = m_canvasRotationIndicatorRect.x() + (m_popupPaletteSize / 2);
     float rotationCorrectedYPos = m_canvasRotationIndicatorRect.y() + (m_popupPaletteSize / 2);
     QRect correctedCanvasRotationIndicator = QRect(rotationCorrectedXPos, rotationCorrectedYPos,
                                                    m_canvasRotationIndicatorRect.width(), m_canvasRotationIndicatorRect.height());
 
     if (correctedCanvasRotationIndicator.contains(point.x(), point.y())) {
         m_isOverCanvasRotationIndicator = true;
     } else {
         m_isOverCanvasRotationIndicator = false;
     }
 
     if (m_isRotatingCanvasIndicator) {
         // we are rotating the canvas, so calculate the rotation angle based off the center
         // calculate the angle we are at first
         QPoint widgetCenterPoint = QPoint(m_popupPaletteSize/2, m_popupPaletteSize/2);
 
         float dX = point.x() - widgetCenterPoint.x();
         float dY = point.y() - widgetCenterPoint.y();
 
 
         float finalAngle = qAtan2(dY,dX) * 180 / M_PI; // what we need if we have two points, but don't know the angle
         finalAngle = finalAngle + 90; // add 90 degrees so 0 degree position points up
         float angleDifference = finalAngle - m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs, so find it out
 
         KisCanvasController *canvasController =
             dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
         canvasController->rotateCanvas(angleDifference);
 
 
         emit sigUpdateCanvas();
     }
 
     // don't highlight the presets if we are in the middle of rotating the canvas
     if (m_isRotatingCanvasIndicator == false) {
         QPainterPath pathColor(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
         {
             int pos = calculatePresetIndex(point, m_resourceManager->numFavoritePresets());
 
             if (pos >= 0 && pos < m_resourceManager->numFavoritePresets()) {
                 setToolTip(m_resourceManager->favoritePresetList().at(pos).data()->name());
                 setHoveredPreset(pos);
             }
         }
         if (pathColor.contains(point)) {
             int pos = calculateIndex(point, m_resourceManager->recentColorsTotal());
 
             if (pos >= 0 && pos < m_resourceManager->recentColorsTotal()) {
                 setHoveredColor(pos);
             }
         }
     }
 
     update();
 }
 
 void KisPopupPalette::mousePressEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     if (event->button() == Qt::LeftButton) {
 
         //in favorite brushes area
         int pos = calculateIndex(point, m_resourceManager->numFavoritePresets());
         if (pos >= 0 && pos < m_resourceManager->numFavoritePresets()
                 && isPointInPixmap(point, pos)) {
             //setSelectedBrush(pos);
             update();
         }
 
         if (m_isOverCanvasRotationIndicator) {
             m_isRotatingCanvasIndicator = true;
         }
 
         // reset the canvas if we are over the reset canvas rotation indicator
         float rotationCorrectedXPos = m_resetCanvasRotationIndicatorRect.x() + (m_popupPaletteSize / 2);
         float rotationCorrectedYPos = m_resetCanvasRotationIndicatorRect.y() + (m_popupPaletteSize / 2);
         QRect correctedResetCanvasRotationIndicator = QRect(rotationCorrectedXPos, rotationCorrectedYPos,
                                                             m_resetCanvasRotationIndicatorRect.width(), m_resetCanvasRotationIndicatorRect.height());
 
         if (correctedResetCanvasRotationIndicator.contains(point.x(), point.y())) {
             float angleDifference = -m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs
             KisCanvasController *canvasController =
                     dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
             canvasController->rotateCanvas(angleDifference);
 
             emit sigUpdateCanvas();
         }
     }
 }
 
 void KisPopupPalette::slotShowTagsPopup()
 {
     KisPaintOpPresetResourceServer *rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QStringList tags = rServer->tagNamesList();
     std::sort(tags.begin(), tags.end());
 
     if (!tags.isEmpty()) {
         QMenu menu;
         Q_FOREACH (const QString& tag, tags) {
             menu.addAction(tag);
         }
 
         QAction *action = menu.exec(QCursor::pos());
         if (action) {
             m_resourceManager->setCurrentTag(action->text());
         }
     } else {
         QWhatsThis::showText(QCursor::pos(),
                              i18n("There are no tags available to show in this popup. To add presets, you need to tag them and then select the tag here."));
     }
 }
 
 void KisPopupPalette::slotZoomToOneHundredPercentClicked() {
     QAction *action = m_actionCollection->action("zoom_to_100pct");
 
     if (action) {
         action->trigger();
     }
 
     // also move the zoom slider to 100% position so they are in sync
     zoomCanvasSlider->setValue(100);
 }
 
 void KisPopupPalette::tabletEvent(QTabletEvent *event) {
     event->ignore();
 }
 
 void KisPopupPalette::showEvent(QShowEvent *event)
 {
     m_clicksEater->reset();
     QWidget::showEvent(event);
 }
 
 void KisPopupPalette::mouseReleaseEvent(QMouseEvent *event)
 {
     QPointF point = event->localPos();
     event->accept();
 
     if (event->buttons() == Qt::NoButton &&
         event->button() == Qt::RightButton) {
 
         showPopupPalette(false);
         return;
     }
 
     m_isOverCanvasRotationIndicator = false;
     m_isRotatingCanvasIndicator = false;
 
     if (event->button() == Qt::LeftButton) {
         QPainterPath pathColor(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
 
         //in favorite brushes area
         if (hoveredPreset() > -1) {
             //setSelectedBrush(hoveredBrush());
             emit sigChangeActivePaintop(hoveredPreset());
         }
         if (pathColor.contains(point)) {
             int pos = calculateIndex(point, m_resourceManager->recentColorsTotal());
 
             if (pos >= 0 && pos < m_resourceManager->recentColorsTotal()) {
                 emit sigUpdateRecentColor(pos);
             }
         }
     }
 }
 
 int KisPopupPalette::calculateIndex(QPointF point, int n)
 {
     calculatePresetIndex(point, n);
     //translate to (0,0)
     point.setX(point.x() - m_popupPaletteSize / 2);
     point.setY(point.y() - m_popupPaletteSize / 2);
 
     //rotate
     float smallerAngle = M_PI / 2 + M_PI / n - atan2(point.y(), point.x());
     float radius = sqrt((float)point.x() * point.x() + point.y() * point.y());
     point.setX(radius * cos(smallerAngle));
     point.setY(radius * sin(smallerAngle));
 
     //calculate brush index
     int pos = floor(acos(point.x() / radius) * n / (2 * M_PI));
     if (point.y() < 0) pos =  n - pos - 1;
 
     return pos;
 }
 
 bool KisPopupPalette::isPointInPixmap(QPointF &point, int pos)
 {
     if (createPathFromPresetIndex(pos).contains(point + QPointF(-m_popupPaletteSize / 2, -m_popupPaletteSize / 2))) {
         return true;
     }
     return false;
 }
 
 KisPopupPalette::~KisPopupPalette()
 {
 }
 
 QPainterPath KisPopupPalette::createPathFromPresetIndex(int index)
 {
     qreal angleSlice = 360.0 / numSlots() ; // how many degrees each slice will get
 
     // the starting angle of the slice we need to draw. the negative sign makes us go clockwise.
     // adding 90 degrees makes us start at the top. otherwise we would start at the right
     qreal startingAngle = -(index * angleSlice) + 90;
 
     // the radius will get smaller as the amount of presets shown increases. 10 slots == 41
     qreal radians = qDegreesToRadians((360.0/10)/2);
     qreal maxRadius = (m_colorHistoryOuterRadius * qSin(radians) / (1-qSin(radians)))-2;
 
     radians = qDegreesToRadians(angleSlice/2);
     qreal presetRadius = m_colorHistoryOuterRadius * qSin(radians) / (1-qSin(radians));
     //If we assume that circles will mesh like a hexagonal grid, then 3.5r is the size of two hexagons interlocking.
 
     qreal length = m_colorHistoryOuterRadius + presetRadius;
     // can we can fit in a second row? We don't want the preset icons to get too tiny.
     if (maxRadius > presetRadius) {
         //redo all calculations assuming a second row.
         if (numSlots() % 2) {
             angleSlice = 360.0/(numSlots()+1);
             startingAngle = -(index * angleSlice) + 90;
         }
         if (numSlots() != m_cachedNumSlots){
             qreal tempRadius = presetRadius;
             qreal distance = 0;
             do{
                 tempRadius+=0.1;
 
                 // Calculate the XY of two adjectant circles using this tempRadius.
                 qreal length1 = m_colorHistoryOuterRadius + tempRadius;
                 qreal length2 = m_colorHistoryOuterRadius + ((maxRadius*2)-tempRadius);
                 qreal pathX1 = length1 * qCos(qDegreesToRadians(startingAngle)) - tempRadius;
                 qreal pathY1 = -(length1) * qSin(qDegreesToRadians(startingAngle)) - tempRadius;
                 qreal startingAngle2 = -(index+1 * angleSlice) + 90;
                 qreal pathX2 = length2 * qCos(qDegreesToRadians(startingAngle2)) - tempRadius;
                 qreal pathY2 = -(length2) * qSin(qDegreesToRadians(startingAngle2)) - tempRadius;
 
                 // Use Pythagorean Theorem to calculate the distance between these two values.
                 qreal m1 = pathX2-pathX1;
                 qreal m2 = pathY2-pathY1;
 
                 distance = sqrt((m1*m1)+(m2*m2));
             }
             //As long at there's more distance than the radius of the two presets, continue increasing the radius.
             while((tempRadius+1)*2 < distance);
             m_cachedRadius = tempRadius;
         }
         m_cachedNumSlots = numSlots();
         presetRadius = m_cachedRadius;
         length = m_colorHistoryOuterRadius + presetRadius;
         if (index % 2) {
             length = m_colorHistoryOuterRadius + ((maxRadius*2)-presetRadius);
         }
     }
     QPainterPath path;
     qreal pathX = length * qCos(qDegreesToRadians(startingAngle)) - presetRadius;
     qreal pathY = -(length) * qSin(qDegreesToRadians(startingAngle)) - presetRadius;
     qreal pathDiameter = 2 * presetRadius; // distance is used to calculate the X/Y in addition to the preset circle size
     path.addEllipse(pathX, pathY, pathDiameter, pathDiameter);
     return path;
 }
 
 int KisPopupPalette::calculatePresetIndex(QPointF point, int /*n*/)
 {
     for(int i = 0; i < numSlots(); i++)
     {
         QPointF adujustedPoint = point - QPointF(m_popupPaletteSize/2, m_popupPaletteSize/2);
         if(createPathFromPresetIndex(i).contains(adujustedPoint))
         {
             return i;
         }
     }
     return -1;
 }
 
 int KisPopupPalette::numSlots()
 {
     KisConfig config(true);
     return qMax(config.favoritePresets(), 10);
 }
diff --git a/libs/ui/kis_popup_palette.h b/libs/ui/kis_popup_palette.h
index d2df8e7232..51732f0e29 100644
--- a/libs/ui/kis_popup_palette.h
+++ b/libs/ui/kis_popup_palette.h
@@ -1,190 +1,191 @@
 /* This file is part of the KDE project
    Copyright 2009 Vera Lukman <shicmap@gmail.com>
    Copyright 2016 Scott Petrovic <scottpetrovic@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    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.
 */
 
 #ifndef KIS_POPUP_PALETTE_H
 #define KIS_POPUP_PALETTE_H
 
 #include <QElapsedTimer>
 #include <QPushButton>
 #include <QSlider>
 #include <QGraphicsOpacityEffect>
 #include "KisViewManager.h"
 #include "kactioncollection.h"
 #include "kis_tool_button.h"
 #include "KisHighlightedToolButton.h"
 #include <KisColorSelectorInterface.h>
 
 class KisFavoriteResourceManager;
 class QWidget;
 class KoColor;
 class KoTriangleColorSelector;
 class KisSignalCompressor;
 class KisBrushHud;
 class KisRoundHudButton;
 class KisCanvasResourceProvider;
 class KisVisualColorSelector;
 class KisAcyclicSignalConnector;
 class KisMouseClickEater;
 
 class KisPopupPalette : public QWidget
 {
     Q_OBJECT
 
     Q_PROPERTY(int hoveredPreset READ hoveredPreset WRITE setHoveredPreset)
     Q_PROPERTY(int hoveredColor READ hoveredColor WRITE setHoveredColor)
     Q_PROPERTY(int selectedColor READ selectedColor WRITE setSelectedColor)
 
 public:
     KisPopupPalette(KisViewManager*, KisCoordinatesConverter* ,KisFavoriteResourceManager*, const KoColorDisplayRendererInterface *displayRenderer,
                     KisCanvasResourceProvider *provider, QWidget *parent = 0);
     ~KisPopupPalette() override;
     QSize sizeHint() const override;
 
     void showPopupPalette(const QPoint&);
     void showPopupPalette(bool b);
 
     //functions to set up selectedBrush
     void setSelectedBrush(int x);
     int selectedBrush() const;
     //functions to set up selectedColor
     void setSelectedColor(int x);
     int selectedColor() const;
     void setParent(QWidget *parent);
 
     void tabletEvent(QTabletEvent *event) override;
 
 protected:
 
     void showEvent(QShowEvent *event) override;
     void paintEvent(QPaintEvent*) override;
     void resizeEvent(QResizeEvent*) override;
     void mouseReleaseEvent(QMouseEvent*) override;
     void mouseMoveEvent(QMouseEvent*) override;
     void mousePressEvent(QMouseEvent*) override;
 
     //functions to calculate index of favorite brush or recent color in array
     //n is the total number of favorite brushes or recent colors
     int calculateIndex(QPointF, int n);
 
     int calculatePresetIndex(QPointF, int n);
 
     //functions to set up hoveredBrush
     void setHoveredPreset(int x);
     int hoveredPreset() const;
     //functions to set up hoveredColor
     void setHoveredColor(int x);
     int hoveredColor() const;
 
 private:
     void setVisible(bool b) override;
 
     QPainterPath drawDonutPathFull(int, int, int, int);
     QPainterPath drawDonutPathAngle(int, int, int);
     QPainterPath drawRotationIndicator(qreal rotationAngle, bool canDrag);
     bool isPointInPixmap(QPointF&, int pos);
 
     QPainterPath createPathFromPresetIndex(int index);
 
     int numSlots();
     void adjustLayout(const QPoint &p);
 
 private:
     int m_hoveredPreset {0};
     int m_hoveredColor {0};
     int m_selectedColor {0};
 
     KisCoordinatesConverter *m_coordinatesConverter;
 
     KisViewManager *m_viewManager;
     KisActionManager *m_actionManager;
     KisFavoriteResourceManager *m_resourceManager;
     KisColorSelectorInterface *m_triangleColorSelector {0};
     const KoColorDisplayRendererInterface *m_displayRenderer;
     QScopedPointer<KisSignalCompressor> m_colorChangeCompressor;
     KActionCollection *m_actionCollection;
 
     QTimer m_timer;
 
     KisBrushHud *m_brushHud {0};
     float m_popupPaletteSize {385.0};
     float m_colorHistoryInnerRadius {72.0};
     qreal m_colorHistoryOuterRadius {92.0};
 
     KisRoundHudButton *m_settingsButton {0};
     KisRoundHudButton *m_brushHudButton {0};
     QPoint m_lastCenterPoint;
     QRect m_canvasRotationIndicatorRect;
     QRect m_resetCanvasRotationIndicatorRect;
     bool m_isOverCanvasRotationIndicator {false};
     bool m_isRotatingCanvasIndicator {false};
     bool m_isZoomingCanvas {false};
 
 
     KisHighlightedToolButton *mirrorMode {0};
     KisHighlightedToolButton *canvasOnlyButton {0};
     QPushButton *zoomToOneHundredPercentButton {0};
     QSlider *zoomCanvasSlider {0};
     int zoomSliderMinValue {10};
     int zoomSliderMaxValue {200};
     KisAcyclicSignalConnector *m_acyclicConnector = 0;
 
     int m_cachedNumSlots {0};
     qreal m_cachedRadius {0.0};
 
     // updates the transparency and effects of the whole widget
     QGraphicsOpacityEffect *opacityChange {0};
     KisMouseClickEater *m_clicksEater;
 
 Q_SIGNALS:
     void sigChangeActivePaintop(int);
     void sigUpdateRecentColor(int);
     void sigChangefGColor(const KoColor&);
     void sigUpdateCanvas();
     void zoomLevelChanged(int);
 
     // These are used to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     void sigEnableChangeFGColor(bool);
     void sigTriggerTimer();
 
 public Q_SLOTS:
     void slotUpdateIcons();
 
 private Q_SLOTS:
+    void slotDisplayConfigurationChanged();
     void slotExternalFgColorChanged(const KoColor &color);
     void slotEmitColorChanged();
     void slotSetSelectedColor(int x) { setSelectedColor(x); update(); }
     void slotTriggerTimer();
     void slotEnableChangeFGColor();
     void slotUpdate() { update(); }
     void slotHide() { showPopupPalette(false); }
     void slotShowTagsPopup();
     void showHudWidget(bool visible);
     void slotZoomToOneHundredPercentClicked();
     void slotZoomSliderChanged(int zoom);
 
     void slotZoomSliderPressed();
     void slotZoomSliderReleased();
 
 };
 
 #endif // KIS_POPUP_PALETTE_H
diff --git a/libs/widgets/KisColorSelectorInterface.cpp b/libs/widgets/KisColorSelectorInterface.cpp
index 840b621023..93d9b0d960 100644
--- a/libs/widgets/KisColorSelectorInterface.cpp
+++ b/libs/widgets/KisColorSelectorInterface.cpp
@@ -1,20 +1,25 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.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 <KisColorSelectorInterface.h>
+
+void KisColorSelectorInterface::slotSetColorSpace(const KoColorSpace *cs)
+{
+    Q_UNUSED(cs)
+}
diff --git a/libs/widgets/KisColorSelectorInterface.h b/libs/widgets/KisColorSelectorInterface.h
index 993196c15b..e98f04db06 100644
--- a/libs/widgets/KisColorSelectorInterface.h
+++ b/libs/widgets/KisColorSelectorInterface.h
@@ -1,56 +1,67 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.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.
  */
 
 #ifndef KISCOLORSELECTORINTERFACE_H
 #define KISCOLORSELECTORINTERFACE_H
 
 #include "kritawidgets_export.h"
 
 #include <QWidget>
 #include <KoColor.h>
 
 class KoColorDisplayRendererInterface;
+class KoColorSpace;
 
 class KRITAWIDGETS_EXPORT KisColorSelectorInterface : public QWidget {
     Q_OBJECT
 public:
     KisColorSelectorInterface(QWidget *parent = 0)
         : QWidget(parent)
     {}
     ~KisColorSelectorInterface() override {}
     virtual void setConfig(bool forceCircular, bool forceSelfUpdate)
     {
         Q_UNUSED(forceCircular);
         Q_UNUSED(forceSelfUpdate);
     }
     virtual void setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer)
     {
         Q_UNUSED(displayRenderer);
     }
 
     virtual KoColor getCurrentColor() const = 0;
 
 Q_SIGNALS:
     void sigNewColor(const KoColor &c);
 
 public Q_SLOTS:
     virtual void slotSetColor(const KoColor &c) = 0;
+    /**
+     * @brief slotSetColorSpace
+     * Set the color space the selector should cover
+     *
+     * This is mostly a hint to decide visual presentation.
+     * Internal processing may be in a different color space and
+     * input conversion shall be handled by the selector itself.
+     * Calling this voids the currently selected color.
+     */
+    virtual void slotSetColorSpace(const KoColorSpace *cs);
 };
 
 #endif // KISCOLORSELECTORINTERFACE_H
diff --git a/libs/widgets/KisDlgInternalColorSelector.cpp b/libs/widgets/KisDlgInternalColorSelector.cpp
index e55b563a04..ae1d13303c 100644
--- a/libs/widgets/KisDlgInternalColorSelector.cpp
+++ b/libs/widgets/KisDlgInternalColorSelector.cpp
@@ -1,385 +1,386 @@
 /*
  * 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 <QList>
 #include <QAbstractSpinBox>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
 #include <QPointer>
 #include <QCompleter>
 
 #include <functional>
 
 #include <KConfigGroup>
 
 #include "KoColorSpaceRegistry.h"
 #include <KoColorSet.h>
 #include <KisPaletteModel.h>
 #include <KisPaletteListWidget.h>
 #include <kis_palette_view.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServer.h>
 
 #include "kis_signal_compressor.h"
 #include "KoColorDisplayRendererInterface.h"
 
 #include "kis_spinbox_color_selector.h"
 
 #include "KisDlgInternalColorSelector.h"
 #include "ui_WdgDlgInternalColorSelector.h"
 #include "kis_config_notifier.h"
 #include "kis_color_input.h"
 #include "kis_icon_utils.h"
 #include "KisSqueezedComboBox.h"
 
 std::function<KisScreenColorPickerBase *(QWidget *)> KisDlgInternalColorSelector::s_screenColorPickerFactory = 0;
 
 struct KisDlgInternalColorSelector::Private
 {
     bool allowUpdates = true;
     KoColor currentColor;
     KoColor previousColor;
     KoColor sRGB = KoColor(KoColorSpaceRegistry::instance()->rgb8());
     const KoColorSpace *currentColorSpace;
     bool lockUsedCS = false;
     bool chooseAlpha = false;
     KisSignalCompressor *compressColorChanges;
     const KoColorDisplayRendererInterface *displayRenderer;
     KisHexColorInput *hexColorInput = 0;
     KisPaletteModel *paletteModel = 0;
     KisPaletteListWidget *paletteChooser = 0;
     KisScreenColorPickerBase *screenColorPicker = 0;
 };
 
 KisDlgInternalColorSelector::KisDlgInternalColorSelector(QWidget *parent, KoColor color, Config config, const QString &caption, const KoColorDisplayRendererInterface *displayRenderer)
     : QDialog(parent)
     , m_d(new Private)
 {
     setModal(config.modal);
     setFocusPolicy(Qt::ClickFocus);
     m_ui = new Ui_WdgDlgInternalColorSelector();
     m_ui->setupUi(this);
 
     setWindowTitle(caption);
 
     m_d->currentColor = color;
     m_d->currentColorSpace = m_d->currentColor.colorSpace();
     m_d->displayRenderer = displayRenderer;
 
     m_ui->spinboxselector->slotSetColor(color);
     connect(m_ui->spinboxselector, SIGNAL(sigNewColor(KoColor)), this, SLOT(slotColorUpdated(KoColor)));
 
     m_ui->spinboxHSXSelector->attachToSelector(m_ui->visualSelector);
 
     m_ui->visualSelector->setDisplayRenderer(displayRenderer);
     m_ui->visualSelector->setConfig(false, config.modal);
     if (config.visualColorSelector) {
         connect(m_ui->visualSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(slotColorUpdated(KoColor)));
         connect(m_ui->visualSelector, SIGNAL(sigColorModelChanged()), this, SLOT(slotSelectorModelChanged()));
         connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), m_ui->visualSelector, SLOT(configurationChanged()));
     } else {
         m_ui->visualSelector->hide();
     }
     m_ui->visualSelector->slotSetColor(color);
 
     m_d->paletteChooser = new KisPaletteListWidget(this);
     m_d->paletteModel = new KisPaletteModel(this);
     m_ui->bnPaletteChooser->setIcon(KisIconUtils::loadIcon("hi16-palette_library"));
     m_ui->paletteBox->setPaletteModel(m_d->paletteModel);
     m_ui->paletteBox->setDisplayRenderer(displayRenderer);
     m_ui->cmbNameList->setCompanionView(m_ui->paletteBox);
     connect(m_d->paletteChooser, SIGNAL(sigPaletteSelected(KoColorSet*)), this, SLOT(slotChangePalette(KoColorSet*)));
     connect(m_ui->cmbNameList, SIGNAL(sigColorSelected(KoColor)), SLOT(slotColorUpdated(KoColor)));
 
     // For some bizarre reason, the modal dialog doesn't like having the colorset set, so let's not.
     if (config.paletteBox) {
         //TODO: Add disable signal as well. Might be not necessary...?
         KConfigGroup cfg(KSharedConfig::openConfig()->group(""));
         QString paletteName = cfg.readEntry("internal_selector_active_color_set", QString());
         KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
         KoColorSet *savedPal = rServer->resourceByName(paletteName);
         if (savedPal) {
             this->slotChangePalette(savedPal);
         } else {
             if (rServer->resources().count()) {
                 savedPal = rServer->resources().first();
                 if (savedPal) {
                     this->slotChangePalette(savedPal);
                 }
             }
         }
 
         connect(m_ui->paletteBox, SIGNAL(sigColorSelected(KoColor)), this,
                 SLOT(slotColorUpdated(KoColor)));
         m_ui->bnPaletteChooser->setPopupWidget(m_d->paletteChooser);
     } else {
         m_ui->paletteBox->setEnabled(false);
         m_ui->cmbNameList->setEnabled(false);
         m_ui->bnPaletteChooser->setEnabled(false);
     }
 
     if (config.prevNextButtons) {
         m_ui->currentColor->setColor(m_d->currentColor);
         m_ui->currentColor->setDisplayRenderer(displayRenderer);
         m_ui->previousColor->setColor(m_d->currentColor);
         m_ui->previousColor->setDisplayRenderer(displayRenderer);
         connect(m_ui->previousColor, SIGNAL(triggered(KoColorPatch*)), SLOT(slotSetColorFromPatch(KoColorPatch*)));
     } else {
         m_ui->currentColor->hide();
         m_ui->previousColor->hide();
     }
 
     if (config.hexInput) {
         m_d->sRGB.fromKoColor(m_d->currentColor);
         m_d->hexColorInput = new KisHexColorInput(this, &m_d->sRGB);
         m_d->hexColorInput->update();
         connect(m_d->hexColorInput, SIGNAL(updated()), SLOT(slotSetColorFromHex()));
         m_ui->rightPane->addWidget(m_d->hexColorInput);
         m_d->hexColorInput->setToolTip(i18n("This is a hexcode input, for webcolors. It can only get colors in the sRGB space."));
     }
 
     // KisScreenColorPicker is in the kritaui module, so dependency inversion is used to access it.
     m_ui->screenColorPickerWidget->setLayout(new QHBoxLayout(m_ui->screenColorPickerWidget));
     if (s_screenColorPickerFactory) {
         m_d->screenColorPicker = s_screenColorPickerFactory(m_ui->screenColorPickerWidget);
         m_ui->screenColorPickerWidget->layout()->addWidget(m_d->screenColorPicker);
         if (config.screenColorPicker) {
             connect(m_d->screenColorPicker, SIGNAL(sigNewColorPicked(KoColor)),this, SLOT(slotColorUpdated(KoColor)));
         } else {
             m_d->screenColorPicker->hide();
         }
     }
 
     m_d->compressColorChanges = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this);
     connect(m_d->compressColorChanges, SIGNAL(timeout()), this, SLOT(endUpdateWithNewColor()));
 
     connect(m_ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept()), Qt::UniqueConnection);
     connect(m_ui->buttonBox, SIGNAL(rejected()), this, SLOT(reject()), Qt::UniqueConnection);
 
     connect(this, SIGNAL(finished(int)), SLOT(slotFinishUp()));
 }
 
 KisDlgInternalColorSelector::~KisDlgInternalColorSelector()
 {
     delete m_ui;
 }
 
 void KisDlgInternalColorSelector::slotColorUpdated(KoColor newColor)
 {
     // not-so-nice solution: if someone calls this slot directly and that code was
     // triggered by our compressor signal, our compressor is technically the sender()!
     if (sender() == m_d->compressColorChanges) {
         return;
     }
     // Do not accept external updates while a color update emit is pending;
     // Note: Assumes external updates only come from parent(), a separate slot might be better
     if (m_d->allowUpdates || (QObject::sender() && QObject::sender() != this->parent())) {
         // Enforce palette colors
         KConfigGroup group(KSharedConfig::openConfig(), "");
         if (group.readEntry("colorsettings/forcepalettecolors", false)) {
             newColor = m_ui->paletteBox->closestColor(newColor);
         }
 
         if (m_d->lockUsedCS){
             newColor.convertTo(m_d->currentColorSpace);
-            m_d->currentColor = newColor;
         } else {
-            m_d->currentColor = newColor;
+            colorSpaceChanged(newColor.colorSpace());
         }
+        m_d->currentColor = newColor;
         updateAllElements(QObject::sender());
     }
 }
 
 void KisDlgInternalColorSelector::slotSetColorFromPatch(KoColorPatch *patch)
 {
     slotColorUpdated(patch->color());
 }
 
 void KisDlgInternalColorSelector::colorSpaceChanged(const KoColorSpace *cs)
 {
     if (cs == m_d->currentColorSpace) {
         return;
     }
 
     m_d->currentColorSpace = KoColorSpaceRegistry::instance()->colorSpace(cs->colorModelId().id(), cs->colorDepthId().id(), cs->profile());
     m_ui->spinboxselector->slotSetColorSpace(m_d->currentColorSpace);
-    m_ui->visualSelector->slotsetColorSpace(m_d->currentColorSpace);
+    m_ui->visualSelector->slotSetColorSpace(m_d->currentColorSpace);
 
 }
 
 void KisDlgInternalColorSelector::lockUsedColorSpace(const KoColorSpace *cs)
 {
     colorSpaceChanged(cs);
     if (m_d->currentColor.colorSpace() != m_d->currentColorSpace) {
         m_d->currentColor.convertTo(m_d->currentColorSpace);
         m_ui->spinboxselector->slotSetColor(m_d->currentColor);
+        m_ui->visualSelector->slotSetColor(m_d->currentColor);
     }
     m_d->lockUsedCS = true;
 }
 
 void KisDlgInternalColorSelector::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     if (displayRenderer) {
         m_d->displayRenderer = displayRenderer;
         m_ui->visualSelector->setDisplayRenderer(displayRenderer);
         m_ui->currentColor->setDisplayRenderer(displayRenderer);
         m_ui->previousColor->setDisplayRenderer(displayRenderer);
         m_ui->paletteBox->setDisplayRenderer(displayRenderer);
     } else {
         m_d->displayRenderer = KoDumbColorDisplayRenderer::instance();
     }
 }
 
 KoColor KisDlgInternalColorSelector::getModalColorDialog(const KoColor color, QWidget* parent, QString caption)
 {
     Config config = Config();
     KisDlgInternalColorSelector dialog(parent, color, config, caption);
     dialog.setPreviousColor(color);
     dialog.exec();
     return dialog.getCurrentColor();
 }
 
 KoColor KisDlgInternalColorSelector::getCurrentColor()
 {
     return m_d->currentColor;
 }
 
 void KisDlgInternalColorSelector::chooseAlpha(bool chooseAlpha)
 {
     m_d->chooseAlpha = chooseAlpha;
 }
 
 void KisDlgInternalColorSelector::setPreviousColor(KoColor c)
 {
     m_d->previousColor = c;
 }
 
 void KisDlgInternalColorSelector::reject()
 {
     slotColorUpdated(m_d->previousColor);
     QDialog::reject();
 }
 
 void KisDlgInternalColorSelector::updateAllElements(QObject *source)
 {
     //update everything!!!
     if (source != m_ui->spinboxselector) {
         m_ui->spinboxselector->slotSetColor(m_d->currentColor);
     }
     if (source != m_ui->visualSelector) {
         m_ui->visualSelector->slotSetColor(m_d->currentColor);
     }
 
     if (source != m_d->hexColorInput) {
         m_d->sRGB.fromKoColor(m_d->currentColor);
         m_d->hexColorInput->update();
     }
 
     if (source != m_ui->paletteBox) {
         m_ui->paletteBox->selectClosestColor(m_d->currentColor);
     }
 
     m_ui->previousColor->setColor(m_d->previousColor);
 
     m_ui->currentColor->setColor(m_d->currentColor);
 
     if (source && source != this->parent()) {
         m_d->allowUpdates = false;
         m_d->compressColorChanges->start();
     }
 
     if (m_d->screenColorPicker) {
         m_d->screenColorPicker->updateIcons();
     }
 }
 
 void KisDlgInternalColorSelector::slotSelectorModelChanged()
 {
     if (m_ui->visualSelector->isHSXModel()) {
         QString label;
         switch (m_ui->visualSelector->getColorModel()) {
         case KisVisualColorSelector::HSV:
             label = i18n("HSV");
             break;
         case KisVisualColorSelector::HSL:
             label = i18n("HSL");
             break;
         case KisVisualColorSelector::HSI:
             label = i18n("HSI");
             break;
         case KisVisualColorSelector::HSY:
             label = i18n("HSY'");
             break;
         default:
             label =  i18n("Unknown");
         }
         if (m_ui->tabWidget->count() == 1) {
             m_ui->tabWidget->addTab(m_ui->tab_hsx, label);
         }
         else {
             m_ui->tabWidget->setTabText(1, label);
         }
     }
     else {
         if (m_ui->tabWidget->count() == 2) {
             m_ui->tabWidget->removeTab(1);
         }
     }
 }
 
 void KisDlgInternalColorSelector::endUpdateWithNewColor()
 {
     emit signalForegroundColorChosen(m_d->currentColor);
     m_d->allowUpdates = true;
 }
 
 void KisDlgInternalColorSelector::focusInEvent(QFocusEvent *)
 {
     //setPreviousColor();
 }
 
 void KisDlgInternalColorSelector::slotFinishUp()
 {
     setPreviousColor(m_d->currentColor);
     KConfigGroup cfg(KSharedConfig::openConfig()->group(""));
     if (m_d->paletteModel) {
         if (m_d->paletteModel->colorSet()) {
             cfg.writeEntry("internal_selector_active_color_set", m_d->paletteModel->colorSet()->name());
         }
     }
 }
 
 void KisDlgInternalColorSelector::slotSetColorFromHex()
 {
     slotColorUpdated(m_d->sRGB);
 }
 
 void KisDlgInternalColorSelector::slotChangePalette(KoColorSet *set)
 {
     if (!set) {
         return;
     }
     m_d->paletteModel->setPalette(set);
 }
 
 void KisDlgInternalColorSelector::showEvent(QShowEvent *event)
 {
     updateAllElements(0);
     QDialog::showEvent(event);
 }
 
diff --git a/libs/widgets/KisVisualColorSelector.cpp b/libs/widgets/KisVisualColorSelector.cpp
index 1304e778de..54f743c8e2 100644
--- a/libs/widgets/KisVisualColorSelector.cpp
+++ b/libs/widgets/KisVisualColorSelector.cpp
@@ -1,645 +1,647 @@
 /*
  * 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 "KisVisualColorSelector.h"
 
 #include <QColor>
 #include <QPixmap>
 #include <QPainter>
 #include <QPainterPath>
 #include <QRect>
 #include <QVector>
 #include <QVector3D>
 #include <QVector4D>
 #include <QVBoxLayout>
 #include <QList>
 #include <QPolygon>
 #include <QtMath>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 #include "KoColorConversions.h"
 #include "KoColorDisplayRendererInterface.h"
 #include "KoColorProfile.h"
 #include "KoChannelInfo.h"
 #include <KoColorModelStandardIds.h>
 #include <QPointer>
 #include "kis_signal_compressor.h"
 #include "kis_debug.h"
 
 #include "KisVisualColorSelectorShape.h"
 #include "KisVisualRectangleSelectorShape.h"
 #include "KisVisualTriangleSelectorShape.h"
 #include "KisVisualEllipticalSelectorShape.h"
 
 struct KisVisualColorSelector::Private
 {
     KoColor currentcolor;
     const KoColorSpace *currentCS {0};
     QList<KisVisualColorSelectorShape*> widgetlist;
     bool acceptTabletEvents {false};
     bool circular {false};
     bool exposureSupported {false};
     bool isRGBA {false};
     bool isLinear {false};
     bool applyGamma {false};
     int displayPosition[4]; // map channel index to storage index for display
     int colorChannelCount {0};
     qreal gamma {2.2};
     qreal lumaRGB[3] {0.2126, 0.7152, 0.0722};
     QVector4D channelValues;
     QVector4D channelMaxValues;
     ColorModel model {ColorModel::None};
     const KoColorDisplayRendererInterface *displayRenderer {0};
     KisColorSelectorConfiguration acs_config;
     KisSignalCompressor *updateTimer {0};
 };
 
 KisVisualColorSelector::KisVisualColorSelector(QWidget *parent)
     : KisColorSelectorInterface(parent)
     , m_d(new Private)
 {
     this->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     m_d->acs_config = KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString()));
     m_d->updateTimer = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE);
     connect(m_d->updateTimer, SIGNAL(timeout()), SLOT(slotRebuildSelectors()), Qt::UniqueConnection);
 }
 
 KisVisualColorSelector::~KisVisualColorSelector()
 {
     delete m_d->updateTimer;
 }
 
 void KisVisualColorSelector::slotSetColor(const KoColor &c)
 {
-    m_d->currentcolor = c;
-    if (m_d->currentCS != c.colorSpace()) {
-        slotsetColorSpace(c.colorSpace());
+    if (!m_d->currentCS) {
+        m_d->currentcolor = c;
+        slotSetColorSpace(c.colorSpace());
     }
     else {
+        m_d->currentcolor = c.convertedTo(m_d->currentCS);
         m_d->channelValues = convertKoColorToShapeCoordinates(m_d->currentcolor);
         Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
             shape->setChannelValues(m_d->channelValues, true);
         }
     }
     if (isHSXModel()) {
         emit sigHSXChanged(QVector3D(m_d->channelValues));
     }
 }
 
-void KisVisualColorSelector::slotsetColorSpace(const KoColorSpace *cs)
+void KisVisualColorSelector::slotSetColorSpace(const KoColorSpace *cs)
 {
     if (m_d->currentCS != cs) {
         m_d->currentCS = cs;
+        m_d->currentcolor = KoColor(cs);
         slotRebuildSelectors();
     }
 }
 
 void KisVisualColorSelector::slotSetHSX(const QVector3D &hsx)
 {
     if (isHSXModel()) {
         m_d->channelValues = QVector4D(hsx, 0.f);
         Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
             shape->setChannelValues(m_d->channelValues, true);
         }
         KoColor newColor = convertShapeCoordsToKoColor(QVector4D(hsx));
         if (newColor != m_d->currentcolor) {
             m_d->currentcolor = newColor;
             emit sigNewColor(m_d->currentcolor);
         }
     }
 }
 
 void KisVisualColorSelector::setConfig(bool forceCircular, bool forceSelfUpdate)
 {
     Q_UNUSED(forceSelfUpdate)
     m_d->circular = forceCircular;
 }
 
 void KisVisualColorSelector::setAcceptTabletEvents(bool on)
 {
     m_d->acceptTabletEvents = on;
     Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
         shape->setAcceptTabletEvents(on);
     }
 }
 
 KoColor KisVisualColorSelector::getCurrentColor() const
 {
     return m_d->currentcolor;
 }
 
 QVector4D KisVisualColorSelector::getChannelValues() const
 {
     return m_d->channelValues;
 }
 
 KisVisualColorSelector::ColorModel KisVisualColorSelector::getColorModel() const
 {
     return m_d->model;
 }
 
 bool KisVisualColorSelector::isHSXModel() const
 {
     return (m_d->model >= ColorModel::HSV && m_d->model <= ColorModel::HSY);
 }
 
 KoColor KisVisualColorSelector::convertShapeCoordsToKoColor(const QVector4D &coordinates) const
 {
     KoColor c(m_d->currentCS);
     QVector4D baseValues(coordinates);
     QVector <float> channelValues(c.colorSpace()->channelCount());
     channelValues.fill(1.0);
 
     if (m_d->model != ColorModel::Channel && m_d->isRGBA == true) {
 
         if (m_d->model == ColorModel::HSV) {
             HSVToRGB(coordinates.x()*360, coordinates.y(), coordinates.z(), &baseValues[0], &baseValues[1], &baseValues[2]);
         }
         else if (m_d->model == ColorModel::HSL) {
             HSLToRGB(coordinates.x()*360, coordinates.y(), coordinates.z(), &baseValues[0], &baseValues[1], &baseValues[2]);
         }
         else if (m_d->model == ColorModel::HSI) {
             // why suddenly qreal?
             qreal temp[3];
             HSIToRGB(coordinates.x(), coordinates.y(), coordinates.z(), &temp[0], &temp[1], &temp[2]);
             baseValues.setX(temp[0]);
             baseValues.setY(temp[1]);
             baseValues.setZ(temp[2]);
         }
         else /*if (m_d->model == ColorModel::HSY)*/ {
             qreal temp[3];
             qreal Y = pow(coordinates.z(), m_d->gamma);
             HSYToRGB(coordinates.x(), coordinates.y(), Y, &temp[0], &temp[1], &temp[2],
                     m_d->lumaRGB[0], m_d->lumaRGB[1], m_d->lumaRGB[2]);
             baseValues.setX(temp[0]);
             baseValues.setY(temp[1]);
             baseValues.setZ(temp[2]);
             if (!m_d->isLinear) {
                 // Note: not all profiles define a TRC necessary for (de-)linearization,
                 // substituting with a linear profiles would be better
                 QVector<qreal> temp({baseValues[0], baseValues[1], baseValues[2]});
                 if (m_d->exposureSupported) {
                     m_d->currentCS->profile()->delinearizeFloatValue(temp);
                 }
                 else {
                     m_d->currentCS->profile()->delinearizeFloatValueFast(temp);
                 }
                 baseValues = QVector4D(temp[0], temp[1], temp[2], 0);
             }
         }
         if (m_d->applyGamma) {
             for (int i=0; i<3; i++) {
                 baseValues[i] = pow(baseValues[i], 2.2);
             }
         }
     }
 
     if (m_d->exposureSupported) {
         baseValues *= m_d->channelMaxValues;
     }
 
     for (int i=0; i<m_d->colorChannelCount; i++) {
         channelValues[m_d->displayPosition[i]] = baseValues[i];
     }
 
     c.colorSpace()->fromNormalisedChannelsValue(c.data(), channelValues);
 
     return c;
 
 }
 
 QVector4D KisVisualColorSelector::convertKoColorToShapeCoordinates(KoColor c) const
 {
     if (c.colorSpace() != m_d->currentCS) {
         c.convertTo(m_d->currentCS);
     }
     QVector <float> channelValues (c.colorSpace()->channelCount());
     channelValues.fill(1.0);
     m_d->currentCS->normalisedChannelsValue(c.data(), channelValues);
     QVector4D channelValuesDisplay(0, 0, 0, 0), coordinates(0, 0, 0, 0);
 
     for (int i =0; i<m_d->colorChannelCount; i++) {
         channelValuesDisplay[i] = channelValues[m_d->displayPosition[i]];
     }
 
     if (m_d->exposureSupported) {
         channelValuesDisplay /= m_d->channelMaxValues;
     }
     if (m_d->model != ColorModel::Channel && m_d->isRGBA == true) {
         if (m_d->isRGBA == true) {
             if (m_d->applyGamma) {
                 for (int i=0; i<3; i++) {
                     channelValuesDisplay[i] = pow(channelValuesDisplay[i], 1/2.2);
                 }
             }
             if (m_d->model == ColorModel::HSV) {
                 QVector3D hsv;
                 RGBToHSV(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsv[0], &hsv[1], &hsv[2]);
                 hsv[0] /= 360;
                 coordinates = QVector4D(hsv, 0.f);
             } else if (m_d->model == ColorModel::HSL) {
                 QVector3D hsl;
                 RGBToHSL(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsl[0], &hsl[1], &hsl[2]);
                 hsl[0] /= 360;
                 coordinates = QVector4D(hsl, 0.f);
             } else if (m_d->model == ColorModel::HSI) {
                 qreal hsi[3];
                 RGBToHSI(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsi[0], &hsi[1], &hsi[2]);
                 coordinates = QVector4D(hsi[0], hsi[1], hsi[2], 0.f);
             } else if (m_d->model == ColorModel::HSY) {
                 if (!m_d->isLinear) {
                     // Note: not all profiles define a TRC necessary for (de-)linearization,
                     // substituting with a linear profiles would be better
                     QVector<qreal> temp({channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2]});
                     m_d->currentCS->profile()->linearizeFloatValue(temp);
                     channelValuesDisplay = QVector4D(temp[0], temp[1], temp[2], 0);
                 }
                 qreal hsy[3];
                 RGBToHSY(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsy[0], &hsy[1], &hsy[2],
                          m_d->lumaRGB[0], m_d->lumaRGB[1], m_d->lumaRGB[2]);
                 hsy[2] = pow(hsy[2], 1/m_d->gamma);
                 coordinates = QVector4D(hsy[0], hsy[1], hsy[2], 0.f);
             }
             // if we couldn't determine a hue, keep last value
             if (coordinates[0] < 0) {
                 coordinates[0] = m_d->channelValues[0];
             }
             for (int i=0; i<3; i++) {
                 coordinates[i] = qBound(0.f, coordinates[i], 1.f);
             }
         }
     } else {
         for (int i=0; i<4; i++) {
             coordinates[i] = qBound(0.f, channelValuesDisplay[i], 1.f);
         }
     }
     return coordinates;
 }
 
 void KisVisualColorSelector::configurationChanged()
 {
     if (m_d->updateTimer) {
         m_d->updateTimer->start();
     }
 }
 
 void KisVisualColorSelector::slotDisplayConfigurationChanged()
 {
     Q_ASSERT(m_d->displayRenderer);
 
     if (m_d->currentCS)
     {
         m_d->channelMaxValues = QVector4D(1, 1, 1, 1);
         QList<KoChannelInfo *> channels = m_d->currentCS->channels();
         for (int i=0; i<m_d->colorChannelCount; ++i)
         {
             m_d->channelMaxValues[i] = m_d->displayRenderer->maxVisibleFloatValue(channels[m_d->displayPosition[i]]);
         }
         // need to re-scale our normalized channel values on exposure changes:
         m_d->channelValues = convertKoColorToShapeCoordinates(m_d->currentcolor);
         Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
             shape->setChannelValues(m_d->channelValues, true);
         }
         if (isHSXModel()) {
             emit sigHSXChanged(QVector3D(m_d->channelValues));
         }
     }
 }
 
 void KisVisualColorSelector::slotRebuildSelectors()
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     m_d->acs_config = KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString()));
 
     ColorModel oldModel = m_d->model;
     QList<KoChannelInfo *> channelList = m_d->currentCS->channels();
     int cCount = 0;
     Q_FOREACH(const KoChannelInfo *channel, channelList)
     {
         if (channel->channelType() != KoChannelInfo::ALPHA)
         {
             m_d->displayPosition[cCount] = channel->displayPosition();
             ++cCount;
         }
     }
     Q_ASSERT_X(cCount < 5, "", "unsupported channel count!");
     m_d->colorChannelCount = cCount;
 
     // TODO: The following is done because the IDs are actually strings. Ideally, in the future, we
     // refactor everything so that the IDs are actually proper enums or something faster.
     if (m_d->displayRenderer
             && (m_d->currentCS->colorDepthId() == Float16BitsColorDepthID
                 || m_d->currentCS->colorDepthId() == Float32BitsColorDepthID
                 || m_d->currentCS->colorDepthId() == Float64BitsColorDepthID)
             && m_d->currentCS->colorModelId() != LABAColorModelID
             && m_d->currentCS->colorModelId() != CMYKAColorModelID) {
         m_d->exposureSupported = true;
     } else {
         m_d->exposureSupported = false;
     }
     m_d->isRGBA = (m_d->currentCS->colorModelId() == RGBAColorModelID);
     const KoColorProfile *profile = m_d->currentCS->profile();
     m_d->isLinear = (profile && profile->isLinear());
 
     qDeleteAll(children());
     m_d->widgetlist.clear();
     // TODO: Layout only used for monochrome selector currently, but always present
     QLayout *layout = new QHBoxLayout;
     //recreate all the widgets.
     m_d->model = KisVisualColorSelector::Channel;
 
     if (m_d->currentCS->colorChannelCount() == 1) {
 
         KisVisualColorSelectorShape *bar;
 
         if (m_d->circular==false) {
             bar = new KisVisualRectangleSelectorShape(this, KisVisualColorSelectorShape::onedimensional, m_d->currentCS, 0, 0,m_d->displayRenderer, 20);
             bar->setMaximumWidth(width()*0.1);
             bar->setMaximumHeight(height());
         }
         else {
             bar = new KisVisualEllipticalSelectorShape(this, KisVisualColorSelectorShape::onedimensional, m_d->currentCS, 0, 0,m_d->displayRenderer, 20, KisVisualEllipticalSelectorShape::borderMirrored);
             layout->setMargin(0);
         }
 
         connect(bar, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         layout->addWidget(bar);
         m_d->widgetlist.append(bar);
     }
     else if (m_d->currentCS->colorChannelCount() == 3) {
         KisVisualColorSelector::ColorModel modelS = KisVisualColorSelector::HSV;
         int channel1 = 0;
         int channel2 = 1;
         int channel3 = 2;
 
         switch(m_d->acs_config.subTypeParameter)
         {
         case KisColorSelectorConfiguration::H:
             channel1 = 0;
             break;
         case KisColorSelectorConfiguration::hsyS:
         case KisColorSelectorConfiguration::hsiS:
         case KisColorSelectorConfiguration::hslS:
         case KisColorSelectorConfiguration::hsvS:
             channel1 = 1;
             break;
         case KisColorSelectorConfiguration::V:
         case KisColorSelectorConfiguration::L:
         case KisColorSelectorConfiguration::I:
         case KisColorSelectorConfiguration::Y:
             channel1 = 2;
             break;
         default:
             Q_ASSERT_X(false, "", "Invalid acs_config.subTypeParameter");
         }
 
         switch(m_d->acs_config.mainTypeParameter)
         {
         case KisColorSelectorConfiguration::hsySH:
             modelS = KisVisualColorSelector::HSY;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::hsiSH:
             modelS = KisVisualColorSelector::HSI;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::hslSH:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::hsvSH:
             modelS = KisVisualColorSelector::HSV;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::YH:
             modelS = KisVisualColorSelector::HSY;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::LH:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::IH:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::VH:
             modelS = KisVisualColorSelector::HSV;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SY:
             modelS = KisVisualColorSelector::HSY;
             channel2 = 1;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SI:
             modelS = KisVisualColorSelector::HSI;
             channel2 = 1;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SL:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 1;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SV:
         case KisColorSelectorConfiguration::SV2:
             modelS = KisVisualColorSelector::HSV;
             channel2 = 1;
             channel3 = 2;
             break;
         default:
             Q_ASSERT_X(false, "", "Invalid acs_config.mainTypeParameter");
         }
         if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
             modelS = KisVisualColorSelector::HSV;
             //Triangle only really works in HSV mode.
         }
 
         // L*a*b* mimics the HSX selector types, but model is still Channel (until someone implements LCH)
         if (m_d->isRGBA) {
             m_d->model = modelS;
             m_d->gamma = cfg.readEntry("gamma", 2.2);
             m_d->applyGamma = (m_d->isLinear && modelS != ColorModel::HSY);
             // Note: only profiles that define colorants will give precise luma coefficients.
             // Maybe using the explicitly set values of the Advanced Color Selector is better?
             QVector <qreal> luma = m_d->currentCS->lumaCoefficients();
             memcpy(m_d->lumaRGB, luma.constData(), 3*sizeof(qreal));
         }
 
         KisVisualColorSelectorShape *bar;
         if (m_d->acs_config.subType == KisColorSelectorConfiguration::Ring) {
             bar = new KisVisualEllipticalSelectorShape(this,
                                                        KisVisualColorSelectorShape::onedimensional,
                                                        m_d->currentCS, channel1, channel1,
                                                        m_d->displayRenderer, 20,KisVisualEllipticalSelectorShape::border);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular == false) {
             bar = new KisVisualRectangleSelectorShape(this,
                                                       KisVisualColorSelectorShape::onedimensional,
                                                       m_d->currentCS, channel1, channel1,
                                                       m_d->displayRenderer, 20);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular == true) {
             bar = new KisVisualEllipticalSelectorShape(this,
                                                        KisVisualColorSelectorShape::onedimensional,
                                                        m_d->currentCS, channel1, channel1,
                                                        m_d->displayRenderer, 20, KisVisualEllipticalSelectorShape::borderMirrored);
         } else {
             // Accessing bar below would crash since it's not initialized.
             // Hopefully this can never happen.
             warnUI << "Invalid subType, cannot initialize KisVisualColorSelectorShape";
             Q_ASSERT_X(false, "", "Invalid subType, cannot initialize KisVisualColorSelectorShape");
             return;
         }
 
         m_d->widgetlist.append(bar);
 
         KisVisualColorSelectorShape *block;
         if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
             block = new KisVisualTriangleSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                        m_d->currentCS, channel2, channel3,
                                                        m_d->displayRenderer);
         }
         else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Square) {
             block = new KisVisualRectangleSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                         m_d->currentCS, channel2, channel3,
                                                         m_d->displayRenderer);
         }
         else {
             block = new KisVisualEllipticalSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                          m_d->currentCS, channel2, channel3,
                                                          m_d->displayRenderer);
         }
 
         connect(bar, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         connect(block, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         m_d->widgetlist.append(block);
     }
     else if (m_d->currentCS->colorChannelCount() == 4) {
         KisVisualRectangleSelectorShape *block =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional, m_d->currentCS, 0, 1);
         KisVisualRectangleSelectorShape *block2 =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional, m_d->currentCS, 2, 3);
         connect(block, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         connect(block2, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         m_d->widgetlist.append(block);
         m_d->widgetlist.append(block2);
     }
 
     this->setLayout(layout);
     // make sure we call "our" resize function
     KisVisualColorSelector::resizeEvent(0);
 
     // finally recalculate channel values and update widgets
     if (m_d->displayRenderer) {
         slotDisplayConfigurationChanged();
     }
     m_d->channelValues = convertKoColorToShapeCoordinates(m_d->currentcolor);
     Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
         shape->setChannelValues(m_d->channelValues, true);
         shape->setAcceptTabletEvents(m_d->acceptTabletEvents);
         // if this widget is currently visible, new children are hidden by default
         shape->show();
     }
     if (m_d->model != oldModel) {
         emit sigColorModelChanged();
     }
 }
 
 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);
         }
     }
     connect(m_d->displayRenderer, SIGNAL(displayConfigurationChanged()),
             SLOT(slotDisplayConfigurationChanged()), Qt::UniqueConnection);
     slotDisplayConfigurationChanged();
 }
 
 void KisVisualColorSelector::slotCursorMoved(QPointF pos)
 {
     const KisVisualColorSelectorShape *shape = qobject_cast<KisVisualColorSelectorShape *>(sender());
     Q_ASSERT(shape);
     QVector<int> channels = shape->getChannels();
     m_d->channelValues[channels.at(0)] = pos.x();
     if (shape->getDimensions() == KisVisualColorSelectorShape::twodimensional) {
         m_d->channelValues[channels.at(1)] = pos.y();
     }
     KoColor newColor = convertShapeCoordsToKoColor(m_d->channelValues);
     if (newColor != m_d->currentcolor) {
         m_d->currentcolor = newColor;
         emit sigNewColor(m_d->currentcolor);
     }
     if (isHSXModel()) {
         emit sigHSXChanged(QVector3D(m_d->channelValues));
     }
     Q_FOREACH (KisVisualColorSelectorShape *widget, m_d->widgetlist) {
         if (widget != shape){
             widget->setChannelValues(m_d->channelValues, false);
         }
     }
 }
 
 void KisVisualColorSelector::resizeEvent(QResizeEvent *) {
     int sizeValue = qMin(width(), height());
     int borderWidth = qMax(sizeValue*0.1, 20.0);
     QRect newrect(0,0, this->geometry().width(), this->geometry().height());
     if (!m_d->currentCS) {
-        slotsetColorSpace(m_d->currentcolor.colorSpace());
+        slotSetColorSpace(m_d->currentcolor.colorSpace());
     }
     if (m_d->currentCS->colorChannelCount()==3) {
         // set border width first, else the resized painting may have happened already, and we'd have to re-render
         m_d->widgetlist.at(0)->setBorderWidth(borderWidth);
         if (m_d->acs_config.subType == KisColorSelectorConfiguration::Ring) {
             m_d->widgetlist.at(0)->resize(sizeValue,sizeValue);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular==false) {
             m_d->widgetlist.at(0)->resize(borderWidth, sizeValue);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular==true) {
             m_d->widgetlist.at(0)->resize(sizeValue,sizeValue);
         }
 
         if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
             m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForTriangle(newrect));
         }
         else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Square) {
             m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForSquare(newrect));
         }
         else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Wheel) {
             m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForCircle(newrect));
         }
     }
     else if (m_d->currentCS->colorChannelCount() == 4) {
         int sizeBlock = qMin(width()/2 - 8, height());
         m_d->widgetlist.at(0)->setGeometry(0, 0, sizeBlock, sizeBlock);
         m_d->widgetlist.at(1)->setGeometry(sizeBlock + 8, 0, sizeBlock, sizeBlock);
     }
 }
diff --git a/libs/widgets/KisVisualColorSelector.h b/libs/widgets/KisVisualColorSelector.h
index 1dde10ab7b..ceae1aa13f 100644
--- a/libs/widgets/KisVisualColorSelector.h
+++ b/libs/widgets/KisVisualColorSelector.h
@@ -1,103 +1,103 @@
 /*
  * 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.
  */
 #ifndef KIS_VISUAL_COLOR_SELECTOR_H
 #define KIS_VISUAL_COLOR_SELECTOR_H
 
 #include <QWidget>
 #include <QScopedPointer>
 #include <QPixmap>
 #include <QRegion>
 #include <QMouseEvent>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include "KoColorDisplayRendererInterface.h"
 
 #include "KisColorSelectorConfiguration.h"
 #include "KisColorSelectorInterface.h"
 #include "kritawidgets_export.h"
 
 /**
  * @brief The KisVisualColorSelector class
  *
  * This gives a color selector box that draws gradients and everything.
  *
  * Unlike other color selectors, this one draws the full gamut of the given
  * colorspace.
  */
 class KRITAWIDGETS_EXPORT KisVisualColorSelector : public KisColorSelectorInterface
 {
     Q_OBJECT
 public:
     enum ColorModel { None, Channel, HSV, HSL, HSI, HSY, YUV };
 
     explicit KisVisualColorSelector(QWidget *parent = 0);
     ~KisVisualColorSelector() override;
 
     /**
      * @brief setConfig
      * @param forceCircular
      * Force circular is for space where you only have room for a circular selector.
      * @param forceSelfUpdate
      * ignored, can possibly be removed from parent class now
      */
     void setConfig(bool forceCircular, bool forceSelfUpdate) override;
     void setAcceptTabletEvents(bool on);
     KoColor getCurrentColor() const override;
     QVector4D getChannelValues() const;
     ColorModel getColorModel() const;
     bool isHSXModel() const;
     KoColor convertShapeCoordsToKoColor(const QVector4D &coordinates) const;
     QVector4D convertKoColorToShapeCoordinates(KoColor c) const;
 
 public Q_SLOTS:
 
     void slotSetColor(const KoColor &c) override;
-    void slotsetColorSpace(const KoColorSpace *cs);
+    void slotSetColorSpace(const KoColorSpace *cs) override;
     void slotSetHSX(const QVector3D &hsx);
     void configurationChanged();
     void setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer) override;
 
 private Q_SLOTS:
     void slotCursorMoved(QPointF pos);
     void slotDisplayConfigurationChanged();
     void slotRebuildSelectors();
 
 Q_SIGNALS:
     /**
      * @brief sigColorModelChanged is emitted whenever the selector's color model changes.
      *
      * This is mostly relevant for configuration changes where the same RGB model
      * gets represented in a different way like HSV, HSL etc. so the values of
      * sigHSXChanged() change meaning.
      *
      * @see getColorModel()
      */
     void sigColorModelChanged();
     void sigHSXChanged(const QVector3D &hsx);
 
 protected:
     void resizeEvent(QResizeEvent *) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 
 };
 
 #endif
diff --git a/plugins/filters/asccdl/kis_wdg_asccdl.cpp b/plugins/filters/asccdl/kis_wdg_asccdl.cpp
index 5ad76ce753..ccd9f14d69 100644
--- a/plugins/filters/asccdl/kis_wdg_asccdl.cpp
+++ b/plugins/filters/asccdl/kis_wdg_asccdl.cpp
@@ -1,116 +1,120 @@
 /*
  * Copyright (c) 2017 Wolthera van Hövell tot Westerflier <griffinvalley@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_wdg_asccdl.h"
 #include <kis_config.h>
 #include <kis_color_button.h>
 #include <kis_filter_configuration.h>
 #include <KisVisualColorSelectorShape.h>
 #include <KisVisualRectangleSelectorShape.h>
 #include <KisVisualEllipticalSelectorShape.h>
 
 KisASCCDLConfigWidget::KisASCCDLConfigWidget(QWidget *parent, const KoColorSpace *cs)
     :KisConfigWidget(parent),
     m_page(new Ui_WdgASCCDL),
     m_cs(cs)
 
 {
     KoColor black(Qt::black, cs);
     m_page->setupUi(this);
     m_page->btnSlope->setColor(black);
     m_page->btnOffset->setColor(black);
     m_page->btnPower->setColor(black);
 
+    m_page->slopeSelector->slotSetColorSpace(m_cs);
+    m_page->offsetSelector->slotSetColorSpace(m_cs);
+    m_page->powerSelector->slotSetColorSpace(m_cs);
+
     connect(m_page->btnSlope , SIGNAL(changed(KoColor)), this,  SLOT(slopeColorChanged(KoColor)));
     connect(m_page->btnOffset, SIGNAL(changed(KoColor)), this,  SLOT(offsetColorChanged(KoColor)));
     connect(m_page->btnPower , SIGNAL(changed(KoColor)), this,  SLOT(powerColorChanged(KoColor)));
     connect(m_page->slopeSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(slopeColorChanged(KoColor)));
     connect(m_page->offsetSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(offsetColorChanged(KoColor)));
     connect(m_page->powerSelector, SIGNAL(sigNewColor(KoColor)), this, SLOT(powerColorChanged(KoColor)));
 }
 
 KisASCCDLConfigWidget::~KisASCCDLConfigWidget()
 {
     delete m_page;
 }
 
 KisPropertiesConfigurationSP KisASCCDLConfigWidget::configuration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration("asc-cdl", 0);
     QVariant colorVariant("KoColor");
     colorVariant.setValue(m_page->btnSlope->color());
     config->setProperty("slope", colorVariant);
     colorVariant.setValue(m_page->btnOffset->color());
     config->setProperty("offset", colorVariant);
     colorVariant.setValue(m_page->btnPower->color());
     config->setProperty("power", colorVariant);
     return config;
 }
 
 void KisASCCDLConfigWidget::setConfiguration(const KisPropertiesConfigurationSP config)
 {
     KoColor white(m_cs);
     QVector<float> channels(m_cs->channelCount());
     m_cs->normalisedChannelsValue(white.data(), channels);
     channels.fill(1.0);
     m_cs->fromNormalisedChannelsValue(white.data(), channels);
     KoColor black(Qt::black, m_cs);
     KoColor slope = config->getColor("slope", white);
     slope.convertTo(m_cs);
     KoColor offset = config->getColor("offset", black);
     offset.convertTo(m_cs);
     KoColor power = config->getColor("power", white);
     power.convertTo(m_cs);
 
     m_page->btnSlope->setColor(slope);
     m_page->slopeSelector->slotSetColor(slope);
     m_page->btnOffset->setColor(offset);
     m_page->offsetSelector->slotSetColor(offset);
     m_page->btnPower->setColor (power);
     m_page->powerSelector->slotSetColor(power);
 }
 
 void KisASCCDLConfigWidget::slopeColorChanged(const KoColor &c)
 {
     if (QObject::sender() == m_page->btnSlope) {
         m_page->slopeSelector->slotSetColor(c);
     } else {
         m_page->btnSlope->setColor(c);
     }
     emit sigConfigurationItemChanged();
 }
 
 void KisASCCDLConfigWidget::offsetColorChanged(const KoColor &c)
 {
     if (QObject::sender() == m_page->btnOffset) {
         m_page->offsetSelector->slotSetColor(c);
     } else {
         m_page->btnOffset->setColor(c);
     }
     emit sigConfigurationItemChanged();
 }
 
 void KisASCCDLConfigWidget::powerColorChanged(const KoColor &c)
 {
     if (QObject::sender() == m_page->btnPower) {
         m_page->powerSelector->slotSetColor(c);
     } else {
         m_page->btnPower->setColor(c);
     }
     emit sigConfigurationItemChanged();
 }