diff --git a/krita/data/gamutmasks/Atmosphere_With_Accent.kgm b/krita/data/gamutmasks/Atmosphere_With_Accent.kgm
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
GIT binary patch
literal 0
Hc$@<O00001

literal 0
Hc$@<O00001

diff --git a/libs/flake/KisGamutMaskViewConverter.h b/libs/flake/KisGamutMaskViewConverter.h
--- a/libs/flake/KisGamutMaskViewConverter.h
+++ b/libs/flake/KisGamutMaskViewConverter.h
@@ -36,7 +36,9 @@
     KisGamutMaskViewConverter();
     ~KisGamutMaskViewConverter();
 
+    QSize viewSize() const;
     void setViewSize(QSize viewSize);
+
     void setMaskSize(QSizeF maskSize);
 
     QPointF documentToView(const QPointF &documentPoint) const override;
diff --git a/libs/flake/KisGamutMaskViewConverter.cpp b/libs/flake/KisGamutMaskViewConverter.cpp
--- a/libs/flake/KisGamutMaskViewConverter.cpp
+++ b/libs/flake/KisGamutMaskViewConverter.cpp
@@ -37,6 +37,11 @@
 {
 }
 
+QSize KisGamutMaskViewConverter::viewSize() const
+{
+    return QSize(m_viewSize, m_viewSize);
+}
+
 QPointF KisGamutMaskViewConverter::documentToView(const QPointF &documentPoint) const
 {
     return QPointF(documentToViewX(documentPoint.x()), documentToViewY(documentPoint.y()));
diff --git a/libs/flake/resources/KoGamutMask.h b/libs/flake/resources/KoGamutMask.h
--- a/libs/flake/resources/KoGamutMask.h
+++ b/libs/flake/resources/KoGamutMask.h
@@ -38,10 +38,10 @@
     KoGamutMaskShape();
     ~KoGamutMaskShape();
 
-    bool coordIsClear(const QPointF& coord, const KoViewConverter& viewConverter) const;
+    bool coordIsClear(const QPointF& coord, const KoViewConverter& viewConverter, int maskRotation) const;
     QPainterPath outline();
-    void paint(QPainter &painter, const KoViewConverter& viewConverter);
-    void paintStroke(QPainter &painter, const KoViewConverter& viewConverter);
+    void paint(QPainter &painter, const KoViewConverter& viewConverter, int maskRotation);
+    void paintStroke(QPainter &painter, const KoViewConverter& viewConverter, int maskRotation);
     KoShape* koShape();
 
 private:
@@ -78,6 +78,9 @@
     QString description();
     void setDescription(QString description);
 
+    int rotation();
+    void setRotation(int rotation);
+
     QSizeF maskSize();
 
     void setMaskShapes(QList<KoShape*> shapes);   
diff --git a/libs/flake/resources/KoGamutMask.cpp b/libs/flake/resources/KoGamutMask.cpp
--- a/libs/flake/resources/KoGamutMask.cpp
+++ b/libs/flake/resources/KoGamutMask.cpp
@@ -54,26 +54,49 @@
     return m_maskShape;
 }
 
-bool KoGamutMaskShape::coordIsClear(const QPointF& coord, const KoViewConverter& viewConverter) const
+bool KoGamutMaskShape::coordIsClear(const QPointF& coord, const KoViewConverter& viewConverter, int maskRotation) const
 {
-    QPointF translatedPoint = viewConverter.viewToDocument(coord);
+    // apply mask rotation to coord
+    const KisGamutMaskViewConverter& converter = dynamic_cast<const KisGamutMaskViewConverter&>(viewConverter);
+    QPointF centerPoint(converter.viewSize().width()*0.5, converter.viewSize().height()*0.5);
+
+    QTransform rotationTransform;
+    rotationTransform.translate(centerPoint.x(), centerPoint.y());
+    rotationTransform.rotate(-maskRotation);
+    rotationTransform.translate(-centerPoint.x(), -centerPoint.y());
+
+    QPointF rotatedCoord = rotationTransform.map(coord);
+    QPointF translatedPoint = viewConverter.viewToDocument(rotatedCoord);
 
     bool isClear = m_maskShape->hitTest(translatedPoint);
 
     return isClear;
 }
 
-void KoGamutMaskShape::paint(QPainter &painter, const KoViewConverter& viewConverter)
+void KoGamutMaskShape::paint(QPainter &painter, const KoViewConverter& viewConverter, int maskRotation)
 {
     painter.save();
+
+    // apply mask rotation before drawing
+    QPointF centerPoint(painter.viewport().width()*0.5, painter.viewport().height()*0.5);
+    painter.translate(centerPoint);
+    painter.rotate(maskRotation);
+    painter.translate(-centerPoint);
     painter.setTransform(m_maskShape->absoluteTransformation(&viewConverter) * painter.transform());
     m_maskShape->paint(painter, viewConverter, m_shapePaintingContext);
     painter.restore();
 }
 
-void KoGamutMaskShape::paintStroke(QPainter &painter, const KoViewConverter &viewConverter)
+void KoGamutMaskShape::paintStroke(QPainter &painter, const KoViewConverter &viewConverter, int maskRotation)
 {
     painter.save();
+
+    // apply mask rotation before drawing
+    QPointF centerPoint(painter.viewport().width()*0.5, painter.viewport().height()*0.5);
+    painter.translate(centerPoint);
+    painter.rotate(maskRotation);
+    painter.translate(-centerPoint);
+
     painter.setTransform(m_maskShape->absoluteTransformation(&viewConverter) * painter.transform());
     m_maskShape->paintStroke(painter, viewConverter, m_shapePaintingContext);
     painter.restore();
@@ -88,20 +111,23 @@
     QVector<KoGamutMaskShape*> maskShapes;
     QVector<KoGamutMaskShape*> previewShapes;
     QSizeF maskSize;
+    int rotation;
 };
 
 KoGamutMask::KoGamutMask(const QString& filename)
     : KoResource(filename)
     , d(new Private())
 {
     d->maskSize = QSizeF(144.0,144.0);
+    setRotation(0);
 }
 
 KoGamutMask::KoGamutMask()
     : KoResource(QString())
     , d(new Private())
 {
     d->maskSize = QSizeF(144.0,144.0);
+    setRotation(0);
 }
 
 KoGamutMask::KoGamutMask(KoGamutMask* rhs)
@@ -136,7 +162,7 @@
     }
 
     for(KoGamutMaskShape* shape: *shapeVector) {
-        if (shape->coordIsClear(coord, viewConverter) == true) {
+        if (shape->coordIsClear(coord, viewConverter, rotation()) == true) {
             return true;
         }
     }
@@ -155,7 +181,7 @@
     }
 
     for(KoGamutMaskShape* shape: *shapeVector) {
-        shape->paint(painter, viewConverter);
+        shape->paint(painter, viewConverter, rotation());
     }
 }
 
@@ -170,7 +196,7 @@
     }
 
     for(KoGamutMaskShape* shape: *shapeVector) {
-        shape->paintStroke(painter, viewConverter);
+        shape->paintStroke(painter, viewConverter, rotation());
     }
 }
 
@@ -364,6 +390,16 @@
     d->description = description;
 }
 
+int KoGamutMask::rotation()
+{
+    return d->rotation;
+}
+
+void KoGamutMask::setRotation(int rotation)
+{
+    d->rotation = rotation;
+}
+
 QSizeF KoGamutMask::maskSize()
 {
     return d->maskSize;
diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -261,6 +261,7 @@
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
     widgets/KisNewsWidget.cpp
+	widgets/KisGamutMaskToolbar.cpp
 
     utils/kis_document_aware_spin_box_unit_manager.cpp
 
@@ -491,6 +492,7 @@
     forms/wdgnewwindowlayout.ui
     forms/KisWelcomePage.ui
     forms/KisNewsPage.ui
+	forms/wdgGamutMaskToolbar.ui
 
     brushhud/kis_dlg_brush_hud_config.ui
     dialogs/kis_delayed_save_dialog.ui
diff --git a/libs/ui/forms/wdgGamutMaskToolbar.ui b/libs/ui/forms/wdgGamutMaskToolbar.ui
new file mode 100644
--- /dev/null
+++ b/libs/ui/forms/wdgGamutMaskToolbar.ui
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>wdgGamutMaskToolbar</class>
+ <widget class="QWidget" name="wdgGamutMaskToolbar">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>378</width>
+    <height>57</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
+    <widget class="QPushButton" name="bnToggleMask">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>0</width>
+       <height>20</height>
+      </size>
+     </property>
+     <property name="toolTip">
+      <string>Toggle gamut mask</string>
+     </property>
+     <property name="text">
+      <string/>
+     </property>
+     <property name="checkable">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="labelMaskName">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>Select a mask in &quot;Gamut Masks&quot; docker</string>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="KisSliderSpinBox" name="rotationSlider" native="true">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>0</width>
+       <height>20</height>
+      </size>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>KisSliderSpinBox</class>
+   <extends>QWidget</extends>
+   <header>kis_slider_spin_box.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/libs/ui/widgets/KisGamutMaskToolbar.h b/libs/ui/widgets/KisGamutMaskToolbar.h
new file mode 100644
--- /dev/null
+++ b/libs/ui/widgets/KisGamutMaskToolbar.h
@@ -0,0 +1,61 @@
+/*
+ *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@gmail.com>
+ *
+ *  This library is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; version 2.1 of the License.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KISGAMUTMASKTOOLBAR_H
+#define KISGAMUTMASKTOOLBAR_H
+
+#include <QWidget>
+#include <QIcon>
+
+#include <resources/KoGamutMask.h>
+#include "kritaui_export.h"
+
+#include "ui_wdgGamutMaskToolbar.h"
+
+class KisCanvasResourceProvider;
+
+class KRITAUI_EXPORT KisGamutMaskToolbar : public QWidget
+{
+    Q_OBJECT
+public:
+    KisGamutMaskToolbar(QWidget* parent = nullptr);
+    void connectMaskSignals(KisCanvasResourceProvider* resourceProvider);
+
+Q_SIGNALS:
+    void sigGamutMaskToggle(bool state);
+    void sigGamutMaskChanged(KoGamutMask*);
+
+public Q_SLOTS:
+    void slotGamutMaskSet(KoGamutMask* mask);
+    void slotGamutMaskUnset();
+
+private Q_SLOTS:
+    void slotGamutMaskToggle(bool state);
+    void slotGamutMaskRotate(int angle);
+
+private:
+    Ui_wdgGamutMaskToolbar* m_ui;
+    KoGamutMask* m_selectedMask;
+
+    QIcon m_iconMaskOff;
+    QIcon m_iconMaskOn;
+
+    QString m_textNoMask;
+    QString m_textMaskDisabled;
+};
+
+#endif // KISGAMUTMASKTOOLBAR_H
diff --git a/libs/ui/widgets/KisGamutMaskToolbar.cpp b/libs/ui/widgets/KisGamutMaskToolbar.cpp
new file mode 100644
--- /dev/null
+++ b/libs/ui/widgets/KisGamutMaskToolbar.cpp
@@ -0,0 +1,115 @@
+/*
+ *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@gmail.com>
+ *
+ *  This library is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation; version 2.1 of the License.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include <QWidget>
+#include "KisGamutMaskToolbar.h"
+#include <kis_icon_utils.h>
+#include <kis_canvas_resource_provider.h>
+
+KisGamutMaskToolbar::KisGamutMaskToolbar(QWidget* parent) : QWidget(parent)
+  , m_selectedMask(nullptr)
+{
+    m_ui = new Ui_wdgGamutMaskToolbar();
+    m_ui->setupUi(this);
+
+    m_iconMaskOff = KisIconUtils::loadIcon("gamut-mask-off");
+    m_iconMaskOn = KisIconUtils::loadIcon("gamut-mask-on");
+
+    m_textNoMask = i18n("Select a mask in \"Gamut Masks\" docker");
+    m_textMaskDisabled = i18n("Mask is disabled");
+
+    m_ui->bnToggleMask->setChecked(false);
+    m_ui->bnToggleMask->setIcon(m_iconMaskOff);
+
+    m_ui->rotationSlider->setRange(0, 360);
+    m_ui->rotationSlider->setPrefix(i18n("Rotation: "));
+    m_ui->rotationSlider->setSuffix("°");
+    m_ui->rotationSlider->setFastSliderStep(30); // TODO: test for usability
+    m_ui->rotationSlider->hide();
+
+    // gamut mask connections
+    connect(m_ui->bnToggleMask, SIGNAL(toggled(bool)), SLOT(slotGamutMaskToggle(bool)));
+    connect(m_ui->rotationSlider, SIGNAL(valueChanged(int)), SLOT(slotGamutMaskRotate(int)));
+}
+
+void KisGamutMaskToolbar::connectMaskSignals(KisCanvasResourceProvider* resourceProvider)
+{
+    connect(resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
+            this, SLOT(slotGamutMaskSet(KoGamutMask*)));
+
+    connect(resourceProvider, SIGNAL(sigGamutMaskUnset()),
+            this, SLOT(slotGamutMaskUnset()));
+
+    connect(this, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
+            resourceProvider, SLOT(slotGamutMaskActivated(KoGamutMask*)));
+}
+
+void KisGamutMaskToolbar::slotGamutMaskSet(KoGamutMask *mask)
+{
+    if (!mask) {
+        return;
+    }
+
+    m_selectedMask = mask;
+
+    if (m_selectedMask) {
+        slotGamutMaskToggle(true);
+    } else {
+        slotGamutMaskToggle(false);
+    }
+}
+
+void KisGamutMaskToolbar::slotGamutMaskUnset()
+{
+    m_ui->rotationSlider->hide();
+    m_ui->labelMaskName->show();
+    m_ui->labelMaskName->setText(m_textNoMask);
+}
+
+void KisGamutMaskToolbar::slotGamutMaskToggle(bool state)
+{
+    bool b = (!m_selectedMask) ? false : state;
+
+    m_ui->bnToggleMask->setChecked(b);
+
+    if (b == true) {
+        m_ui->bnToggleMask->setIcon(m_iconMaskOn);
+        m_ui->labelMaskName->hide();
+        m_ui->rotationSlider->show();
+
+        m_ui->rotationSlider->blockSignals(true);
+        m_ui->rotationSlider->setValue(m_selectedMask->rotation());
+        m_ui->rotationSlider->blockSignals(false);
+    } else {
+        m_ui->bnToggleMask->setIcon(m_iconMaskOff);
+        m_ui->rotationSlider->hide();
+        m_ui->labelMaskName->show();
+        m_ui->labelMaskName->setText(m_textMaskDisabled);
+    }
+
+    emit sigGamutMaskToggle(state);
+}
+
+void KisGamutMaskToolbar::slotGamutMaskRotate(int angle)
+{
+    if (!m_selectedMask) {
+        return;
+    }
+
+    m_selectedMask->setRotation(angle);
+    emit sigGamutMaskChanged(m_selectedMask);
+}
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.h b/plugins/dockers/advancedcolorselector/kis_color_selector.h
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.h
@@ -50,7 +50,10 @@
 public Q_SLOTS:
     void reset() override;
     void updateSettings() override;
-
+    void slotGamutMaskSet(KoGamutMask* gamutMask);
+    void slotGamutMaskUnset();
+    void slotGamutMaskPreviewUpdate();
+    void slotGamutMaskToggle(bool state);
 
 Q_SIGNALS:
     void settingsButtonClicked();
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -149,9 +149,38 @@
 {
     KisColorSelectorBase::updateSettings();
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
+
     setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString())));
 }
 
+void KisColorSelector::slotGamutMaskSet(KoGamutMask *gamutMask)
+{
+    m_mainComponent->setGamutMask(gamutMask);
+    m_subComponent->setGamutMask(gamutMask);
+
+    slotGamutMaskToggle(true);
+}
+
+void KisColorSelector::slotGamutMaskUnset()
+{
+    m_mainComponent->unsetGamutMask();
+    m_subComponent->unsetGamutMask();
+
+    slotGamutMaskToggle(false);
+}
+
+void KisColorSelector::slotGamutMaskPreviewUpdate()
+{
+    m_mainComponent->updateGamutMaskPreview();
+    m_subComponent->updateGamutMaskPreview();
+}
+
+void KisColorSelector::slotGamutMaskToggle(bool state)
+{
+    m_mainComponent->toggleGamutMask(state);
+    m_subComponent->toggleGamutMask(state);
+}
+
 void KisColorSelector::updateIcons() {
     if (m_button) {
         m_button->setIcon(KisIconUtils::loadIcon("configure"));
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
@@ -32,6 +32,7 @@
 class KisCanvas2;
 class KisColorPreviewPopup;
 class KisDisplayColorConverter;
+class KoGamutMask;
 
 
 /// Base class for all color selectors, that should support color management and zooming.
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
@@ -40,6 +40,7 @@
 #include "kis_image.h"
 #include "kis_display_color_converter.h"
 
+#include <resources/KoGamutMask.h>
 
 class KisColorPreviewPopup : public QWidget {
 public:
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_component.h b/plugins/dockers/advancedcolorselector/kis_color_selector_component.h
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_component.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_component.h
@@ -20,6 +20,9 @@
 
 #include <QObject>
 #include <QColor>
+
+#include <resources/KoGamutMask.h>
+
 #include "kis_color_selector.h"
 
 class KoColorSpace;
@@ -39,7 +42,7 @@
     void paintEvent(QPainter*);
 
     /// saves the mouse position, so that a blip can be created.
-    void mouseEvent(int x, int y);
+    virtual void mouseEvent(int x, int y);
 
     /// return the color, that was selected by calling mouseEvent
     KoColor currentColor();
@@ -59,6 +62,11 @@
     /// returns true, if this component wants to grab the mouse (normally true, if containsPoint returns true)
     bool wantsGrab(int x, int y) {return containsPointInComponentCoords(x-m_x, y-m_y);}
 
+    void setGamutMask(KoGamutMask* gamutMask);
+    void unsetGamutMask();
+    void updateGamutMaskPreview();
+    void toggleGamutMask(bool state);
+
 public Q_SLOTS:
     /// set hue, saturation, value or/and lightness
     /// unused parameters should be set to -1
@@ -100,15 +108,18 @@
     Parameter m_parameter;
     Type m_type;
     KisColorSelector* m_parent;
+    bool m_gamutMaskOn;
+    KoGamutMask* m_currentGamutMask;
+    bool m_maskPreviewActive;
+    qreal m_lastX;
+    qreal m_lastY;
+    int m_x;
+    int m_y;
 private:
     int m_width;
     int m_height;
-    int m_x;
-    int m_y;
     bool m_dirty;
     const KoColorSpace* m_lastColorSpace;
-    qreal m_lastX;
-    qreal m_lastY;
 };
 
 #endif // KIS_COLOR_SELECTOR_COMPONENT_H
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_component.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_component.cpp
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_component.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_component.cpp
@@ -22,6 +22,7 @@
 #include "KoColorSpace.h"
 #include <QPainter>
 #include <QMouseEvent>
+#include <resources/KoGamutMask.h>
 
 
 KisColorSelectorComponent::KisColorSelectorComponent(KisColorSelector* parent) :
@@ -36,14 +37,17 @@
     m_hsySaturation(1),
     m_luma(0.299),
     m_parent(parent),
-    m_width(0),
-    m_height(0),
+    m_gamutMaskOn(false),
+    m_currentGamutMask(nullptr),
+    m_maskPreviewActive(true),
+    m_lastX(0),
+    m_lastY(0),
     m_x(0),
     m_y(0),
+    m_width(0),
+    m_height(0),
     m_dirty(true),
-    m_lastColorSpace(0),
-    m_lastX(0),
-    m_lastY(0)
+    m_lastColorSpace(0)
 {
     Q_ASSERT(parent);
 }
@@ -90,6 +94,32 @@
     m_dirty = true;
 }
 
+void KisColorSelectorComponent::setGamutMask(KoGamutMask *gamutMask)
+{
+    m_currentGamutMask = gamutMask;
+    m_gamutMaskOn = true;
+}
+
+void KisColorSelectorComponent::unsetGamutMask()
+{
+    m_gamutMaskOn = false;
+    m_currentGamutMask = nullptr;
+}
+
+void KisColorSelectorComponent::updateGamutMaskPreview()
+{
+    setDirty();
+    update();
+}
+
+void KisColorSelectorComponent::toggleGamutMask(bool state)
+{
+    m_gamutMaskOn = state;
+    setDirty();
+    update();
+}
+
+
 bool KisColorSelectorComponent::isDirty() const
 {
     return m_dirty || m_lastColorSpace!=colorSpace();
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_container.h b/plugins/dockers/advancedcolorselector/kis_color_selector_container.h
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_container.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_container.h
@@ -27,6 +27,7 @@
 class KisMinimalShadeSelector;
 class QBoxLayout;
 class QAction;
+class KisGamutMaskToolbar;
 
 class KisColorSelectorContainer : public QWidget
 {
@@ -58,6 +59,7 @@
     KisMyPaintShadeSelector* m_myPaintShadeSelector;
     KisMinimalShadeSelector* m_minimalShadeSelector;
     QWidget* m_shadeSelector;
+    KisGamutMaskToolbar* m_gamutMaskToolbar;
 
     int m_onDockerResizeSetting;
 
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
@@ -33,6 +33,7 @@
 #include <kactioncollection.h>
 
 #include <KisDocument.h>
+#include <KisGamutMaskToolbar.h>
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
@@ -48,16 +49,25 @@
     m_myPaintShadeSelector(new KisMyPaintShadeSelector(this)),
     m_minimalShadeSelector(new KisMinimalShadeSelector(this)),
     m_shadeSelector(m_myPaintShadeSelector),
+    m_gamutMaskToolbar(new KisGamutMaskToolbar(this)),
     m_canvas(0)
 {
     m_widgetLayout = new QBoxLayout(QBoxLayout::TopToBottom, this);
     m_widgetLayout->setSpacing(0);
     m_widgetLayout->setMargin(0);
 
+    m_gamutMaskToolbar->setContentsMargins(0, 0, 0, 5);
+    m_gamutMaskToolbar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
+    m_colorSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    m_myPaintShadeSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    m_minimalShadeSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+
+    m_widgetLayout->addWidget(m_gamutMaskToolbar);
     m_widgetLayout->addWidget(m_colorSelector);
     m_widgetLayout->addWidget(m_myPaintShadeSelector);
     m_widgetLayout->addWidget(m_minimalShadeSelector);
 
+    m_gamutMaskToolbar->hide();
     m_myPaintShadeSelector->hide();
     m_minimalShadeSelector->hide();
 
@@ -78,8 +88,6 @@
     m_minimalAction = KisActionRegistry::instance()->makeQAction("show_minimal_shade_selector", this);
     connect(m_minimalAction, SIGNAL(triggered()), m_minimalShadeSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
-
-
 }
 
 void KisColorSelectorContainer::unsetCanvas()
@@ -136,12 +144,25 @@
             connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigLayerActivated(KisLayerSP)), SLOT(reactOnLayerChange()), Qt::UniqueConnection);
         }
 
+        connect(m_canvas->viewManager()->resourceProvider(), SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
+                m_colorSelector, SLOT(slotGamutMaskSet(KoGamutMask*)));
+
+        connect(m_canvas->viewManager()->resourceProvider(), SIGNAL(sigGamutMaskUnset()),
+                m_colorSelector, SLOT(slotGamutMaskUnset()));
+
+        connect(m_canvas->viewManager()->resourceProvider(), SIGNAL(sigGamutMaskPreviewUpdate()),
+                m_colorSelector, SLOT(slotGamutMaskPreviewUpdate()));
+
+        m_gamutMaskToolbar->connectMaskSignals(m_canvas->viewManager()->resourceProvider());
+
+        // gamut mask connections
+        connect(m_gamutMaskToolbar, SIGNAL(sigGamutMaskToggle(bool)), m_colorSelector, SLOT(slotGamutMaskToggle(bool)));
+
         KActionCollection* actionCollection = canvas->viewManager()->actionCollection();
         actionCollection->addAction("show_color_selector", m_colorSelAction);
         actionCollection->addAction("show_mypaint_shade_selector", m_mypaintAction);
         actionCollection->addAction("show_minimal_shade_selector", m_minimalAction);
     }
-
 }
 
 void KisColorSelectorContainer::updateSettings()
@@ -169,6 +190,13 @@
     if(m_shadeSelector!=0)
         m_shadeSelector->show();
 
+
+    if (m_colorSelector->configuration().mainType == KisColorSelectorConfiguration::Wheel) {
+        m_gamutMaskToolbar->show();
+    } else {
+        m_gamutMaskToolbar->hide();
+    }
+
 }
 
 void KisColorSelectorContainer::reactOnLayerChange()
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.h b/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.h
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.h
@@ -22,6 +22,9 @@
 
 #include <QColor>
 #include <QImage>
+#include <QSize>
+
+#include <KisGamutMaskViewConverter.h>
 
 #include "KoColor.h"
 #include "kis_color_selector_component.h"
@@ -40,19 +43,27 @@
 protected:
     KoColor selectColor(int x, int y) override;
     void paint(QPainter*) override;
+    void mouseEvent(int x, int y) override;
 
 private:
     friend class Acs::PixelCacheRenderer;
     KoColor colorAt(int x, int y, bool forceValid = false);
 
 private:
+    bool coordIsClear(int x, int y);
     QPointF m_lastClickPos;
     QImage m_pixelCache;
     QPoint m_pixelCacheOffset;
     qreal R;
     qreal G;
     qreal B;
     qreal Gamma;
+
+    QSize m_renderAreaSize;
+    qreal m_renderAreaOffsetX;
+    qreal m_renderAreaOffsetY;
+    QTransform m_toRenderArea;
+    KisGamutMaskViewConverter* m_viewConverter;
 };
 
 #endif // KIS_COLOR_SELECTOR_WHEEL_H
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.cpp
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_wheel.cpp
@@ -25,14 +25,21 @@
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
+#include <KisGamutMaskViewConverter.h>
+
 #include "kis_display_color_converter.h"
 #include "kis_acs_pixel_cache_renderer.h"
 
 
 KisColorSelectorWheel::KisColorSelectorWheel(KisColorSelector *parent) :
     KisColorSelectorComponent(parent),
-    m_lastClickPos(-1,-1)
+    m_lastClickPos(-1,-1),
+    m_renderAreaSize(1,1),
+    m_renderAreaOffsetX(0.0),
+    m_renderAreaOffsetY(0.0),
+    m_toRenderArea(QTransform())
 {
+    m_viewConverter = new KisGamutMaskViewConverter();
 }
 
 KoColor KisColorSelectorWheel::selectColor(int x, int y)
@@ -186,14 +193,54 @@
         tmpPainter.setCompositionMode(QPainter::CompositionMode_Clear);
         int size=qMin(width(), height());
 
+        m_renderAreaSize = QSize(size,size);
+        m_renderAreaOffsetX = ((qreal)width()-(qreal)m_renderAreaSize.width())*0.5;
+        m_renderAreaOffsetY = ((qreal)height()-(qreal)m_renderAreaSize.height())*0.5;
+        m_toRenderArea.reset();
+        m_toRenderArea.translate(-m_renderAreaOffsetX,-m_renderAreaOffsetY);
+
+        m_viewConverter->setViewSize(m_renderAreaSize);
+        if (m_currentGamutMask) {
+           m_viewConverter->setMaskSize(m_currentGamutMask->maskSize());
+        }
+
         QPoint ellipseCenter(width() / 2 - size / 2, height() / 2 - size / 2);
         ellipseCenter -= m_pixelCacheOffset;
 
         tmpPainter.drawEllipse(ellipseCenter.x(), ellipseCenter.y(), size, size);
     }
 
     painter->drawImage(m_pixelCacheOffset.x(),m_pixelCacheOffset.y(), m_pixelCache);
 
+    // draw gamut mask
+    if (m_gamutMaskOn && m_currentGamutMask) {
+        QImage maskBuffer  = QImage(m_renderAreaSize.width(), m_renderAreaSize.height(), QImage::Format_ARGB32_Premultiplied);
+        maskBuffer.fill(0);
+        QPainter maskPainter(&maskBuffer);
+
+        QRect rect = QRect(0, 0, m_renderAreaSize.width(), m_renderAreaSize.height());
+        maskPainter.setRenderHint(QPainter::Antialiasing, true);
+
+        maskPainter.resetTransform();
+        maskPainter.translate(rect.width()/2, rect.height()/2);
+        maskPainter.scale(rect.width()/2, rect.height()/2);
+
+        maskPainter.setPen(QPen(QBrush(Qt::white), 0.002));
+        maskPainter.setBrush(QColor(128,128,128,255)); // middle gray
+
+        maskPainter.drawEllipse(QPointF(0,0), 1.0, 1.0);
+
+        maskPainter.resetTransform();
+
+        maskPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
+        m_currentGamutMask->paint(maskPainter, *m_viewConverter, m_maskPreviewActive);
+
+        maskPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+        m_currentGamutMask->paintStroke(maskPainter, *m_viewConverter, m_maskPreviewActive);
+
+        painter->drawImage(m_renderAreaOffsetX, m_renderAreaOffsetY, maskBuffer);
+    }
+
     // draw blips
 
     if(m_lastClickPos!=QPoint(-1,-1) && m_parent->displayBlip()) {
@@ -210,6 +257,18 @@
     }
 }
 
+void KisColorSelectorWheel::mouseEvent(int x, int y)
+{
+    int newX=qBound(0, (x-m_x), width());
+    int newY=qBound(0, (y-m_y), height());
+
+    if (coordIsClear(newX,newY)) {
+        selectColor(newX, newY);
+        m_lastX=newX;
+        m_lastY=newY;
+    }
+}
+
 KoColor KisColorSelectorWheel::colorAt(int x, int y, bool forceValid)
 {
     KoColor color(Qt::transparent, m_parent->colorSpace());
@@ -267,3 +326,16 @@
     }
     return color;
 }
+
+bool KisColorSelectorWheel::coordIsClear(int x, int y)
+{
+    bool retval = false;
+    if (m_gamutMaskOn && m_currentGamutMask) {
+        bool isClear = m_currentGamutMask->coordIsClear(m_toRenderArea.map(QPointF(x,y)), *m_viewConverter, m_maskPreviewActive);
+        retval = (isClear) ? true : false;
+    } else {
+        retval = true;
+    }
+
+    return retval;
+}
diff --git a/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui b/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui
--- a/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui
+++ b/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>612</width>
-    <height>973</height>
+    <width>721</width>
+    <height>1108</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -499,7 +499,7 @@
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
-           <height>228</height>
+           <height>40</height>
           </size>
          </property>
         </spacer>
@@ -1508,6 +1508,11 @@
   </layout>
  </widget>
  <customwidgets>
+  <customwidget>
+   <class>KisDoubleParseSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>kis_double_parse_spin_box.h</header>
+  </customwidget>
   <customwidget>
    <class>KisColorSpaceSelector</class>
    <extends>QWidget</extends>
@@ -1529,11 +1534,6 @@
    <extends>QComboBox</extends>
    <header>kis_shade_selector_lines_settings.h</header>
   </customwidget>
-  <customwidget>
-   <class>KisDoubleParseSpinBox</class>
-   <extends>QDoubleSpinBox</extends>
-   <header>kis_double_parse_spin_box.h</header>
-  </customwidget>
  </customwidgets>
  <resources/>
  <connections>
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
@@ -62,7 +62,6 @@
     void slotPreferenceChanged();
     void slotResetDefaultSettings();
     void slotGamutMaskToggle(bool value);
-    void slotGamutMaskActivatePreview(bool value);
     void slotGamutMaskSet(KoGamutMask* mask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -47,6 +47,8 @@
 #include "artisticcolorselector_dock.h"
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
+#include <kis_arcs_constants.h>
+#include <KisGamutMaskToolbar.h>
 
 #include "ui_wdgArtisticColorSelector.h"
 #include "ui_wdgARCSSettings.h"
@@ -94,8 +96,6 @@
     QPixmap valueScaleStepsPixmap = KisIconUtils::loadIcon("wheel-light").pixmap(16,16);
     QIcon infinityIcon = KisIconUtils::loadIcon("infinity");
     m_infinityPixmap = infinityIcon.pixmap(16,16);
-    m_iconMaskOff = KisIconUtils::loadIcon("gamut-mask-off");
-    m_iconMaskOn = KisIconUtils::loadIcon("gamut-mask-on");
 
     m_selectorUI->colorSelector->loadSettings();
 
@@ -105,9 +105,6 @@
     m_selectorUI->bnDockerPrefs->setPopupWidget(m_preferencesUI);
     m_selectorUI->bnDockerPrefs->setIcon(KisIconUtils::loadIcon("configure"));
 
-    m_selectorUI->bnToggleMask->setChecked(false);
-    m_selectorUI->bnToggleMask->setIcon(m_iconMaskOff);
-
     //preferences
     m_hsxButtons->addButton(m_preferencesUI->bnHsy, KisColor::HSY);
     m_hsxButtons->addButton(m_preferencesUI->bnHsi, KisColor::HSI);
@@ -163,13 +160,11 @@
     m_preferencesUI->defaultSaturationSteps->setValue(m_selectorUI->colorSelector->getDefaultSaturationSteps());
     m_preferencesUI->defaultValueScaleSteps->setValue(m_selectorUI->colorSelector->getDefaultValueScaleSteps());
 
-    m_preferencesUI->showColorBlip->setChecked(m_selectorUI->colorSelector->getShowColorBlip());
     m_preferencesUI->showBgColor->setChecked(m_selectorUI->colorSelector->getShowBgColor());
     m_preferencesUI->showValueScaleNumbers->setChecked(m_selectorUI->colorSelector->getShowValueScaleNumbers());
 
     m_preferencesUI->enforceGamutMask->setChecked(m_selectorUI->colorSelector->enforceGamutMask());
     m_preferencesUI->permissiveGamutMask->setChecked(!m_selectorUI->colorSelector->enforceGamutMask());
-    m_preferencesUI->showMaskPreview->setChecked(m_selectorUI->colorSelector->maskPreviewActive());
 
     m_preferencesUI->spLumaR->setValue(m_selectorUI->colorSelector->lumaR());
     m_preferencesUI->spLumaG->setValue(m_selectorUI->colorSelector->lumaG());
@@ -204,11 +199,9 @@
     connect(m_preferencesUI->bnDefInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnDefInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
 
-    connect(m_preferencesUI->showColorBlip      , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->showBgColor        , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->showValueScaleNumbers, SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->enforceGamutMask   , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
-    connect(m_preferencesUI->showMaskPreview   , SIGNAL(toggled(bool)), SLOT(slotGamutMaskActivatePreview(bool)));
 
     connect(m_preferencesUI->spLumaR   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaG   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
@@ -219,7 +212,7 @@
     connect(m_selectorUI->colorSelector         , SIGNAL(sigBgColorChanged(KisColor))     , SLOT(slotBgColorChanged(KisColor)));
 
     // gamut mask connections
-    connect(m_selectorUI->bnToggleMask          , SIGNAL(toggled(bool))                          , SLOT(slotGamutMaskToggle(bool)));
+    connect(m_selectorUI->gamutMaskToolbar, SIGNAL(sigGamutMaskToggle(bool)), SLOT(slotGamutMaskToggle(bool)));
 
     connect(m_hsxButtons                        , SIGNAL(buttonClicked(int))                     , SLOT(slotColorSpaceSelected()));
 
@@ -244,10 +237,10 @@
     connect(m_resourceProvider, SIGNAL(sigGamutMaskUnset()),
             this, SLOT(slotGamutMaskUnset()));
 
-    if (m_selectorUI->colorSelector->maskPreviewActive()) {
-        connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
-                this, SLOT(slotGamutMaskPreviewUpdate()));
-    }
+    connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
+            this, SLOT(slotGamutMaskPreviewUpdate()));
+
+    m_selectorUI->gamutMaskToolbar->connectMaskSignals(m_resourceProvider);
 }
 
 void ArtisticColorSelectorDock::slotCanvasResourceChanged(int key, const QVariant& value)
@@ -340,21 +333,11 @@
     }
     m_selectorUI->colorSelector->setDefaultValueScaleSteps(defValueScaleSteps);
 
-    m_selectorUI->colorSelector->setShowColorBlip(m_preferencesUI->showColorBlip->isChecked());
     m_selectorUI->colorSelector->setShowBgColor(m_preferencesUI->showBgColor->isChecked());
     m_selectorUI->colorSelector->setShowValueScaleNumbers(m_preferencesUI->showValueScaleNumbers->isChecked());
     m_selectorUI->colorSelector->setEnforceGamutMask(m_preferencesUI->enforceGamutMask->isChecked());
 
-    // the selector wheel forbids saturation inversion in some cases,
-    // reflecting that in the ui
-    if (m_selectorUI->colorSelector->saturationIsInvertible()) {
-        m_wheelPrefsUI->bnInverseSat->setEnabled(true);
-        m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
-    } else {
-        m_wheelPrefsUI->bnInverseSat->setEnabled(false);
-        m_wheelPrefsUI->bnInverseSat->setChecked(false);
-        m_selectorUI->colorSelector->setInverseSaturation(false);
-    }
+    m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
 }
 
 void ArtisticColorSelectorDock::slotResetDefaultSettings()
@@ -395,48 +378,15 @@
     }
 }
 
-void ArtisticColorSelectorDock::slotGamutMaskActivatePreview(bool value)
-{
-    m_selectorUI->colorSelector->setMaskPreviewActive(value);
-
-    if (value) {
-        connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
-                this, SLOT(slotGamutMaskPreviewUpdate()));
-    } else {
-        disconnect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
-                this, SLOT(slotGamutMaskPreviewUpdate()));
-    }
-
-    m_selectorUI->colorSelector->update();
-}
-
 void ArtisticColorSelectorDock::slotGamutMaskToggle(bool checked)
 {
     bool b = (!m_selectedMask) ? false : checked;
 
-    m_selectorUI->bnToggleMask->setChecked(b);
-
     if (b == true) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
-        m_selectorUI->bnToggleMask->setIcon(m_iconMaskOn);
-    } else {
-        m_selectorUI->bnToggleMask->setIcon(m_iconMaskOff);
     }
 
     m_selectorUI->colorSelector->setGamutMaskOn(b);
-
-    // TODO: HACK
-    // the selector wheel forbids saturation inversion in some cases,
-    // reflecting that in the ui
-    if (m_selectorUI->colorSelector->saturationIsInvertible()) {
-        m_wheelPrefsUI->bnInverseSat->setEnabled(true);
-        m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
-    } else {
-        m_wheelPrefsUI->bnInverseSat->setEnabled(false);
-        m_wheelPrefsUI->bnInverseSat->setChecked(false);
-        m_selectorUI->colorSelector->setInverseSaturation(false);
-    }
-
 }
 
 void ArtisticColorSelectorDock::setCanvas(KoCanvasBase *canvas)
@@ -480,11 +430,9 @@
 
     if (m_selectedMask) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
-        m_selectorUI->labelMaskName->setText(m_selectedMask->title());
         slotGamutMaskToggle(true);
     } else {
         slotGamutMaskToggle(false);
-        m_selectorUI->labelMaskName->setText(i18n("Select a mask in \"Gamut Masks\" docker"));
     }
 }
 
@@ -497,7 +445,6 @@
     m_selectedMask = nullptr;
 
     slotGamutMaskToggle(false);
-    m_selectorUI->labelMaskName->setText(i18n("Select a mask in \"Gamut Masks\" docker"));
     m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
 }
 
diff --git a/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui b/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui
--- a/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui
+++ b/plugins/dockers/artisticcolorselector/forms/wdgARCSSettings.ui
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>446</width>
-    <height>769</height>
+    <height>633</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
@@ -17,13 +17,6 @@
       <string>Selector Appearance</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
-      <item>
-       <widget class="QCheckBox" name="showColorBlip">
-        <property name="text">
-         <string>Show color blip</string>
-        </property>
-       </widget>
-      </item>
       <item>
        <widget class="QCheckBox" name="showBgColor">
         <property name="text">
@@ -277,16 +270,6 @@
         </item>
        </layout>
       </item>
-      <item>
-       <widget class="QCheckBox" name="showMaskPreview">
-        <property name="text">
-         <string>Show preview while editing a mask</string>
-        </property>
-        <property name="checked">
-         <bool>false</bool>
-        </property>
-       </widget>
-      </item>
      </layout>
     </widget>
    </item>
@@ -400,17 +383,17 @@
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>KisDoubleParseSpinBox</class>
-   <extends>QDoubleSpinBox</extends>
-   <header>kis_double_parse_spin_box.h</header>
-  </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>KisDoubleParseSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>kis_double_parse_spin_box.h</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
diff --git a/plugins/dockers/artisticcolorselector/forms/wdgArtisticColorSelector.ui b/plugins/dockers/artisticcolorselector/forms/wdgArtisticColorSelector.ui
--- a/plugins/dockers/artisticcolorselector/forms/wdgArtisticColorSelector.ui
+++ b/plugins/dockers/artisticcolorselector/forms/wdgArtisticColorSelector.ui
@@ -20,32 +20,13 @@
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <item>
-      <widget class="QPushButton" name="bnToggleMask">
-       <property name="toolTip">
-        <string>Toggle gamut mask</string>
-       </property>
-       <property name="text">
-        <string/>
-       </property>
-       <property name="checkable">
-        <bool>true</bool>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QLabel" name="labelMaskName">
+      <widget class="KisGamutMaskToolbar" name="gamutMaskToolbar" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
-       <property name="text">
-        <string>Select a mask in &quot;Gamut Masks&quot; docker</string>
-       </property>
-       <property name="wordWrap">
-        <bool>true</bool>
-       </property>
       </widget>
      </item>
      <item>
@@ -66,6 +47,12 @@
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
        <property name="maximumSize">
         <size>
          <width>16777215</width>
@@ -96,7 +83,7 @@
        </property>
        <property name="minimumSize">
         <size>
-         <width>30</width>
+         <width>0</width>
          <height>0</height>
         </size>
        </property>
@@ -137,6 +124,12 @@
    <header>kis_color_selector.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>KisGamutMaskToolbar</class>
+   <extends>QWidget</extends>
+   <header>KisGamutMaskToolbar.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
diff --git a/plugins/dockers/artisticcolorselector/kis_arcs_constants.h b/plugins/dockers/artisticcolorselector/kis_arcs_constants.h
--- a/plugins/dockers/artisticcolorselector/kis_arcs_constants.h
+++ b/plugins/dockers/artisticcolorselector/kis_arcs_constants.h
@@ -41,14 +41,14 @@
 
 // color scheme for the selector
 static const QColor COLOR_MIDDLE_GRAY = QColor(128,128,128,255);
-static const QColor COLOR_DARK = QColor(20,20,20,255);
-static const QColor COLOR_LIGHT = QColor(232,232,232,255);
-static const QColor COLOR_ACCENT = QColor(255,60,60,255);
+static const QColor COLOR_DARK = QColor(50,50,50,255);
+static const QColor COLOR_LIGHT = QColor(200,200,200,255);
+static const QColor COLOR_SELECTED_DARK = QColor(30,30,30,255);
+static const QColor COLOR_SELECTED_LIGHT = QColor(220,220,220,255);
 
 static const QColor COLOR_MASK_FILL = COLOR_MIDDLE_GRAY;
 static const QColor COLOR_MASK_OUTLINE = COLOR_LIGHT;
 static const QColor COLOR_MASK_CLEAR = COLOR_LIGHT;
-static const QColor COLOR_SELECTED = COLOR_ACCENT;
 static const QColor COLOR_NORMAL_OUTLINE = COLOR_MIDDLE_GRAY;
 
 #endif // KIS_ARCS_CONSTANTS_H
diff --git a/plugins/dockers/artisticcolorselector/kis_color_selector.h b/plugins/dockers/artisticcolorselector/kis_color_selector.h
--- a/plugins/dockers/artisticcolorselector/kis_color_selector.h
+++ b/plugins/dockers/artisticcolorselector/kis_color_selector.h
@@ -80,18 +80,14 @@
     void setDefaultHueSteps(int num);
     void setDefaultSaturationSteps(int num);
     void setDefaultValueScaleSteps(int num);
-    void setShowColorBlip(bool value);
     void setShowBgColor(bool value);
     void setShowValueScaleNumbers(bool value);
     void setGamutMask(KoGamutMask* gamutMask);
     bool gamutMaskOn();
     void setGamutMaskOn(bool gamutMaskOn);
     void setEnforceGamutMask(bool enforce);
     KoGamutMask* gamutMask();
 
-    bool maskPreviewActive();
-    void setMaskPreviewActive(bool value);
-
     bool saturationIsInvertible();
 
     void saveSettings();
@@ -106,7 +102,6 @@
     quint32        getDefaultHueSteps  () const { return m_defaultHueSteps;        }
     quint32        getDefaultSaturationSteps () const { return m_defaultSaturationSteps;        }
     quint32        getDefaultValueScaleSteps () const { return m_defaultValueScaleSteps;        }
-    bool           getShowColorBlip () const { return m_showColorBlip;        }
     bool           getShowBgColor () const { return m_showBgColor;        }
     bool           getShowValueScaleNumbers () const { return m_showValueScaleNumbers;        }
     bool           enforceGamutMask () const { return m_enforceGamutMask;        }
@@ -183,7 +178,6 @@
     quint8 m_defaultHueSteps;
     quint8 m_defaultSaturationSteps;
     quint8 m_defaultValueScaleSteps;
-    bool m_showColorBlip;
     bool m_showValueScaleNumbers;
     bool m_showBgColor;
 
diff --git a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
--- a/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/artisticcolorselector/kis_color_selector.cpp
@@ -219,16 +219,6 @@
     return m_currentGamutMask;
 }
 
-bool KisColorSelector::maskPreviewActive()
-{
-    return m_maskPreviewActive;
-}
-
-void KisColorSelector::setMaskPreviewActive(bool value)
-{
-    m_maskPreviewActive = value;
-}
-
 bool KisColorSelector::gamutMaskOn()
 {
     return m_gamutMaskOn;
@@ -579,7 +569,7 @@
     painter.scale(rect.width()/2, rect.height()/2);
 
     QPen normalPen = QPen(QBrush(COLOR_NORMAL_OUTLINE), 0.005);
-    QPen selectedPen = QPen(QBrush(COLOR_LIGHT), 0.01);
+    QPen selectedPen;
 
     painter.setPen(normalPen);
 
@@ -592,6 +582,12 @@
             painter.setTransform(mirror, true);
             painter.scale(rect.width()/2, rect.height()/2);
 
+            if (m_selectedColor.getX() < 0.55) {
+                selectedPen = QPen(QBrush(COLOR_SELECTED_LIGHT), 0.007);
+            } else {
+                selectedPen = QPen(QBrush(COLOR_SELECTED_DARK), 0.007);
+            }
+
             painter.setPen(selectedPen);
             painter.drawPath(m_colorRings[m_selectedRing].pieced[m_selectedPiece]);
         }
@@ -606,6 +602,12 @@
             qreal iRad = m_colorRings[m_selectedRing].innerRadius;
             qreal oRad = m_colorRings[m_selectedRing].outerRadius;
 
+            if (m_selectedColor.getX() < 0.55) {
+                selectedPen = QPen(QBrush(COLOR_SELECTED_LIGHT), 0.005);
+            } else {
+                selectedPen = QPen(QBrush(COLOR_SELECTED_DARK), 0.005);
+            }
+
             painter.setPen(selectedPen);
             painter.drawEllipse(QRectF(-iRad, -iRad, iRad*2.0, iRad*2.0));
             painter.drawEllipse(QRectF(-oRad, -oRad, oRad*2.0, oRad*2.0));
@@ -619,6 +621,9 @@
 void KisColorSelector::drawLightStrip(QPainter& painter, const QRect& rect)
 {
     qreal    penSize    = qreal(qMin(QWidget::width(), QWidget::height())) / 200.0;
+    qreal    penSizeSmall = penSize / 1.2;
+    QPen selectedPen;
+
     KisColor valueScaleColor(m_selectedColor, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
     KisColor grayScaleColor(Qt::gray, m_colorConverter, m_colorSpace, m_lumaR, m_lumaG, m_lumaB, m_lumaGamma);
     int rectSize = rect.height();
@@ -653,16 +658,20 @@
             rectColor = matrix.mapRect(rectColor);
 
             valueScaleColor.setX(light);
-
             painter.fillRect(rectColor, valueScaleColor.toQColor());
 
             if (i == m_selectedLightPiece) {
-                painter.setPen(QPen(QBrush(COLOR_SELECTED), penSize));
+                if (light < 0.55) {
+                    selectedPen = QPen(QBrush(COLOR_SELECTED_LIGHT), penSize);
+                } else {
+                    selectedPen = QPen(QBrush(COLOR_SELECTED_DARK), penSize);
+                }
+
+                painter.setPen(selectedPen);
                 painter.drawRect(rectColor);
             }
         }
-    }
-    else {
+    } else {
         painter.setRenderHint(QPainter::Antialiasing, false);
 
         for(int i=0; i<rectSize; ++i) {
@@ -672,27 +681,19 @@
             painter.setPen(QPen(QBrush(valueScaleColor.toQColor()), penSize));
             painter.drawLine(rect.left(), y, rect.right(), y);
         }
-
-        painter.setRenderHint(QPainter::Antialiasing, true);
-
-        painter.setPen(QPen(QBrush(COLOR_SELECTED), penSize));
-        qreal t = 1.0 - m_selectedColor.getX();
-
-        int y = rect.y() + int(rectSize * t);
-        painter.drawLine(rect.left(), y, rect.right(), y);
     }
 
-    if (m_showColorBlip) {
-        painter.setRenderHint(QPainter::Antialiasing, false);
-        // draw position of fg color value on the strip
-        qreal fgColorValue = 1.0 - m_fgColor.getX();
-
-        int y = rect.y() + int(rectSize * fgColorValue);
-        painter.setPen(QPen(QBrush(COLOR_LIGHT), penSize));
-        painter.drawLine(rect.left(), y, rect.right(), y);
-        painter.setPen(QPen(QBrush(COLOR_MIDDLE_GRAY), penSize));
-        painter.drawLine(rect.left(), y+1.5*penSize, rect.right(), y+1.5*penSize);
-    }
+    // draw color blip
+    painter.setRenderHint(QPainter::Antialiasing, false);
+    // draw position of fg color value on the strip
+    qreal fgColorValue = 1.0 - m_fgColor.getX();
+
+    int y = rect.y() + int(rectSize * fgColorValue);
+    painter.setPen(QPen(QBrush(COLOR_SELECTED_LIGHT), penSizeSmall));
+    painter.drawLine(rect.left(), y, rect.right(), y);
+    painter.setPen(QPen(QBrush(COLOR_SELECTED_DARK), penSizeSmall));
+    painter.drawLine(rect.left(), y+2*penSizeSmall, rect.right(), y+2*penSizeSmall);
+    // draw color blip
 
     if (m_showValueScaleNumbers) {
         painter.setRenderHint(QPainter::Antialiasing, true);
@@ -703,8 +704,12 @@
         }
 
         QFont font = painter.font();
-        font.setPointSize(font.pointSize()-2);
-        painter.setFont(font);
+        QFontMetrics fm = painter.fontMetrics();
+        while (fm.boundingRect("100%").width() > rect.width()*rectColorLeftX) {
+            font.setPointSize(font.pointSize() - 1);
+            painter.setFont(font);
+            fm = painter.fontMetrics();
+        }
 
         for(int i=0; i<valueScalePieces; ++i) {
             qreal  t1    = qreal(i)   / qreal(valueScalePieces);
@@ -741,7 +746,7 @@
 
 void KisColorSelector::drawBlip(QPainter& painter, const QRect& rect)
 {
-    painter.setRenderHint(QPainter::Antialiasing, false);
+    painter.setRenderHint(QPainter::Antialiasing, true);
     painter.resetTransform();
     painter.translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
     painter.scale(rect.width()/2, rect.height()/2);
@@ -754,10 +759,10 @@
                << "-> coord X:" << fgColorPos.x() << " Y:" << fgColorPos.y();
 #endif
 
-    painter.setPen(QPen(QBrush(COLOR_DARK), 0.01));
+    painter.setPen(QPen(QBrush(COLOR_SELECTED_DARK), 0.01));
     painter.drawEllipse(fgColorPos, 0.05, 0.05);
 
-    painter.setPen(QPen(QBrush(COLOR_LIGHT), 0.01));
+    painter.setPen(QPen(QBrush(COLOR_SELECTED_LIGHT), 0.01));
     painter.setBrush(m_fgColor.toQColor());
     painter.drawEllipse(fgColorPos, 0.04, 0.04);
 }
@@ -845,12 +850,8 @@
     }
 
     drawOutline   (wdgPainter, m_renderArea);
-
     drawLightStrip(wdgPainter, m_lightStripArea);
-
-    if (m_showColorBlip) {
-        drawBlip (wdgPainter, m_renderArea);
-    }
+    drawBlip (wdgPainter, m_renderArea);
 }
 
 void KisColorSelector::mousePressEvent(QMouseEvent* event)
@@ -1012,11 +1013,8 @@
     cfg.writeEntry("ArtColorSel.defaultValueScaleSteps", quint32(m_defaultValueScaleSteps));
 
     cfg.writeEntry("ArtColorSel.showBgColor", m_showBgColor);
-    cfg.writeEntry("ArtColorSel.showColorBlip", m_showColorBlip);
     cfg.writeEntry("ArtColorSel.showValueScale", m_showValueScaleNumbers);
     cfg.writeEntry("ArtColorSel.enforceGamutMask", m_enforceGamutMask);
-
-    cfg.writeEntry("ArtColorSel.maskPreviewActive", m_maskPreviewActive);
 }
 
 void KisColorSelector::loadSettings()
@@ -1049,12 +1047,9 @@
     setNumPieces(cfg.readEntry("ArtColorSel.RingPieces", DEFAULT_HUE_STEPS));
 
     m_showBgColor = cfg.readEntry("ArtColorSel.showBgColor", true);
-    m_showColorBlip = cfg.readEntry("ArtColorSel.showColorBlip", true);
     m_showValueScaleNumbers = cfg.readEntry("ArtColorSel.showValueScale", false);
     m_enforceGamutMask = cfg.readEntry("ArtColorSel.enforceGamutMask", false);
 
-    m_maskPreviewActive = cfg.readEntry("ArtColorSel.maskPreviewActive", true);
-
     selectColor(m_selectedColor);
     update();
 }
@@ -1077,11 +1072,6 @@
     m_defaultValueScaleSteps = num;
 }
 
-void KisColorSelector::setShowColorBlip(bool value) {
-    m_showColorBlip = value;
-    update();
-}
-
 void KisColorSelector::setShowBgColor(bool value)
 {
     m_showBgColor = value;