diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
index 0f7f759e51..3a73876486 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -1,424 +1,423 @@
 /*
  *  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_canvas_resource_provider.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())));
 
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->canvasResourceProvider()) {
         bool gamutMaskActive = m_canvas->viewManager()->canvasResourceProvider()->gamutMaskActive();
 
         if (gamutMaskActive) {
             KoGamutMaskSP currentMask = m_canvas->viewManager()->canvasResourceProvider()->currentGamutMask();
             if (currentMask) {
                 slotGamutMaskSet(currentMask);
             }
         } else {
             slotGamutMaskToggle(false);
         }
     }
 }
 
 void KisColorSelector::slotGamutMaskSet(KoGamutMaskSP 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);
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     // If checked, use theme colors for background of selector
     if (cfg.readEntry("useCustomColorForBackground", false)) {
-        QColor customColor = cfg.readEntry("customSelectorBackgroundColor", QColor(Qt::gray));
-        p.fillRect(0,0,width(), height(), customColor);
+        p.fillRect(0,0,width(), height(), cfg.readEntry("customSelectorBackgroundColor", QColor(Qt::gray)));
     } else {
         p.fillRect(0,0,width(), height(), qApp->palette().window().color());
     }
 
     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_settings.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
index 976148f8e4..15f7f259dc 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
@@ -1,634 +1,650 @@
 /*
  *  Copyright (C) 2010 Celarek Adam <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
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_color_selector_settings.h"
 #include "ui_wdg_color_selector_settings.h"
 
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QComboBox>
 
 #include <kconfiggroup.h>
 
 
 #include <kis_icon.h>
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 
 #include "kis_color_selector_combo_box.h"
 #include "kis_color_selector.h"
 #include "kis_config.h"
 
 
 KisColorSelectorSettings::KisColorSelectorSettings(QWidget *parent) :
     KisPreferenceSet(parent),
     ui(new Ui::KisColorSelectorSettings)
 {
     ui->setupUi(this);
 
     resize(minimumSize());
 
     ui->colorSelectorConfiguration->setColorSpace(ui->colorSpace->currentColorSpace());
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
 
     connect(ui->useDifferentColorSpaceCheckbox, SIGNAL(clicked(bool)), this, SLOT(useDifferentColorSpaceChecked(bool)));
 
     /* color docker selector drop down */
     ui->dockerColorSettingsComboBox->addItem(i18n("Advanced Color Selector"));
     //ui->dockerColorSettingsComboBox->addItem(i18n("Color Sliders"));
     ui->dockerColorSettingsComboBox->addItem(i18n("Color Hotkeys"));
     ui->dockerColorSettingsComboBox->setCurrentIndex(0); // start off seeing advanced color selector properties
 
     connect( ui->dockerColorSettingsComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedColorDocker(int)));
     changedColorDocker(0);
 
 
     /* advanced color docker options */
     ui->dockerResizeOptionsComboBox->addItem(i18n("Change to a Horizontal Layout"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Hide Shade Selector"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Do Nothing"));
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
 
 
     ui->zoomSelectorOptionComboBox->addItem(i18n("When Pressing Middle Mouse Button"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("On Mouse Over"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("Never"));
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
 
 
     ui->colorSelectorTypeComboBox->addItem(i18n("HSV"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSL"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSI"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSY'"));
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
     connect( ui->colorSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSColorSelectorType(int)));
     changedACSColorSelectorType(0); // initialize everything to HSV at the start
 
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSV"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSL"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSI"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSY'"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
 
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("MyPaint"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Minimal"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Do Not Show"));
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     changedACSShadeSelectorType(0); // show/hide UI elements for MyPaint settings
     connect( ui->ACSShadeSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSShadeSelectorType(int)));
 
 
     ui->commonColorsAlignVertical->setChecked(true);
     ui->commonColorsAlignHorizontal->setChecked(true);
     connect( ui->commonColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSColorAlignment(bool)));
     connect( ui->lastUsedColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSLastUsedColorAlignment(bool)));
 
     changedACSColorAlignment(ui->commonColorsAlignHorizontal->isChecked());
     changedACSLastUsedColorAlignment(ui->lastUsedColorsAlignHorizontal->isChecked());
 
 
     connect(ui->colorSpace,                 SIGNAL(colorSpaceChanged(const KoColorSpace*)),
             ui->colorSelectorConfiguration, SLOT(setColorSpace(const KoColorSpace*)));
 
 
     connect(this, SIGNAL(hsxchanged(int)),
             ui->colorSelectorConfiguration, SLOT(setList(int)));
 
     connect(ui->minimalShadeSelectorLineCount,      SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SLOT(setLineCount(int)));
 
     connect(ui->minimalShadeSelectorLineSettings,   SIGNAL(lineCountChanged(int)),
             ui->minimalShadeSelectorLineCount,      SLOT(setValue(int)));
 
     connect(ui->minimalShadeSelectorAsGradient,     SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setGradient(bool)));
 
     connect(ui->minimalShadeSelectorAsColorPatches, SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatches(bool)));
 
     connect(ui->minimalShadeSelectorLineHeight,     SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setLineHeight(int)));
 
     connect(ui->minimalShadeSelectorPatchesPerLine, SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatchCount(int)));
 }
 
 KisColorSelectorSettings::~KisColorSelectorSettings()
 {
     delete ui;
 }
 
 QString KisColorSelectorSettings::id()
 {
     return QString("advancedColorSelector");
 }
 
 QString KisColorSelectorSettings::name()
 {
     return header();
 }
 
 QString KisColorSelectorSettings::header()
 {
     return QString(i18n("Color Selector Settings"));
 }
 
 
 QIcon KisColorSelectorSettings::icon()
 {
     return KisIconUtils::loadIcon("extended_color_selector");
 }
 
 
 void KisColorSelectorSettings::savePreferences() const
 {
     // write cfg
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
     //  advanced color selector
     cfg.writeEntry("onDockerResize", ui->dockerResizeOptionsComboBox->currentIndex());
     cfg.writeEntry("zoomSelectorOptions", ui->zoomSelectorOptionComboBox->currentIndex() );
     cfg.writeEntry("zoomSize", ui->popupSize->value());
     cfg.writeEntry("showColorSelector", ui->chkShowColorSelector->isChecked());
 
     bool useCustomColorSpace =  ui->useDifferentColorSpaceCheckbox->isChecked();
     const KoColorSpace* colorSpace = useCustomColorSpace ? ui->colorSpace->currentColorSpace() : 0;
 
     KisConfig kisconfig(false);
     kisconfig.setCustomColorSelectorColorSpace(colorSpace);
 
     //color patches
     cfg.writeEntry("lastUsedColorsShow", ui->lastUsedColorsShow->isChecked());
     cfg.writeEntry("lastUsedColorsAlignment", ui->lastUsedColorsAlignVertical->isChecked());
     cfg.writeEntry("lastUsedColorsScrolling", ui->lastUsedColorsAllowScrolling->isChecked());
     cfg.writeEntry("lastUsedColorsNumCols", ui->lastUsedColorsNumCols->value());
     cfg.writeEntry("lastUsedColorsNumRows", ui->lastUsedColorsNumRows->value());
     cfg.writeEntry("lastUsedColorsCount", ui->lastUsedColorsPatchCount->value());
     cfg.writeEntry("lastUsedColorsWidth", ui->lastUsedColorsWidth->value());
     cfg.writeEntry("lastUsedColorsHeight", ui->lastUsedColorsHeight->value());
 
     cfg.writeEntry("commonColorsShow", ui->commonColorsShow->isChecked());
     cfg.writeEntry("commonColorsAlignment", ui->commonColorsAlignVertical->isChecked());
     cfg.writeEntry("commonColorsScrolling", ui->commonColorsAllowScrolling->isChecked());
     cfg.writeEntry("commonColorsNumCols", ui->commonColorsNumCols->value());
     cfg.writeEntry("commonColorsNumRows", ui->commonColorsNumRows->value());
     cfg.writeEntry("commonColorsCount", ui->commonColorsPatchCount->value());
     cfg.writeEntry("commonColorsWidth", ui->commonColorsWidth->value());
     cfg.writeEntry("commonColorsHeight", ui->commonColorsHeight->value());
     cfg.writeEntry("commonColorsAutoUpdate", ui->commonColorsAutoUpdate->isChecked());
 
     //shade selector
 
 
 
     int shadeSelectorTypeIndex =  ui->ACSShadeSelectorTypeComboBox->currentIndex();
 
     if(shadeSelectorTypeIndex == 0) {
         cfg.writeEntry("shadeSelectorType", "MyPaint");
     } else if (shadeSelectorTypeIndex == 1) {
         cfg.writeEntry("shadeSelectorType", "Minimal");
     } else {
         cfg.writeEntry("shadeSelectorType", "Hidden");
     }
 
     cfg.writeEntry("shadeSelectorUpdateOnRightClick", ui->shadeSelectorUpdateOnRightClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnForeground", ui->shadeSelectorUpdateOnForeground->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnLeftClick", ui->shadeSelectorUpdateOnLeftClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnBackground", ui->shadeSelectorUpdateOnBackground->isChecked());
     cfg.writeEntry("hidePopupOnClickCheck", ui->hidePopupOnClickCheck->isChecked());
     cfg.writeEntry("useCustomColorForBackground", ui->useCustomColorForBackground->isChecked());
 
+    cfg.writeEntry("customSelectorBackgroundColor", ui->customColorBackgroundSelector->color().toQColor());
+
     //mypaint model
 
     int shadeMyPaintComboBoxIndex  = ui->ACSshadeSelectorMyPaintColorModelComboBox->currentIndex();
     if (shadeMyPaintComboBoxIndex == 0 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSV");
     } else  if (shadeMyPaintComboBoxIndex == 1 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSL");
     } else  if (shadeMyPaintComboBoxIndex == 2 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSI");
     } else {   // HSY
         cfg.writeEntry("shadeMyPaintType",   "HSY");
     }
 
 
 
     cfg.writeEntry("minimalShadeSelectorAsGradient", ui->minimalShadeSelectorAsGradient->isChecked());
     cfg.writeEntry("minimalShadeSelectorPatchCount", ui->minimalShadeSelectorPatchesPerLine->value());
     cfg.writeEntry("minimalShadeSelectorLineConfig",  ui->minimalShadeSelectorLineSettings->toString());
     cfg.writeEntry("minimalShadeSelectorLineHeight", ui->minimalShadeSelectorLineHeight->value());
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cfg.writeEntry("colorSelectorConfiguration", cstw->configuration().toString());
 
     cfg.writeEntry("hsxSettingType", ui->colorSelectorTypeComboBox->currentIndex());
 
     //luma//
     cfg.writeEntry("lumaR", ui->l_lumaR->value());
     cfg.writeEntry("lumaG", ui->l_lumaG->value());
     cfg.writeEntry("lumaB", ui->l_lumaB->value());
     cfg.writeEntry("gamma", ui->SP_Gamma->value());
 
     //slider//
     hsxcfg.writeEntry("hsvH", ui->csl_hsvH->isChecked());
     hsxcfg.writeEntry("hsvS", ui->csl_hsvS->isChecked());
     hsxcfg.writeEntry("hsvV", ui->csl_hsvV->isChecked());
     hsxcfg.writeEntry("hslH", ui->csl_hslH->isChecked());
     hsxcfg.writeEntry("hslS", ui->csl_hslS->isChecked());
     hsxcfg.writeEntry("hslL", ui->csl_hslL->isChecked());
     hsxcfg.writeEntry("hsiH", ui->csl_hsiH->isChecked());
     hsxcfg.writeEntry("hsiS", ui->csl_hsiS->isChecked());
     hsxcfg.writeEntry("hsiI", ui->csl_hsiI->isChecked());
     hsxcfg.writeEntry("hsyH", ui->csl_hsyH->isChecked());
     hsxcfg.writeEntry("hsyS", ui->csl_hsyS->isChecked());
     hsxcfg.writeEntry("hsyY", ui->csl_hsyY->isChecked());
 
     //hotkeys//
     hotkeycfg.writeEntry("steps_lightness", ui->sb_lightness->value());
     hotkeycfg.writeEntry("steps_saturation", ui->sb_saturation->value());
     hotkeycfg.writeEntry("steps_hue", ui->sb_hue->value());
     hotkeycfg.writeEntry("steps_redgreen", ui->sb_rg->value());
     hotkeycfg.writeEntry("steps_blueyellow", ui->sb_by->value());
 
     emit settingsChanged();
 }
 
 //void KisColorSelectorSettings::changeEvent(QEvent *e)
 //{
 //    QDialog::changeEvent(e);
 //    switch (e->type()) {
 //    case QEvent::LanguageChange:
 //        ui->retranslateUi(this);
 //        break;
 //    default:
 //        break;
 //    }
 //}
 
 
 void KisColorSelectorSettings::changedColorDocker(int index)
 {
     // having a situation where too many sections are visible makes the window too large. turn all off before turning more on
     ui->colorSliderOptions->hide();
     ui->advancedColorSelectorOptions->hide();
     ui->hotKeyOptions->hide();
 
     if (index == 0)     { // advanced color selector options selected
         ui->advancedColorSelectorOptions->show();
         ui->colorSliderOptions->hide();
         ui->hotKeyOptions->hide();
     }
 //    else if (index == 1) {  // color slider options selected
 //        ui->advancedColorSelectorOptions->hide();
 //        ui->hotKeyOptions->hide();
 //        ui->colorSliderOptions->show();
 //    }
     else {
        ui->colorSliderOptions->hide();
        ui->advancedColorSelectorOptions->hide();
        ui->hotKeyOptions->show();
     }
 }
 
 void KisColorSelectorSettings::changedACSColorSelectorType(int index)
 {
     ui->lumaCoefficientGroupbox->setVisible(false);
 
     if (index == 0)     {  // HSV
         ui->ACSTypeDescriptionLabel->setText(i18n("Values goes from black to white, or black to the most saturated color. Saturation, in turn, goes from the most saturated color to white, gray or black."));
     }
     else if (index == 1)     {  // HSL
         ui->ACSTypeDescriptionLabel->setText(i18n("Lightness goes from black to white, with middle gray being equal to the most saturated color."));
     }
     else if (index == 2)     {  // HSI
         ui->ACSTypeDescriptionLabel->setText(i18n("Intensity maps to the sum of rgb components"));
     }
     else {  // HSY'
         ui->ACSTypeDescriptionLabel->setText(i18n("Luma(Y') is weighted by its coefficients which are configurable. Default values are set to 'rec 709'."));
         ui->lumaCoefficientGroupbox->setVisible(true);
     }
 
     ui->colorSelectorConfiguration->update();
     emit hsxchanged(index);
 
 }
 
 
 void KisColorSelectorSettings::changedACSColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_commonColorsNumCols->setDisabled(toggled);
     ui->commonColorsNumCols->setDisabled(toggled);
 
     ui->lbl_commonColorsNumRows->setEnabled(toggled);
     ui->commonColorsNumRows->setEnabled(toggled);
 }
 
 void KisColorSelectorSettings::changedACSLastUsedColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_lastUsedNumCols->setDisabled(toggled);
     ui->lastUsedColorsNumCols->setDisabled(toggled);
 
     ui->lbl_lastUsedNumRows->setEnabled(toggled);
     ui->lastUsedColorsNumRows->setEnabled(toggled);
 }
 
 void KisColorSelectorSettings::changedACSShadeSelectorType(int index)
 {
 
     if (index == 0)     {  // MyPaint
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->show();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->show();
 
     } else if (index == 1) { // Minimal
         ui->minimalShadeSelectorGroup->show();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
 
     }else { // do not show
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
     }
 }
 
 void KisColorSelectorSettings::useDifferentColorSpaceChecked(bool enabled)
 {
     ui->colorSpace->setEnabled(enabled);
 }
 
+void KisColorSelectorSettings::useCustomColorForSelector(bool enabled) 
+{
+    ui->customColorBackgroundSelector->setEnabled(enabled);
+}
+
 void KisColorSelectorSettings::loadPreferences()
 {
     //read cfg
     //don't forget to also add a new entry to the default preferences
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
 
     // Advanced color selector
     ui->dockerResizeOptionsComboBox->setCurrentIndex(  (int)cfg.readEntry("onDockerResize", 0) );
     ui->zoomSelectorOptionComboBox->setCurrentIndex(   (int) cfg.readEntry("zoomSelectorOptions", 0) );
     ui->popupSize->setValue(cfg.readEntry("zoomSize", 280));
     ui->chkShowColorSelector->setChecked((bool) cfg.readEntry("showColorSelector", true));
 
     {
         KisConfig kisconfig(true);
         const KoColorSpace *cs = kisconfig.customColorSelectorColorSpace();
 
         if (cs) {
             ui->useDifferentColorSpaceCheckbox->setChecked(true);
             ui->colorSpace->setEnabled(true);
             ui->colorSpace->setCurrentColorSpace(cs);
         } else {
             ui->useDifferentColorSpaceCheckbox->setChecked(false);
             ui->colorSpace->setEnabled(false);
         }
     }
 
 
     //color patches
     ui->lastUsedColorsShow->setChecked(cfg.readEntry("lastUsedColorsShow", true));
     bool a = cfg.readEntry("lastUsedColorsAlignment", true);
     ui->lastUsedColorsAlignVertical->setChecked(a);
     ui->lastUsedColorsAlignHorizontal->setChecked(!a);
     ui->lastUsedColorsAllowScrolling->setChecked(cfg.readEntry("lastUsedColorsScrolling", true));
     ui->lastUsedColorsNumCols->setValue(cfg.readEntry("lastUsedColorsNumCols", 1));
     ui->lastUsedColorsNumRows->setValue(cfg.readEntry("lastUsedColorsNumRows", 1));
     ui->lastUsedColorsPatchCount->setValue(cfg.readEntry("lastUsedColorsCount", 20));
     ui->lastUsedColorsWidth->setValue(cfg.readEntry("lastUsedColorsWidth", 16));
     ui->lastUsedColorsHeight->setValue(cfg.readEntry("lastUsedColorsHeight", 16));
 
     ui->commonColorsShow->setChecked(cfg.readEntry("commonColorsShow", true));
     a = cfg.readEntry("commonColorsAlignment", false);
     ui->commonColorsAlignVertical->setChecked(a);
     ui->commonColorsAlignHorizontal->setChecked(!a);
     ui->commonColorsAllowScrolling->setChecked(cfg.readEntry("commonColorsScrolling", true));
     ui->commonColorsNumCols->setValue(cfg.readEntry("commonColorsNumCols", 1));
     ui->commonColorsNumRows->setValue(cfg.readEntry("commonColorsNumRows", 1));
     ui->commonColorsPatchCount->setValue(cfg.readEntry("commonColorsCount", 12));
     ui->commonColorsWidth->setValue(cfg.readEntry("commonColorsWidth", 16));
     ui->commonColorsHeight->setValue(cfg.readEntry("commonColorsHeight", 16));
     ui->commonColorsAutoUpdate->setChecked(cfg.readEntry("commonColorsAutoUpdate", false));
 
     //shade selector
     QString shadeSelectorType=cfg.readEntry("shadeSelectorType", "Minimal");
 
     if ( shadeSelectorType == "MyPaint") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     } else if (shadeSelectorType == "Minimal") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1);
     } else {   // Hidden
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(2);
     }
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnRightClick", false));
     ui->shadeSelectorUpdateOnLeftClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnLeftClick", false));
     ui->shadeSelectorUpdateOnForeground->setChecked(cfg.readEntry("shadeSelectorUpdateOnForeground", true));
     ui->shadeSelectorUpdateOnBackground->setChecked(cfg.readEntry("shadeSelectorUpdateOnBackground", true));
     ui->hidePopupOnClickCheck->setChecked(cfg.readEntry("hidePopupOnClickCheck", false));
     ui->useCustomColorForBackground->setChecked(cfg.readEntry("useCustomColorForBackground", false));
+    connect(ui->useCustomColorForBackground, SIGNAL(clicked(bool)), this, SLOT(useCustomColorForSelector(bool)));
+
+    
+    QColor storedColor = cfg.readEntry("customSelectorBackgroundColor", QColor(Qt::gray));
+    KoColor c;
+    c.fromQColor(storedColor);
+    ui->customColorBackgroundSelector->setColor(c);
+
+    ui->customColorBackgroundSelector->setEnabled(cfg.readEntry("useCustomColorForBackground", false));
 
     QString shadeMyPaintType = cfg.readEntry("shadeMyPaintType", "HSV");
 
     if (shadeMyPaintType == "HSV" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
     } else  if (shadeMyPaintType == "HSL" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(1);
     } else  if (shadeMyPaintType == "HSI" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(2);
     } else {   // HSY
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(3);
     }
 
 
     bool asGradient = cfg.readEntry("minimalShadeSelectorAsGradient", true);
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(cfg.readEntry("minimalShadeSelectorPatchCount", 10));
     ui->minimalShadeSelectorLineSettings->fromString(cfg.readEntry("minimalShadeSelectorLineConfig", "0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;"));
     ui->minimalShadeSelectorLineHeight->setValue(cfg.readEntry("minimalShadeSelectorLineHeight", 10));
 
     int hsxSettingType= (int)cfg.readEntry("hsxSettingType", 0);
     ui->colorSelectorTypeComboBox->setCurrentIndex(hsxSettingType);
 
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", "3|0|5|0"))); // triangle selector
 
     //luma values//
     ui->l_lumaR->setValue(cfg.readEntry("lumaR", 0.2126));
     ui->l_lumaG->setValue(cfg.readEntry("lumaG", 0.7152));
     ui->l_lumaB->setValue(cfg.readEntry("lumaB", 0.0722));
     ui->SP_Gamma->setValue(cfg.readEntry("gamma", 2.2));
 
     //color sliders//
     ui->csl_hsvH->setChecked(hsxcfg.readEntry("hsvH", false));
     ui->csl_hsvS->setChecked(hsxcfg.readEntry("hsvS", false));
     ui->csl_hsvV->setChecked(hsxcfg.readEntry("hsvV", false));
     ui->csl_hslH->setChecked(hsxcfg.readEntry("hslH", true));
     ui->csl_hslS->setChecked(hsxcfg.readEntry("hslS", true));
     ui->csl_hslL->setChecked(hsxcfg.readEntry("hslL", true));
     ui->csl_hsiH->setChecked(hsxcfg.readEntry("hsiH", false));
     ui->csl_hsiS->setChecked(hsxcfg.readEntry("hsiS", false));
     ui->csl_hsiI->setChecked(hsxcfg.readEntry("hsiI", false));
     ui->csl_hsyH->setChecked(hsxcfg.readEntry("hsyH", false));
     ui->csl_hsyS->setChecked(hsxcfg.readEntry("hsyS", false));
     ui->csl_hsyY->setChecked(hsxcfg.readEntry("hsyY", false));
 
     //hotkeys//
     ui->sb_lightness->setValue(hotkeycfg.readEntry("steps_lightness", 10));
     ui->sb_saturation->setValue(hotkeycfg.readEntry("steps_saturation", 10));
     ui->sb_hue->setValue(hotkeycfg.readEntry("steps_hue", 36));
     ui->sb_rg->setValue(hotkeycfg.readEntry("steps_redgreen", 10));
     ui->sb_by->setValue(hotkeycfg.readEntry("steps_blueyellow", 10));
 
 
 }
 
 void KisColorSelectorSettings::loadDefaultPreferences()
 {
     //set defaults
     //if you change something, don't forget that loadPreferences should be kept in sync
 
     // advanced color selector docker
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
     ui->popupSize->setValue(280);
     ui->chkShowColorSelector->setChecked(true);
 
 
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
     ui->colorSpace->setCurrentColorModel(KoID("RGBA"));
     ui->colorSpace->setCurrentColorDepth(KoID("U8"));
     ui->colorSpace->setCurrentProfile(KoColorSpaceRegistry::instance()->rgb8()->profile()->name());
 
     //color patches
     ui->lastUsedColorsShow->setChecked(true);
     ui->lastUsedColorsAlignVertical->setChecked(true);
     ui->lastUsedColorsAlignHorizontal->setChecked(false);
     ui->lastUsedColorsAllowScrolling->setChecked(true);
     ui->lastUsedColorsNumCols->setValue(1);
     ui->lastUsedColorsNumRows->setValue(1);
     ui->lastUsedColorsPatchCount->setValue(20);
     ui->lastUsedColorsWidth->setValue(16);
     ui->lastUsedColorsHeight->setValue(16);
 
     ui->commonColorsShow->setChecked(true);
     ui->commonColorsAlignVertical->setChecked(false);
     ui->commonColorsAlignHorizontal->setChecked(true);
     ui->commonColorsAllowScrolling->setChecked(true);
     ui->commonColorsNumCols->setValue(1);
     ui->commonColorsNumRows->setValue(1);
     ui->commonColorsPatchCount->setValue(12);
     ui->commonColorsWidth->setValue(16);
     ui->commonColorsHeight->setValue(16);
     ui->commonColorsAutoUpdate->setChecked(false);
 
     //shade selector
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1); // Minimal
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(false);
     ui->shadeSelectorUpdateOnLeftClick->setChecked(false);
     ui->shadeSelectorUpdateOnForeground->setChecked(true);
     ui->shadeSelectorUpdateOnBackground->setChecked(true);
 
     bool asGradient = true;
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(10);
     ui->minimalShadeSelectorLineSettings->fromString("0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;");
     ui->minimalShadeSelectorLineHeight->setValue(10);
 
     // set advanced color selector to use HSV
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
 
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration("3|0|5|0")); // triangle selector
 
     //luma//
     ui->l_lumaR->setValue(0.2126);
     ui->l_lumaG->setValue(0.7152);
     ui->l_lumaB->setValue(0.0722);
     ui->SP_Gamma->setValue(2.2);
 
     //color sliders//
     ui->csl_hsvH->setChecked(false);
     ui->csl_hsvS->setChecked(false);
     ui->csl_hsvV->setChecked(false);
     ui->csl_hslH->setChecked(true);
     ui->csl_hslS->setChecked(true);
     ui->csl_hslL->setChecked(true);
     ui->csl_hsiH->setChecked(false);
     ui->csl_hsiS->setChecked(false);
     ui->csl_hsiI->setChecked(false);
     ui->csl_hsyH->setChecked(false);
     ui->csl_hsyS->setChecked(false);
     ui->csl_hsyY->setChecked(false);
 
     //hotkeys//
     ui->sb_lightness->setValue(10);
     ui->sb_saturation->setValue(10);
     ui->sb_hue->setValue(36);
     ui->sb_rg->setValue(10);
     ui->sb_by->setValue(10);
 
 }
 
 KisColorSelectorSettingsDialog::KisColorSelectorSettingsDialog(QWidget *parent) :
     QDialog(parent),
     m_widget(new KisColorSelectorSettings(this))
 {
     QLayout* l = new QVBoxLayout(this);
     l->addWidget(m_widget);
 
     m_widget->loadPreferences();
 
     QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::RestoreDefaults,
                                                        Qt::Horizontal,
                                                        this);
     l->addWidget(buttonBox);
 
     connect(buttonBox, SIGNAL(accepted()), m_widget, SLOT(savePreferences()));
     connect(buttonBox, SIGNAL(accepted()), this,     SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), this,     SLOT(reject()));
     connect(buttonBox->button(QDialogButtonBox::RestoreDefaults),
             SIGNAL(clicked()),  m_widget, SLOT(loadDefaultPreferences()));
 }
 
 
 
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.h b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.h
index 499eb8a658..2af1897365 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.h
@@ -1,95 +1,96 @@
 /*
  *  Copyright (C) 2010 Celarek Adam <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
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_COLOR_SELECTOR_SETTINGS_H
 #define KIS_COLOR_SELECTOR_SETTINGS_H
 
 
 #include <QDialog>
 #include "kis_preference_set_registry.h"
 
 namespace Ui {
     class KisColorSelectorSettings;
 }
 class QIcon;
 
 class KisColorSelectorSettings : public KisPreferenceSet {
     Q_OBJECT
 public:
     KisColorSelectorSettings(QWidget *parent = 0);
     ~KisColorSelectorSettings() override;
 
     QString id() override;
     QString name() override;
     QString header() override;
     QIcon icon() override;
 
 public Q_SLOTS:
     void savePreferences() const override;
     void loadPreferences() override;
     void loadDefaultPreferences() override;
 
     void changedColorDocker(int);
     void useDifferentColorSpaceChecked(bool);
+    void useCustomColorForSelector(bool);
     void changedACSColorSelectorType(int);
     void changedACSShadeSelectorType(int);
     void changedACSColorAlignment(bool);
     void changedACSLastUsedColorAlignment(bool);
 
 Q_SIGNALS:
     void settingsChanged() const;
     void hsxchanged(int);
 
 protected:
     //void changeEvent(QEvent *e);
 
 private:
     Ui::KisColorSelectorSettings *ui;
 };
 
 class KisColorSelectorSettingsUpdateRepeater : public QObject {
     Q_OBJECT
 Q_SIGNALS:
     void settingsUpdated();
 public Q_SLOTS:
     void updateSettings() {
         emit settingsUpdated();
     }
 };
 
 class KisColorSelectorSettingsFactory : public KisAbstractPreferenceSetFactory {
 public:
     KisPreferenceSet* createPreferenceSet() override {
         KisColorSelectorSettings* ps = new KisColorSelectorSettings();
         QObject::connect(ps, SIGNAL(settingsChanged()), &repeater, SLOT(updateSettings()), Qt::UniqueConnection);
         return ps;
     }
     QString id() const override { return "ColorSelectorSettings"; }
     KisColorSelectorSettingsUpdateRepeater repeater;
 };
 
 class KisColorSelectorSettingsDialog : public QDialog {
 Q_OBJECT
 public:
     KisColorSelectorSettingsDialog(QWidget *parent = 0);
 private:
     KisColorSelectorSettings* m_widget;
 };
 
 
 #endif // KIS_COLOR_SELECTOR_SETTINGS_H
diff --git a/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp b/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp
index 0dd89a9e82..602b37a01a 100644
--- a/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp
@@ -1,190 +1,190 @@
 /*
  *  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_minimal_shade_selector.h"
 
 #include <QColor>
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QMouseEvent>
 #include <QApplication>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "KoCanvasResourceProvider.h"
 
 #include "kis_shade_selector_line.h"
 
 #include "kis_color_selector_base_proxy.h"
 
 
 KisMinimalShadeSelector::KisMinimalShadeSelector(QWidget *parent)
     : KisColorSelectorBase(parent)
     , m_canvas(0)
     , m_proxy(new KisColorSelectorBaseProxyObject(this))
 {
     setAcceptDrops(true);
 
     QVBoxLayout* l = new QVBoxLayout(this);
     l->setSpacing(0);
     l->setMargin(0);
 
     updateSettings();
 
     setMouseTracking(true);
 }
 
 KisMinimalShadeSelector::~KisMinimalShadeSelector()
 {
 }
 
 void KisMinimalShadeSelector::unsetCanvas()
 {
     KisColorSelectorBase::unsetCanvas();
     m_canvas = 0;
 }
 
 void KisMinimalShadeSelector::setCanvas(KisCanvas2 *canvas)
 {
     KisColorSelectorBase::setCanvas(canvas);
     m_canvas = canvas;
 }
 
 void KisMinimalShadeSelector::setColor(const KoColor& color)
 {
     m_lastRealColor = color;
 
     for(int i=0; i<m_shadingLines.size(); i++) {
         m_shadingLines.at(i)->setColor(color);
     }
 }
 
 void KisMinimalShadeSelector::updateSettings()
 {
     KisColorSelectorBase::updateSettings();
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     QString stri = cfg.readEntry("minimalShadeSelectorLineConfig", "0|0.2|0|0");
     QStringList strili = stri.split(';', QString::SkipEmptyParts);
 
     int lineCount = strili.size();
     while(lineCount-m_shadingLines.size() > 0) {
         KisShadeSelectorLine *line = new KisShadeSelectorLine(m_proxy.data(), this);
         m_shadingLines.append(line);
         m_shadingLines.last()->setLineNumber(m_shadingLines.size()-1);
         layout()->addWidget(m_shadingLines.last());
     }
     while(lineCount-m_shadingLines.size() < 0) {
         layout()->removeWidget(m_shadingLines.last());
         delete m_shadingLines.takeLast();
     }
 
     for(int i=0; i<strili.size(); i++) {
         m_shadingLines.at(i)->fromString(strili.at(i));
     }
 
     int lineHeight = cfg.readEntry("minimalShadeSelectorLineHeight", 20);
     setMinimumHeight(lineCount*lineHeight+2*lineCount);
     setMaximumHeight(lineCount*lineHeight+2*lineCount);
 
     for(int i=0; i<m_shadingLines.size(); i++)
         m_shadingLines.at(i)->updateSettings();
 
     setPopupBehaviour(false, false);
 }
 
 void KisMinimalShadeSelector::mousePressEvent(QMouseEvent * e)
 {
     Q_FOREACH (KisShadeSelectorLine* line, m_shadingLines) {
         QMouseEvent newEvent(e->type(),
                                           line->mapFromGlobal(e->globalPos()),
                                           e->button(),
                                           e->buttons(),
                                           e->modifiers());
         if(line->rect().contains(newEvent.pos()))
             line->mousePressEvent(&newEvent);
     }
     KisColorSelectorBase::mousePressEvent(e);
 }
 
 void KisMinimalShadeSelector::mouseMoveEvent(QMouseEvent * e)
 {
     Q_FOREACH (KisShadeSelectorLine* line, m_shadingLines) {
         QMouseEvent newEvent(e->type(),
                                           line->mapFromGlobal(e->globalPos()),
                                           e->button(),
                                           e->buttons(),
                                           e->modifiers());
         if(line->rect().contains(newEvent.pos()))
             line->mouseMoveEvent(&newEvent);
     }
     KisColorSelectorBase::mouseMoveEvent(e);
 }
 
 void KisMinimalShadeSelector::mouseReleaseEvent(QMouseEvent * e)
 {
     Q_FOREACH (KisShadeSelectorLine* line, m_shadingLines) {
         QMouseEvent newEvent(e->type(),
                                           line->mapFromGlobal(e->globalPos()),
                                           e->button(),
                                           e->buttons(),
                                           e->modifiers());
 
         if(line->rect().contains(newEvent.pos()))
             line->mouseReleaseEvent(&newEvent);
     }
     KisColorSelectorBase::mouseReleaseEvent(e);
 }
 
 void KisMinimalShadeSelector::canvasResourceChanged(int key, const QVariant &v)
 {
     if(m_colorUpdateAllowed==false)
         return;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     bool onForeground = cfg.readEntry("shadeSelectorUpdateOnForeground", false);
     bool onBackground = cfg.readEntry("shadeSelectorUpdateOnBackground", true);
 
     if ((key == KoCanvasResourceProvider::ForegroundColor && onForeground)
         || (key == KoCanvasResourceProvider::BackgroundColor && onBackground)) {
 
         setColor(v.value<KoColor>());
     }
 }
 
 void KisMinimalShadeSelector::paintEvent(QPaintEvent *)
 {
     QPainter p(this);
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     if (cfg.readEntry("useCustomColorForBackground", false)) {
-        p.fillRect(0,0,width(), height(), qApp->palette().window().color());
+        p.fillRect(0,0,width(), height(), cfg.readEntry("customSelectorBackgroundColor", QColor(Qt::gray)));
     } else {
-        p.fillRect(0,0,width(), height(), QColor(128,128,128));
+        p.fillRect(0,0,width(), height(), qApp->palette().window().color());
     }
 }
 
 KisColorSelectorBase* KisMinimalShadeSelector::createPopup() const
 {
     KisMinimalShadeSelector* popup = new KisMinimalShadeSelector(0);
     popup->setColor(m_lastRealColor);
     return popup;
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_shade_selector_line_combo_box_popup.cpp b/plugins/dockers/advancedcolorselector/kis_shade_selector_line_combo_box_popup.cpp
index 021c9a1c03..af4b003019 100644
--- a/plugins/dockers/advancedcolorselector/kis_shade_selector_line_combo_box_popup.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_shade_selector_line_combo_box_popup.cpp
@@ -1,182 +1,182 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_shade_selector_line_combo_box.h"
 #include "kis_shade_selector_line_combo_box_popup.h"
 
 #include <QVBoxLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QApplication>
 #include <kconfig.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include "kis_global.h"
 #include "kis_shade_selector_line.h"
 #include "kis_shade_selector_line_editor.h"
 #include "kis_color_selector_base_proxy.h"
 
 
 KisShadeSelectorLineComboBoxPopup::KisShadeSelectorLineComboBoxPopup(QWidget* parent)
     : QWidget(parent, Qt::Popup),
       spacing(10),
       m_lastHighlightedItem(0),
       m_lastSelectedItem(0),
       m_lineEditor(0),
       m_parentProxy(new KisColorSelectorBaseProxyNoop())
 {
     setMouseTracking(true);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->setSpacing(spacing);
 
     layout->addWidget(new KisShadeSelectorLine(1.0, 0.0, 0.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.1, 0.0, 0.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.2, 0.0, 0.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, 0.5, 0.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, 1.0, 0.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, 0.0, 0.5, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, 0.0, 1.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, 0.5, 0.5, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, 1.0, 1.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, -0.5, 0.5, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, -1.0, 1.0, m_parentProxy.data(), this));
     layout->addWidget(new KisShadeSelectorLine(0.0, 0.5, 0.5, m_parentProxy.data(), this, -0.04));
     layout->addWidget(new KisShadeSelectorLine(0.0, 0.5, 0.5, m_parentProxy.data(), this, +0.04));
     layout->addWidget(new KisShadeSelectorLine(0.0, -0.5, 0.5, m_parentProxy.data(), this, -0.04));
 
     KisShadeSelectorLine* preview = new KisShadeSelectorLine(0.0, -0.5, 0.5, m_parentProxy.data(), this, +0.04);
     m_lineEditor = new KisShadeSelectorLineEditor(this, preview);
     layout->addWidget(preview);
     layout->addWidget(m_lineEditor);
 
     connect(m_lineEditor, SIGNAL(requestActivateLine(QWidget*)), SLOT(activateItem(QWidget*)));
 
     for(int i=0; i<this->layout()->count(); i++) {
         KisShadeSelectorLine* item = dynamic_cast<KisShadeSelectorLine*>(this->layout()->itemAt(i)->widget());
         if(item!=0) {
             item->setMouseTracking(true);
             item->setEnabled(false);
             KoColor color;
             color.fromQColor(QColor(190, 50, 50));
             item->setColor(color);
             item->showHelpText();
         }
     }
 }
 
 KisShadeSelectorLineComboBoxPopup::~KisShadeSelectorLineComboBoxPopup()
 {
 }
 
 void KisShadeSelectorLineComboBoxPopup::setConfiguration(const QString &string)
 {
     m_lineEditor->fromString(string);
 }
 
 void KisShadeSelectorLineComboBoxPopup::updateSelectedArea(const QRect &newRect)
 {
     QRect oldSelectedArea = m_selectedArea;
     m_selectedArea = newRect;
     update(oldSelectedArea);
     update(m_selectedArea);
 }
 
 void KisShadeSelectorLineComboBoxPopup::updateHighlightedArea(const QRect &newRect)
 {
     QRect oldHighlightArea = m_highlightedArea;
     m_highlightedArea = newRect;
     update(oldHighlightArea);
     update(m_highlightedArea);
 }
 
 void KisShadeSelectorLineComboBoxPopup::activateItem(QWidget *widget)
 {
     KisShadeSelectorLineBase* item = dynamic_cast<KisShadeSelectorLineBase*>(widget);
     KIS_ASSERT_RECOVER_RETURN(item);
 
     QRect itemRect = kisGrowRect(item->geometry(), spacing / 2 - 1);
     m_lastSelectedItem = item;
 
     updateSelectedArea(itemRect);
 }
 
 void KisShadeSelectorLineComboBoxPopup::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
     QPainter p(this);
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     if (cfg.readEntry("useCustomColorForBackground", false)) {
-        p.fillRect(0,0,width(), height(), qApp->palette().window().color());
+        p.fillRect(0,0,width(), height(), cfg.readEntry("customSelectorBackgroundColor", QColor(Qt::gray)));
     } else {
-        p.fillRect(0,0,width(), height(), QColor(128,128,128));
+        p.fillRect(0,0,width(), height(), qApp->palette().window().color());
     }
     painter.fillRect(m_selectedArea, palette().highlight());
 
     painter.setPen(QPen(palette().highlight(), 2));
     painter.drawRect(m_highlightedArea);
 }
 
 void KisShadeSelectorLineComboBoxPopup::mouseMoveEvent(QMouseEvent * e)
 {
     if(rect().contains(e->pos())) {
         for(int i = 0; i < layout()->count(); i++) {
             KisShadeSelectorLineBase* item = dynamic_cast<KisShadeSelectorLineBase*>(layout()->itemAt(i)->widget());
             KIS_ASSERT_RECOVER_RETURN(item);
 
             QRect itemRect = kisGrowRect(item->geometry(), spacing / 2 - 1);
             if(itemRect.contains(e->pos())) {
                 m_lastHighlightedItem = item;
 
                 updateHighlightedArea(itemRect);
             }
         }
     }
     else {
         updateHighlightedArea(QRect());
     }
 }
 
 void KisShadeSelectorLineComboBoxPopup::mousePressEvent(QMouseEvent* e)
 {
     if(rect().contains(e->pos())) {
         mouseMoveEvent(e);
 
         m_lastSelectedItem = m_lastHighlightedItem;
 
         if (m_lastSelectedItem != m_lineEditor) {
             m_lineEditor->blockSignals(true);
             m_lineEditor->fromString(m_lastSelectedItem->toString());
             m_lineEditor->blockSignals(false);
         }
         updateSelectedArea(m_highlightedArea);
     }
     if (m_lastSelectedItem) {
         KisShadeSelectorLineComboBox *parent = dynamic_cast<KisShadeSelectorLineComboBox*>(this->parent());
         Q_ASSERT(parent);
         parent->setConfiguration(m_lastSelectedItem->toString());
     }
     e->accept();
 
     this->parentWidget()->update();
     hide();
 }
 
diff --git a/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui b/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui
index b2658dfcbd..8dd821c0fc 100644
--- a/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui
+++ b/plugins/dockers/advancedcolorselector/wdg_color_selector_settings.ui
@@ -1,1591 +1,1600 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>KisColorSelectorSettings</class>
  <widget class="QWidget" name="KisColorSelectorSettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>723</width>
     <height>1108</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Minimum" vsizetype="MinimumExpanding">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="windowTitle">
    <string>Color Selector Settings</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_16">
    <item>
     <layout class="QFormLayout" name="dockerSelectForm">
      <property name="labelAlignment">
       <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
      </property>
      <property name="verticalSpacing">
       <number>6</number>
      </property>
      <property name="bottomMargin">
       <number>20</number>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="dockerColorSettingsLabel">
        <property name="text">
         <string>Docker:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QComboBox" name="dockerColorSettingsComboBox">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>30</height>
         </size>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QTabWidget" name="advancedColorSelectorOptions">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>280</height>
       </size>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab_typeshape">
       <attribute name="title">
        <string>Color Selector</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_4">
        <item>
         <widget class="QGroupBox" name="chkShowColorSelector">
          <property name="title">
           <string>Show color selector</string>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
          <layout class="QHBoxLayout" name="horizontalLayout_13">
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_6">
             <item>
              <layout class="QVBoxLayout" name="verticalLayout_5">
               <item>
                <widget class="KisColorSelectorComboBox" name="colorSelectorConfiguration">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                </widget>
               </item>
               <item>
                <spacer name="verticalSpacer_2">
                 <property name="orientation">
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeType">
                  <enum>QSizePolicy::MinimumExpanding</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>20</width>
                   <height>5</height>
                  </size>
                 </property>
                </spacer>
               </item>
              </layout>
             </item>
             <item>
              <layout class="QVBoxLayout" name="verticalLayout_2">
               <property name="spacing">
                <number>6</number>
               </property>
               <item>
                <layout class="QHBoxLayout" name="horizontalLayout_12">
                 <property name="spacing">
                  <number>12</number>
                 </property>
                 <property name="topMargin">
                  <number>6</number>
                 </property>
                 <property name="rightMargin">
                  <number>6</number>
                 </property>
                 <item>
                  <layout class="QVBoxLayout" name="verticalLayout_3">
                   <item>
                    <widget class="QLabel" name="l_type">
                     <property name="sizePolicy">
                      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                       <horstretch>0</horstretch>
                       <verstretch>0</verstretch>
                      </sizepolicy>
                     </property>
                     <property name="layoutDirection">
                      <enum>Qt::LeftToRight</enum>
                     </property>
                     <property name="text">
                      <string>Color &amp;Model Type: </string>
                     </property>
                     <property name="alignment">
                      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
                     </property>
                     <property name="buddy">
                      <cstring>colorSelectorConfiguration</cstring>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QComboBox" name="colorSelectorTypeComboBox">
                     <property name="sizePolicy">
                      <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                       <horstretch>0</horstretch>
                       <verstretch>0</verstretch>
                      </sizepolicy>
                     </property>
                    </widget>
                   </item>
                  </layout>
                 </item>
                 <item>
                  <widget class="QLabel" name="ACSTypeDescriptionLabel">
                   <property name="sizePolicy">
                    <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                     <horstretch>0</horstretch>
                     <verstretch>0</verstretch>
                    </sizepolicy>
                   </property>
                   <property name="text">
                    <string notr="true">Type Description goes here</string>
                   </property>
                   <property name="alignment">
                    <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
                   </property>
                   <property name="wordWrap">
                    <bool>true</bool>
                   </property>
                  </widget>
                 </item>
                </layout>
               </item>
               <item>
                <widget class="QGroupBox" name="lumaCoefficientGroupbox">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="title">
                  <string>Luma Coefficients</string>
                 </property>
                 <layout class="QHBoxLayout" name="horizontalLayout_15">
                  <item>
                   <layout class="QGridLayout" name="gridLayout_5">
                    <property name="leftMargin">
                     <number>0</number>
                    </property>
                    <property name="rightMargin">
                     <number>0</number>
                    </property>
                    <property name="verticalSpacing">
                     <number>6</number>
                    </property>
                    <item row="0" column="0">
                     <widget class="QLabel" name="redlabel">
                      <property name="sizePolicy">
                       <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                        <horstretch>0</horstretch>
                        <verstretch>0</verstretch>
                       </sizepolicy>
                      </property>
                      <property name="text">
                       <string>Red': </string>
                      </property>
                      <property name="alignment">
                       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                      </property>
                     </widget>
                    </item>
                    <item row="0" column="3">
                     <widget class="KisDoubleParseSpinBox" name="l_lumaG">
                      <property name="sizePolicy">
                       <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
                        <horstretch>0</horstretch>
                        <verstretch>0</verstretch>
                       </sizepolicy>
                      </property>
                      <property name="minimumSize">
                       <size>
                        <width>50</width>
                        <height>0</height>
                       </size>
                      </property>
                      <property name="decimals">
                       <number>4</number>
                      </property>
                     </widget>
                    </item>
                    <item row="0" column="2">
                     <widget class="QLabel" name="greenlabel">
                      <property name="sizePolicy">
                       <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                        <horstretch>0</horstretch>
                        <verstretch>0</verstretch>
                       </sizepolicy>
                      </property>
                      <property name="text">
                       <string>Green':</string>
                      </property>
                     </widget>
                    </item>
                    <item row="0" column="4">
                     <widget class="QLabel" name="bluelabel">
                      <property name="sizePolicy">
                       <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                        <horstretch>0</horstretch>
                        <verstretch>0</verstretch>
                       </sizepolicy>
                      </property>
                      <property name="text">
                       <string>Blue':</string>
                      </property>
                     </widget>
                    </item>
                    <item row="0" column="1">
                     <widget class="KisDoubleParseSpinBox" name="l_lumaR">
                      <property name="sizePolicy">
                       <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
                        <horstretch>0</horstretch>
                        <verstretch>0</verstretch>
                       </sizepolicy>
                      </property>
                      <property name="minimumSize">
                       <size>
                        <width>50</width>
                        <height>0</height>
                       </size>
                      </property>
                      <property name="decimals">
                       <number>4</number>
                      </property>
                     </widget>
                    </item>
                    <item row="0" column="5">
                     <widget class="KisDoubleParseSpinBox" name="l_lumaB">
                      <property name="sizePolicy">
                       <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
                        <horstretch>0</horstretch>
                        <verstretch>0</verstretch>
                       </sizepolicy>
                      </property>
                      <property name="minimumSize">
                       <size>
                        <width>50</width>
                        <height>0</height>
                       </size>
                      </property>
                      <property name="decimals">
                       <number>4</number>
                      </property>
                     </widget>
                    </item>
                    <item row="1" column="1">
                     <widget class="KisDoubleParseSpinBox" name="SP_Gamma">
                      <property name="toolTip">
                       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;This sets the gamma value that the linearised HSY Luminosity is crunched with. 1 makes the selector fully linear, 2.2 is a practical default value.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                      </property>
                      <property name="decimals">
                       <number>1</number>
                      </property>
                      <property name="minimum">
                       <double>-3.000000000000000</double>
                      </property>
                      <property name="maximum">
                       <double>3.000000000000000</double>
                      </property>
                      <property name="singleStep">
                       <double>0.100000000000000</double>
                      </property>
                      <property name="value">
                       <double>2.200000000000000</double>
                      </property>
                     </widget>
                    </item>
                    <item row="1" column="0">
                     <widget class="QLabel" name="gamma_label">
                      <property name="text">
                       <string>Gamma:</string>
                      </property>
                     </widget>
                    </item>
                   </layout>
                  </item>
                 </layout>
                </widget>
               </item>
              </layout>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
+       <layout class="QHBoxLayout" name="horizontalLayout_16">
+
        <item>
-        <widget class="QCheckBox" name="useCustomColorForBackground">
+        <layout class="QGridLayout" name="gridLayout_7">
+        <item row="0" column="0">
+         <widget class="QCheckBox" name="useCustomColorForBackground">
          <property name="text">
           <string>Use custom color for selector background.</string>
          </property>
         </widget>
        </item>
-       <item>
+       <item row="0" column="1">
           <widget class="KisColorButton" name="customColorBackgroundSelector">
            <property name="text">
             <string/>
            </property>
+           <property name="alignment">
+               <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
           </widget>
        </item>
+       </layout>
+       </layout>
        <item>
         <widget class="QGroupBox" name="useDifferentColorSpaceCheckbox">
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="title">
           <string>Color Selector Uses Different Color Space than Ima&amp;ge</string>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_10">
           <item>
            <widget class="KisColorSpaceSelector" name="colorSpace" native="true">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_9">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::MinimumExpanding</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>5</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_general">
       <attribute name="title">
        <string>Behavior</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_15">
        <item>
         <layout class="QGridLayout" name="gridLayout_6">
          <item row="0" column="0">
           <widget class="QLabel" name="label_3">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="layoutDirection">
             <enum>Qt::LeftToRight</enum>
            </property>
            <property name="text">
             <string>When Docker Resizes: </string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QComboBox" name="zoomSelectorOptionComboBox"/>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_5">
            <property name="text">
             <string>Show Zoom Selector UI: </string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_11">
            <property name="text">
             <string>Zoom Selector Size: </string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="KisIntParseSpinBox" name="popupSize">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="minimum">
             <number>100</number>
            </property>
            <property name="maximum">
             <number>1000</number>
            </property>
            <property name="singleStep">
             <number>10</number>
            </property>
            <property name="value">
             <number>260</number>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="dockerResizeOptionsComboBox">
            <property name="enabled">
             <bool>true</bool>
            </property>
            <property name="sizePolicy">
             <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="QCheckBox" name="hidePopupOnClickCheck">
            <property name="text">
             <string>Hide Popup on click.</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::MinimumExpanding</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tabShadeSelector">
       <attribute name="title">
        <string>Shade Selector</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_9">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_11">
          <item>
           <layout class="QVBoxLayout" name="verticalLayout_8">
            <item>
             <layout class="QGridLayout" name="gridLayout_3">
              <item row="0" column="0">
               <widget class="QLabel" name="label_16">
                <property name="text">
                 <string>Type:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <widget class="QLabel" name="myPaintColorModelLabel">
                <property name="text">
                 <string>Color model:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QComboBox" name="ACSShadeSelectorTypeComboBox"/>
              </item>
              <item row="0" column="3">
               <widget class="QComboBox" name="ACSshadeSelectorMyPaintColorModelComboBox"/>
              </item>
             </layout>
            </item>
           </layout>
          </item>
          <item>
           <spacer name="horizontalSpacer_5">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>20</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <layout class="QVBoxLayout" name="verticalLayout_7">
            <property name="spacing">
             <number>0</number>
            </property>
            <item>
             <widget class="QLabel" name="label_7">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string>Update Selector When:</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="shadeSelectorUpdateOnRightClick">
              <property name="text">
               <string>Right clicking on shade selector</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="shadeSelectorUpdateOnLeftClick">
              <property name="text">
               <string>Left clicking on shade selector</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="shadeSelectorUpdateOnForeground">
              <property name="toolTip">
               <string>this doesn't include a color change by the shade selector</string>
              </property>
              <property name="text">
               <string>Foreground color changes</string>
              </property>
              <property name="checked">
               <bool>false</bool>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="shadeSelectorUpdateOnBackground">
              <property name="toolTip">
               <string>this doesn't include a color change by the shade selector</string>
              </property>
              <property name="text">
               <string>Background color change</string>
              </property>
              <property name="checked">
               <bool>true</bool>
              </property>
             </widget>
            </item>
           </layout>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QGroupBox" name="minimalShadeSelectorGroup">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="title">
           <string>Minimal Shade Selector</string>
          </property>
          <layout class="QHBoxLayout" name="horizontalLayout_10">
           <item>
            <layout class="QVBoxLayout" name="verticalLayout_6">
             <item>
              <layout class="QHBoxLayout" name="horizontalLayout_9">
               <item>
                <widget class="QLabel" name="label_15">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="text">
                  <string>Display:</string>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QRadioButton" name="minimalShadeSelectorAsGradient">
                 <property name="text">
                  <string>&amp;Gradient</string>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QRadioButton" name="minimalShadeSelectorAsColorPatches">
                 <property name="text">
                  <string>Colo&amp;r Patches</string>
                 </property>
                </widget>
               </item>
              </layout>
             </item>
             <item>
              <widget class="KisShadeSelectorLinesSettings" name="minimalShadeSelectorLineSettings">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item>
            <spacer name="horizontalSpacer_4">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>59</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item>
            <layout class="QFormLayout" name="formLayout_3">
             <item row="0" column="0">
              <widget class="QLabel" name="label_2">
               <property name="text">
                <string>Line Count: </string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="KisIntParseSpinBox" name="minimalShadeSelectorLineCount">
               <property name="minimum">
                <number>1</number>
               </property>
               <property name="maximum">
                <number>10</number>
               </property>
               <property name="value">
                <number>3</number>
               </property>
              </widget>
             </item>
             <item row="1" column="0">
              <widget class="QLabel" name="label_6">
               <property name="text">
                <string>Line Height: </string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
              </widget>
             </item>
             <item row="1" column="1">
              <widget class="KisIntParseSpinBox" name="minimalShadeSelectorLineHeight">
               <property name="suffix">
                <string> px</string>
               </property>
               <property name="minimum">
                <number>8</number>
               </property>
               <property name="maximum">
                <number>99</number>
               </property>
               <property name="value">
                <number>16</number>
               </property>
              </widget>
             </item>
             <item row="2" column="0">
              <widget class="QLabel" name="patchesPerLineLabel">
               <property name="text">
                <string>Patches Per Line: </string>
               </property>
               <property name="alignment">
                <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
               </property>
              </widget>
             </item>
             <item row="2" column="1">
              <widget class="KisIntParseSpinBox" name="minimalShadeSelectorPatchesPerLine"/>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_5">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::MinimumExpanding</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_ColorHistory">
       <property name="enabled">
        <bool>true</bool>
       </property>
       <property name="sizePolicy">
        <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Color History</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_11">
        <item>
         <widget class="QGroupBox" name="lastUsedColorsShow">
          <property name="sizePolicy">
           <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="title">
           <string>Show Color Histor&amp;y</string>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_12">
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_7">
             <item>
              <widget class="QGroupBox" name="groupBox">
               <property name="title">
                <string>Patch Options</string>
               </property>
               <layout class="QFormLayout" name="formLayout_4">
                <item row="0" column="0">
                 <widget class="QLabel" name="label_14">
                  <property name="text">
                   <string>Height:</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                 </widget>
                </item>
                <item row="0" column="1">
                 <widget class="KisIntParseSpinBox" name="lastUsedColorsWidth">
                  <property name="suffix">
                   <string> px</string>
                  </property>
                  <property name="prefix">
                   <string/>
                  </property>
                  <property name="minimum">
                   <number>16</number>
                  </property>
                 </widget>
                </item>
                <item row="1" column="0">
                 <widget class="QLabel" name="label">
                  <property name="text">
                   <string>Width: </string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                 </widget>
                </item>
                <item row="1" column="1">
                 <widget class="KisIntParseSpinBox" name="lastUsedColorsHeight">
                  <property name="suffix">
                   <string> px</string>
                  </property>
                  <property name="minimum">
                   <number>16</number>
                  </property>
                 </widget>
                </item>
                <item row="2" column="0">
                 <widget class="QLabel" name="label_10">
                  <property name="text">
                   <string>Max Patches: </string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                 </widget>
                </item>
                <item row="2" column="1">
                 <widget class="KisIntParseSpinBox" name="lastUsedColorsPatchCount">
                  <property name="minimum">
                   <number>1</number>
                  </property>
                  <property name="value">
                   <number>30</number>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_6">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QGroupBox" name="groupBox_2">
               <property name="title">
                <string>Layout</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <property name="verticalSpacing">
                 <number>0</number>
                </property>
                <item row="0" column="0">
                 <widget class="QRadioButton" name="lastUsedColorsAlignVertical">
                  <property name="text">
                   <string>&amp;Vertical</string>
                  </property>
                  <property name="checked">
                   <bool>true</bool>
                  </property>
                 </widget>
                </item>
                <item row="0" column="1">
                 <widget class="QLabel" name="lbl_lastUsedNumCols">
                  <property name="text">
                   <string>Colu&amp;mns:</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                  <property name="buddy">
                   <cstring>lastUsedColorsNumCols</cstring>
                  </property>
                 </widget>
                </item>
                <item row="0" column="2">
                 <widget class="KisIntParseSpinBox" name="lastUsedColorsNumCols">
                  <property name="minimum">
                   <number>1</number>
                  </property>
                  <property name="maximum">
                   <number>20</number>
                  </property>
                  <property name="value">
                   <number>2</number>
                  </property>
                 </widget>
                </item>
                <item row="1" column="0">
                 <widget class="QRadioButton" name="lastUsedColorsAlignHorizontal">
                  <property name="text">
                   <string>Hori&amp;zontal</string>
                  </property>
                 </widget>
                </item>
                <item row="1" column="1">
                 <widget class="QLabel" name="lbl_lastUsedNumRows">
                  <property name="text">
                   <string>&amp;Rows:</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                  <property name="buddy">
                   <cstring>lastUsedColorsNumRows</cstring>
                  </property>
                 </widget>
                </item>
                <item row="1" column="2">
                 <widget class="KisIntParseSpinBox" name="lastUsedColorsNumRows">
                  <property name="minimum">
                   <number>1</number>
                  </property>
                  <property name="maximum">
                   <number>20</number>
                  </property>
                  <property name="value">
                   <number>3</number>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
            </layout>
           </item>
           <item>
            <widget class="QCheckBox" name="lastUsedColorsAllowScrolling">
             <property name="text">
              <string>Allow scrolling</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_6">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::MinimumExpanding</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>5</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_colorsFromImage">
       <attribute name="title">
        <string>Colors from Image</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_14">
        <item>
         <widget class="QGroupBox" name="commonColorsShow">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="title">
           <string>Show Colors from the ima&amp;ge</string>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_13">
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_8">
             <item>
              <widget class="QGroupBox" name="groupBox_3">
               <property name="title">
                <string>Patch Options</string>
               </property>
               <layout class="QFormLayout" name="formLayout_2">
                <item row="0" column="0">
                 <widget class="QLabel" name="label_12">
                  <property name="text">
                   <string>Height:</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                 </widget>
                </item>
                <item row="0" column="1">
                 <widget class="KisIntParseSpinBox" name="commonColorsWidth">
                  <property name="suffix">
                   <string> px</string>
                  </property>
                  <property name="prefix">
                   <string/>
                  </property>
                  <property name="minimum">
                   <number>16</number>
                  </property>
                 </widget>
                </item>
                <item row="1" column="0">
                 <widget class="QLabel" name="label_4">
                  <property name="text">
                   <string>Width:</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                 </widget>
                </item>
                <item row="1" column="1">
                 <widget class="KisIntParseSpinBox" name="commonColorsHeight">
                  <property name="suffix">
                   <string> px</string>
                  </property>
                  <property name="minimum">
                   <number>16</number>
                  </property>
                 </widget>
                </item>
                <item row="2" column="0">
                 <widget class="QLabel" name="label_9">
                  <property name="text">
                   <string>Max Patches: </string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                 </widget>
                </item>
                <item row="2" column="1">
                 <widget class="KisIntParseSpinBox" name="commonColorsPatchCount">
                  <property name="minimum">
                   <number>1</number>
                  </property>
                  <property name="value">
                   <number>30</number>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_7">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QGroupBox" name="groupBox_4">
               <property name="title">
                <string>Layout</string>
               </property>
               <layout class="QGridLayout" name="gridLayout_2">
                <property name="horizontalSpacing">
                 <number>6</number>
                </property>
                <property name="verticalSpacing">
                 <number>0</number>
                </property>
                <item row="0" column="0">
                 <widget class="QRadioButton" name="commonColorsAlignVertical">
                  <property name="text">
                   <string>&amp;Vertical</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="1">
                 <widget class="QLabel" name="lbl_commonColorsNumCols">
                  <property name="text">
                   <string>Colu&amp;mns:</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                  <property name="buddy">
                   <cstring>commonColorsNumCols</cstring>
                  </property>
                 </widget>
                </item>
                <item row="0" column="2">
                 <widget class="KisIntParseSpinBox" name="commonColorsNumCols">
                  <property name="minimum">
                   <number>1</number>
                  </property>
                  <property name="maximum">
                   <number>20</number>
                  </property>
                  <property name="value">
                   <number>2</number>
                  </property>
                 </widget>
                </item>
                <item row="1" column="0">
                 <widget class="QRadioButton" name="commonColorsAlignHorizontal">
                  <property name="text">
                   <string>Hori&amp;zontal</string>
                  </property>
                  <property name="checked">
                   <bool>true</bool>
                  </property>
                 </widget>
                </item>
                <item row="1" column="1">
                 <widget class="QLabel" name="lbl_commonColorsNumRows">
                  <property name="text">
                   <string>&amp;Rows:</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                  </property>
                  <property name="buddy">
                   <cstring>commonColorsNumRows</cstring>
                  </property>
                 </widget>
                </item>
                <item row="1" column="2">
                 <widget class="KisIntParseSpinBox" name="commonColorsNumRows">
                  <property name="minimum">
                   <number>1</number>
                  </property>
                  <property name="maximum">
                   <number>20</number>
                  </property>
                  <property name="value">
                   <number>3</number>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
            </layout>
           </item>
           <item>
            <widget class="QCheckBox" name="commonColorsAutoUpdate">
             <property name="toolTip">
              <string>this can be slow on big images</string>
             </property>
             <property name="text">
              <string>Update after every stroke</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QCheckBox" name="commonColorsAllowScrolling">
             <property name="text">
              <string>Allow scrolling</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_7">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::MinimumExpanding</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="colorSliderOptions" native="true">
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QGroupBox" name="groupHsv">
         <property name="title">
          <string>HSV Sliders to Show</string>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QCheckBox" name="csl_hsvH">
            <property name="text">
             <string>Hue</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hsvS">
            <property name="text">
             <string>Saturation</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hsvV">
            <property name="text">
             <string>Value</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="groupHsl">
         <property name="title">
          <string>HSL Sliders to Show</string>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <widget class="QCheckBox" name="csl_hslH">
            <property name="text">
             <string>Hue</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hslS">
            <property name="text">
             <string>Saturation</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hslL">
            <property name="text">
             <string>Lightness</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="groupHsi">
         <property name="title">
          <string>HSI Sliders to Show</string>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_2">
          <item>
           <widget class="QCheckBox" name="csl_hsiH">
            <property name="text">
             <string>Hue</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hsiS">
            <property name="text">
             <string>Saturation</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hsiI">
            <property name="text">
             <string>Intensity</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="groupHsy">
         <property name="title">
          <string>HSY' Sliders to Show</string>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_4">
          <item>
           <widget class="QCheckBox" name="csl_hsyH">
            <property name="text">
             <string>Hue</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hsyS">
            <property name="text">
             <string>Saturation</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="csl_hsyY">
            <property name="text">
             <string>Luma</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="hotKeyOptions" native="true">
      <layout class="QVBoxLayout" name="hotkeyOptions">
       <item>
        <widget class="QGroupBox" name="hsy">
         <property name="title">
          <string>Lightness, Saturation and Hue hotkey steps</string>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_5">
          <item>
           <widget class="QLabel" name="label_8">
            <property name="text">
             <string>Lightness: </string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="KisIntParseSpinBox" name="sb_lightness">
            <property name="suffix">
             <string> steps</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Saturation: </string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="KisIntParseSpinBox" name="sb_saturation">
            <property name="suffix">
             <string> steps</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_2">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLabel" name="label_17">
            <property name="text">
             <string>Hue: </string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="KisIntParseSpinBox" name="sb_hue">
            <property name="suffix">
             <string> steps</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="horizontalGroupBox_2">
         <property name="title">
          <string>YUV Redder/Greener/Bluer/Yellower hotkey steps</string>
         </property>
         <layout class="QHBoxLayout" name="yuv">
          <item>
           <widget class="QLabel" name="label_18">
            <property name="text">
             <string>Redder/Greener: </string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="KisIntParseSpinBox" name="sb_rg">
            <property name="suffix">
             <string> steps</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_3">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
          <item>
           <widget class="QLabel" name="label_19">
            <property name="text">
             <string>Bluer/Yellower: </string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="KisIntParseSpinBox" name="sb_by">
            <property name="suffix">
             <string> steps</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>10</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisColorSpaceSelector</class>
    <extends>QWidget</extends>
    <header>widgets/kis_color_space_selector.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisColorSelectorComboBox</class>
    <extends>QComboBox</extends>
    <header>kis_color_selector_combo_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisShadeSelectorLinesSettings</class>
    <extends>QComboBox</extends>
    <header>kis_shade_selector_lines_settings.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections>
   <connection>
    <sender>minimalShadeSelectorAsColorPatches</sender>
    <signal>toggled(bool)</signal>
    <receiver>minimalShadeSelectorPatchesPerLine</receiver>
    <slot>setEnabled(bool)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>194</x>
      <y>393</y>
     </hint>
     <hint type="destinationlabel">
      <x>520</x>
      <y>463</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>