diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
index edd285b5d5..d3f87f6aea 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -1,423 +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("useBackgroundColorForSelector", true)) {
-        p.fillRect(0,0,width(), height(), cfg.readEntry("colorEditorBackground", qApp->palette().window().color()));
+        p.fillRect(0,0,width(), height(), qApp->palette().window().color());
     } else {
         p.fillRect(0,0,width(), height(), QColor(128,128,128));
     }
 
     p.setRenderHint(QPainter::Antialiasing);
 
     // this variable name isn't entirely accurate to what always happens. see definition in header file to understand it better
     if (!m_hasAtLeastOneDocumentOpen) {
         p.setOpacity(0.2);
     }
 
     m_mainComponent->paintEvent(&p);
     m_subComponent->paintEvent(&p);
 
     p.setOpacity(1.0);
 }
 
 inline int iconSize(qreal width, qreal height) {
     qreal radius = qMin(width, height)/2.;
     qreal xm = width/2.;
     qreal ym = height/2.;
     if(xm>=2*ym || ym>=2*xm)
         return qBound<qreal>(5., radius, 32.);
 
     qreal a=-2;
     qreal b=2.*(xm+ym);
     qreal c=radius*radius-xm*xm-ym*ym;
     return qBound<qreal>(5., ((-b+sqrt(b*b-4*a*c))/(2*a)), 32.);
 }
 
 void KisColorSelector::resizeEvent(QResizeEvent* e) {
     if (m_configuration.subType == KisColorSelectorConfiguration::Ring) {
 
         m_ring->setGeometry(0,0,width(), height());
 
         if (displaySettingsButton()) {
             int size = iconSize(width(), height());
             m_button->setGeometry(0, 0, size, size);
         }
 
         if (m_configuration.mainType == KisColorSelectorConfiguration::Triangle) {
             m_triangle->setGeometry(width()/2-m_ring->innerRadius(),
                                     height()/2-m_ring->innerRadius(),
                                     m_ring->innerRadius()*2,
                                     m_ring->innerRadius()*2);
         }
         else {
             int size = m_ring->innerRadius()*2/sqrt(2.);
             m_square->setGeometry(width()/2-size/2,
                                   height()/2-size/2,
                                   size,
                                   size);
         }
     }
     else {
         // type wheel and square
         if (m_configuration.mainType == KisColorSelectorConfiguration::Wheel) {
             if(displaySettingsButton()) {
                 int size = iconSize(width(), height()*0.9);
                 m_button->setGeometry(0, height()*0.1, size, size);
             }
             m_mainComponent->setGeometry(0, height()*0.1, width(), height()*0.9);
             m_subComponent->setGeometry( 0, 0,            width(), height()*0.1);
         }
         else {
             int buttonSize = 0;
             if(displaySettingsButton()) {
                 buttonSize = qBound(20, int(0.1*height()), 32);
                 m_button->setGeometry(0, 0, buttonSize, buttonSize);
             }
 
             if(height()>width()) {
                 int selectorHeight=height()-buttonSize;
                 m_mainComponent->setGeometry(0, buttonSize+selectorHeight*0.1, width(), selectorHeight*0.9);
                 m_subComponent->setGeometry( 0, buttonSize,                    width(), selectorHeight*0.1);
             }
             else {
                 int selectorWidth=width()-buttonSize;
                 m_mainComponent->setGeometry(buttonSize, height()*0.1, selectorWidth, height()*0.9);
                 m_subComponent->setGeometry( buttonSize, 0,            selectorWidth, height()*0.1);
             }
         }
     }
 
     // reset the correct color after resizing the widget
     setColor(m_lastRealColor);
 
     KisColorSelectorBase::resizeEvent(e);
 }
 
 void KisColorSelector::mousePressEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mousePressEvent(e);
 
     if(!e->isAccepted()) {
         if(m_mainComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_mainComponent;
         else if(m_subComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_subComponent;
 
         mouseEvent(e);
         updatePreviousColorPreview();
         e->accept();
     }
 }
 
 void KisColorSelector::mouseMoveEvent(QMouseEvent* e)
 {
     KisColorSelectorBase::mouseMoveEvent(e);
 
     mouseEvent(e);
     e->accept();
 }
 
 void KisColorSelector::mouseReleaseEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mouseReleaseEvent(e);
 
     if(!e->isAccepted() &&
        !(m_lastRealColor == m_currentRealColor)) {
 
         m_lastRealColor = m_currentRealColor;
         m_lastColorRole = Acs::buttonToRole(e->button());
 
         updateColor(m_lastRealColor, m_lastColorRole, false);
         updateBaseColorPreview(m_currentRealColor);
         e->accept();
     }
 
     m_grabbingComponent=0;
 }
 
 bool KisColorSelector::displaySettingsButton()
 {
     return dynamic_cast<KisColorSelectorContainer*>(parent());
 }
 
 void KisColorSelector::setColor(const KoColor &color)
 {
     m_mainComponent->setColor(color);
     m_subComponent->setColor(color);
     m_lastRealColor = color;
 
     m_signalCompressor->start();
 }
 
 void KisColorSelector::mouseEvent(QMouseEvent *e)
 {
     if (m_grabbingComponent && (e->buttons() & Qt::LeftButton || e->buttons() & Qt::RightButton)) {
 
         m_grabbingComponent->mouseEvent(e->x(), e->y());
 
         KoColor color = m_mainComponent->currentColor();
         Acs::ColorRole role = Acs::buttonsToRole(e->button(), e->buttons());
         m_currentRealColor = color;
 
         requestUpdateColorAndPreview(color, role);
     }
 }
 
 void KisColorSelector::init()
 {
     setAcceptDrops(true);
 
     m_lastColorRole = Acs::Foreground;
     m_ring = new KisColorSelectorRing(this);
     m_triangle = new KisColorSelectorTriangle(this);
     m_slider = new KisColorSelectorSimple(this);
     m_square = new KisColorSelectorSimple(this);
     m_wheel = new KisColorSelectorWheel(this);
 
     if(displaySettingsButton()) {
         m_button = new QPushButton(this);
         m_button->setIcon(KisIconUtils::loadIcon("configure"));
         m_button->setFlat(true);
         connect(m_button, SIGNAL(clicked()), SIGNAL(settingsButtonClicked()));
     }
 
     // a tablet can send many more signals, than a mouse
     // this causes many repaints, if updating after every signal.
     m_signalCompressor = new KisSignalCompressor(20, KisSignalCompressor::FIRST_INACTIVE, this);
     connect(m_signalCompressor, SIGNAL(timeout()), SLOT(update()));
 
     setMinimumSize(40, 40);
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp b/plugins/dockers/advancedcolorselector/kis_minimal_shade_selector.cpp
index b51256b9c2..c571df58df 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("useBackgroundColorForSelector", true)) {
-        p.fillRect(0,0,width(), height(), cfg.readEntry("colorEditorBackground", qApp->palette().window().color()));
+        p.fillRect(0,0,width(), height(), qApp->palette().window().color());
     } else {
         p.fillRect(0,0,width(), height(), QColor(128,128,128));
     }
 }
 
 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 2ba1f76a72..d056a55229 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("useBackgroundColorForSelector", true)) {
-        p.fillRect(0,0,width(), height(), cfg.readEntry("colorEditorBackground", qApp->palette().window().color()));
+        p.fillRect(0,0,width(), height(), qApp->palette().window().color());
     } else {
         p.fillRect(0,0,width(), height(), QColor(128,128,128));
     }
     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();
 }