diff --git a/libs/ui/kis_canvas_resource_provider.cpp b/libs/ui/kis_canvas_resource_provider.cpp
index 23d0d34532..3405048221 100644
--- a/libs/ui/kis_canvas_resource_provider.cpp
+++ b/libs/ui/kis_canvas_resource_provider.cpp
@@ -1,546 +1,563 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt  <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_canvas_resource_provider.h"
 
 #include <QImage>
 #include <QPainter>
 
 #include <KoCanvasBase.h>
 #include <KoID.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceServerProvider.h>
 #include <resources/KoStopGradient.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <resources/KoPattern.h>
 #include <kis_paint_device.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_favorite_resource_manager.h"
 
 #include "kis_config.h"
 #include "KisViewManager.h"
 #include "canvas/kis_canvas2.h"
 
 KisCanvasResourceProvider::KisCanvasResourceProvider(KisViewManager * view)
     : m_view(view)
 {
     m_fGChanged = true;
     m_enablefGChange = true;    // default to true, so that colour history is working without popup palette
 }
 
 KisCanvasResourceProvider::~KisCanvasResourceProvider()
 {
     disconnect(); // in case Qt gets confused
 }
 
 KoCanvasResourceProvider* KisCanvasResourceProvider::resourceManager()
 {
     return m_resourceManager;
 }
 
 void KisCanvasResourceProvider::setResourceManager(KoCanvasResourceProvider *resourceManager)
 {
     m_resourceManager = resourceManager;
 
     QVariant v;
     v.setValue(KoColor(Qt::black, KoColorSpaceRegistry::instance()->rgb8()));
     m_resourceManager->setResource(KoCanvasResourceProvider::ForegroundColor, v);
 
     v.setValue(KoColor(Qt::white, KoColorSpaceRegistry::instance()->rgb8()));
     m_resourceManager->setResource(KoCanvasResourceProvider::BackgroundColor, v);
 
     setCurrentCompositeOp(COMPOSITE_OVER);
 
     setMirrorHorizontal(false);
     setMirrorVertical(false);
 
     m_resourceManager->setResource(HdrExposure, 0.0);
     m_resourceManager->setResource(HdrGamma, 1.0);
     m_resourceManager->setResource(EffectiveZoom, 1.0);
 
     connect(m_resourceManager, SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     m_resourceManager->setResource(KoCanvasResourceProvider::ApplicationSpeciality, KoCanvasResourceProvider::NoAdvancedText);
+
+    m_resourceManager->setResource(GamutMaskActive, false);
 }
 
 
 KoCanvasBase * KisCanvasResourceProvider::canvas() const
 {
     return m_view->canvasBase();
 }
 
 KoColor KisCanvasResourceProvider::bgColor() const
 {
     return m_resourceManager->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>();
 }
 
 KoColor KisCanvasResourceProvider::fgColor() const
 {
     return m_resourceManager->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
 }
 
 float KisCanvasResourceProvider::HDRExposure() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrExposure).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRExposure(float exposure)
 {
     m_resourceManager->setResource(HdrExposure, static_cast<double>(exposure));
 }
 
 float KisCanvasResourceProvider::HDRGamma() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrGamma).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRGamma(float gamma)
 {
     m_resourceManager->setResource(HdrGamma, static_cast<double>(gamma));
 }
 
 
 KoPattern * KisCanvasResourceProvider::currentPattern() const
 {
     if (m_resourceManager->hasResource(CurrentPattern)) {
         return m_resourceManager->resource(CurrentPattern).value<KoPattern*>();
     }
     else {
         return 0;
     }
 }
 
 KoAbstractGradient* KisCanvasResourceProvider::currentGradient() const
 {
     if (m_resourceManager->hasResource(CurrentGradient)) {
         return m_resourceManager->resource(CurrentGradient).value<KoAbstractGradient*>();
     }
     else {
         return 0;
     }
 }
 
 KisImageWSP KisCanvasResourceProvider::currentImage() const
 {
     return m_view->image();
 }
 
 KisNodeSP KisCanvasResourceProvider::currentNode() const
 {
     return m_view->activeNode();
 }
 
 KoGamutMask *KisCanvasResourceProvider::currentGamutMask() const
 {
     if (m_resourceManager->hasResource(CurrentGamutMask)) {
         return m_resourceManager->resource(CurrentGamutMask).value<KoGamutMask*>();
     }
     else {
         return nullptr;
     }
 }
 
+bool KisCanvasResourceProvider::gamutMaskActive() const
+{
+    return m_resourceManager->resource(GamutMaskActive).toBool();
+}
+
 KisPaintOpPresetSP KisCanvasResourceProvider::currentPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(CurrentPaintOpPreset, v);
 }
 
 KisPaintOpPresetSP KisCanvasResourceProvider::previousPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(PreviousPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPreviousPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPreviousPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(PreviousPaintOpPreset, v);
 }
 
 void KisCanvasResourceProvider::slotPatternActivated(KoResource * res)
 {
     KoPattern *pattern = dynamic_cast<KoPattern*>(res);
     QVariant v;
     v.setValue<KoPattern*>(pattern);
     m_resourceManager->setResource(CurrentPattern, v);
     emit sigPatternChanged(pattern);
 }
 
 void KisCanvasResourceProvider::slotGradientActivated(KoResource *res)
 {
 
     KoAbstractGradient * gradient = dynamic_cast<KoAbstractGradient*>(res);
     QVariant v;
     v.setValue<KoAbstractGradient*>(gradient);
     m_resourceManager->setResource(CurrentGradient, v);
     emit sigGradientChanged(gradient);
 }
 
 
 void KisCanvasResourceProvider::setBGColor(const KoColor& c)
 {
     QVariant v;
     v.setValue(c);
     m_resourceManager->setResource(KoCanvasResourceProvider::BackgroundColor, v);
     emit sigBGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::setFGColor(const KoColor& c)
 {
     m_fGChanged = true;
 
     QVariant v;
     v.setValue(c);
     m_resourceManager->setResource(KoCanvasResourceProvider::ForegroundColor, v);
     emit sigFGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::slotSetFGColor(const KoColor& c)
 {
     setFGColor(c);
 }
 
 void KisCanvasResourceProvider::slotSetBGColor(const KoColor& c)
 {
     setBGColor(c);
 }
 
 void KisCanvasResourceProvider::slotNodeActivated(const KisNodeSP node)
 {
     QVariant v;
     v.setValue(KisNodeWSP(node));
     m_resourceManager->setResource(CurrentKritaNode, v);
     emit sigNodeChanged(currentNode());
 }
 
 
 void KisCanvasResourceProvider::slotImageSizeChanged()
 {
     if (KisImageWSP image = m_view->image()) {
         float fw = image->width() / image->xRes();
         float fh = image->height() / image->yRes();
 
         QSizeF postscriptSize(fw, fh);
         m_resourceManager->setResource(KoCanvasResourceProvider::PageSize, postscriptSize);
     }
 }
 
 void KisCanvasResourceProvider::slotOnScreenResolutionChanged()
 {
     KisImageWSP image = m_view->image();
     KisCanvas2 *canvas = m_view->canvasBase();
 
     if(!image || !canvas) return;
 
     qreal zoomX, zoomY;
     canvas->coordinatesConverter()->zoom(&zoomX, &zoomY);
 
     qreal scaleX = zoomX / image->xRes();
     qreal scaleY = zoomY / image->yRes();
 
     emit sigOnScreenResolutionChanged(scaleX, scaleY);
 }
 
 void KisCanvasResourceProvider::slotCanvasResourceChanged(int key, const QVariant & res)
 {
     if(key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoAbstractGradient* resource = KoResourceServerProvider::instance()->gradientServer()->resources()[0];
         KoStopGradient* stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0,  KoColor(QColor(0, 0, 0, 0), fgColor().colorSpace()));
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
         resource = KoResourceServerProvider::instance()->gradientServer()->resources()[1];
         stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0, bgColor());
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
     }
     switch (key) {
     case(KoCanvasResourceProvider::ForegroundColor):
         m_fGChanged = true;
         emit sigFGColorChanged(res.value<KoColor>());
         break;
     case(KoCanvasResourceProvider::BackgroundColor):
         emit sigBGColorChanged(res.value<KoColor>());
         break;
     case(CurrentPattern):
         emit sigPatternChanged(static_cast<KoPattern *>(res.value<void *>()));
         break;
     case(CurrentGradient):
         emit sigGradientChanged(static_cast<KoAbstractGradient *>(res.value<void *>()));
         break;
     case(CurrentKritaNode) :
         emit sigNodeChanged(currentNode());
         break;
     case (Opacity):
     {
         emit sigOpacityChanged(res.toDouble());
     }
     default:
         ;
         // Do nothing
     };
 }
 
 void KisCanvasResourceProvider::setCurrentCompositeOp(const QString& compositeOp)
 {
     m_resourceManager->setResource(CurrentCompositeOp,
                                    QVariant::fromValue(compositeOp));
 }
 
 QString KisCanvasResourceProvider::currentCompositeOp() const
 {
     return m_resourceManager->resource(CurrentCompositeOp).value<QString>();
 }
 
 bool KisCanvasResourceProvider::eraserMode() const
 {
     return m_resourceManager->resource(EraserMode).toBool();
 }
 
 void KisCanvasResourceProvider::setEraserMode(bool value)
 {
     m_resourceManager->setResource(EraserMode,
                                    QVariant::fromValue(value));
 }
 
 void KisCanvasResourceProvider::slotPainting()
 {
     if (m_fGChanged && m_enablefGChange) {
         emit sigFGColorUsed(fgColor());
         m_fGChanged = false;
     }
 }
 
 void KisCanvasResourceProvider::slotGamutMaskActivated(KoGamutMask *mask)
 {
     QVariant v;
     v.setValue<KoGamutMask*>(mask);
     m_resourceManager->setResource(CurrentGamutMask, v);
+
+    m_resourceManager->setResource(GamutMaskActive, QVariant::fromValue(true));
+
     emit sigGamutMaskChanged(mask);
 }
 
 void KisCanvasResourceProvider::slotGamutMaskUnset()
 {
+    m_resourceManager->setResource(GamutMaskActive, QVariant::fromValue(false));
     m_resourceManager->clearResource(CurrentGamutMask);
     emit sigGamutMaskUnset();
 }
 
 void KisCanvasResourceProvider::slotGamutMaskPreviewUpdate()
 {
     emit sigGamutMaskPreviewUpdate();
 }
 
+void KisCanvasResourceProvider::slotGamutMaskDeactivate()
+{
+    m_resourceManager->setResource(GamutMaskActive, QVariant::fromValue(false));
+    emit sigGamutMaskDeactivated();
+}
+
 void KisCanvasResourceProvider::slotResetEnableFGChange(bool b)
 {
     m_enablefGChange = b;
 }
 
 QList<QPointer<KisAbstractPerspectiveGrid> > KisCanvasResourceProvider::perspectiveGrids() const
 {
     return m_perspectiveGrids;
 }
 
 void KisCanvasResourceProvider::addPerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.append(grid);
 }
 
 void KisCanvasResourceProvider::removePerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.removeOne(grid);
 }
 
 void KisCanvasResourceProvider::clearPerspectiveGrids()
 {
     m_perspectiveGrids.clear();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontal(bool mirrorHorizontal)
 {
     m_resourceManager->setResource(MirrorHorizontal, mirrorHorizontal);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontal() const
 {
     return m_resourceManager->resource(MirrorHorizontal).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVertical(bool mirrorVertical)
 {
     m_resourceManager->setResource(MirrorVertical, mirrorVertical);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorVertical() const
 {
     return m_resourceManager->resource(MirrorVertical).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorHorizontalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontalLock() {
      return m_resourceManager->resource(MirrorHorizontalLock).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorVerticalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 
 
 bool KisCanvasResourceProvider::mirrorVerticalHideDecorations() {
      return m_resourceManager->resource(MirrorVerticalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorVerticalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorHorizontalHideDecorations() {
      return m_resourceManager->resource(MirrorHorizontalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorHorizontalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorVerticalLock() {
      return m_resourceManager->resource(MirrorVerticalLock).toBool();
 }
 
 void KisCanvasResourceProvider::mirrorVerticalMoveCanvasToCenter() {
      emit moveMirrorVerticalCenter();
 }
 
 void KisCanvasResourceProvider::mirrorHorizontalMoveCanvasToCenter() {
      emit moveMirrorHorizontalCenter();
 }
 
 
 
 void KisCanvasResourceProvider::setOpacity(qreal opacity)
 {
     m_resourceManager->setResource(Opacity, opacity);
 }
 
 qreal KisCanvasResourceProvider::opacity() const
 {
     return m_resourceManager->resource(Opacity).toReal();
 }
 
 void KisCanvasResourceProvider::setFlow(qreal flow)
 {
     m_resourceManager->setResource(Flow, flow);
 }
 
 qreal KisCanvasResourceProvider::flow() const
 {
     return m_resourceManager->resource(Flow).toReal();
 }
 
 void KisCanvasResourceProvider::setSize(qreal size)
 {
     m_resourceManager->setResource(Size, size);
 }
 
 qreal KisCanvasResourceProvider::size() const
 {
     return m_resourceManager->resource(Size).toReal();
 }
 
 void KisCanvasResourceProvider::setGlobalAlphaLock(bool lock)
 {
     m_resourceManager->setResource(GlobalAlphaLock, lock);
 }
 
 bool KisCanvasResourceProvider::globalAlphaLock() const
 {
     return m_resourceManager->resource(GlobalAlphaLock).toBool();
 }
 
 void KisCanvasResourceProvider::setDisablePressure(bool value)
 {
     m_resourceManager->setResource(DisablePressure, value);
 }
 
 bool KisCanvasResourceProvider::disablePressure() const
 {
     return m_resourceManager->resource(DisablePressure).toBool();
 }
 
 void KisCanvasResourceProvider::notifyLoadingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigLoadingWorkspace(workspace);
 }
 
 void KisCanvasResourceProvider::notifySavingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigSavingWorkspace(workspace);
 }
 
diff --git a/libs/ui/kis_canvas_resource_provider.h b/libs/ui/kis_canvas_resource_provider.h
index 5cfb97dace..ebad9a0e18 100644
--- a/libs/ui/kis_canvas_resource_provider.h
+++ b/libs/ui/kis_canvas_resource_provider.h
@@ -1,246 +1,250 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt  <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CANVAS_RESOURCE_PROVIDER_H_
 #define KIS_CANVAS_RESOURCE_PROVIDER_H_
 
 #include <QObject>
 
 #include <KoColor.h>
 #include <KoID.h>
 #include <KoCanvasResourceProvider.h>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 
 class KisWorkspaceResource;
 class KoColorProfile;
 class KoAbstractGradient;
 class KoResource;
 
 class KoCanvasBase;
 class KisViewManager;
 class KoPattern;
 class KoGamutMask;
 class KisFilterConfiguration;
 
 #include <kis_abstract_perspective_grid.h>
 
 /**
  * KisCanvasResourceProvider contains the per-window current settings that
  * influence painting, like paintop, color, gradients and so on.
  */
 class KRITAUI_EXPORT KisCanvasResourceProvider : public QObject
 {
     Q_OBJECT
 
 public:
 
     enum Resources {
         HdrExposure = KoCanvasResourceProvider::KritaStart + 1,
         CurrentPattern,
         CurrentGamutMask,
+        GamutMaskActive,
         CurrentGradient,
         CurrentDisplayProfile,
         CurrentKritaNode,
         CurrentPaintOpPreset,
         CurrentGeneratorConfiguration,
         CurrentCompositeOp,
         CurrentEffectiveCompositeOp,
         LodAvailability, ///<-user choice
         LodSizeThreshold, ///<-user choice
         LodSizeThresholdSupported, ///<-paintop property
         EffectiveLodAvailablility, ///<- a superposition of user choice, threshold and paintop traits
         EraserMode,
         MirrorHorizontal,
         MirrorVertical,
         MirrorHorizontalLock,
         MirrorVerticalLock,
         MirrorVerticalHideDecorations,
         MirrorHorizontalHideDecorations,
         Opacity,
         Flow,
         Size,
         HdrGamma,
         GlobalAlphaLock,
         DisablePressure,
         PreviousPaintOpPreset,
         EffectiveZoom ///<-Used only by painting tools for non-displaying purposes
     };
 
 
     KisCanvasResourceProvider(KisViewManager * view);
     ~KisCanvasResourceProvider() override;
 
     void setResourceManager(KoCanvasResourceProvider *resourceManager);
     KoCanvasResourceProvider* resourceManager();
 
     KoCanvasBase * canvas() const;
 
     KoColor bgColor() const;
     void setBGColor(const KoColor& c);
 
     KoColor fgColor() const;
     void setFGColor(const KoColor& c);
 
     float HDRExposure() const;
     void setHDRExposure(float exposure);
 
     float HDRGamma() const;
     void setHDRGamma(float gamma);
 
     bool eraserMode() const;
     void setEraserMode(bool value);
 
     KoPattern *currentPattern() const;
 
     KoAbstractGradient *currentGradient() const;
 
     KisImageWSP currentImage() const;
 
     KisNodeSP currentNode() const;
 
     KoGamutMask* currentGamutMask() const;
+    bool gamutMaskActive() const;
 
     KisPaintOpPresetSP currentPreset() const;
     void setPaintOpPreset(const KisPaintOpPresetSP preset);
 
     KisPaintOpPresetSP previousPreset() const;
     void setPreviousPaintOpPreset(const KisPaintOpPresetSP preset);
 
     void setCurrentCompositeOp(const QString& compositeOp);
     QString currentCompositeOp() const;
 
     QList<QPointer<KisAbstractPerspectiveGrid> > perspectiveGrids() const;
     void addPerspectiveGrid(KisAbstractPerspectiveGrid*);
     void removePerspectiveGrid(KisAbstractPerspectiveGrid*);
     void clearPerspectiveGrids();
 
     void setMirrorHorizontal(bool mirrorHorizontal);
     bool mirrorHorizontal() const;
 
     void setMirrorVertical(bool mirrorVertical);
     bool mirrorVertical() const;
 
     // options for horizontal and vertical mirror toolbar
     void setMirrorHorizontalLock(bool isLocked);
     bool mirrorHorizontalLock();
     void setMirrorVerticalLock(bool isLocked);
     bool mirrorVerticalLock();
 
     void setMirrorVerticalHideDecorations(bool hide);
     bool mirrorVerticalHideDecorations();
 
     void setMirrorHorizontalHideDecorations(bool hide);
     bool mirrorHorizontalHideDecorations();
 
     void mirrorVerticalMoveCanvasToCenter();
     void mirrorHorizontalMoveCanvasToCenter();
 
     void setOpacity(qreal opacity);
     qreal opacity() const;
 
     void setFlow(qreal opacity);
     qreal flow() const;
 
     void setSize(qreal size);
     qreal size() const;
 
     void setGlobalAlphaLock(bool lock);
     bool globalAlphaLock() const;
 
     void setDisablePressure(bool value);
     bool disablePressure() const;
 
     ///Notify that the workspace is saved and settings should be saved to it
     void notifySavingWorkspace(KisWorkspaceResource* workspace);
 
     ///Notify that the workspace is loaded and settings can be read
     void notifyLoadingWorkspace(KisWorkspaceResource* workspace);
 
 public Q_SLOTS:
 
     void slotSetFGColor(const KoColor& c);
     void slotSetBGColor(const KoColor& c);
     void slotPatternActivated(KoResource *pattern);
     void slotGradientActivated(KoResource *gradient);
     void slotNodeActivated(const KisNodeSP node);
     void slotPainting();
 
     void slotGamutMaskActivated(KoGamutMask* mask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
+    void slotGamutMaskDeactivate();
 
     /**
      * Set the image size in pixels. The resource provider will store
      * the image size in postscript points.
      */
     // FIXME: this slot doesn't catch the case when image resolution is changed
     void slotImageSizeChanged();
     void slotOnScreenResolutionChanged();
 
     // This is a flag 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 slotResetEnableFGChange(bool);
 
 private Q_SLOTS:
 
     void slotCanvasResourceChanged(int key, const QVariant & res);
 
 Q_SIGNALS:
 
     void sigFGColorChanged(const KoColor &);
     void sigBGColorChanged(const KoColor &);
     void sigGradientChanged(KoAbstractGradient *);
     void sigPatternChanged(KoPattern *);
     void sigNodeChanged(const KisNodeSP);
     void sigDisplayProfileChanged(const KoColorProfile *);
     void sigFGColorUsed(const KoColor&);
     void sigOnScreenResolutionChanged(qreal scaleX, qreal scaleY);
     void sigOpacityChanged(qreal);
     void sigSavingWorkspace(KisWorkspaceResource* workspace);
     void sigLoadingWorkspace(KisWorkspaceResource* workspace);
 
     void mirrorModeChanged();
     void moveMirrorVerticalCenter();
     void moveMirrorHorizontalCenter();
 
     void sigGamutMaskChanged(KoGamutMask* mask);
     void sigGamutMaskUnset();
     void sigGamutMaskPreviewUpdate();
+    void sigGamutMaskDeactivated();
 
 private:
 
     KisViewManager * m_view;
     KoCanvasResourceProvider *m_resourceManager;
     bool m_fGChanged;
     QList<QPointer<KisAbstractPerspectiveGrid> > m_perspectiveGrids;
 
     // This is a flag 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
     bool m_enablefGChange;
 
 };
 
 #endif
diff --git a/libs/ui/widgets/KisGamutMaskToolbar.cpp b/libs/ui/widgets/KisGamutMaskToolbar.cpp
index 6c007584cc..2a1851f773 100644
--- a/libs/ui/widgets/KisGamutMaskToolbar.cpp
+++ b/libs/ui/widgets/KisGamutMaskToolbar.cpp
@@ -1,116 +1,144 @@
 /*
  *  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 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this 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>
+#include <kis_signals_blocker.h>
 
 KisGamutMaskToolbar::KisGamutMaskToolbar(QWidget* parent) : QWidget(parent)
   , m_selectedMask(nullptr)
+  , m_selfUpdate(false)
 {
     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*)), Qt::UniqueConnection);
 
     connect(resourceProvider, SIGNAL(sigGamutMaskUnset()),
             this, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
     connect(this, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
             resourceProvider, SLOT(slotGamutMaskActivated(KoGamutMask*)), Qt::UniqueConnection);
+
+    connect(this, SIGNAL(sigGamutMaskDeactivated()),
+            resourceProvider, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
+
+    connect(resourceProvider, SIGNAL(sigGamutMaskDeactivated()),
+            this, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
 }
 
 void KisGamutMaskToolbar::slotGamutMaskSet(KoGamutMask *mask)
 {
     if (!mask) {
         return;
     }
 
+    if (m_selfUpdate) {
+        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::slotGamutMaskDeactivate()
+{
+    if (m_selfUpdate) {
+        return;
+    }
+
+    slotGamutMaskToggle(false);
+}
+
 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);
+
+        m_selfUpdate = true;
+        emit sigGamutMaskChanged(m_selectedMask);
+        m_selfUpdate = 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);
+        m_selfUpdate = true;
+        emit sigGamutMaskDeactivated();
+        m_selfUpdate = false;
+    }
 }
 
 void KisGamutMaskToolbar::slotGamutMaskRotate(int angle)
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask->setRotation(angle);
     emit sigGamutMaskChanged(m_selectedMask);
 }
diff --git a/libs/ui/widgets/KisGamutMaskToolbar.h b/libs/ui/widgets/KisGamutMaskToolbar.h
index c61792aa33..941d7794c2 100644
--- a/libs/ui/widgets/KisGamutMaskToolbar.h
+++ b/libs/ui/widgets/KisGamutMaskToolbar.h
@@ -1,62 +1,65 @@
 /*
  *  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 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this 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*);
+    void sigGamutMaskDeactivated();
 
 public Q_SLOTS:
     void slotGamutMaskSet(KoGamutMask* mask);
     void slotGamutMaskUnset();
+    void slotGamutMaskDeactivate();
 
 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;
+
+    bool m_selfUpdate;
 };
 
 #endif // KISGAMUTMASKTOOLBAR_H
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
index 83c6a29aba..3427f0d031 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -1,396 +1,401 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_color_selector.h"
 
 #include <cmath>
 
 #include <QHBoxLayout>
 #include <QColor>
 #include <QPainter>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QPushButton>
 #include <QApplication>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <kis_debug.h>
 
 #include <KoCanvasResourceProvider.h>
 #include <kis_icon.h>
 
 #include "kis_color_selector_ring.h"
 #include "kis_color_selector_triangle.h"
 #include "kis_color_selector_simple.h"
 #include "kis_color_selector_wheel.h"
 #include "kis_color_selector_container.h"
 #include "kis_canvas2.h"
 #include "kis_signal_compressor.h"
 #include "KisViewManager.h"
 
 
 KisColorSelector::KisColorSelector(KisColorSelectorConfiguration conf, QWidget* parent)
     : KisColorSelectorBase(parent),
       m_ring(0),
       m_triangle(0),
       m_slider(0),
       m_square(0),
       m_wheel(0),
       m_mainComponent(0),
       m_subComponent(0),
       m_grabbingComponent(0),
       m_blipDisplay(true)
 {
     init();
     updateSettings();
     setConfiguration(conf);
 }
 
 KisColorSelector::KisColorSelector(QWidget* parent)
     : KisColorSelectorBase(parent),
       m_ring(0),
       m_triangle(0),
       m_slider(0),
       m_square(0),
       m_wheel(0),
       m_button(0),
       m_mainComponent(0),
       m_subComponent(0),
       m_grabbingComponent(0),
       m_blipDisplay(true)
 {
     init();
     updateSettings();
 }
 
 KisColorSelectorBase* KisColorSelector::createPopup() const
 {
     KisColorSelectorBase* popup = new KisColorSelector(0);
     popup->setColor(m_lastRealColor);
     return popup;
 }
 
 void KisColorSelector::setConfiguration(KisColorSelectorConfiguration conf)
 {
     m_configuration = conf;
 
     if(m_mainComponent!=0) {
         Q_ASSERT(m_subComponent!=0);
         m_mainComponent->setGeometry(0, 0, 0, 0);
         m_subComponent->setGeometry(0, 0, 0, 0);
 
         m_mainComponent->disconnect();
         m_subComponent->disconnect();
     }
 
     switch (m_configuration.mainType) {
     case KisColorSelectorConfiguration::Square:
         m_mainComponent=m_square;
         break;
     case KisColorSelectorConfiguration::Wheel:
         m_mainComponent=m_wheel;
         break;
     case KisColorSelectorConfiguration::Triangle:
         m_mainComponent=m_triangle;
         break;
     default:
         Q_ASSERT(false);
     }
 
     switch (m_configuration.subType) {
     case KisColorSelectorConfiguration::Ring:
         m_subComponent=m_ring;
         break;
     case KisColorSelectorConfiguration::Slider:
         m_subComponent=m_slider;
         break;
     default:
         Q_ASSERT(false);
     }
 
     connect(m_mainComponent, SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
             m_subComponent,  SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
     connect(m_subComponent,  SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
             m_mainComponent, SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
 
     connect(m_mainComponent, SIGNAL(update()), m_signalCompressor, SLOT(start()), Qt::UniqueConnection);
     connect(m_subComponent,  SIGNAL(update()), m_signalCompressor, SLOT(start()), Qt::UniqueConnection);
 
     m_mainComponent->setConfiguration(m_configuration.mainTypeParameter, m_configuration.mainType);
     m_subComponent->setConfiguration(m_configuration.subTypeParameter, m_configuration.subType);
 
     QResizeEvent event(QSize(width(), height()), QSize());
     resizeEvent(&event);
 }
 
 KisColorSelectorConfiguration KisColorSelector::configuration() const
 {
     return m_configuration;
 }
 
 void KisColorSelector::updateSettings()
 {
     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::slotGamutMaskDeactivate()
+{
+    slotGamutMaskToggle(false);
+}
+
 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"));
     }
 }
 
 void KisColorSelector::hasAtLeastOneDocument(bool value)
 {
     m_hasAtLeastOneDocumentOpen = value;
 }
 
 void KisColorSelector::reset()
 {
     if (m_mainComponent) {
         m_mainComponent->setDirty();
     }
 
     if (m_subComponent) {
         m_subComponent->setDirty();
     }
 
     KisColorSelectorBase::reset();
 }
 
 void KisColorSelector::paintEvent(QPaintEvent* e)
 {
     Q_UNUSED(e);
     QPainter p(this);
     p.fillRect(0,0,width(), height(), QColor(128,128,128));
     p.setRenderHint(QPainter::Antialiasing);
 
     // this variable name isn't entirely accurate to what always happens. see definition in header file to understand it better
     if (!m_hasAtLeastOneDocumentOpen) {
         p.setOpacity(0.2);
     }
 
     m_mainComponent->paintEvent(&p);
     m_subComponent->paintEvent(&p);
 
     p.setOpacity(1.0);
 }
 
 inline int iconSize(qreal width, qreal height) {
     qreal radius = qMin(width, height)/2.;
     qreal xm = width/2.;
     qreal ym = height/2.;
     if(xm>=2*ym || ym>=2*xm)
         return qBound<qreal>(5., radius, 32.);
 
     qreal a=-2;
     qreal b=2.*(xm+ym);
     qreal c=radius*radius-xm*xm-ym*ym;
     return qBound<qreal>(5., ((-b+sqrt(b*b-4*a*c))/(2*a)), 32.);
 }
 
 void KisColorSelector::resizeEvent(QResizeEvent* e) {
     if (m_configuration.subType == KisColorSelectorConfiguration::Ring) {
 
         m_ring->setGeometry(0,0,width(), height());
 
         if (displaySettingsButton()) {
             int size = iconSize(width(), height());
             m_button->setGeometry(0, 0, size, size);
         }
 
         if (m_configuration.mainType == KisColorSelectorConfiguration::Triangle) {
             m_triangle->setGeometry(width()/2-m_ring->innerRadius(),
                                     height()/2-m_ring->innerRadius(),
                                     m_ring->innerRadius()*2,
                                     m_ring->innerRadius()*2);
         }
         else {
             int size = m_ring->innerRadius()*2/sqrt(2.);
             m_square->setGeometry(width()/2-size/2,
                                   height()/2-size/2,
                                   size,
                                   size);
         }
     }
     else {
         // type wheel and square
         if (m_configuration.mainType == KisColorSelectorConfiguration::Wheel) {
             if(displaySettingsButton()) {
                 int size = iconSize(width(), height()*0.9);
                 m_button->setGeometry(0, height()*0.1, size, size);
             }
             m_mainComponent->setGeometry(0, height()*0.1, width(), height()*0.9);
             m_subComponent->setGeometry( 0, 0,            width(), height()*0.1);
         }
         else {
             int buttonSize = 0;
             if(displaySettingsButton()) {
                 buttonSize = qBound(20, int(0.1*height()), 32);
                 m_button->setGeometry(0, 0, buttonSize, buttonSize);
             }
 
             if(height()>width()) {
                 int selectorHeight=height()-buttonSize;
                 m_mainComponent->setGeometry(0, buttonSize+selectorHeight*0.1, width(), selectorHeight*0.9);
                 m_subComponent->setGeometry( 0, buttonSize,                    width(), selectorHeight*0.1);
             }
             else {
                 int selectorWidth=width()-buttonSize;
                 m_mainComponent->setGeometry(buttonSize, height()*0.1, selectorWidth, height()*0.9);
                 m_subComponent->setGeometry( buttonSize, 0,            selectorWidth, height()*0.1);
             }
         }
     }
 
     // reset the correct color after resizing the widget
     setColor(m_lastRealColor);
 
     KisColorSelectorBase::resizeEvent(e);
 }
 
 void KisColorSelector::mousePressEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mousePressEvent(e);
 
     if(!e->isAccepted()) {
         if(m_mainComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_mainComponent;
         else if(m_subComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_subComponent;
 
         mouseEvent(e);
         updatePreviousColorPreview();
         e->accept();
     }
 }
 
 void KisColorSelector::mouseMoveEvent(QMouseEvent* e)
 {
     KisColorSelectorBase::mouseMoveEvent(e);
 
     mouseEvent(e);
     e->accept();
 }
 
 void KisColorSelector::mouseReleaseEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mouseReleaseEvent(e);
 
     if(!e->isAccepted() &&
        !(m_lastRealColor == m_currentRealColor)) {
 
         m_lastRealColor = m_currentRealColor;
         m_lastColorRole = Acs::buttonToRole(e->button());
 
         updateColor(m_lastRealColor, m_lastColorRole, false);
         updateBaseColorPreview(m_currentRealColor);
         e->accept();
     }
 
     m_grabbingComponent=0;
 }
 
 bool KisColorSelector::displaySettingsButton()
 {
     return dynamic_cast<KisColorSelectorContainer*>(parent());
 }
 
 void KisColorSelector::setColor(const KoColor &color)
 {
     m_mainComponent->setColor(color);
     m_subComponent->setColor(color);
     m_lastRealColor = color;
 
     m_signalCompressor->start();
 }
 
 void KisColorSelector::mouseEvent(QMouseEvent *e)
 {
     if (m_grabbingComponent && (e->buttons() & Qt::LeftButton || e->buttons() & Qt::RightButton)) {
 
         m_grabbingComponent->mouseEvent(e->x(), e->y());
 
         KoColor color = m_mainComponent->currentColor();
         Acs::ColorRole role = Acs::buttonsToRole(e->button(), e->buttons());
         m_currentRealColor = color;
 
         requestUpdateColorAndPreview(color, role);
     }
 }
 
 void KisColorSelector::init()
 {
     setAcceptDrops(true);
 
     m_lastColorRole = Acs::Foreground;
     m_ring = new KisColorSelectorRing(this);
     m_triangle = new KisColorSelectorTriangle(this);
     m_slider = new KisColorSelectorSimple(this);
     m_square = new KisColorSelectorSimple(this);
     m_wheel = new KisColorSelectorWheel(this);
 
     if(displaySettingsButton()) {
         m_button = new QPushButton(this);
         m_button->setIcon(KisIconUtils::loadIcon("configure"));
         m_button->setFlat(true);
         connect(m_button, SIGNAL(clicked()), SIGNAL(settingsButtonClicked()));
     }
 
     // a tablet can send many more signals, than a mouse
     // this causes many repaints, if updating after every signal.
     m_signalCompressor = new KisSignalCompressor(20, KisSignalCompressor::FIRST_INACTIVE, this);
     connect(m_signalCompressor, SIGNAL(timeout()), SLOT(update()));
 
     setMinimumSize(40, 40);
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.h b/plugins/dockers/advancedcolorselector/kis_color_selector.h
index 5d73ba5489..a28c860b27 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.h
@@ -1,105 +1,106 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_COLOR_SELECTOR_H
 #define KIS_COLOR_SELECTOR_H
 
 #include "kis_color_selector_base.h"
 #include <KisColorSelectorConfiguration.h>
 
 
 class KisColorSelectorRing;
 class KisColorSelectorComponent;
 class KisColorSelectorSimple;
 class KisColorSelectorWheel;
 class QPushButton;
 class KisSignalCompressor;
 
 class KisColorSelector : public KisColorSelectorBase
 {
     Q_OBJECT
 public:
 
     KisColorSelector(KisColorSelectorConfiguration conf, QWidget* parent = 0);
     KisColorSelector(QWidget* parent=0);
     KisColorSelectorBase* createPopup() const override;
 
     void setConfiguration(KisColorSelectorConfiguration conf);
     KisColorSelectorConfiguration configuration() const;
     void setColor(const KoColor &color) override;
 
     /// update icons when a theme update happens
     void updateIcons();
 
     void hasAtLeastOneDocument(bool value);
 
 public Q_SLOTS:
     void reset() override;
     void updateSettings() override;
     void slotGamutMaskSet(KoGamutMask* gamutMask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
     void slotGamutMaskToggle(bool state);
+    void slotGamutMaskDeactivate();
 
 Q_SIGNALS:
     void settingsButtonClicked();
 
 protected:
     void paintEvent(QPaintEvent*) override;
     void resizeEvent(QResizeEvent*) override;
     void mousePressEvent(QMouseEvent*) override;
     void mouseMoveEvent(QMouseEvent*) override;
     void mouseReleaseEvent(QMouseEvent*) override;
     bool displaySettingsButton();
 
 private:
     void mouseEvent(QMouseEvent* e);
     void init();
 
     KisColorSelectorRing* m_ring;
     KisColorSelectorComponent* m_triangle;
     KisColorSelectorSimple* m_slider;
     KisColorSelectorSimple* m_square;
     KisColorSelectorWheel* m_wheel;
     QPushButton* m_button;
     KisColorSelectorComponent* m_mainComponent;
     KisColorSelectorComponent* m_subComponent;
     KisColorSelectorComponent* m_grabbingComponent;
 
     KisSignalCompressor *m_signalCompressor;
 
     KisColorSelectorConfiguration m_configuration;
 
     KoColor m_lastRealColor;
     KoColor m_currentRealColor;
     bool m_blipDisplay;
     Acs::ColorRole m_lastColorRole;
 
 
     /// if Krita starts with a reference to this component that is attached to a canvas, it will call setCanvas()
     /// that check will be what ultimately decides whether this component will look enabled or disabled
     /// This color selector is sometimes not attached to the canvas, so we shouldn't disable it in that situation
     /// One instance of that is when you select the color wheel type from the settings.
     bool m_hasAtLeastOneDocumentOpen = true;
 
 public:
     void setDisplayBlip(bool disp) {m_blipDisplay = disp;}
     bool displayBlip() const {return m_blipDisplay;}
 };
 
 #endif // KIS_COLSELNG_COLOR_SELECTOR_H
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
index 215d1850da..1366fc68e8 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
@@ -1,251 +1,251 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  */
 
 #include "kis_color_selector_container.h"
 
 #include "kis_color_selector.h"
 #include "kis_my_paint_shade_selector.h"
 #include "kis_minimal_shade_selector.h"
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QAction>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <kactioncollection.h>
 
 #include <KisDocument.h>
 #include <KisGamutMaskToolbar.h>
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node_manager.h"
 #include "kis_node.h"
 #include "kis_paint_device.h"
 
 #include "kis_action_registry.h"
 
 KisColorSelectorContainer::KisColorSelectorContainer(QWidget *parent) :
     QWidget(parent),
     m_colorSelector(new KisColorSelector(this)),
     m_myPaintShadeSelector(new KisMyPaintShadeSelector(this)),
     m_minimalShadeSelector(new KisMinimalShadeSelector(this)),
     m_shadeSelector(m_myPaintShadeSelector),
     m_gamutMaskToolbar(new KisGamutMaskToolbar(this)),
     m_showColorSelector(true),
     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();
 
     connect(m_colorSelector,SIGNAL(settingsButtonClicked()), SIGNAL(openSettings()));
 
     connect(this, SIGNAL(settingsChanged()), m_colorSelector,        SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), m_myPaintShadeSelector, SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), this,                   SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), m_minimalShadeSelector, SLOT(updateSettings()));
 
 
     m_colorSelAction = KisActionRegistry::instance()->makeQAction("show_color_selector", this);
     connect(m_colorSelAction, SIGNAL(triggered()), m_colorSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
     m_mypaintAction = KisActionRegistry::instance()->makeQAction("show_mypaint_shade_selector", this);
     connect(m_mypaintAction, SIGNAL(triggered()), m_myPaintShadeSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
     m_minimalAction = KisActionRegistry::instance()->makeQAction("show_minimal_shade_selector", this);
     connect(m_minimalAction, SIGNAL(triggered()), m_minimalShadeSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
 }
 
 void KisColorSelectorContainer::unsetCanvas()
 {
     m_colorSelector->hasAtLeastOneDocument(doesAtleastOneDocumentExist());
 
     m_colorSelector->unsetCanvas();
     m_myPaintShadeSelector->unsetCanvas();
     m_minimalShadeSelector->unsetCanvas();
     m_canvas = 0;
 }
 
 bool KisColorSelectorContainer::doesAtleastOneDocumentExist()
 {
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->document() ) {
         if (m_canvas->viewManager()->document()->image()->height() == 0) {
             return false;
         } else {
            return true;
         }
     } else {
         return false;
     }
 }
 
 void KisColorSelectorContainer::slotUpdateIcons()
 {
     m_colorSelector->updateIcons();
 }
 
 void KisColorSelectorContainer::setCanvas(KisCanvas2* canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_canvas->viewManager()->nodeManager()->disconnect(this);
         KActionCollection *ac = m_canvas->viewManager()->actionCollection();
         ac->takeAction(ac->action("show_color_selector"));
         ac->takeAction(ac->action("show_mypaint_shade_selector"));
         ac->takeAction(ac->action("show_minimal_shade_selector"));
     }
 
     m_canvas = canvas;
 
     m_colorSelector->setCanvas(canvas);
     m_myPaintShadeSelector->setCanvas(canvas);
     m_minimalShadeSelector->setCanvas(canvas);
 
 
     m_colorSelector->hasAtLeastOneDocument(doesAtleastOneDocumentExist());
 
 
     if (m_canvas && m_canvas->viewManager()) {
         if (m_canvas->viewManager()->nodeManager()) {
             connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigLayerActivated(KisLayerSP)), SLOT(reactOnLayerChange()), Qt::UniqueConnection);
         }
 
         connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
                 m_colorSelector, SLOT(slotGamutMaskSet(KoGamutMask*)), Qt::UniqueConnection);
 
         connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskUnset()),
                 m_colorSelector, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
         connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskPreviewUpdate()),
                 m_colorSelector, SLOT(slotGamutMaskPreviewUpdate()), Qt::UniqueConnection);
 
-        m_gamutMaskToolbar->connectMaskSignals(m_canvas->viewManager()->canvasResourceProvider());
+        connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskDeactivated()),
+                m_colorSelector, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
 
-        // gamut mask connections
-        connect(m_gamutMaskToolbar, SIGNAL(sigGamutMaskToggle(bool)), m_colorSelector, SLOT(slotGamutMaskToggle(bool)), Qt::UniqueConnection);
+        m_gamutMaskToolbar->connectMaskSignals(m_canvas->viewManager()->canvasResourceProvider());
 
         KActionCollection* actionCollection = canvas->viewManager()->actionCollection();
         actionCollection->addAction("show_color_selector", m_colorSelAction);
         actionCollection->addAction("show_mypaint_shade_selector", m_mypaintAction);
         actionCollection->addAction("show_minimal_shade_selector", m_minimalAction);
     }
 }
 
 void KisColorSelectorContainer::updateSettings()
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     m_onDockerResizeSetting =  (int)cfg.readEntry("onDockerResize", 0);
     m_showColorSelector = (bool) cfg.readEntry("showColorSelector", true);
 
     if (m_showColorSelector) {
         m_colorSelector->show();
 
         if (m_colorSelector->configuration().mainType == KisColorSelectorConfiguration::Wheel) {
             m_gamutMaskToolbar->show();
         } else {
             m_gamutMaskToolbar->hide();
         }
     } else {
         m_colorSelector->hide();
         m_gamutMaskToolbar->hide();
     }
 
     QString type = cfg.readEntry("shadeSelectorType", "Minimal");
 
     QWidget* newShadeSelector;
     if(type=="MyPaint")
         newShadeSelector = m_myPaintShadeSelector;
     else if (type=="Minimal")
         newShadeSelector = m_minimalShadeSelector;
     else
         newShadeSelector = 0;
 
 
 
     if(m_shadeSelector!=newShadeSelector && m_shadeSelector!=0) {
         m_shadeSelector->hide();
     }
     m_shadeSelector=newShadeSelector;
 
     if(m_shadeSelector!=0)
         m_shadeSelector->show();
 }
 
 void KisColorSelectorContainer::reactOnLayerChange()
 {
     if (m_canvas) {
         KisNodeSP node = m_canvas->viewManager()->canvasResourceProvider()->currentNode();
         if (node) {
             KisPaintDeviceSP device = node->paintDevice();
             if (device) {
                 m_colorSelAction->setEnabled(true);
                 m_mypaintAction->setEnabled(true);
                 m_minimalAction->setEnabled(true);
             }
             else {
                 //            m_colorSelAction->setEnabled(false);
                 //            m_mypaintAction->setEnabled(false);
                 //            m_minimalAction->setEnabled(false);
             }
         }
     }
 }
 
 void KisColorSelectorContainer::resizeEvent(QResizeEvent * e)
 {
     if(m_shadeSelector!=0) {
         int minimumHeightForBothWidgets = m_colorSelector->minimumHeight()+m_shadeSelector->minimumHeight()+30; //+30 for the buttons (temporarily)
 
         if(height()<minimumHeightForBothWidgets && m_onDockerResizeSetting== 1) {  // 1 option is hide shade selector
             m_shadeSelector->hide();
         }
         else {
             m_shadeSelector->show();
         }
 
         // m_onDockerResizeSetting==0 is allow horizontal layout
         if(height() < width() && m_onDockerResizeSetting==0 && m_shadeSelector!=m_minimalShadeSelector) {
             m_widgetLayout->setDirection(QBoxLayout::LeftToRight);
         }
         else {
             m_widgetLayout->setDirection(QBoxLayout::TopToBottom);
         }
     }
 
     QWidget::resizeEvent(e);
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
index 58c9788fe0..ab2b45c0fe 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -1,460 +1,465 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  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 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <kis_debug.h>
 
 #include <klocalizedstring.h>
 #include <KoCanvasResourceProvider.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerObserver.h>
 #include <KoResourceServerAdapter.h>
 #include <KoCanvasBase.h>
 #include <kis_canvas2.h>
 #include <KoColor.h>
 #include <resources/KoGamutMask.h>
 #include <kis_icon_utils.h>
 #include <KisPart.h>
 #include <kis_shape_layer.h>
 #include <kis_types.h>
 #include <KisDocument.h>
 #include <kis_node_selection_adapter.h>
 #include <kis_group_layer.h>
 #include <KisView.h>
 #include <KoResourceItemChooser.h>
 #include <kis_display_color_converter.h>
 
 #include <QWidget>
 #include <QMenu>
 #include <QButtonGroup>
 #include <QRegExpValidator>
 #include <QRegExp>
 #include <QFileInfo>
 
 #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"
 #include "ui_wdgWheelPreferencesPopup.h"
 
 class KisMainWindow;
 
 struct ArtisticColorSelectorUI: public QWidget, public Ui_wdgArtisticColorSelector
 {
     ArtisticColorSelectorUI() {
         setupUi(this);
     }
 };
 
 struct ARCSSettingsUI: public QWidget, public Ui_wdgARCSSettings
 {
     ARCSSettingsUI() {
         setupUi(this);
     }
 };
 
 struct WheelPreferencesPopupUI: public QWidget, public Ui_wdgWheelPreferencesPopup
 {
     WheelPreferencesPopupUI() {
         setupUi(this);
     }
 };
 
 
 ArtisticColorSelectorDock::ArtisticColorSelectorDock()
     : QDockWidget(i18n("Artistic Color Selector"))
     , m_canvas(nullptr)
     , m_resourceProvider(0)
     , m_selectedMask(nullptr)
 {
     setEnabled(false);
 
     m_hsxButtons    = new QButtonGroup();
     m_preferencesUI = new ARCSSettingsUI();
     m_wheelPrefsUI  = new WheelPreferencesPopupUI();
     m_selectorUI    = new ArtisticColorSelectorUI();
 
     QPixmap hueStepsPixmap = KisIconUtils::loadIcon("wheel-sectors").pixmap(16,16);
     QPixmap saturationStepsPixmap = KisIconUtils::loadIcon("wheel-rings").pixmap(16,16);
     QPixmap valueScaleStepsPixmap = KisIconUtils::loadIcon("wheel-light").pixmap(16,16);
     QIcon infinityIcon = KisIconUtils::loadIcon("infinity");
     m_infinityPixmap = infinityIcon.pixmap(16,16);
 
     m_selectorUI->colorSelector->loadSettings();
 
     m_selectorUI->bnWheelPrefs->setIcon(KisIconUtils::loadIcon("wheel-sectors"));
     m_selectorUI->bnWheelPrefs->setPopupWidget(m_wheelPrefsUI);
 
     m_selectorUI->bnDockerPrefs->setPopupWidget(m_preferencesUI);
     m_selectorUI->bnDockerPrefs->setIcon(KisIconUtils::loadIcon("configure"));
 
     //preferences
     m_hsxButtons->addButton(m_preferencesUI->bnHsy, KisColor::HSY);
     m_hsxButtons->addButton(m_preferencesUI->bnHsi, KisColor::HSI);
     m_hsxButtons->addButton(m_preferencesUI->bnHsl, KisColor::HSL);
     m_hsxButtons->addButton(m_preferencesUI->bnHsv, KisColor::HSV);
 
     m_wheelPrefsUI->bnInverseSat->setChecked(m_selectorUI->colorSelector->isSaturationInverted());
 
     m_wheelPrefsUI->labelHueSteps->setPixmap(hueStepsPixmap);
     m_wheelPrefsUI->labelSaturationSteps->setPixmap(saturationStepsPixmap);
     m_wheelPrefsUI->labelValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
     m_wheelPrefsUI->numHueSteps->setRange(MIN_NUM_UI_HUE_PIECES, MAX_NUM_HUE_PIECES);
     m_wheelPrefsUI->numSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
     m_wheelPrefsUI->numValueScaleSteps->setRange(MIN_NUM_UI_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
     m_wheelPrefsUI->bnInfHueSteps->setIcon(infinityIcon);
     m_wheelPrefsUI->bnInfValueScaleSteps->setIcon(infinityIcon);
 
     m_wheelPrefsUI->bnInfHueSteps->setToolTip(i18n("Continuous Mode"));
     m_wheelPrefsUI->bnInfValueScaleSteps->setToolTip(i18n("Continuous Mode"));
 
     int selectorHueSteps = m_selectorUI->colorSelector->getNumPieces();
     if (selectorHueSteps == 1) {
         m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
     }
     m_wheelPrefsUI->numHueSteps->setValue(selectorHueSteps);
 
     m_wheelPrefsUI->numSaturationSteps->setValue(m_selectorUI->colorSelector->getNumRings());
 
     int selectorValueScaleSteps = m_selectorUI->colorSelector->getNumLightPieces();
     if (selectorValueScaleSteps == 1) {
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
     }
     m_wheelPrefsUI->numValueScaleSteps->setValue(m_selectorUI->colorSelector->getNumLightPieces());
 
     m_preferencesUI->bnDefInfHueSteps->setIcon(infinityIcon);
     m_preferencesUI->bnDefInfValueScaleSteps->setIcon(infinityIcon);
 
     m_preferencesUI->labelDefHueSteps->setPixmap(hueStepsPixmap);
     m_preferencesUI->labelDefSaturationSteps->setPixmap(saturationStepsPixmap);
     m_preferencesUI->labelDefValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
     m_preferencesUI->defaultHueSteps->setRange(MIN_NUM_HUE_PIECES, MAX_NUM_HUE_PIECES);
     m_preferencesUI->defaultSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
     m_preferencesUI->defaultValueScaleSteps->setRange(MIN_NUM_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
     m_preferencesUI->defaultHueSteps->setValue(m_selectorUI->colorSelector->getDefaultHueSteps());
     m_preferencesUI->defaultSaturationSteps->setValue(m_selectorUI->colorSelector->getDefaultSaturationSteps());
     m_preferencesUI->defaultValueScaleSteps->setValue(m_selectorUI->colorSelector->getDefaultValueScaleSteps());
 
     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->spLumaR->setValue(m_selectorUI->colorSelector->lumaR());
     m_preferencesUI->spLumaG->setValue(m_selectorUI->colorSelector->lumaG());
     m_preferencesUI->spLumaB->setValue(m_selectorUI->colorSelector->lumaB());
     m_preferencesUI->spLumaGamma->setValue(m_selectorUI->colorSelector->lumaGamma());
 
     switch(m_selectorUI->colorSelector->getColorSpace())
     {
         case KisColor::HSV: { m_preferencesUI->bnHsv->setChecked(true); } break;
         case KisColor::HSI: { m_preferencesUI->bnHsi->setChecked(true); } break;
         case KisColor::HSL: { m_preferencesUI->bnHsl->setChecked(true); } break;
         case KisColor::HSY: { m_preferencesUI->bnHsy->setChecked(true); } break;
     }
 
     if (m_selectorUI->colorSelector->getColorSpace() == KisColor::HSY) {
         m_preferencesUI->lumaCoefficientBox->show();
     } else {
         m_preferencesUI->lumaCoefficientBox->hide();
     }
 
     connect(m_wheelPrefsUI->numValueScaleSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->numHueSteps         , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->numSaturationSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInverseSat        , SIGNAL(clicked(bool))                          , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnDefault           , SIGNAL(clicked(bool))                          , SLOT(slotResetDefaultSettings()));
 
     connect(m_preferencesUI->defaultHueSteps    , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->defaultSaturationSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->defaultValueScaleSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnDefInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnDefInfValueScaleSteps, SIGNAL(clicked(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->spLumaR   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaG   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaB   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaGamma   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
 
     connect(m_selectorUI->colorSelector         , SIGNAL(sigFgColorChanged(KisColor))     , SLOT(slotFgColorChanged(KisColor)));
     connect(m_selectorUI->colorSelector         , SIGNAL(sigBgColorChanged(KisColor))     , SLOT(slotBgColorChanged(KisColor)));
 
-    // gamut mask connections
-    connect(m_selectorUI->gamutMaskToolbar, SIGNAL(sigGamutMaskToggle(bool)), SLOT(slotGamutMaskToggle(bool)));
-
     connect(m_hsxButtons                        , SIGNAL(buttonClicked(int))                     , SLOT(slotColorSpaceSelected()));
 
     setWidget(m_selectorUI);
 }
 
 ArtisticColorSelectorDock::~ArtisticColorSelectorDock()
 {
     m_selectorUI->colorSelector->saveSettings();
     delete m_hsxButtons;
 }
 
 void ArtisticColorSelectorDock::setViewManager(KisViewManager* kisview)
 {
     m_resourceProvider = kisview->canvasResourceProvider();
     m_selectorUI->colorSelector->setFgColor(m_resourceProvider->resourceManager()->foregroundColor());
     m_selectorUI->colorSelector->setBgColor(m_resourceProvider->resourceManager()->backgroundColor());
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
             this, SLOT(slotGamutMaskSet(KoGamutMask*)), Qt::UniqueConnection);
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskUnset()),
             this, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
             this, SLOT(slotGamutMaskPreviewUpdate()), Qt::UniqueConnection);
 
+    connect(m_resourceProvider, SIGNAL(sigGamutMaskDeactivated()),
+            this, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
+
     m_selectorUI->gamutMaskToolbar->connectMaskSignals(m_resourceProvider);
 }
 
 void ArtisticColorSelectorDock::slotCanvasResourceChanged(int key, const QVariant& value)
 {
     if(key == KoCanvasResourceProvider::ForegroundColor)
         m_selectorUI->colorSelector->setFgColor(value.value<KoColor>());
 
     if(key == KoCanvasResourceProvider::BackgroundColor)
         m_selectorUI->colorSelector->setBgColor(value.value<KoColor>());
 }
 
 void ArtisticColorSelectorDock::slotFgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setForegroundColor(
         KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->foregroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotBgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setBackgroundColor(
         KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->backgroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotColorSpaceSelected()
 {
     KisColor::Type type = static_cast<KisColor::Type>(
                 m_hsxButtons->id(m_hsxButtons->checkedButton()));
 
     m_selectorUI->colorSelector->setColorSpace(type);
 
     if (type == KisColor::HSY) {
         m_preferencesUI->lumaCoefficientBox->show();
     } else {
         m_preferencesUI->lumaCoefficientBox->hide();
     }
 
     m_selectorUI->colorSelector->setLumaCoefficients(
                 m_preferencesUI->spLumaR->value(),
                 m_preferencesUI->spLumaG->value(),
                 m_preferencesUI->spLumaB->value(),
                 m_preferencesUI->spLumaGamma->value()
                 );
 }
 
 void ArtisticColorSelectorDock::slotPreferenceChanged()
 {
     int hueSteps = DEFAULT_HUE_STEPS;
     if (m_wheelPrefsUI->bnInfHueSteps->isChecked()) {
         m_wheelPrefsUI->numHueSteps->setEnabled(false);
         hueSteps = 1;
     } else {
         m_wheelPrefsUI->numHueSteps->setEnabled(true);
         hueSteps = m_wheelPrefsUI->numHueSteps->value();
     }
     m_selectorUI->colorSelector->setNumPieces(hueSteps);
 
     m_selectorUI->colorSelector->setNumRings(m_wheelPrefsUI->numSaturationSteps->value());
 
     int valueScaleSteps;
     if (m_wheelPrefsUI->bnInfValueScaleSteps->isChecked()) {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
         valueScaleSteps = 1;
     } else {
         valueScaleSteps = m_wheelPrefsUI->numValueScaleSteps->value();
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
     }
     m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
 
     int defHueSteps;
     if (m_preferencesUI->bnDefInfHueSteps->isChecked()) {
         m_preferencesUI->defaultHueSteps->setEnabled(false);
         defHueSteps = 1;
     } else {
         m_preferencesUI->defaultHueSteps->setEnabled(true);
         defHueSteps = m_preferencesUI->defaultHueSteps->value();
     }
     m_selectorUI->colorSelector->setDefaultHueSteps(defHueSteps);
 
     m_selectorUI->colorSelector->setDefaultSaturationSteps(m_preferencesUI->defaultSaturationSteps->value());
 
     int defValueScaleSteps;
     if (m_preferencesUI->bnDefInfValueScaleSteps->isChecked()) {
         m_preferencesUI->defaultValueScaleSteps->setEnabled(false);
         defValueScaleSteps = 1;
     } else {
         m_preferencesUI->defaultValueScaleSteps->setEnabled(true);
         defValueScaleSteps = m_preferencesUI->defaultValueScaleSteps->value();
     }
     m_selectorUI->colorSelector->setDefaultValueScaleSteps(defValueScaleSteps);
 
     m_selectorUI->colorSelector->setShowBgColor(m_preferencesUI->showBgColor->isChecked());
     m_selectorUI->colorSelector->setShowValueScaleNumbers(m_preferencesUI->showValueScaleNumbers->isChecked());
     m_selectorUI->colorSelector->setEnforceGamutMask(m_preferencesUI->enforceGamutMask->isChecked());
 
     m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
 }
 
 void ArtisticColorSelectorDock::slotResetDefaultSettings()
 {
     quint32 hueSteps = m_selectorUI->colorSelector->getDefaultHueSteps();
     quint32 saturationSteps = m_selectorUI->colorSelector->getDefaultSaturationSteps();
     quint32 valueScaleSteps = m_selectorUI->colorSelector->getDefaultValueScaleSteps();
 
     m_selectorUI->colorSelector->setNumRings(saturationSteps);
     m_wheelPrefsUI->numSaturationSteps->blockSignals(true);
     m_wheelPrefsUI->numSaturationSteps->setValue(saturationSteps);
     m_wheelPrefsUI->numSaturationSteps->blockSignals(false);
 
     m_selectorUI->colorSelector->setNumPieces(hueSteps);
     m_wheelPrefsUI->numHueSteps->blockSignals(true);
     m_wheelPrefsUI->numHueSteps->setValue(hueSteps);
     m_wheelPrefsUI->numHueSteps->blockSignals(false);
 
     if (hueSteps == 1) {
         m_wheelPrefsUI->numHueSteps->setEnabled(false);
         m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->numHueSteps->setEnabled(true);
         m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
     }
 
     m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
     m_wheelPrefsUI->numValueScaleSteps->blockSignals(true);
     m_wheelPrefsUI->numValueScaleSteps->setValue(valueScaleSteps);
     m_wheelPrefsUI->numValueScaleSteps->blockSignals(false);
 
     if (valueScaleSteps == 1) {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
     }
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskToggle(bool checked)
 {
     bool b = (!m_selectedMask) ? false : checked;
 
     if (b == true) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
     }
 
     m_selectorUI->colorSelector->setGamutMaskOn(b);
 }
 
 void ArtisticColorSelectorDock::setCanvas(KoCanvasBase *canvas)
 {
     if (!canvas) {
         return;
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
 
     if (m_canvas) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                 SLOT(slotCanvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(slotSelectorSettingsChanged()), Qt::UniqueConnection);
 
         m_selectorUI->colorSelector->setColorConverter(m_canvas->displayColorConverter());
         setEnabled(true);
     }
 }
 
 void ArtisticColorSelectorDock::unsetCanvas()
 {
     setEnabled(false);
     m_canvas = nullptr;
     m_selectorUI->colorSelector->setColorConverter(KisDisplayColorConverter::dumbConverterInstance());
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskSet(KoGamutMask *mask)
 {
     if (!mask) {
         return;
     }
 
     m_selectedMask = mask;
 
     if (m_selectedMask) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
         slotGamutMaskToggle(true);
     } else {
         slotGamutMaskToggle(false);
     }
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskUnset()
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask = nullptr;
 
     slotGamutMaskToggle(false);
     m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskPreviewUpdate()
 {
     m_selectorUI->colorSelector->setDirty();
 }
 
+void ArtisticColorSelectorDock::slotGamutMaskDeactivate()
+{
+    slotGamutMaskToggle(false);
+}
+
 void ArtisticColorSelectorDock::slotSelectorSettingsChanged()
 {
     m_selectorUI->colorSelector->setDirty();
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
index 68172f0c43..edafebacc7 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
@@ -1,87 +1,88 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  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 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef H_ARTISTIC_COLOR_SELECTOR_DOCK_H
 #define H_ARTISTIC_COLOR_SELECTOR_DOCK_H
 
 #include <QDockWidget>
 #include <QPointer>
 #include <QRegExpValidator>
 
 #include <KoCanvasObserverBase.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceServerObserver.h>
 #include <resources/KoGamutMask.h>
 #include <KisDocument.h>
 #include <kis_types.h>
 #include <KoResourceItemChooser.h>
 
 #include <kis_mainwindow_observer.h>
 
 class KisCanvasResourceProvider;
 class KisColor;
 class QButtonGroup;
 class QMenu;
 
 struct ArtisticColorSelectorUI;
 struct ARCSSettingsUI;
 struct WheelPreferencesPopupUI;
 
 class ArtisticColorSelectorDock: public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
     
 public:
     ArtisticColorSelectorDock();
     ~ArtisticColorSelectorDock() override;
     QString observerName() override { return "ArtisticColorSelectorDock"; }
     void setViewManager(KisViewManager* kisview) override;
     void setCanvas(KoCanvasBase* canvas) override;
     void unsetCanvas() override;
 
 private Q_SLOTS:
     void slotCanvasResourceChanged(int key, const QVariant& value);
     void slotFgColorChanged(const KisColor& color);
     void slotBgColorChanged(const KisColor& color);
     void slotColorSpaceSelected();
     void slotPreferenceChanged();
     void slotResetDefaultSettings();
     void slotGamutMaskToggle(bool value);
     void slotGamutMaskSet(KoGamutMask* mask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
+    void slotGamutMaskDeactivate();
     void slotSelectorSettingsChanged();
 
 private:
     KisCanvas2* m_canvas;
     KisCanvasResourceProvider* m_resourceProvider;
     QButtonGroup*            m_hsxButtons;
     ArtisticColorSelectorUI* m_selectorUI;
     ARCSSettingsUI* m_preferencesUI;
     WheelPreferencesPopupUI* m_wheelPrefsUI;
     KoGamutMask* m_selectedMask;
 
     QIcon m_iconMaskOff;
     QIcon m_iconMaskOn;
 
     QPixmap m_infinityPixmap;
 };
 
 
 #endif // H_ARTISTIC_COLOR_SELECTOR_DOCK_H