diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 3835c53c2a..44a19e56c2 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1037 +1,1052 @@
 /*
  *  preferencesdlg.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_preferences.h"
 
 #include <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QCursor>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSlider>
 #include <QToolButton>
 #include <QThread>
 #include <QDesktopServices>
 #include <QGridLayout>
 #include <QRadioButton>
 #include <QGroupBox>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 
 #include <KisDocument.h>
 #include <KoColorProfile.h>
 #include <KisApplication.h>
 #include <KoFileDialog.h>
 #include <KisPart.h>
 #include <KoColorSpaceEngine.h>
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include "KoID.h"
 #include <KoConfigAuthorPage.h>
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 
 #include "widgets/squeezedcombobox.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorConversionTransformation.h"
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_preference_set_registry.h"
 #include "kis_color_manager.h"
 #include "KisProofingConfiguration.h"
 #include "kis_image_config.h"
 
 #include "slider_and_spin_box_sync.h"
 
 // for the performance update
 #include <kis_cubic_curve.h>
 
 #include "input/config/kis_input_configuration_page.h"
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg;
 
     m_cmbCursorShape->addItem(i18n("No Cursor"));
     m_cmbCursorShape->addItem(i18n("Tool Icon"));
     m_cmbCursorShape->addItem(i18n("Arrow"));
     m_cmbCursorShape->addItem(i18n("Small Circle"));
     m_cmbCursorShape->addItem(i18n("Crosshair"));
     m_cmbCursorShape->addItem(i18n("Triangle Righthanded"));
     m_cmbCursorShape->addItem(i18n("Triangle Lefthanded"));
     m_cmbCursorShape->addItem(i18n("Black Pixel"));
     m_cmbCursorShape->addItem(i18n("White Pixel"));
 
     m_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
     m_undoStackSize->setValue(cfg.undoStackLimit());
     m_backupFileCheckBox->setChecked(cfg.backupFile());
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen());
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
-    m_mdiColor->setColor(cfg.getMDIBackgroundColor());
+    KoColor mdiColor;
+    mdiColor.fromQColor(cfg.getMDIBackgroundColor());
+    m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
     m_chkCompressKra->setChecked(cfg.compressKra());
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 }
 
 void GeneralTab::setDefault()
 {
     KisConfig cfg;
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle(true));
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle(true));
     chkShowRootLayer->setChecked(cfg.showRootLayer(true));
     m_autosaveCheckBox->setChecked(cfg.autoSaveInterval(true) > 0);
     //convert to minutes
     m_autosaveSpinBox->setValue(cfg.autoSaveInterval(true) / 60);
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen(true));
     m_cmbMDIType->setCurrentIndex((int)QMdiArea::TabbedView);
     m_chkRubberBand->setChecked(cfg.useOpenGL(true));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets(true));
-    m_mdiColor->setColor(cfg.getMDIBackgroundColor(true));
+    KoColor mdiColor;
+    mdiColor.fromQColor(cfg.getMDIBackgroundColor(true));
+    m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage(true));
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages(true));
     m_chkCompressKra->setChecked(cfg.compressKra(true));
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
 
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 bool GeneralTab::showRootLayer()
 {
     return chkShowRootLayer->isChecked();
 }
 
 int GeneralTab::autoSaveInterval()
 {
     //convert to seconds
     return m_autosaveCheckBox->isChecked() ? m_autosaveSpinBox->value()*60 : 0;
 }
 
 int GeneralTab::undoStackSize()
 {
     return m_undoStackSize->value();
 }
 
 bool GeneralTab::showOutlineWhilePainting()
 {
     return m_showOutlinePainting->isChecked();
 }
 
 bool GeneralTab::hideSplashScreen()
 {
     return m_hideSplashScreen->isChecked();
 }
 
 int GeneralTab::mdiMode()
 {
     return m_cmbMDIType->currentIndex();
 }
 
 int GeneralTab::favoritePresets()
 {
     return m_favoritePresetsSpinBox->value();
 }
 
 bool GeneralTab::showCanvasMessages()
 {
     return m_chkCanvasMessages->isChecked();
 }
 
 bool GeneralTab::compressKra()
 {
     return m_chkCompressKra->isChecked();
 }
 
 bool GeneralTab::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
 
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::PicturesLocation));
     dialog.setImageFilters();
 
     QString fn = dialog.filename();
     // dialog box was canceled or somehow no file was selected
     if (fn.isEmpty()) {
         return;
     }
 
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     else {
         m_backgroundimage->setText(fn);
     }
 }
 
 void GeneralTab::clearBackgroundImage()
 {
     // clearing the background image text will implicitly make the background color be used
     m_backgroundimage->setText("");
 }
 
 ShortcutSettingsTab::ShortcutSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgShortcutSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisPart::instance()->loadActions();
     KisActionRegistry::instance()->setupDialog(m_page);
 }
 
 void ShortcutSettingsTab::setDefault()
 {
     m_page->allDefault();
 }
 
 void ShortcutSettingsTab::saveChanges()
 {
     m_page->save();
     KisActionRegistry::instance()->settingsPageSaved();
 }
 
 void ShortcutSettingsTab::revertChanges()
 {
     m_page->allDefault();
 }
 
 ColorSettingsTab::ColorSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     // XXX: Make sure only profiles that fit the specified color model
     // are shown in the profile combos
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgColorSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg;
 
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
     connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
 
 // XXX: no color management integration on Windows or OSX yet
 #ifndef HAVE_X11
     m_page->chkUseSystemMonitorProfile->setVisible(false);
 #endif
     m_page->cmbWorkingColorSpace->setIDList(KoColorSpaceRegistry::instance()->listKeys());
     m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
 
     m_page->bnAddColorProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     m_page->bnAddColorProfile->setToolTip( i18n("Open Color Profile") );
     connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
 
     QGridLayout *monitorProfileGrid = new QGridLayout(m_page->monitorprofileholder);
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         monitorProfileGrid->addWidget(lbl, i, 0);
         m_monitorProfileLabels << lbl;
         SqueezedComboBox *cmb = new SqueezedComboBox();
         monitorProfileGrid->addWidget(cmb, i, 1);
         m_monitorProfileWidgets << cmb;
     }
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
 
     KisImageConfig cfgImage;
 
     KisProofingConfiguration *proofingConfig = cfgImage.defaultProofingconfiguration();
-    m_gamutWarning = new KoColorPopupAction(this);
-    m_gamutWarning->setToolTip(i18n("Set default color used for out of Gamut Warning"));
-    m_gamutWarning->setCurrentColor(proofingConfig->warningColor);
-    m_page->gamutAlarm->setDefaultAction(m_gamutWarning);
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)proofingConfig->adaptationState*20);
 
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
     m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
 
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, PASTE_ASSUME_WEB);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, PASTE_ASSUME_MONITOR);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, PASTE_ASK);
 
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
     Q_ASSERT(button);
 
     if (button) {
         button->setChecked(true);
     }
 
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
 
     toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
 
 }
 
 void ColorSettingsTab::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QDesktopServices::storageLocation(QDesktopServices::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         QUrl file(profileName);
         if (!QFile::copy(profileName, saveLocation + file.fileName())) {
             dbgKrita << "Could not install profile!";
             return;
         }
         iccEngine->addProfile(saveLocation + file.fileName());
 
     }
 
     KisConfig cfg;
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     if (useSystemProfile) {
         KisConfig cfg;
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::desktop()->screenCount()) {
             for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                     if (devices[i] == monitorForScreen) {
                         m_monitorProfileWidgets[i]->setCurrentIndex(i);
                     }
                 }
             }
         }
     }
     else {
         KisConfig cfg;
         refillMonitorProfiles(KoID("RGBA", ""));
 
         for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
     KisConfig cfg;
     KisImageConfig cfgImage;
     KisProofingConfiguration *proofingConfig =  cfgImage.defaultProofingconfiguration();
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
     m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
     m_page->sldAdaptationState->setValue(0);
 
-    m_gamutWarning->setCurrentColor(proofingConfig->warningColor);
+    m_page->gamutAlarm->setColor(proofingConfig->warningColor);
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation(true));
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization(true));
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent(true));
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
     Q_ASSERT(button);
     if (button) {
         button->setChecked(true);
     }
 }
 
 
 void ColorSettingsTab::refillMonitorProfiles(const KoID & s)
 {
     const KoColorSpaceFactory * csf = KoColorSpaceRegistry::instance()->colorSpaceFactory(s.id());
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
     if (!csf)
         return;
 
     QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(csf);
 
     Q_FOREACH (const KoColorProfile *profile, profileList) {
 //        //dbgKrita << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
         if (profile->isSuitableForDisplay()) {
             for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(csf->defaultProfile());
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 }
 
 TabletSettingsTab::TabletSettingsTab(QWidget* parent, const char* name): QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgTabletSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg;
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM() {
     KisImageConfig cfg;
     return cfg.totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg;
     const int totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(i18n("%1 MiB", totalRAM));
 
     sliderMemoryLimit->setSuffix(i18n(" %"));
     sliderMemoryLimit->setRange(1, 100, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderPoolLimit->setSuffix(i18n(" %"));
     sliderPoolLimit->setRange(0, 20, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderUndoLimit->setSuffix(i18n(" %"));
     sliderUndoLimit->setRange(0, 50, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     intMemoryLimit->setMinimumWidth(80);
     intPoolLimit->setMinimumWidth(80);
     intUndoLimit->setMinimumWidth(80);
 
 
     SliderAndSpinBoxSync *sync1 =
         new SliderAndSpinBoxSync(sliderMemoryLimit,
                                  intMemoryLimit,
                                  getTotalRAM);
 
     sync1->slotParentValueChanged();
     m_syncs << sync1;
 
     SliderAndSpinBoxSync *sync2 =
         new SliderAndSpinBoxSync(sliderPoolLimit,
                                  intPoolLimit,
                                  std::bind(&KisIntParseSpinBox::value,
                                              intMemoryLimit));
 
 
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
     sync2->slotParentValueChanged();
     m_syncs << sync2;
 
     SliderAndSpinBoxSync *sync3 =
         new SliderAndSpinBoxSync(sliderUndoLimit,
                                  intUndoLimit,
                                  std::bind(&PerformanceTab::realTilesRAM,
                                              this));
 
 
     connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg;
 
     sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
     sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
     sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
     chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
     chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
     sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
     lblSwapFileLocation->setText(cfg.swapDir(requestDefault));
 
     {
         KisConfig cfg2;
         chkOpenGLLogging->setChecked(cfg2.enableOpenGLDebugging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
     }
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg;
 
     cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
     cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
     cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
     cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
     cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
     cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
     cfg.setSwapDir(lblSwapFileLocation->text());
 
     {
         KisConfig cfg2;
         cfg2.setEnableOpenGLDebugging(chkOpenGLLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
     }
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg;
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     lblSwapFileLocation->setText(swapDir);
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 #include "KoColorPopupAction.h"
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
     KisConfig cfg;
 
     if (!KisOpenGL::hasOpenGL()) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     } else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL());
         chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
         chkDisableVsync->setVisible(cfg.showAdvancedOpenGLSettings());
         chkDisableVsync->setEnabled(cfg.useOpenGL());
         chkDisableVsync->setChecked(cfg.disableVSync());
         cmbFilterMode->setEnabled(cfg.useOpenGL());
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode());
         // Don't show the high quality filtering mode if it's not available
         if (!KisOpenGL::supportsGLSL13()) {
             cmbFilterMode->removeItem(3);
         }
     }
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     KoColor c;
     c.fromQColor(cfg.selectionOverlayMaskColor());
-    m_selectionOverlayColorAction = new KoColorPopupAction(this);
-    m_selectionOverlayColorAction->setCurrentColor(c);
-    m_selectionOverlayColorAction->setToolTip(i18n("Change the background color of the image"));
-    btnSelectionOverlayColor->setDefaultAction(m_selectionOverlayColorAction);
+    c.setOpacity(1.0);
+    btnSelectionOverlayColor->setColor(c);
+    sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
+    sldSelectionOverlayOpacity->setSingleStep(0.05);
+    sldSelectionOverlayOpacity->setValue(cfg.selectionOverlayMaskColor().alphaF());
 
     intCheckSize->setValue(cfg.checkSize());
     chkMoving->setChecked(cfg.scrollCheckers());
-    colorChecks1->setColor(cfg.checkersColor1());
-    colorChecks2->setColor(cfg.checkersColor2());
-    canvasBorder->setColor(cfg.canvasBorderColor());
+    KoColor ck1;
+    ck1.fromQColor(cfg.checkersColor1());
+    colorChecks1->setColor(ck1);
+    KoColor ck2;
+    ck2.fromQColor(cfg.checkersColor2());
+    colorChecks2->setColor(ck2);
+    KoColor cb;
+    cb.fromQColor(cfg.canvasBorderColor());
+    canvasBorder->setColor(cb);
     hideScrollbars->setChecked(cfg.hideScrollbars());
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves());
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline());
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor());
     chkHidePopups->setChecked(cfg.hidePopups());
 
     connect(grpOpenGL, SIGNAL(toggled(bool)), SLOT(slotUseOpenGLToggled(bool)));
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg;
     if (!KisOpenGL::hasOpenGL()) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     }
     else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL(true));
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
         chkUseTextureBuffer->setEnabled(true);
         chkDisableVsync->setEnabled(true);
         chkDisableVsync->setChecked(cfg.disableVSync(true));
         cmbFilterMode->setEnabled(true);
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
     }
 
     chkMoving->setChecked(cfg.scrollCheckers(true));
     intCheckSize->setValue(cfg.checkSize(true));
-    colorChecks1->setColor(cfg.checkersColor1(true));
-    colorChecks2->setColor(cfg.checkersColor2(true));
-    canvasBorder->setColor(cfg.canvasBorderColor(true));
+    KoColor ck1;
+    ck1.fromQColor(cfg.checkersColor1(true));
+    colorChecks1->setColor(ck1);
+    KoColor ck2;
+    ck2.fromQColor(cfg.checkersColor2(true));
+    colorChecks2->setColor(ck2);
+    KoColor cvb;
+    cvb.fromQColor(cfg.canvasBorderColor(true));
+    canvasBorder->setColor(cvb);
     hideScrollbars->setChecked(cfg.hideScrollbars(true));
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves(true));
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline(true));
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor(true));
     chkHidePopups->setChecked(cfg.hidePopups(true));
 
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg;
 
     chkDockers->setChecked(cfg.hideDockersFullscreen());
     chkMenu->setChecked(cfg.hideMenuFullscreen());
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen());
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen());
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen());
     chkToolbar->setChecked(cfg.hideToolbarFullscreen());
 
 }
 
 void FullscreenSettingsTab::setDefault()
 {
     KisConfig cfg;
     chkDockers->setChecked(cfg.hideDockersFullscreen(true));
     chkMenu->setChecked(cfg.hideMenuFullscreen(true));
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen(true));
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen(true));
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen(true));
     chkToolbar->setChecked(cfg.hideToolbarFullscreen(true));
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 KisDlgPreferences::KisDlgPreferences(QWidget* parent, const char* name)
     : KPageDialog(parent)
 {
     Q_UNUSED(name);
     setWindowTitle(i18n("Preferences"));
     // QT5TODO: help button needs custom wiring up to whatever help should be shown
     setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Help | QDialogButtonBox::RestoreDefaults);
     button(QDialogButtonBox::Ok)->setDefault(true);
 
     setFaceType(KPageDialog::List);
 
     // General
     KoVBox *vbox = new KoVBox();
     KPageWidgetItem *page = new KPageWidgetItem(vbox, i18n("General"));
     page->setObjectName("general");
     page->setHeader(i18n("General"));
     page->setIcon(KisIconUtils::loadIcon("go-home"));
     addPage(page);
     m_general = new GeneralTab(vbox);
 
     // Shortcuts
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Keyboard Shortcuts"));
     page->setObjectName("shortcuts");
     page->setHeader(i18n("Shortcuts"));
     page->setIcon(KisIconUtils::loadIcon("document-export"));
     addPage(page);
     m_shortcutSettings = new ShortcutSettingsTab(vbox);
     connect(this, SIGNAL(accepted()), m_shortcutSettings, SLOT(saveChanges()));
 
     // Canvas input settings
     m_inputConfiguration = new KisInputConfigurationPage();
     page = addPage(m_inputConfiguration, i18n("Canvas Input Settings"));
     page->setHeader(i18n("Canvas Input"));
     page->setObjectName("canvasinput");
     page->setIcon(KisIconUtils::loadIcon("configure"));
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     addPage(page);
     m_displaySettings = new DisplaySettingsTab(vbox);
 
     // Color
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Color Management"));
     page->setObjectName("colormanagement");
     page->setHeader(i18n("Color"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-color"));
     addPage(page);
     m_colorSettings = new ColorSettingsTab(vbox);
 
     // Performance
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Performance"));
     page->setObjectName("performance");
     page->setHeader(i18n("Performance"));
     page->setIcon(KisIconUtils::loadIcon("applications-system"));
     addPage(page);
     m_performanceSettings = new PerformanceTab(vbox);
 
     // Tablet
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Tablet settings"));
     page->setObjectName("tablet");
     page->setHeader(i18n("Tablet"));
     page->setIcon(KisIconUtils::loadIcon("document-edit"));
     addPage(page);
     m_tabletSettings = new TabletSettingsTab(vbox);
 
     // full-screen mode
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Canvas-only settings"));
     page->setObjectName("canvasonly");
     page->setHeader(i18n("Canvas-only"));
     page->setIcon(KisIconUtils::loadIcon("folder-pictures"));
     addPage(page);
     m_fullscreenSettings = new FullscreenSettingsTab(vbox);
 
     // Author profiles
     m_authorPage = new KoConfigAuthorPage();
     page = addPage(m_authorPage, i18nc("@title:tab Author page", "Author" ));
     page->setObjectName("author");
     page->setHeader(i18n("Author"));
     page->setIcon(KisIconUtils::loadIcon("im-user"));
 
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
 
     connect(this, SIGNAL(accepted()), m_inputConfiguration, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_inputConfiguration, SLOT(revertChanges()));
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     Q_FOREACH (KisAbstractPreferenceSetFactory *preferenceSetFactory, preferenceSetRegistry->values()) {
         KisPreferenceSet* preferenceSet = preferenceSetFactory->createPreferenceSet();
         vbox = new KoVBox();
         page = new KPageWidgetItem(vbox, preferenceSet->name());
         page->setHeader(preferenceSet->header());
         page->setIcon(preferenceSet->icon());
         addPage(page);
         preferenceSet->setParent(vbox);
         preferenceSet->loadPreferences();
 
         connect(restoreDefaultsButton, SIGNAL(clicked(bool)), preferenceSet, SLOT(loadDefaultPreferences()), Qt::UniqueConnection);
         connect(this, SIGNAL(accepted()), preferenceSet, SLOT(savePreferences()), Qt::UniqueConnection);
     }
 
 
     connect(restoreDefaultsButton, SIGNAL(clicked(bool)), this, SLOT(slotDefault()));
 
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
 }
 
 void KisDlgPreferences::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
     KisDlgPreferences* dialog;
 
     dialog = new KisDlgPreferences();
     bool baccept = (dialog->exec() == Accepted);
     if (baccept) {
         // General settings
         KisConfig cfg;
         cfg.setNewCursorStyle(dialog->m_general->cursorStyle());
         cfg.setNewOutlineStyle(dialog->m_general->outlineStyle());
         cfg.setShowRootLayer(dialog->m_general->showRootLayer());
         cfg.setShowOutlineWhilePainting(dialog->m_general->showOutlineWhilePainting());
         cfg.setHideSplashScreen(dialog->m_general->hideSplashScreen());
         cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
-        cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color());
+        cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toQColor());
         cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
         cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
         cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
         cfg.setCompressKra(dialog->m_general->compressKra());
         cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
         cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
         cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
 
         KisPart *part = KisPart::instance();
         if (part) {
             Q_FOREACH (QPointer<KisDocument> doc, part->documents()) {
                 if (doc) {
                     doc->setAutoSave(dialog->m_general->autoSaveInterval());
                     doc->setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
                     doc->undoStack()->setUndoLimit(dialog->m_general->undoStackSize());
                 }
             }
         }
         cfg.setUndoStackLimit(dialog->m_general->undoStackSize());
         cfg.setFavoritePresets(dialog->m_general->favoritePresets());
 
         // Color settings
         cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
                 int currentIndex = dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
                 QString monitorid = dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
                                       dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemHighlighted(),
                                       dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
         cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
         KisImageConfig cfgImage;
-        cfgImage.setDefaultProofingConfig(dialog->m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(), dialog->m_colorSettings->m_page->cmbProofingIntent->currentIndex(), dialog->m_colorSettings->m_page->ckbProofBlackPoint->isChecked(), dialog->m_colorSettings->m_gamutWarning->currentKoColor(), (double)dialog->m_colorSettings->m_page->sldAdaptationState->value()/20);
+        cfgImage.setDefaultProofingConfig(dialog->m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(), dialog->m_colorSettings->m_page->cmbProofingIntent->currentIndex(), dialog->m_colorSettings->m_page->ckbProofBlackPoint->isChecked(), dialog->m_colorSettings->m_page->gamutAlarm->color(), (double)dialog->m_colorSettings->m_page->sldAdaptationState->value()/20);
         cfg.setUseBlackPointCompensation(dialog->m_colorSettings->m_page->chkBlackpoint->isChecked());
         cfg.setAllowLCMSOptimization(dialog->m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
         cfg.setPasteBehaviour(dialog->m_colorSettings->m_pasteBehaviourGroup.checkedId());
         cfg.setRenderIntent(dialog->m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
         cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
 
         dialog->m_performanceSettings->save();
 
         if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
         cfg.setUseOpenGL(dialog->m_displaySettings->grpOpenGL->isChecked());
         cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
         cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
         cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
 
         cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value());
         cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked());
-        cfg.setCheckersColor1(dialog->m_displaySettings->colorChecks1->color());
-        cfg.setCheckersColor2(dialog->m_displaySettings->colorChecks2->color());
-        cfg.setCanvasBorderColor(dialog->m_displaySettings->canvasBorder->color());
+        cfg.setCheckersColor1(dialog->m_displaySettings->colorChecks1->color().toQColor());
+        cfg.setCheckersColor2(dialog->m_displaySettings->colorChecks2->color().toQColor());
+        cfg.setCanvasBorderColor(dialog->m_displaySettings->canvasBorder->color().toQColor());
         cfg.setHideScrollbars(dialog->m_displaySettings->hideScrollbars->isChecked());
-        cfg.setSelectionOverlayMaskColor(dialog->m_displaySettings->m_selectionOverlayColorAction->currentKoColor().toQColor());
+        KoColor c = dialog->m_displaySettings->btnSelectionOverlayColor->color();
+        c.setOpacity(dialog->m_displaySettings->sldSelectionOverlayOpacity->value());
+        cfg.setSelectionOverlayMaskColor(c.toQColor());
         cfg.setAntialiasCurves(dialog->m_displaySettings->chkCurveAntialiasing->isChecked());
         cfg.setAntialiasSelectionOutline(dialog->m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
         cfg.setShowSingleChannelAsColor(dialog->m_displaySettings->chkChannelsAsColor->isChecked());
         cfg.setHidePopups(dialog->m_displaySettings->chkHidePopups->isChecked());
 
         cfg.setHideDockersFullscreen(dialog->m_fullscreenSettings->chkDockers->checkState());
         cfg.setHideMenuFullscreen(dialog->m_fullscreenSettings->chkMenu->checkState());
         cfg.setHideScrollbarsFullscreen(dialog->m_fullscreenSettings->chkScrollbars->checkState());
         cfg.setHideStatusbarFullscreen(dialog->m_fullscreenSettings->chkStatusbar->checkState());
         cfg.setHideTitlebarFullscreen(dialog->m_fullscreenSettings->chkTitlebar->checkState());
         cfg.setHideToolbarFullscreen(dialog->m_fullscreenSettings->chkToolbar->checkState());
 
         dialog->m_authorPage->apply();
 
     }
     delete dialog;
     return baccept;
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_preferences.h b/libs/ui/dialogs/kis_dlg_preferences.h
index ea0449425c..03a31c3737 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.h
+++ b/libs/ui/dialogs/kis_dlg_preferences.h
@@ -1,329 +1,330 @@
 /*
  *  preferencesdlg.h - part of KImageShop^WKrita
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_DLG_PREFERENCES_H_
 #define _KIS_DLG_PREFERENCES_H_
 
 #include <QWidget>
 
 #include <kpagedialog.h>
 #include "KoColorPopupAction.h"
 
 #include "kis_global.h"
+#include "widgets/squeezedcombobox.h"
 
 #include "ui_wdggeneralsettings.h"
 #include "ui_wdgdisplaysettings.h"
 #include "ui_wdgcolorsettings.h"
 #include "ui_wdgtabletsettings.h"
 #include "ui_wdgperformancesettings.h"
 #include "ui_wdgfullscreensettings.h"
 #include "KisShortcutsDialog.h"
 
 class KoID;
 class KisInputConfigurationPage;
 class KoConfigAuthorPage;
 
 /**
  *  "General"-tab for preferences dialog
  */
 
 class WdgGeneralSettings : public QWidget, public Ui::WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
     WdgGeneralSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name);
         setupUi(this);
         chkShowRootLayer->setVisible(false);
     }
 };
 
 class GeneralTab : public WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
 
     GeneralTab(QWidget *parent = 0, const char *name = 0);
 
     CursorStyle cursorStyle();
     OutlineStyle outlineStyle();
 
     bool showRootLayer();
     int autoSaveInterval();
     void setDefault();
     int undoStackSize();
     bool showOutlineWhilePainting();
     bool hideSplashScreen();
     int mdiMode();
     int favoritePresets();
     bool showCanvasMessages();
     bool compressKra();
     bool toolOptionsInDocker();
     bool switchSelectionCtrlAlt();
     bool convertToImageColorspaceOnImport();
 private Q_SLOTS:
     void getBackgroundImage();
     void clearBackgroundImage();
 
 };
 
 
 
 /**
  *  "Shortcuts" tab for preferences dialog
  */
 
 class WdgShortcutSettings : public KisShortcutsDialog
 {
     Q_OBJECT
 
 public:
     WdgShortcutSettings(QWidget *parent)
         : KisShortcutsDialog(KisShortcutsEditor::AllActions,
                              KisShortcutsEditor::LetterShortcutsAllowed,
                              parent)
     { }
 };
 
 class ShortcutSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ShortcutSettingsTab(QWidget *parent = 0, const char *name = 0);
 
 public:
     void setDefault();
     WdgShortcutSettings  *m_page;
 
 
 public Q_SLOTS:
     void saveChanges();
     void revertChanges();
 };
 
 
 
 /**
  *  "Color" tab for preferences dialog
  */
 
 class WdgColorSettings : public QWidget, public Ui::WdgColorSettings
 {
     Q_OBJECT
 
 public:
     WdgColorSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class ColorSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ColorSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 private Q_SLOTS:
 
     void refillMonitorProfiles(const KoID & s);
     void installProfile();
     void toggleAllowMonitorProfileSelection(bool useSystemProfile);
 
 public:
     void setDefault();
     WdgColorSettings  *m_page;
     KoColorPopupAction *m_gamutWarning;
     QButtonGroup m_pasteBehaviourGroup;
     QList<QLabel*> m_monitorProfileLabels;
     QList<SqueezedComboBox*> m_monitorProfileWidgets;
 };
 
 //=======================
 
 class WdgTabletSettings : public QWidget, public Ui::WdgTabletSettings {
 
     Q_OBJECT
 
 public:
     WdgTabletSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 
 };
 
 class TabletSettingsTab : public QWidget {
     Q_OBJECT
 public:
     TabletSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 public:
     void setDefault();
     WdgTabletSettings  *m_page;
 
 
 };
 
 //=======================
 
 /**
   * "Performance"-tab for preferences dialog
  */
 
 class SliderAndSpinBoxSync;
 
 class WdgPerformanceSettings : public QWidget, public Ui::WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     WdgPerformanceSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 class PerformanceTab : public WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     PerformanceTab(QWidget *parent = 0, const char *name = 0);
 
     ~PerformanceTab();
 
     void load(bool requestDefault);
     void save();
 
 private Q_SLOTS:
 
     void selectSwapDir();
 
 private:
     int realTilesRAM();
 
 private:
     QVector<SliderAndSpinBoxSync*> m_syncs;
 };
 
 //=======================
 
 class WdgDisplaySettings : public QWidget, public Ui::WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     WdgDisplaySettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 /**
  *  Display settings tab for preferences dialog
  */
 
 class KoColorPopupAction;
 
 class DisplaySettingsTab : public WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     DisplaySettingsTab(QWidget *parent = 0, const char *name = 0);
 
 public:
     void setDefault();
 protected Q_SLOTS:
     void slotUseOpenGLToggled(bool isChecked);
 
 public:
     KoColorPopupAction *m_selectionOverlayColorAction;
 };
 
 //=======================
 
 /**
  *  Full screen settings tab for preferences dialog
  */
 
 class WdgFullscreenSettingsBase : public QWidget, public Ui::WdgFullscreenSettings
 {
     Q_OBJECT
 
 public:
     WdgFullscreenSettingsBase(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class FullscreenSettingsTab : public WdgFullscreenSettingsBase
 {
     Q_OBJECT
 public:
     FullscreenSettingsTab(QWidget *parent);
 public:
     void setDefault();
 };
 
 
 //=======================
 
 
 /**
  *  Preferences dialog of KImageShop^WKrayon^WKrita
  */
 class KisDlgPreferences : public KPageDialog
 {
     Q_OBJECT
 
 public:
 
     static bool editPreferences();
 
 
 protected:
 
     KisDlgPreferences(QWidget *parent = 0, const char *name = 0);
     ~KisDlgPreferences();
 
 protected:
 
     GeneralTab *m_general;
     ShortcutSettingsTab  *m_shortcutSettings;
     ColorSettingsTab *m_colorSettings;
     PerformanceTab *m_performanceSettings;
     DisplaySettingsTab  *m_displaySettings;
     TabletSettingsTab *m_tabletSettings;
     FullscreenSettingsTab *m_fullscreenSettings;
     KisInputConfigurationPage *m_inputConfiguration;
     KoConfigAuthorPage *m_authorPage;
 
 protected Q_SLOTS:
 
     void slotDefault();
 
 };
 
 #endif
diff --git a/libs/ui/forms/wdgautogradient.ui b/libs/ui/forms/wdgautogradient.ui
index e6c2ee7608..cb25376aec 100644
--- a/libs/ui/forms/wdgautogradient.ui
+++ b/libs/ui/forms/wdgautogradient.ui
@@ -1,390 +1,389 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>KisWdgAutogradient</class>
  <widget class="QWidget" name="KisWdgAutogradient">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>500</width>
     <height>250</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>500</width>
     <height>250</height>
    </size>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Name:</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QLineEdit" name="nameedit"/>
      </item>
     </layout>
    </item>
    <item>
     <widget class="KisGradientSliderWidget" name="gradientSlider" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
        <horstretch>0</horstretch>
        <verstretch>1</verstretch>
       </sizepolicy>
      </property>
      <property name="focusPolicy">
       <enum>Qt::ClickFocus</enum>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout">
      <item row="0" column="0" colspan="2">
       <widget class="QLabel" name="textLabel1">
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="text">
         <string>Segment Color</string>
        </property>
       </widget>
      </item>
      <item row="0" column="2">
       <widget class="QLabel" name="textLabel2">
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="text">
         <string>Opacity:</string>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="labelLeftColor">
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="text">
         <string>Left:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
-      <widget class="KColorButton" name="leftColorButton">
+      <widget class="KisColorButton" name="leftColorButton">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>30</height>
         </size>
        </property>
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="focusPolicy">
         <enum>Qt::ClickFocus</enum>
        </property>
       </widget>
      </item>
      <item row="1" column="2">
       <widget class="KisIntParseSpinBox" name="intNumInputLeftOpacity">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="focusPolicy">
         <enum>Qt::ClickFocus</enum>
        </property>
        <property name="maximum">
         <number>100</number>
        </property>
        <property name="value">
         <number>100</number>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="labelRightColor">
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="text">
         <string>Right:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
-      <widget class="KColorButton" name="rightColorButton">
+      <widget class="KisColorButton" name="rightColorButton">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>30</height>
         </size>
        </property>
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="focusPolicy">
         <enum>Qt::ClickFocus</enum>
        </property>
        <property name="color" stdset="0">
         <color>
          <red>255</red>
          <green>255</green>
          <blue>255</blue>
         </color>
        </property>
        <property name="defaultColor" stdset="0">
         <color>
          <red>255</red>
          <green>255</green>
          <blue>255</blue>
         </color>
        </property>
       </widget>
      </item>
      <item row="2" column="2">
       <widget class="KisIntParseSpinBox" name="intNumInputRightOpacity">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Ignored">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="focusPolicy">
         <enum>Qt::ClickFocus</enum>
        </property>
        <property name="maximum">
         <number>100</number>
        </property>
        <property name="value">
         <number>100</number>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QHBoxLayout">
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item>
       <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="QComboBox" name="comboBoxInterpolationType">
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="focusPolicy">
         <enum>Qt::ClickFocus</enum>
        </property>
        <item>
         <property name="text">
          <string>Linear</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Curved</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Sine</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Sphere Inc.</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Sphere Dec.</string>
         </property>
        </item>
       </widget>
      </item>
      <item>
       <widget class="QComboBox" name="comboBoxColorInterpolationType">
        <property name="font">
         <font>
          <family>Sans Serif</family>
          <pointsize>9</pointsize>
          <weight>50</weight>
          <italic>false</italic>
          <bold>false</bold>
          <underline>false</underline>
          <strikeout>false</strikeout>
         </font>
        </property>
        <property name="focusPolicy">
         <enum>Qt::ClickFocus</enum>
        </property>
        <item>
         <property name="text">
          <string>RGB</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>HSV CW</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>HSV CCW</string>
         </property>
        </item>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
-   <class>KColorButton</class>
+   <class>KisColorButton</class>
    <extends>QPushButton</extends>
-   <header>kcolorbutton.h</header>
-   <container>1</container>
+   <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisGradientSliderWidget</class>
    <extends></extends>
    <header>widgets/kis_gradient_slider_widget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgcolorsettings.ui b/libs/ui/forms/wdgcolorsettings.ui
index e06a24f2ea..c51dc04f02 100644
--- a/libs/ui/forms/wdgcolorsettings.ui
+++ b/libs/ui/forms/wdgcolorsettings.ui
@@ -1,389 +1,389 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgColorSettings</class>
  <widget class="QWidget" name="WdgColorSettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>586</width>
     <height>613</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Color Settings</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_4">
    <item>
     <layout class="QHBoxLayout">
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item>
       <widget class="QLabel" name="textLabel1_2">
        <property name="text">
         <string>Default color model for new images:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KisCmbIDList" name="cmbWorkingColorSpace">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>20</height>
         </size>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QGroupBox" name="grpDisplay">
      <property name="title">
       <string>Display</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <item>
        <widget class="QCheckBox" name="chkUseSystemMonitorProfile">
         <property name="text">
          <string>Use system monitor profile</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <item>
          <widget class="QWidget" name="monitorprofileholder" native="true"/>
         </item>
        </layout>
       </item>
       <item>
        <layout class="QHBoxLayout">
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <item>
          <widget class="QLabel" name="lblRenderingIntent">
           <property name="toolTip">
            <string>The icm profile for your calibrated monitor</string>
           </property>
           <property name="text">
            <string>&amp;Rendering intent:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="buddy">
            <cstring>cmbMonitorIntent</cstring>
           </property>
          </widget>
         </item>
         <item>
          <widget class="KComboBox" name="cmbMonitorIntent">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <item>
            <property name="text">
             <string>Perceptual</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Relative Colorimetric</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Saturation</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Absolute Colorimetric</string>
            </property>
           </item>
          </widget>
         </item>
        </layout>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_2">
         <item>
          <widget class="QLabel" name="label_2">
           <property name="text">
            <string>Add new color profile:</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QPushButton" name="bnAddColorProfile">
           <property name="maximumSize">
            <size>
             <width>24</width>
             <height>24</height>
            </size>
           </property>
           <property name="text">
            <string/>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="grpProofingOptions">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="title">
       <string>Soft Proof Options</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
-      <item row="5" column="1">
-       <widget class="QToolButton" name="gamutAlarm">
-        <property name="text">
-         <string>...</string>
-        </property>
-       </widget>
-      </item>
       <item row="3" column="0">
        <widget class="QLabel" name="lblProofingIntent">
         <property name="text">
          <string>Proofing Rendering Intent:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0" colspan="4">
        <widget class="KisColorSpaceSelector" name="proofingSpaceSelector" native="true"/>
       </item>
       <item row="5" column="2" colspan="2">
        <widget class="QCheckBox" name="ckbProofBlackPoint">
         <property name="text">
          <string>Black Point Compensation</string>
         </property>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="QLabel" name="lblGamutWarning">
         <property name="text">
          <string>Gamut Warning:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="3" column="1" colspan="3">
        <widget class="QComboBox" name="cmbProofingIntent">
         <item>
          <property name="text">
           <string>Perceptual</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Relative Colorimetric</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Saturation</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Absolute Colorimetric</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="4" column="1" colspan="3">
        <widget class="QSlider" name="sldAdaptationState">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QLabel" name="lblAdaptationState">
         <property name="text">
          <string>Adaptation State:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
+      <item row="5" column="1">
+       <widget class="KisColorButton" name="gamutAlarm">
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="grpPasteBehaviour">
      <property name="title">
       <string>When Pasting Into Krita From Other Applications</string>
      </property>
      <layout class="QVBoxLayout">
       <item>
        <widget class="QRadioButton" name="radioPasteWeb">
         <property name="text">
          <string>Assume sRGB (like images from the web are supposed to be seen)</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QRadioButton" name="radioPasteMonitor">
         <property name="text">
          <string>Assume monitor profile (like you see it in the other application)</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QRadioButton" name="radioPasteAsk">
         <property name="text">
          <string>Ask each time</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QLabel" name="textLabel1_2_2">
         <property name="text">
          <string>Note: When copying/pasting inside Krita color info is always preserved.</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <layout class="QVBoxLayout">
      <property name="spacing">
       <number>6</number>
      </property>
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item>
       <widget class="QCheckBox" name="chkBlackpoint">
        <property name="text">
         <string>Use Blackpoint Compensation</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QCheckBox" name="chkAllowLCMSOptimization">
        <property name="text">
         <string>Allow Little CMS optimizations (uncheck when using linear light RGB or XYZ)</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <spacer>
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Expanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>16</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
+  <customwidget>
+   <class>KisColorButton</class>
+   <extends>QPushButton</extends>
+   <header>kis_color_button.h</header>
+  </customwidget>
   <customwidget>
    <class>KisColorSpaceSelector</class>
    <extends>QWidget</extends>
    <header>widgets/kis_color_space_selector.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KComboBox</class>
    <extends>QComboBox</extends>
    <header>kcombobox.h</header>
   </customwidget>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends>QComboBox</extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
-  <customwidget>
-   <class>SqueezedComboBox</class>
-   <extends>QComboBox</extends>
-   <header>widgets/squeezedcombobox.h</header>
-  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgdisplaysettings.ui b/libs/ui/forms/wdgdisplaysettings.ui
index 0bbd7ed23a..deb5017970 100644
--- a/libs/ui/forms/wdgdisplaysettings.ui
+++ b/libs/ui/forms/wdgdisplaysettings.ui
@@ -1,360 +1,362 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgDisplaySettings</class>
  <widget class="QWidget" name="WdgDisplaySettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>504</width>
     <height>685</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="windowTitle">
    <string>Display</string>
   </property>
   <layout class="QGridLayout">
    <item row="4" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Miscellaneous</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QCheckBox" name="chkChannelsAsColor">
         <property name="text">
          <string>Color channels in color</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="chkCurveAntialiasing">
         <property name="text">
          <string>Enable curve anti-aliasing</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="chkSelectionOutlineAntialiasing">
         <property name="text">
          <string>Enable selection outline anti-aliasing</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="chkHidePopups">
         <property name="text">
          <string>Hide layer thumbnail popup</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QGroupBox" name="grpCheckers">
      <property name="title">
       <string>Transparency Checkerboard Pattern</string>
      </property>
      <layout class="QGridLayout">
       <item row="0" column="0">
        <widget class="QLabel" name="lblCheckSize">
         <property name="text">
          <string>S&amp;ize:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>intCheckSize</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="KisIntParseSpinBox" name="intCheckSize">
         <property name="suffix">
          <string> px</string>
         </property>
         <property name="maximum">
          <number>256</number>
         </property>
         <property name="value">
          <number>32</number>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <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 row="0" column="3">
        <widget class="QLabel" name="lblColor">
         <property name="text">
          <string>Colors:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="4">
-       <widget class="KColorButton" name="colorChecks1"/>
+       <widget class="KisColorButton" name="colorChecks1"/>
       </item>
       <item row="0" column="5">
-       <widget class="KColorButton" name="colorChecks2"/>
+       <widget class="KisColorButton" name="colorChecks2"/>
       </item>
       <item row="0" column="6">
        <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 row="1" column="0" colspan="3">
        <widget class="QCheckBox" name="chkMoving">
         <property name="toolTip">
          <string>If checked, the checkers will move when scrolling the canvas.</string>
         </property>
         <property name="whatsThis">
          <string>Determines whether the checks will stay put or whether they will scroll together with the canvas</string>
         </property>
         <property name="text">
          <string>&amp;Move checkers when scrolling</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="5" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="0" column="0">
     <widget class="QGroupBox" name="grpOpenGL">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Open&amp;GL</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout">
       <item row="0" column="1">
        <widget class="QComboBox" name="cmbFilterMode">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="currentIndex">
          <number>0</number>
         </property>
         <item>
          <property name="text">
           <string>Nearest Neighbour</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Bilinear Filtering</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Trilinear Filtering</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>High Quality Filtering</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QCheckBox" name="chkDisableVsync">
         <property name="toolTip">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Try to disable vsync for Krita. This makes painting more responsive. Uncheck only when experiencing crashes with some GPU/driver combinations.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="text">
          <string>Disable vsync (needs restart)</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QCheckBox" name="chkUseTextureBuffer">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Use Texture Buffering. This can be faster on some GPU/Driver combinations (like Intel) or broken on some others (like AMD/Radeon).&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="text">
          <string>Use texture buffer</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="label">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Scaling Mode:</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QGroupBox" name="grpCanvasBorder">
      <property name="title">
       <string>Canvas border</string>
      </property>
      <layout class="QGridLayout">
       <item row="1" column="0">
        <widget class="QLabel" name="lblCanvasBorderColor">
         <property name="text">
          <string>Color:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
-       <widget class="KColorButton" name="canvasBorder"/>
+       <widget class="KisColorButton" name="canvasBorder"/>
       </item>
       <item row="1" column="2">
        <spacer name="horizontalSpacer_4">
         <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 row="2" column="0" colspan="3">
        <widget class="QCheckBox" name="hideScrollbars">
         <property name="text">
          <string>Hide Scrollbars</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="2" column="0">
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>Selection Overlay</string>
      </property>
      <layout class="QHBoxLayout" name="horizontalLayout">
       <item>
        <widget class="QLabel" name="label_2">
         <property name="text">
          <string>Color:</string>
         </property>
        </widget>
       </item>
       <item>
-       <widget class="QToolButton" name="btnSelectionOverlayColor">
+       <widget class="KisColorButton" name="btnSelectionOverlayColor">
         <property name="text">
-         <string>...</string>
+         <string/>
         </property>
        </widget>
       </item>
       <item>
-       <spacer name="horizontalSpacer_3">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
-        </property>
-        <property name="sizeHint" stdset="0">
-         <size>
-          <width>358</width>
-          <height>20</height>
-         </size>
+       <widget class="KisDoubleSliderSpinBox" name="sldSelectionOverlayOpacity" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
         </property>
-       </spacer>
+       </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
-   <class>KColorButton</class>
+   <class>KisColorButton</class>
    <extends>QPushButton</extends>
-   <header>kcolorbutton.h</header>
+   <header>kis_color_button.h</header>
+  </customwidget>
+  <customwidget>
+   <class>KisDoubleSliderSpinBox</class>
+   <extends>QWidget</extends>
+   <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdggeneralsettings.ui b/libs/ui/forms/wdggeneralsettings.ui
index d38056e557..5093ea32d6 100644
--- a/libs/ui/forms/wdggeneralsettings.ui
+++ b/libs/ui/forms/wdggeneralsettings.ui
@@ -1,715 +1,714 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgGeneralSettings</class>
  <widget class="QWidget" name="WdgGeneralSettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>552</width>
     <height>295</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>552</width>
     <height>295</height>
    </size>
   </property>
   <property name="layoutDirection">
    <enum>Qt::LeftToRight</enum>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
-      <number>3</number>
+      <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Cursor</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_2">
        <item row="1" column="0">
         <layout class="QFormLayout" name="formLayout_2">
          <property name="horizontalSpacing">
           <number>10</number>
          </property>
          <property name="verticalSpacing">
           <number>10</number>
          </property>
          <property name="leftMargin">
           <number>10</number>
          </property>
          <property name="topMargin">
           <number>10</number>
          </property>
          <property name="rightMargin">
           <number>10</number>
          </property>
          <property name="bottomMargin">
           <number>10</number>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="textLabel1">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Cursor Shape:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="m_cmbCursorShape"/>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="textLabel1_2">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Outline Shape:</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="m_cmbOutlineShape"/>
          </item>
          <item row="2" column="1">
           <widget class="QCheckBox" name="m_showOutlinePainting">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>200</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Show brush outline while painting</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="1" column="1">
         <spacer name="horizontalSpacer_5">
          <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 row="2" column="0">
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_3">
       <attribute name="title">
        <string>Window</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_3">
        <item row="2" column="0">
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="1" column="0">
         <layout class="QGridLayout" name="gridLayout_6">
          <property name="leftMargin">
           <number>10</number>
          </property>
          <property name="topMargin">
           <number>10</number>
          </property>
          <property name="rightMargin">
           <number>10</number>
          </property>
          <property name="bottomMargin">
           <number>10</number>
          </property>
          <property name="spacing">
           <number>10</number>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="label_2">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Multiple Document Mode:</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_4">
            <property name="text">
             <string>Window Background:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout" stretch="0,0,0">
            <item>
             <widget class="QLabel" name="m_backgroundimage">
              <property name="minimumSize">
               <size>
                <width>200</width>
                <height>0</height>
               </size>
              </property>
              <property name="frameShape">
               <enum>QFrame::StyledPanel</enum>
              </property>
              <property name="frameShadow">
               <enum>QFrame::Sunken</enum>
              </property>
              <property name="text">
               <string/>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QToolButton" name="m_bnFileName">
              <property name="text">
               <string>...</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QPushButton" name="clearBgImageButton">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string>Clear</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="2" column="1">
-          <widget class="KColorButton" name="m_mdiColor">
+          <widget class="KisColorButton" name="m_mdiColor">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string/>
            </property>
            <property name="color" stdset="0">
             <color>
              <red>0</red>
              <green>0</green>
              <blue>0</blue>
             </color>
            </property>
            <property name="defaultColor" stdset="0">
             <color>
              <red>0</red>
              <green>0</green>
              <blue>0</blue>
             </color>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_5">
            <property name="text">
             <string>Background Image (overrides color):</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="m_cmbMDIType">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="currentIndex">
             <number>1</number>
            </property>
            <item>
             <property name="text">
              <string>Subwindows</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Tabs</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="3" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_2">
            <item>
             <widget class="QCheckBox" name="m_chkRubberBand">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string/>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="label_6">
              <property name="text">
               <string>Don't show contents when moving sub-windows</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>
           </layout>
          </item>
          <item row="4" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_3">
            <item>
             <widget class="QCheckBox" name="m_chkCanvasMessages">
              <property name="text">
               <string/>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="label_7">
              <property name="text">
               <string>Show on-canvas popup messages:</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>
           </layout>
          </item>
         </layout>
        </item>
        <item row="1" column="1">
         <spacer name="horizontalSpacer_4">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>40</width>
            <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="Tools">
       <attribute name="title">
        <string>Tools</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_4">
        <item row="1" column="1">
         <layout class="QVBoxLayout" name="verticalLayout">
          <property name="spacing">
           <number>10</number>
          </property>
          <property name="leftMargin">
           <number>10</number>
          </property>
          <property name="topMargin">
           <number>10</number>
          </property>
          <property name="rightMargin">
           <number>10</number>
          </property>
          <property name="bottomMargin">
           <number>10</number>
          </property>
          <item>
           <widget class="QGroupBox" name="groupBox_4">
            <property name="title">
             <string>Tool Options Location (needs restart)</string>
            </property>
            <layout class="QVBoxLayout" name="verticalLayout_3">
             <item>
              <widget class="QRadioButton" name="m_radioToolOptionsInDocker">
               <property name="text">
                <string>In Doc&amp;ker</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QRadioButton" name="m_radioToolOptionsInToolbar">
               <property name="text">
                <string>In Tool&amp;bar</string>
               </property>
               <property name="checked">
                <bool>true</bool>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="m_chkSwitchSelectionCtrlAlt">
            <property name="text">
             <string>Switch Control/Alt Selection Modifiers</string>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="verticalSpacer_2">
            <property name="orientation">
             <enum>Qt::Vertical</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>20</width>
              <height>40</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item row="1" column="2">
         <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>
       </layout>
      </widget>
      <widget class="QWidget" name="Miscellaneous">
       <attribute name="title">
        <string>Miscellaneous</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_5">
        <item row="0" column="0">
         <layout class="QGridLayout" name="gridLayout_7">
          <property name="leftMargin">
           <number>10</number>
          </property>
          <property name="topMargin">
           <number>10</number>
          </property>
          <property name="rightMargin">
           <number>10</number>
          </property>
          <property name="bottomMargin">
           <number>10</number>
          </property>
          <property name="spacing">
           <number>10</number>
          </property>
          <item row="0" column="0">
           <widget class="QCheckBox" name="m_autosaveCheckBox">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="layoutDirection">
             <enum>Qt::RightToLeft</enum>
            </property>
            <property name="text">
             <string>Autosave every:</string>
            </property>
            <property name="checked">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Undo stack size:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QCheckBox" name="m_chkCompressKra">
            <property name="text">
             <string>Compress .kra files more (slows loading/saving)</string>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="QCheckBox" name="m_backupFileCheckBox">
            <property name="text">
             <string>Create backup file </string>
            </property>
           </widget>
          </item>
          <item row="5" column="1">
           <widget class="KisIntParseSpinBox" name="m_favoritePresetsSpinBox">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>75</width>
              <height>0</height>
             </size>
            </property>
            <property name="minimum">
             <number>10</number>
            </property>
            <property name="maximum">
             <number>30</number>
            </property>
           </widget>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="label_3">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Favorite presets:</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="m_autosaveSpinBox">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>75</width>
              <height>0</height>
             </size>
            </property>
            <property name="suffix">
             <string> min</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>1440</number>
            </property>
            <property name="singleStep">
             <number>5</number>
            </property>
            <property name="value">
             <number>15</number>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="KisIntParseSpinBox" name="m_undoStackSize">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>75</width>
              <height>0</height>
             </size>
            </property>
            <property name="minimum">
             <number>0</number>
            </property>
            <property name="maximum">
             <number>1000</number>
            </property>
            <property name="singleStep">
             <number>5</number>
            </property>
            <property name="value">
             <number>30</number>
            </property>
           </widget>
          </item>
          <item row="6" column="1">
           <widget class="QCheckBox" name="chkShowRootLayer">
            <property name="text">
             <string>Show root layer</string>
            </property>
           </widget>
          </item>
          <item row="7" column="1">
           <widget class="QCheckBox" name="m_hideSplashScreen">
            <property name="text">
             <string>Hide splash screen on startup</string>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="QCheckBox" name="m_chkConvertOnImport">
            <property name="text">
             <string>On importing images as layers, convert to the image colorspace</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="1" column="0">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item row="1" column="0">
     <spacer name="verticalSpacer_5">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
-   <class>KColorButton</class>
+   <class>KisColorButton</class>
    <extends>QPushButton</extends>
-   <header>kcolorbutton.h</header>
-   <container>1</container>
+   <header>kis_color_button.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgnewimage.ui b/libs/ui/forms/wdgnewimage.ui
index 4d5ee82786..c4841f5ac0 100644
--- a/libs/ui/forms/wdgnewimage.ui
+++ b/libs/ui/forms/wdgnewimage.ui
@@ -1,698 +1,697 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgNewImage</class>
  <widget class="QWidget" name="WdgNewImage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>600</width>
     <height>422</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>600</width>
     <height>0</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>New Image</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Dimensions</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_3">
        <item row="1" column="0">
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <widget class="QGroupBox" name="grpImage">
            <property name="minimumSize">
             <size>
              <width>0</width>
              <height>140</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>16777215</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="title">
             <string>Image Size</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
            </property>
            <property name="flat">
             <bool>false</bool>
            </property>
            <property name="checkable">
             <bool>false</bool>
            </property>
            <layout class="QGridLayout" name="gridLayout">
             <item row="1" column="0">
              <layout class="QHBoxLayout" name="horizontalLayout">
               <item>
                <widget class="QLabel" name="label_2">
                 <property name="text">
                  <string>P&amp;redefined:</string>
                 </property>
                 <property name="alignment">
                  <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                 </property>
                 <property name="buddy">
                  <cstring>cmbPredefined</cstring>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QComboBox" name="cmbPredefined">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QLabel" name="label_3">
                 <property name="text">
                  <string>Save As:</string>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QLineEdit" name="txtPredefinedName">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QPushButton" name="bnSaveAsPredefined">
                 <property name="toolTip">
                  <string>Save the current dimensions</string>
                 </property>
                 <property name="text">
                  <string>&amp;Save</string>
                 </property>
                </widget>
               </item>
              </layout>
             </item>
             <item row="2" column="0">
              <layout class="QHBoxLayout">
               <item>
                <layout class="QGridLayout" name="gridLayout_4">
                 <item row="0" column="3">
                  <widget class="QToolButton" name="bnLandscape">
                   <property name="toolTip">
                    <string>Landscape</string>
                   </property>
                   <property name="text">
                    <string>...</string>
                   </property>
                   <property name="checkable">
                    <bool>true</bool>
                   </property>
                   <property name="autoExclusive">
                    <bool>true</bool>
                   </property>
                   <property name="autoRaise">
                    <bool>true</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="KisDoubleParseSpinBox" name="doubleWidth">
                   <property name="decimals">
                    <number>2</number>
                   </property>
                   <property name="minimum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>100000000.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="0">
                  <widget class="QLabel" name="lblHeight">
                   <property name="text">
                    <string>&amp;Height:</string>
                   </property>
                   <property name="alignment">
                    <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                   </property>
                   <property name="buddy">
                    <cstring>doubleHeight</cstring>
                   </property>
                  </widget>
                 </item>
                 <item row="2" column="1">
                  <widget class="KisDoubleParseSpinBox" name="doubleResolution">
                   <property name="decimals">
                    <number>0</number>
                   </property>
                   <property name="minimum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>9999.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="2" column="0">
                  <widget class="QLabel" name="lblResolution">
                   <property name="text">
                    <string>Resolution:</string>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="1">
                  <widget class="KisDoubleParseSpinBox" name="doubleHeight">
                   <property name="minimum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>100000000.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="2">
                  <widget class="QComboBox" name="cmbWidthUnit"/>
                 </item>
                 <item row="1" column="2">
                  <widget class="QComboBox" name="cmbHeightUnit"/>
                 </item>
                 <item row="2" column="2">
                  <widget class="QLabel" name="label">
                   <property name="toolTip">
                    <string>pixels-per-inch</string>
                   </property>
                   <property name="text">
                    <string>ppi</string>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="0">
                  <widget class="QLabel" name="lblWidth">
                   <property name="text">
                    <string>W&amp;idth:</string>
                   </property>
                   <property name="alignment">
                    <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                   </property>
                   <property name="buddy">
                    <cstring>doubleWidth</cstring>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="4">
                  <widget class="QToolButton" name="bnPortrait">
                   <property name="toolTip">
                    <string>Portrait</string>
                   </property>
                   <property name="text">
                    <string>...</string>
                   </property>
                   <property name="checkable">
                    <bool>true</bool>
                   </property>
                   <property name="checked">
                    <bool>true</bool>
                   </property>
                   <property name="autoExclusive">
                    <bool>true</bool>
                   </property>
                   <property name="autoRaise">
                    <bool>true</bool>
                   </property>
                  </widget>
                 </item>
                </layout>
               </item>
               <item>
                <layout class="QVBoxLayout" name="orientationLayout"/>
               </item>
               <item>
                <spacer>
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
                 </property>
                 <property name="sizeType">
                  <enum>QSizePolicy::Expanding</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>191</width>
                   <height>61</height>
                  </size>
                 </property>
                </spacer>
               </item>
              </layout>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <widget class="QGroupBox" name="grpClipboard">
            <property name="title">
             <string>Clipboard</string>
            </property>
            <layout class="QVBoxLayout" name="verticalLayout_2">
             <item>
              <widget class="QLabel" name="lblPreview">
               <property name="maximumSize">
                <size>
                 <width>75</width>
                 <height>75</height>
                </size>
               </property>
               <property name="baseSize">
                <size>
                 <width>250</width>
                 <height>250</height>
                </size>
               </property>
               <property name="frameShape">
                <enum>QFrame::StyledPanel</enum>
               </property>
               <property name="text">
                <string>TextLabel</string>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="imageGroupSpacer">
               <property name="orientation">
                <enum>Qt::Vertical</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>20</width>
                 <height>40</height>
                </size>
               </property>
              </spacer>
             </item>
            </layout>
           </widget>
          </item>
         </layout>
        </item>
        <item row="0" column="0">
         <layout class="QHBoxLayout">
          <item>
           <widget class="QLabel" name="lblName">
            <property name="text">
             <string>&amp;Name:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>txtName</cstring>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLineEdit" name="txtName">
            <property name="text">
             <string>untitled-1</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="2" column="0">
         <widget class="QGroupBox" name="grpMode">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="title">
           <string>Color</string>
          </property>
          <layout class="QVBoxLayout">
           <item>
            <widget class="KisColorSpaceSelector" name="colorSpaceSelector" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Content</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_2">
        <item row="1" column="1">
         <widget class="QLabel" name="label_4">
          <property name="text">
           <string>Layers:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="3" column="1">
         <widget class="QLabel" name="lblOpacity">
          <property name="text">
           <string>Ima&amp;ge Background Opacity:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
          <property name="buddy">
           <cstring>sliderOpacity</cstring>
          </property>
         </widget>
        </item>
        <item row="1" column="2">
         <widget class="KisIntParseSpinBox" name="intNumLayers">
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="minimum">
           <number>1</number>
          </property>
          <property name="maximum">
           <number>200</number>
          </property>
          <property name="value">
           <number>2</number>
          </property>
         </widget>
        </item>
        <item row="2" column="1">
         <widget class="QLabel" name="lblColor">
          <property name="text">
           <string>&amp;Image Background Color:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
          <property name="buddy">
           <cstring>cmbColor</cstring>
          </property>
         </widget>
        </item>
        <item row="4" column="1">
         <widget class="QLabel" name="lblBackgroundStyle">
          <property name="text">
           <string>Background:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
          </property>
         </widget>
        </item>
        <item row="5" column="1">
         <widget class="QLabel" name="lblDescription">
          <property name="text">
           <string>&amp;Description:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
          </property>
          <property name="buddy">
           <cstring>txtDescription</cstring>
          </property>
         </widget>
        </item>
        <item row="5" column="2">
         <widget class="QTextEdit" name="txtDescription">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>16777215</width>
            <height>100</height>
           </size>
          </property>
         </widget>
        </item>
        <item row="4" column="2">
         <layout class="QVBoxLayout" name="verticalLayout_3">
          <item>
           <widget class="QRadioButton" name="radioBackgroundAsLayer">
            <property name="text">
             <string>As fi&amp;rst layer</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QRadioButton" name="radioBackgroundAsProjection">
            <property name="text">
             <string>As ca&amp;nvas color</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="2" column="2">
-        <widget class="KColorButton" name="cmbColor">
+        <widget class="KisColorButton" name="cmbColor">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>50</width>
            <height>0</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Reset the image background color in the Image Properties dialog</string>
          </property>
          <property name="color" stdset="0">
           <color>
            <red>255</red>
            <green>255</green>
            <blue>255</blue>
           </color>
          </property>
          <property name="defaultColor" stdset="0">
           <color>
            <red>255</red>
            <green>255</green>
            <blue>255</blue>
           </color>
          </property>
         </widget>
        </item>
        <item row="3" column="2">
         <widget class="QFrame" name="opacityPanel">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Plain</enum>
          </property>
          <layout class="QHBoxLayout" name="_2">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <widget class="KisDoubleSliderSpinBox" name="sliderOpacity" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
        <item row="6" column="2">
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
       <zorder>label_4</zorder>
       <zorder>lblBackgroundStyle</zorder>
       <zorder>txtDescription</zorder>
       <zorder>lblDescription</zorder>
       <zorder>intNumLayers</zorder>
       <zorder>opacityPanel</zorder>
       <zorder>lblColor</zorder>
       <zorder>cmbColor</zorder>
       <zorder>lblOpacity</zorder>
      </widget>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Expanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>10</width>
        <height>10</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <layout class="QHBoxLayout">
      <item>
       <spacer>
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::Expanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>480</width>
          <height>10</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QPushButton" name="createButton">
        <property name="text">
         <string>&amp;Create</string>
        </property>
        <property name="autoDefault">
         <bool>true</bool>
        </property>
        <property name="default">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>KisColorSpaceSelector</class>
-   <extends>QWidget</extends>
-   <header>widgets/kis_color_space_selector.h</header>
-   <container>1</container>
-  </customwidget>
-  <customwidget>
-   <class>KisDoubleParseSpinBox</class>
-   <extends>QDoubleSpinBox</extends>
-   <header>kis_double_parse_spin_box.h</header>
+   <class>KisIntParseSpinBox</class>
+   <extends>QSpinBox</extends>
+   <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
-   <class>KColorButton</class>
+   <class>KisColorButton</class>
    <extends>QPushButton</extends>
-   <header>kcolorbutton.h</header>
-   <container>1</container>
+   <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisIntParseSpinBox</class>
-   <extends>QSpinBox</extends>
-   <header>kis_int_parse_spin_box.h</header>
+   <class>KisColorSpaceSelector</class>
+   <extends>QWidget</extends>
+   <header>widgets/kis_color_space_selector.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>KisDoubleParseSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>kis_double_parse_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>tabWidget</tabstop>
   <tabstop>txtName</tabstop>
   <tabstop>cmbPredefined</tabstop>
   <tabstop>txtPredefinedName</tabstop>
   <tabstop>bnSaveAsPredefined</tabstop>
   <tabstop>doubleWidth</tabstop>
   <tabstop>doubleHeight</tabstop>
   <tabstop>doubleResolution</tabstop>
   <tabstop>cmbWidthUnit</tabstop>
   <tabstop>cmbHeightUnit</tabstop>
   <tabstop>bnLandscape</tabstop>
   <tabstop>bnPortrait</tabstop>
   <tabstop>createButton</tabstop>
   <tabstop>intNumLayers</tabstop>
   <tabstop>cmbColor</tabstop>
   <tabstop>radioBackgroundAsLayer</tabstop>
   <tabstop>radioBackgroundAsProjection</tabstop>
   <tabstop>txtDescription</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/kis_autogradient.cc b/libs/ui/kis_autogradient.cc
index 733a8ce970..8786ee5e94 100644
--- a/libs/ui/kis_autogradient.cc
+++ b/libs/ui/kis_autogradient.cc
@@ -1,177 +1,171 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *                2004 Sven Langkamp <sven.langkamp@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_autogradient.h"
 #include <QPainter>
 #include <QComboBox>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
 
 #include <KoColorSpace.h>
 #include <resources/KoSegmentGradient.h>
 
 #include "kis_debug.h"
 
 #include "widgets/kis_gradient_slider_widget.h"
 
 /****************************** KisAutogradient ******************************/
 
 KisAutogradient::KisAutogradient(KoSegmentGradient* gradient, QWidget *parent, const char* name, const QString& caption)
     : QWidget(parent), m_autogradientResource(gradient)
 {
     setObjectName(name);
     setupUi(this);
     setWindowTitle(caption);
     gradientSlider->setGradientResource(m_autogradientResource);
     nameedit->setText(gradient->name());
     KoGradientSegment* segment = gradientSlider->selectedSegment();
     if (segment) {
         slotSelectedSegment(segment);
     }
 
     connect(nameedit, SIGNAL(editingFinished()), this, SLOT(slotChangedName()));
     connect(gradientSlider, SIGNAL(sigSelectedSegment(KoGradientSegment*)), SLOT(slotSelectedSegment(KoGradientSegment*)));
     connect(gradientSlider, SIGNAL(sigChangedSegment(KoGradientSegment*)), SLOT(slotChangedSegment(KoGradientSegment*)));
     connect(comboBoxColorInterpolationType, SIGNAL(activated(int)), SLOT(slotChangedColorInterpolation(int)));
     connect(comboBoxInterpolationType, SIGNAL(activated(int)), SLOT(slotChangedInterpolation(int)));
-    connect(leftColorButton, SIGNAL(changed(const QColor&)), SLOT(slotChangedLeftColor(const QColor&)));
-    connect(rightColorButton, SIGNAL(changed(const QColor&)), SLOT(slotChangedRightColor(const QColor&)));
+    connect(leftColorButton, SIGNAL(changed(const KoColor&)), SLOT(slotChangedLeftColor(const KoColor&)));
+    connect(rightColorButton, SIGNAL(changed(const KoColor&)), SLOT(slotChangedRightColor(const KoColor&)));
 
     connect(intNumInputLeftOpacity, SIGNAL(valueChanged(int)), SLOT(slotChangedLeftOpacity(int)));
     connect(intNumInputRightOpacity, SIGNAL(valueChanged(int)), SLOT(slotChangedRightOpacity(int)));
 
 }
 
 void KisAutogradient::activate()
 {
     paramChanged();
 }
 
 void KisAutogradient::slotSelectedSegment(KoGradientSegment* segment)
 {
-    QColor startColor;
-    QColor endColor;
 
-    segment->startColor().toQColor(&startColor);
-    segment->endColor().toQColor(&endColor);
-
-    leftColorButton->setColor(startColor);
-    rightColorButton->setColor(endColor);
+    leftColorButton->setColor(segment->startColor());
+    rightColorButton->setColor(segment->endColor());
     comboBoxColorInterpolationType->setCurrentIndex(segment->colorInterpolation());
     comboBoxInterpolationType->setCurrentIndex(segment->interpolation());
 
-    int leftOpacity = (startColor.alpha() * 100) / OPACITY_OPAQUE_U8;
+    int leftOpacity = segment->startColor().opacityF();
     intNumInputLeftOpacity->setValue(leftOpacity);
     intNumInputLeftOpacity->setSuffix(i18n(" %"));
 
-    int rightOpacity = (endColor.alpha() * 100) / OPACITY_OPAQUE_U8;
+    int rightOpacity = segment->endColor().opacityF();
     intNumInputRightOpacity->setValue(rightOpacity);
     intNumInputRightOpacity->setSuffix(i18n(" %"));
 
     paramChanged();
 }
 
 void KisAutogradient::slotChangedSegment(KoGradientSegment*)
 {
     paramChanged();
 }
 
 void KisAutogradient::slotChangedInterpolation(int type)
 {
     KoGradientSegment* segment = gradientSlider->selectedSegment();
     if (segment)
         segment->setInterpolation(type);
     gradientSlider->update();
 
     paramChanged();
 }
 
 void KisAutogradient::slotChangedColorInterpolation(int type)
 {
     KoGradientSegment* segment = gradientSlider->selectedSegment();
     if (segment)
         segment->setColorInterpolation(type);
     gradientSlider->update();
 
     paramChanged();
 }
 
-void KisAutogradient::slotChangedLeftColor(const QColor& color)
+void KisAutogradient::slotChangedLeftColor(const KoColor& color)
 {
     KoGradientSegment* segment = gradientSlider->selectedSegment();
     if (segment) {
         KoColor c(color, segment->startColor().colorSpace());
         c.setOpacity(segment->startColor().opacityU8());
         segment->setStartColor(c);
     }
     gradientSlider->update();
 
     paramChanged();
 }
 
-void KisAutogradient::slotChangedRightColor(const QColor& color)
+void KisAutogradient::slotChangedRightColor(const KoColor& color)
 {
     KoGradientSegment* segment = gradientSlider->selectedSegment();
     if (segment) {
-        QColor unused;
         KoColor c(color, segment->endColor().colorSpace());
         c.setOpacity(segment->endColor().opacityU8());
         segment->setEndColor(c);
     }
     gradientSlider->repaint();
 
     paramChanged();
 }
 
 void KisAutogradient::slotChangedLeftOpacity(int value)
 {
     KoGradientSegment* segment = gradientSlider->selectedSegment();
     if (segment) {
-        KoColor c(segment->startColor().toQColor(), segment->startColor().colorSpace());
+        KoColor c(segment->startColor(), segment->startColor().colorSpace());
         c.setOpacity(qreal(value) / qreal(100.0));
         segment->setStartColor(c);
     }
     gradientSlider->repaint();
 
     paramChanged();
 }
 
 void KisAutogradient::slotChangedRightOpacity(int value)
 {
     KoGradientSegment* segment = gradientSlider->selectedSegment();
     if (segment) {
-        KoColor c(segment->endColor().toQColor(), segment->endColor().colorSpace());
+        KoColor c(segment->endColor(), segment->endColor().colorSpace());
         c.setOpacity(quint8((value *OPACITY_OPAQUE_U8) / 100));
         segment->setEndColor(c);
     }
     gradientSlider->repaint();
 
     paramChanged();
 }
 
 void KisAutogradient::slotChangedName()
 {
     m_autogradientResource->setName(nameedit->text());
 }
 
 void KisAutogradient::paramChanged()
 {
     m_autogradientResource->updatePreview();
 }
 
diff --git a/libs/ui/kis_autogradient.h b/libs/ui/kis_autogradient.h
index 2228fdc315..0684fe7a80 100644
--- a/libs/ui/kis_autogradient.h
+++ b/libs/ui/kis_autogradient.h
@@ -1,50 +1,50 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *                2004 Sven Langkamp <sven.langkamp@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.
  */
 
 #ifndef _KIS_AUTOGRADIENT_H_
 #define _KIS_AUTOGRADIENT_H_
 
 #include "ui_wdgautogradient.h"
 
 class KoGradientSegment;
 class KoSegmentGradient;
 
 class KisAutogradient : public QWidget, public Ui::KisWdgAutogradient
 {
     Q_OBJECT
 
 public:
     KisAutogradient(KoSegmentGradient* gradient, QWidget *parent, const char* name, const QString& caption);
     void activate();
 private:
     KoSegmentGradient* m_autogradientResource;
 private Q_SLOTS:
     void slotSelectedSegment(KoGradientSegment* segment);
     void slotChangedSegment(KoGradientSegment* segment);
     void slotChangedInterpolation(int type);
     void slotChangedColorInterpolation(int type);
-    void slotChangedLeftColor(const QColor& color);
-    void slotChangedRightColor(const QColor& color);
+    void slotChangedLeftColor(const KoColor& color);
+    void slotChangedRightColor(const KoColor& color);
     void slotChangedLeftOpacity(int value);
     void slotChangedRightOpacity(int value);
     void slotChangedName();
     void paramChanged();
 };
 
 #endif
diff --git a/libs/ui/widgets/kis_custom_image_widget.cc b/libs/ui/widgets/kis_custom_image_widget.cc
index cd63954727..2269c8a6ba 100644
--- a/libs/ui/widgets/kis_custom_image_widget.cc
+++ b/libs/ui/widgets/kis_custom_image_widget.cc
@@ -1,467 +1,469 @@
 /* This file is part of the Calligra project
  * Copyright (C) 2005 Thomas Zander <zander@kde.org>
  * Copyright (C) 2005 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "widgets/kis_custom_image_widget.h"
 
 #include <QMimeData>
 #include <QPushButton>
 #include <QSlider>
 #include <QComboBox>
 #include <QRect>
 #include <QApplication>
 #include <QClipboard>
 #include <QDesktopWidget>
 #include <QFile>
 #include <QSpacerItem>
 
 #include <QMessageBox>
 #include <KoResourcePaths.h>
 
 
 #include <kis_debug.h>
 
 #include <kis_icon.h>
 #include <KoCompositeOp.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoID.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_fill_painter.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 
 #include "kis_config.h"
 #include "KisPart.h"
 #include "kis_clipboard.h"
 #include "KisDocument.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "widgets/squeezedcombobox.h"
 
 
 KisCustomImageWidget::KisCustomImageWidget(QWidget* parent, qint32 defWidth, qint32 defHeight, double resolution, const QString& defColorModel, const QString& defColorDepth, const QString& defColorProfile, const QString& imageName)
     : WdgNewImage(parent)
 {
     setObjectName("KisCustomImageWidget");
     m_openPane = qobject_cast<KisOpenPane*>(parent);
     Q_ASSERT(m_openPane);
 
     txtName->setText(imageName);
     m_widthUnit = KoUnit(KoUnit::Pixel, resolution);
     doubleWidth->setValue(defWidth);
     doubleWidth->setDecimals(0);
     m_width = m_widthUnit.fromUserValue(defWidth);
     cmbWidthUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::ListAll));
     cmbWidthUnit->setCurrentIndex(m_widthUnit.indexInListForUi(KoUnit::ListAll));
 
     m_heightUnit = KoUnit(KoUnit::Pixel, resolution);
     doubleHeight->setValue(defHeight);
     doubleHeight->setDecimals(0);
     m_height = m_heightUnit.fromUserValue(defHeight);
     cmbHeightUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::ListAll));
     cmbHeightUnit->setCurrentIndex(m_heightUnit.indexInListForUi(KoUnit::ListAll));
 
     doubleResolution->setValue(72.0 * resolution);
     doubleResolution->setDecimals(0);
 
     imageGroupSpacer->changeSize(0, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
     grpClipboard->hide();
 
     sliderOpacity->setRange(0, 100, 0);
     sliderOpacity->setValue(100);
     sliderOpacity->setSuffix("%");
 
     connect(cmbPredefined, SIGNAL(activated(int)), SLOT(predefinedClicked(int)));
     connect(doubleResolution, SIGNAL(valueChanged(double)),
             this, SLOT(resolutionChanged(double)));
     connect(cmbWidthUnit, SIGNAL(activated(int)),
             this, SLOT(widthUnitChanged(int)));
     connect(doubleWidth, SIGNAL(valueChanged(double)),
             this, SLOT(widthChanged(double)));
     connect(cmbHeightUnit, SIGNAL(activated(int)),
             this, SLOT(heightUnitChanged(int)));
     connect(doubleHeight, SIGNAL(valueChanged(double)),
             this, SLOT(heightChanged(double)));
     connect(createButton, SIGNAL(clicked()), this, SLOT(createImage()));
     createButton->setDefault(true);
 
     bnPortrait->setIcon(KisIconUtils::loadIcon("portrait"));
     connect(bnPortrait, SIGNAL(clicked()), SLOT(setPortrait()));
     connect(bnLandscape, SIGNAL(clicked()), SLOT(setLandscape()));
     bnLandscape->setIcon(KisIconUtils::loadIcon("landscape"));
 
     connect(doubleWidth, SIGNAL(valueChanged(double)), this, SLOT(switchPortraitLandscape()));
     connect(doubleHeight, SIGNAL(valueChanged(double)), this, SLOT(switchPortraitLandscape()));
     connect(bnSaveAsPredefined, SIGNAL(clicked()), this, SLOT(saveAsPredefined()));
 
     colorSpaceSelector->setCurrentColorModel(KoID(defColorModel));
     colorSpaceSelector->setCurrentColorDepth(KoID(defColorDepth));
     colorSpaceSelector->setCurrentProfile(defColorProfile);
 
     //connect(chkFromClipboard,SIGNAL(stateChanged(int)),this,SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(changed(QClipboard::Mode)), this, SLOT(clipboardDataChanged()));
     connect(colorSpaceSelector, SIGNAL(selectionChanged(bool)), createButton, SLOT(setEnabled(bool)));
 
     KisConfig cfg;
     intNumLayers->setValue(cfg.numDefaultLayers());
-    cmbColor->setColor(cfg.defaultBackgroundColor());
+    KoColor bcol(KoColorSpaceRegistry::instance()->rgb8());
+    bcol.fromQColor(cfg.defaultBackgroundColor());
+    cmbColor->setColor(bcol);
     setBackgroundOpacity(cfg.defaultBackgroundOpacity());
 
     KisConfig::BackgroundStyle bgStyle = cfg.defaultBackgroundStyle();
 
     if (bgStyle == KisConfig::LAYER) {
       radioBackgroundAsLayer->setChecked(true);
     } else {
       radioBackgroundAsProjection->setChecked(true);
     }
 
     fillPredefined();
     switchPortraitLandscape();
 
     // this makes the portrait and landscape buttons more
     // obvious what is selected by changing the higlight color
     QPalette p = QApplication::palette();
     QPalette palette_highlight(p );
     QColor c = p.color(QPalette::Highlight);
     palette_highlight.setColor(QPalette::Button, c);
     bnLandscape->setPalette(palette_highlight);
     bnPortrait->setPalette(palette_highlight);
 }
 
 void KisCustomImageWidget::showEvent(QShowEvent *)
 {
     fillPredefined();
     this->createButton->setFocus();
     this->createButton->setEnabled(true);
 }
 
 KisCustomImageWidget::~KisCustomImageWidget()
 {
     qDeleteAll(m_predefined);
     m_predefined.clear();
 }
 
 void KisCustomImageWidget::resolutionChanged(double res)
 {
     if (m_widthUnit.type() == KoUnit::Pixel) {
         m_widthUnit.setFactor(res / 72.0);
         m_width = m_widthUnit.fromUserValue(doubleWidth->value());
     }
 
     if (m_heightUnit.type() == KoUnit::Pixel) {
         m_heightUnit.setFactor(res / 72.0);
         m_height = m_heightUnit.fromUserValue(doubleHeight->value());
     }
 }
 
 
 void KisCustomImageWidget::widthUnitChanged(int index)
 {
     doubleWidth->blockSignals(true);
 
     m_widthUnit = KoUnit::fromListForUi(index, KoUnit::ListAll);
     if (m_widthUnit.type() == KoUnit::Pixel) {
         doubleWidth->setDecimals(0);
         m_widthUnit.setFactor(doubleResolution->value() / 72.0);
     } else {
         doubleWidth->setDecimals(2);
     }
 
     doubleWidth->setValue(KoUnit::ptToUnit(m_width, m_widthUnit));
 
     doubleWidth->blockSignals(false);
 }
 
 void KisCustomImageWidget::widthChanged(double value)
 {
     m_width = m_widthUnit.fromUserValue(value);
 }
 
 void KisCustomImageWidget::heightUnitChanged(int index)
 {
     doubleHeight->blockSignals(true);
 
     m_heightUnit = KoUnit::fromListForUi(index, KoUnit::ListAll);
     if (m_heightUnit.type() == KoUnit::Pixel) {
         doubleHeight->setDecimals(0);
         m_heightUnit.setFactor(doubleResolution->value() / 72.0);
     } else {
         doubleHeight->setDecimals(2);
     }
 
     doubleHeight->setValue(KoUnit::ptToUnit(m_height, m_heightUnit));
 
     doubleHeight->blockSignals(false);
 }
 
 void KisCustomImageWidget::heightChanged(double value)
 {
     m_height = m_heightUnit.fromUserValue(value);
 }
 
 void KisCustomImageWidget::createImage()
 {
     createButton->setEnabled(false);
     KisDocument *doc = createNewImage();
     if (doc) {
         doc->setModified(false);
         emit m_openPane->documentSelected(doc);
     }
 }
 
 KisDocument* KisCustomImageWidget::createNewImage()
 {
 
     const KoColorSpace * cs = colorSpaceSelector->currentColorSpace();
 
     if (cs->colorModelId() == RGBAColorModelID &&
         cs->colorDepthId() == Integer8BitsColorDepthID) {
 
         const KoColorProfile *profile = cs->profile();
 
         if (profile->name().contains("linear") ||
             profile->name().contains("scRGB") ||
             profile->info().contains("linear") ||
             profile->info().contains("scRGB")) {
 
             int result =
                 QMessageBox::warning(this,
                                      i18nc("@title:window", "Krita"),
                                      i18n("Linear gamma RGB color spaces are not supposed to be used "
                                           "in 8-bit integer modes. It is suggested to use 16-bit integer "
                                           "or any floating point colorspace for linear profiles.\n\n"
                                           "Press \"Continue\" to create a 8-bit integer linear RGB color space "
                                           "or \"Cancel\" to return to the settings dialog."),
                                      QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
 
             if (result == QMessageBox::Cancel) {
                 dbgKrita << "Model RGB8" << "NOT SUPPORTED";
                 dbgKrita << ppVar(cs->name());
                 dbgKrita << ppVar(cs->profile()->name());
                 dbgKrita << ppVar(cs->profile()->info());
                 return 0;
             }
         }
     }
     KisDocument *doc = static_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     qint32 width, height;
     double resolution;
     resolution = doubleResolution->value() / 72.0;  // internal resolution is in pixels per pt
 
     width = static_cast<qint32>(0.5  + KoUnit::ptToUnit(m_width, KoUnit(KoUnit::Pixel, resolution)));
     height = static_cast<qint32>(0.5 + KoUnit::ptToUnit(m_height, KoUnit(KoUnit::Pixel, resolution)));
 
-    QColor qc = cmbColor->color();
+    QColor qc = cmbColor->color().toQColor();
     qc.setAlpha(backgroundOpacity());
     KoColor bgColor(qc, cs);
 
     bool backgroundAsLayer = radioBackgroundAsLayer->isChecked();
 
     doc->newImage(txtName->text(), width, height, cs, bgColor, backgroundAsLayer, intNumLayers->value(), txtDescription->toPlainText(), resolution);
 
     KisConfig cfg;
     cfg.setNumDefaultLayers(intNumLayers->value());
     cfg.setDefaultBackgroundOpacity(backgroundOpacity());
-    cfg.setDefaultBackgroundColor(cmbColor->color());
+    cfg.setDefaultBackgroundColor(cmbColor->color().toQColor());
     cfg.setDefaultBackgroundStyle(backgroundAsLayer ? KisConfig::LAYER : KisConfig::PROJECTION);
 
     return doc;
 }
 
 void KisCustomImageWidget::setNumberOfLayers(int layers)
 {
     intNumLayers->setValue(layers);
 }
 
 quint8 KisCustomImageWidget::backgroundOpacity() const
 {
     qint32 opacity = sliderOpacity->value();
 
     if (!opacity)
         return 0;
 
     return (opacity * 255) / 100;
 }
 
 void KisCustomImageWidget::setBackgroundOpacity(quint8 value) {
   sliderOpacity->setValue((value * 100) / 255);
 }
 
 void KisCustomImageWidget::clipboardDataChanged()
 {
 }
 
 
 
 void KisCustomImageWidget::fillPredefined()
 {
     cmbPredefined->clear();
     qDeleteAll(m_predefined);
     m_predefined.clear();
 
     cmbPredefined->addItem("");
 
     QStringList definitions = KoResourcePaths::findAllResources("data", "predefined_image_sizes/*.predefinedimage", KoResourcePaths::Recursive);
     definitions.sort();
 
     if (!definitions.empty()) {
 
         Q_FOREACH (const QString &definition, definitions) {
             QFile f(definition);
             f.open(QIODevice::ReadOnly);
             if (f.exists()) {
                 QString xml = QString::fromUtf8(f.readAll());
                 KisPropertiesConfiguration *predefined = new KisPropertiesConfiguration;
                 predefined->fromXML(xml);
                 if (predefined->hasProperty("name")
                         && predefined->hasProperty("width")
                         && predefined->hasProperty("height")
                         && predefined->hasProperty("resolution")
                         && predefined->hasProperty("x-unit")
                         && predefined->hasProperty("y-unit")) {
                     m_predefined << predefined;
                     cmbPredefined->addItem(predefined->getString("name"));
                 }
             }
         }
     }
 
     cmbPredefined->setCurrentIndex(0);
 
 }
 
 
 void KisCustomImageWidget::predefinedClicked(int index)
 {
     if (index < 1 || index > m_predefined.size()) return;
 
     KisPropertiesConfiguration *predefined = m_predefined[index - 1];
     txtPredefinedName->setText(predefined->getString("name"));
     doubleResolution->setValue(predefined->getDouble("resolution"));
     cmbWidthUnit->setCurrentIndex(predefined->getInt("x-unit"));
     cmbHeightUnit->setCurrentIndex(predefined->getInt("y-unit"));
 
     widthUnitChanged(cmbWidthUnit->currentIndex());
     heightUnitChanged(cmbHeightUnit->currentIndex());
 
     doubleWidth->setValue(predefined->getDouble("width"));
     doubleHeight->setValue(predefined->getDouble("height"));
 
 }
 
 void KisCustomImageWidget::saveAsPredefined()
 {
     QString fileName = txtPredefinedName->text();
     if (fileName.isEmpty()) {
         return;
     }
     QString saveLocation = KoResourcePaths::saveLocation("data", "predefined_image_sizes/", true);
     QFile f(saveLocation + '/' + fileName.replace(' ', '_').replace('(', '_').replace(')', '_') + ".predefinedimage");
 
     f.open(QIODevice::WriteOnly | QIODevice::Truncate);
     KisPropertiesConfiguration *predefined = new KisPropertiesConfiguration();
     predefined->setProperty("name", txtPredefinedName->text());
     predefined->setProperty("width", doubleWidth->value());
     predefined->setProperty("height", doubleHeight->value());
     predefined->setProperty("resolution", doubleResolution->value());
     predefined->setProperty("x-unit", cmbWidthUnit->currentIndex());
     predefined->setProperty("y-unit", cmbHeightUnit->currentIndex());
 
     QString xml = predefined->toXML();
 
     f.write(xml.toUtf8());
     f.flush();
     f.close();
 
     int i = 0;
     bool found = false;
     Q_FOREACH (KisPropertiesConfiguration *pr, m_predefined) {
         if (pr->getString("name") == txtPredefinedName->text()) {
             found = true;
             break;
         }
         ++i;
     }
     if (found) {
         m_predefined[i] = predefined;
     }
     else {
         m_predefined.append(predefined);
         cmbPredefined->addItem(txtPredefinedName->text());
     }
 
 }
 
 void KisCustomImageWidget::setLandscape()
 {
     if (doubleWidth->value() < doubleHeight->value()) {
         switchWidthHeight();
     }
 }
 
 void KisCustomImageWidget::setPortrait()
 {
     if (doubleWidth->value() > doubleHeight->value()) {
         switchWidthHeight();
     }
 }
 
 void KisCustomImageWidget::switchWidthHeight()
 {
     double width = doubleWidth->value();
     double height = doubleHeight->value();
 
     doubleHeight->blockSignals(true);
     doubleWidth->blockSignals(true);
     cmbWidthUnit->blockSignals(true);
     cmbHeightUnit->blockSignals(true);
 
     doubleWidth->setValue(height);
     doubleHeight->setValue(width);
     cmbWidthUnit->setCurrentIndex(m_heightUnit.indexInListForUi(KoUnit::ListAll));
     cmbHeightUnit->setCurrentIndex(m_widthUnit.indexInListForUi(KoUnit::ListAll));
 
     doubleHeight->blockSignals(false);
     doubleWidth->blockSignals(false);
     cmbWidthUnit->blockSignals(false);
     cmbHeightUnit->blockSignals(false);
     switchPortraitLandscape();
 
     widthChanged(doubleWidth->value());
     heightChanged(doubleHeight->value());
 }
 
 void KisCustomImageWidget::switchPortraitLandscape()
 {
     if(doubleWidth->value() > doubleHeight->value())
         bnLandscape->setChecked(true);
     else
         bnPortrait->setChecked(true);
 }
 
diff --git a/plugins/filters/colors/kis_wdg_color_to_alpha.cpp b/plugins/filters/colors/kis_wdg_color_to_alpha.cpp
index e45e7b08ac..1d13900252 100644
--- a/plugins/filters/colors/kis_wdg_color_to_alpha.cpp
+++ b/plugins/filters/colors/kis_wdg_color_to_alpha.cpp
@@ -1,119 +1,127 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_wdg_color_to_alpha.h"
 #include <QCheckBox>
 #include <QLayout>
 #include <QSpinBox>
 
 #include <KoColor.h>
 #include <KoToolManager.h>
 
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_selection.h>
 #include <kis_paint_device.h>
 #include <kis_processing_information.h>
+#include <KoColorSpaceRegistry.h>
 
 #include "ui_wdgcolortoalphabase.h"
 
 KisWdgColorToAlpha::KisWdgColorToAlpha(QWidget * parent)
     : KisConfigWidget(parent),
       m_view(0)
 {
     m_widget = new Ui_WdgColorToAlphaBase();
     m_widget->setupUi(this);
 
 
     m_widget->textLabel1->hide();
 
     m_widget->intThreshold->setRange(1, 255, 0);
 
-    connect(m_widget->colorSelector, SIGNAL(colorChanged(const QColor&)), SLOT(slotColorSelectorChanged(const QColor&)));
+    connect(m_widget->colorSelector, SIGNAL(sigNewColor(KoColor)), SLOT(slotColorSelectorChanged(const KoColor&)));
     connect(m_widget->intThreshold, SIGNAL(valueChanged(qreal)), SIGNAL(sigConfigurationItemChanged()));
-    connect(m_widget->btnCustomColor, SIGNAL(changed(const QColor&)), SLOT(slotCustomColorSelected(const QColor&)));
+    connect(m_widget->btnCustomColor, SIGNAL(changed(const KoColor)), SLOT(slotCustomColorSelected(const KoColor&)));
 
-    m_widget->btnCustomColor->setColor(Qt::white);
+    KoColor c(Qt::white, KoColorSpaceRegistry::instance()->rgb8());
+    m_widget->btnCustomColor->setColor(c);
 }
 
 KisWdgColorToAlpha::~KisWdgColorToAlpha()
 {
     delete m_widget;
 }
 
 void KisWdgColorToAlpha::setView(KisViewManager *view)
 {
     m_view = view;
 }
 
 void KisWdgColorToAlpha::slotFgColorChanged(const KoColor &color)
 {
-    m_widget->btnCustomColor->setColor(color.toQColor());
+    m_widget->btnCustomColor->setColor(color);
 }
 
-void KisWdgColorToAlpha::slotColorSelectorChanged(const QColor &color)
+void KisWdgColorToAlpha::slotColorSelectorChanged(const KoColor &color)
 {
     m_widget->btnCustomColor->setColor(color);
 }
 
-void KisWdgColorToAlpha::slotCustomColorSelected(const QColor &color)
+void KisWdgColorToAlpha::slotCustomColorSelected(const KoColor &color)
 {
-    m_widget->colorSelector->setQColor(color);
+    m_widget->colorSelector->slotSetColor(color);
     emit sigConfigurationItemChanged();
 }
 
 void KisWdgColorToAlpha::setConfiguration(const KisPropertiesConfiguration* config)
 {
     QVariant value;
     if (config->getProperty("targetcolor", value)) {
-        m_widget->colorSelector->setQColor(value.value<QColor>());
+        KoColor c;
+        if (value.value<QColor>().isValid()) {
+            c.fromQColor(value.value<QColor>());
+        } else {
+            c = value.value<KoColor>();
+        }
+        m_widget->colorSelector->slotSetColor(c);
     }
     if (config->getProperty("threshold", value)) {
         m_widget->intThreshold->setValue(value.toInt());
     }
 }
 
 KisPropertiesConfiguration* KisWdgColorToAlpha::configuration() const
 {
     KisFilterConfiguration* config = new KisFilterConfiguration("colortoalpha", 1);
-    config->setProperty("targetcolor", widget()->colorSelector->color());
+    config->setProperty("targetcolor", widget()->colorSelector->getCurrentColor().toQColor());
     config->setProperty("threshold", widget()->intThreshold->value());
     return config;
 }
 
 void KisWdgColorToAlpha::hideEvent(QHideEvent *)
 {
     if (m_view) {
         disconnect(m_view->resourceProvider(), SIGNAL(sigFGColorChanged(const KoColor&)), this, SLOT(slotFgColorChanged(const KoColor&)));
         KoToolManager::instance()->switchBackRequested();
     }
 }
 
 void KisWdgColorToAlpha::showEvent(QShowEvent *)
 {
     if (m_view) {
         connect(m_view->resourceProvider(), SIGNAL(sigFGColorChanged(const KoColor&)), this, SLOT(slotFgColorChanged(const KoColor&)));
         KoToolManager::instance()->switchToolTemporaryRequested("KritaSelected/KisToolColorPicker");
     }
 }
 
 
diff --git a/plugins/filters/colors/kis_wdg_color_to_alpha.h b/plugins/filters/colors/kis_wdg_color_to_alpha.h
index 2b7a7cf980..2a2937d253 100644
--- a/plugins/filters/colors/kis_wdg_color_to_alpha.h
+++ b/plugins/filters/colors/kis_wdg_color_to_alpha.h
@@ -1,60 +1,60 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  *  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_WDG_COLOR_TO_ALPHA_H_
 #define _KIS_WDG_COLOR_TO_ALPHA_H_
 
 #include <kis_config_widget.h>
 
 class KoColor;
 class Ui_WdgColorToAlphaBase;
 
 
 class KisWdgColorToAlpha : public KisConfigWidget
 {
     Q_OBJECT
 public:
     KisWdgColorToAlpha(QWidget * parent);
     virtual ~KisWdgColorToAlpha();
     inline const Ui_WdgColorToAlphaBase* widget() const {
         return m_widget;
     }
 
     void setView(KisViewManager *view);
 
     virtual void setConfiguration(const KisPropertiesConfiguration*);
     virtual KisPropertiesConfiguration* configuration() const;
 
 protected:
 
     void hideEvent(QHideEvent *);
     void showEvent(QShowEvent *);
 
 private Q_SLOTS:
     void slotFgColorChanged(const KoColor &color);
-    void slotColorSelectorChanged(const QColor &color);
-    void slotCustomColorSelected(const QColor &color);
+    void slotColorSelectorChanged(const KoColor &color);
+    void slotCustomColorSelected(const KoColor &color);
 
 private:
     Ui_WdgColorToAlphaBase* m_widget;
     KisViewManager *m_view;
 };
 
 #endif
diff --git a/plugins/filters/colors/wdgcolortoalphabase.ui b/plugins/filters/colors/wdgcolortoalphabase.ui
index 4d7c8b3af7..961c7726db 100644
--- a/plugins/filters/colors/wdgcolortoalphabase.ui
+++ b/plugins/filters/colors/wdgcolortoalphabase.ui
@@ -1,218 +1,217 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgColorToAlphaBase</class>
  <widget class="QWidget" name="WdgColorToAlphaBase">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>335</width>
     <height>362</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <property name="spacing">
     <number>6</number>
    </property>
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <item>
       <widget class="QLabel" name="textLabel1">
        <property name="text">
         <string>Color:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
        <property name="wordWrap">
         <bool>false</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>0</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item>
-    <widget class="KoTriangleColorSelector" name="colorSelector">
+    <widget class="KisVisualColorSelector" name="colorSelector" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>180</width>
        <height>180</height>
       </size>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <property name="spacing">
        <number>0</number>
       </property>
       <item row="1" column="0">
        <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 row="1" column="1">
        <layout class="QVBoxLayout" name="verticalLayout"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout">
      <property name="topMargin">
       <number>15</number>
      </property>
      <property name="verticalSpacing">
       <number>0</number>
      </property>
      <item row="1" column="0">
       <widget class="QLabel" name="textLabel1_2">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Threshold:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
        </property>
        <property name="wordWrap">
         <bool>false</bool>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
-      <widget class="KisDoubleSliderSpinBox" name="intThreshold">
+      <widget class="KisDoubleSliderSpinBox" name="intThreshold" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
      <item row="0" column="0">
       <widget class="QLabel" name="pickerLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Color Picker:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
-      <widget class="KColorButton" name="btnCustomColor">
+      <widget class="KisColorButton" name="btnCustomColor">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="maximumSize">
         <size>
          <width>16777215</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="autoDefault">
         <bool>false</bool>
        </property>
        <property name="default">
         <bool>false</bool>
        </property>
        <property name="flat">
         <bool>false</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>KColorButton</class>
-   <extends>QPushButton</extends>
-   <header>kcolorbutton.h</header>
+   <class>KisVisualColorSelector</class>
+   <extends>QWidget</extends>
+   <header>kis_visual_color_selector.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KoTriangleColorSelector</class>
-   <extends>QWidget</extends>
-   <header>KoTriangleColorSelector.h</header>
-   <container>1</container>
+   <class>KisColorButton</class>
+   <extends>QPushButton</extends>
+   <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <includes>
   <include location="local">kcolorbutton.h</include>
  </includes>
  <resources/>
  <connections/>
 </ui>