diff --git a/libs/ui/widgets/kis_advanced_color_space_selector.cc b/libs/ui/widgets/kis_advanced_color_space_selector.cc
index e75b2ae32d..1344e10228 100644
--- a/libs/ui/widgets/kis_advanced_color_space_selector.cc
+++ b/libs/ui/widgets/kis_advanced_color_space_selector.cc
@@ -1,793 +1,793 @@
 /*
  *  Copyright (C) 2007 Cyrille Berger <cberger@cberger.net>
  *  Copyright (C) 2011 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (C) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@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_advanced_color_space_selector.h"
 
 #include <KoFileDialog.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorModelStandardIds.h>
 #include <KoID.h>
 
 #include <KoConfig.h>
 #include <kis_icon.h>
 
 #include <QStandardPaths>
 #include <QTextBrowser>
 #include <QScrollBar>
 
 #include <KoResourcePaths.h>
 
 #include <QUrl>
 
 #include "ui_wdgcolorspaceselectoradvanced.h"
 
 #include <kis_debug.h>
 
 struct KisAdvancedColorSpaceSelector::Private {
     Ui_WdgColorSpaceSelectorAdvanced* colorSpaceSelector;
     QString knsrcFile;
 };
 
 KisAdvancedColorSpaceSelector::KisAdvancedColorSpaceSelector(QWidget* parent, const QString &caption)
     : QDialog(parent)
     , d(new Private)
 {
     setWindowTitle(caption);
 
     d->colorSpaceSelector = new Ui_WdgColorSpaceSelectorAdvanced;
     d->colorSpaceSelector->setupUi(this);
 
     d->colorSpaceSelector->cmbColorModels->setIDList(KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::OnlyUserVisible));
     fillCmbDepths(d->colorSpaceSelector->cmbColorModels->currentItem());
 
     d->colorSpaceSelector->bnInstallProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     d->colorSpaceSelector->bnInstallProfile->setToolTip( i18n("Open Color Profile") );
 
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(KoID)),
             this, SLOT(fillCmbDepths(KoID)));
     connect(d->colorSpaceSelector->cmbColorDepth, SIGNAL(activated(KoID)),
             this, SLOT(fillLstProfiles()));
     connect(d->colorSpaceSelector->cmbColorModels, SIGNAL(activated(KoID)),
             this, SLOT(fillLstProfiles()));
     connect(d->colorSpaceSelector->lstProfile, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),
             this, SLOT(colorSpaceChanged()));
     connect(this, SIGNAL(selectionChanged(bool)),
             this, SLOT(fillDescription()));
     connect(this, SIGNAL(selectionChanged(bool)), d->colorSpaceSelector->TongueWidget, SLOT(repaint()));
     connect(this, SIGNAL(selectionChanged(bool)), d->colorSpaceSelector->TRCwidget, SLOT(repaint()));
 
     connect(d->colorSpaceSelector->bnInstallProfile, SIGNAL(clicked()), this, SLOT(installProfile()));
 
     connect(d->colorSpaceSelector->bnOK, SIGNAL(accepted()), this, SLOT(accept()));
     connect(d->colorSpaceSelector->bnOK, SIGNAL(rejected()), this, SLOT(reject()));
 
     fillLstProfiles();
 }
 
 KisAdvancedColorSpaceSelector::~KisAdvancedColorSpaceSelector()
 {
     delete d->colorSpaceSelector;
     delete d;
 }
 
 void KisAdvancedColorSpaceSelector::fillLstProfiles()
 {
     d->colorSpaceSelector->lstProfile->blockSignals(true);
     const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
     const QString defaultProfileName = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId);
     d->colorSpaceSelector->lstProfile->clear();
 
     QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId);
     QStringList profileNames;
     Q_FOREACH (const KoColorProfile *profile, profileList) {
         profileNames.append(profile->name());
     }
     std::sort(profileNames.begin(), profileNames.end());
     QListWidgetItem *defaultProfile = new QListWidgetItem;
     defaultProfile->setText(defaultProfileName + " " + i18nc("This is appended to the color profile which is the default for the given colorspace and bit-depth","(Default)"));
     Q_FOREACH (QString stringName, profileNames) {
         if (stringName == defaultProfileName) {
             d->colorSpaceSelector->lstProfile->addItem(defaultProfile);
         } else {
             d->colorSpaceSelector->lstProfile->addItem(stringName);
         }
     }
     d->colorSpaceSelector->lstProfile->setCurrentItem(defaultProfile);
     d->colorSpaceSelector->lstProfile->blockSignals(false);
     colorSpaceChanged();
 }
 
 void KisAdvancedColorSpaceSelector::fillCmbDepths(const KoID& id)
 {
     KoID activeDepth = d->colorSpaceSelector->cmbColorDepth->currentItem();
     d->colorSpaceSelector->cmbColorDepth->clear();
     QList<KoID> depths = KoColorSpaceRegistry::instance()->colorDepthList(id, KoColorSpaceRegistry::OnlyUserVisible);
     QList<KoID> sortedDepths;
     if (depths.contains(Integer8BitsColorDepthID)) {
         sortedDepths << Integer8BitsColorDepthID;
     }
     if (depths.contains(Integer16BitsColorDepthID)) {
         sortedDepths << Integer16BitsColorDepthID;
     }
     if (depths.contains(Float16BitsColorDepthID)) {
         sortedDepths << Float16BitsColorDepthID;
     }
     if (depths.contains(Float32BitsColorDepthID)) {
         sortedDepths << Float32BitsColorDepthID;
     }
     if (depths.contains(Float64BitsColorDepthID)) {
         sortedDepths << Float64BitsColorDepthID;
     }
 
     d->colorSpaceSelector->cmbColorDepth->setIDList(sortedDepths);
     if (sortedDepths.contains(activeDepth)) {
         d->colorSpaceSelector->cmbColorDepth->setCurrent(activeDepth);
     }
 }
 
 void KisAdvancedColorSpaceSelector::fillDescription()
 {
     QString notApplicable = i18nc("Not Applicable, used where there's no colorants or gamma curve found","N/A");
     QString notApplicableTooltip = i18nc("@info:tooltip","This profile has no colorants.");
     QString profileName = i18nc("Shows up instead of the name when there's no profile","No Profile Found");
     QString whatIsColorant = i18n("Colorant in d50-adapted xyY.");
     //set colorants
     const QString colorSpaceId = KoColorSpaceRegistry::instance()->colorSpaceId(d->colorSpaceSelector->cmbColorModels->currentItem(), d->colorSpaceSelector->cmbColorDepth->currentItem());
     QList<const KoColorProfile *>  profileList = KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId);
 
     if (!profileList.isEmpty()) {
         profileName = currentColorSpace()->profile()->name();
         if (currentColorSpace()->profile()->hasColorants()){
             QVector <double> colorants = currentColorSpace()->profile()->getColorantsxyY();
             QVector <double> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
             //QString text = currentColorSpace()->profile()->info() + " =" +
             d->colorSpaceSelector->lblXYZ_W->setText(nameWhitePoint(whitepoint));
             d->colorSpaceSelector->lblXYZ_W->setToolTip(QString::number(whitepoint[0], 'f', 4) + ", " + QString::number(whitepoint[1], 'f', 4) + ", " + QString::number(whitepoint[2], 'f', 4));
             d->colorSpaceSelector->TongueWidget->setToolTip("<html><head/><body><table><tr><th colspan='4'>"+i18nc("@info:tooltip","This profile has the following xyY colorants:")+"</th></tr><tr><td>"+
                i18n("Red:")  +"</td><td>"+QString::number(colorants[0], 'f', 4) + "</td><td>" + QString::number(colorants[1], 'f', 4) + "</td><td>" + QString::number(colorants[2], 'f', 4)+"</td></tr><tr><td>"+
                i18n("Green:")+"</td><td>"+QString::number(colorants[3], 'f', 4) + "</td><td>" + QString::number(colorants[4], 'f', 4) + "</td><td>" + QString::number(colorants[5], 'f', 4)+"</th></tr><tr><td>"+
                i18n("Blue:") +"</td><td>"+QString::number(colorants[6], 'f', 4) + "</td><td>" + QString::number(colorants[7], 'f', 4) + "</td><td>" + QString::number(colorants[8], 'f', 4)+"</th></tr></table></body></html>");
         } else {
             QVector <double> whitepoint2 = currentColorSpace()->profile()->getWhitePointxyY();
             d->colorSpaceSelector->lblXYZ_W->setText(nameWhitePoint(whitepoint2));
             d->colorSpaceSelector->lblXYZ_W->setToolTip(QString::number(whitepoint2[0], 'f', 4) + ", " + QString::number(whitepoint2[1], 'f', 4) + ", " + QString::number(whitepoint2[2], 'f', 4));
             d->colorSpaceSelector->TongueWidget->setToolTip(notApplicableTooltip);
         }
     } else {
         d->colorSpaceSelector->lblXYZ_W->setText(notApplicable);
         d->colorSpaceSelector->lblXYZ_W->setToolTip(notApplicableTooltip);
         d->colorSpaceSelector->TongueWidget->setToolTip(notApplicableTooltip);
     }
 
     //set TRC
     QVector <double> estimatedTRC(3);
     QString estimatedGamma = i18nc("Estimated Gamma indicates how the TRC (Tone Response Curve or Tone Reproduction Curve) is bent. A Gamma of 1.0 means linear.", "<b>Estimated Gamma</b>: ");
     QString estimatedsRGB = i18nc("This is for special Gamma types that LCMS cannot differentiate between", "<b>Estimated Gamma</b>: sRGB, L* or rec709 TRC");
     QString whatissRGB = i18nc("@info:tooltip","The Tone Response Curve of this color space is either sRGB, L* or rec709 TRC.");
     QString currentModelStr = d->colorSpaceSelector->cmbColorModels->currentItem().id();
 
     if (profileList.isEmpty()) {
         d->colorSpaceSelector->TongueWidget->setProfileDataAvailable(false);
         d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
     }
     else if (currentModelStr == "RGBA") {
         QVector <qreal> colorants = currentColorSpace()->profile()->getColorantsxyY();
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         if (currentColorSpace()->profile()->hasColorants()){
             d->colorSpaceSelector->TongueWidget->setRGBData(whitepoint, colorants);
         } else {
             colorants.fill(0.0);
             d->colorSpaceSelector->TongueWidget->setRGBData(whitepoint, colorants);
         }
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF redcurve;
         QPolygonF greencurve;
         QPolygonF bluecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 redcurve<<tonepoint;
                 tonepoint.setX(linear[1]);
                 greencurve<<tonepoint;
                 tonepoint.setX(linear[2]);
                 bluecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setRGBCurve(redcurve, greencurve, bluecurve);
         } else {
             QPolygonF curve = currentColorSpace()->estimatedTRCXYY();
             redcurve << curve.at(0) << curve.at(1) << curve.at(2) << curve.at(3) << curve.at(4);
             greencurve << curve.at(5) << curve.at(6) << curve.at(7) << curve.at(8) << curve.at(9);
             bluecurve << curve.at(10) << curve.at(11) << curve.at(12) << curve.at(13) << curve.at(14);
             d->colorSpaceSelector->TRCwidget->setRGBCurve(redcurve, greencurve, bluecurve);
         }
 
         if (estimatedTRC[0] == -1) {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+whatissRGB+"<br />"+estimatedCurve+"</body></html>");
         } else {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0]) + "," + QString::number(estimatedTRC[1]) + "," + QString::number(estimatedTRC[2])+"<br />"+estimatedCurve+"</body></html>");
         }
     }
     else if (currentModelStr == "GRAYA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setGrayData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         if (estimatedTRC[0] == -1) {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+whatissRGB+"<br />"+estimatedCurve+"</body></html>");
         } else {
             d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0])+"<br />"+estimatedCurve+"</body></html>");
         }
     }
     else if (currentModelStr == "CMYKA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setCMYKData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         QPolygonF cyancurve;
         QPolygonF magentacurve;
         QPolygonF yellowcurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             QPolygonF curve = currentColorSpace()->estimatedTRCXYY();
             cyancurve << curve.at(0) << curve.at(1) << curve.at(2) << curve.at(3) << curve.at(4);
             magentacurve << curve.at(5) << curve.at(6) << curve.at(7) << curve.at(8) << curve.at(9);
             yellowcurve << curve.at(10) << curve.at(11) << curve.at(12) << curve.at(13) << curve.at(14);
             tonecurve << curve.at(15) << curve.at(16) << curve.at(17) << curve.at(18) << curve.at(19);
             d->colorSpaceSelector->TRCwidget->setCMYKCurve(cyancurve, magentacurve, yellowcurve, tonecurve);
         }
         d->colorSpaceSelector->TRCwidget->setToolTip(i18nc("@info:tooltip","Estimated Gamma cannot be retrieved for CMYK."));
     }
     else if (currentModelStr == "XYZA") {
         QString estimatedCurve = " Estimated curve: ";
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setXYZData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+estimatedGamma + QString::number(estimatedTRC[0])+"< br />"+estimatedCurve+"</body></html>");
     }
     else if (currentModelStr == "LABA") {
         estimatedTRC = currentColorSpace()->profile()->getEstimatedTRC();
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setLABData(whitepoint);
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip("<html><head/><body>"+i18nc("@info:tooltip","This is assumed to be the L * TRC. ")+"<br />"+estimatedCurve+"</body></html>");
     }
     else if (currentModelStr == "YCbCrA") {
         QVector <qreal> whitepoint = currentColorSpace()->profile()->getWhitePointxyY();
         d->colorSpaceSelector->TongueWidget->setYCbCrData(whitepoint);
         QString estimatedCurve = " Estimated curve: ";
         QPolygonF tonecurve;
         if (currentColorSpace()->profile()->hasTRC()){
             for (int i=0; i<=10; i++) {
                 QVector <qreal> linear(3);
                 linear.fill(i*0.1);
                 currentColorSpace()->profile()->linearizeFloatValue(linear);
                 estimatedCurve = estimatedCurve + ", " + QString::number(linear[0]);
                 QPointF tonepoint(linear[0],i*0.1);
                 tonecurve<<tonepoint;
             }
             d->colorSpaceSelector->TRCwidget->setGreyscaleCurve(tonecurve);
         } else {
             d->colorSpaceSelector->TRCwidget->setProfileDataAvailable(false);
         }
         d->colorSpaceSelector->TongueWidget->setGamut(currentColorSpace()->gamutXYY());
         d->colorSpaceSelector->TRCwidget->setToolTip(i18nc("@info:tooltip","Estimated Gamma cannot be retrieved for YCrCb."));
     }
 
     d->colorSpaceSelector->textProfileDescription->clear();
     if (profileList.isEmpty()==false) {
         d->colorSpaceSelector->textProfileDescription->append("<h3>"+i18nc("About <Profilename>","About ")  +  currentColorSpace()->name()  +  "/"  +  profileName  +  "</h3>");
         d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("ICC profile version","ICC Version: ")  + QString::number(currentColorSpace()->profile()->version())  +  "</p>");
         //d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("Who made the profile?","Manufacturer: ")  + currentColorSpace()->profile()->manufacturer()  +  "</p>"); //This would work if people actually wrote the manufacturer into the manufacturer fiedl...
         d->colorSpaceSelector->textProfileDescription->append("<p>"+ i18nc("What is the copyright? These are from embedded strings from the icc profile, so they default to english.","Copyright: ")  + currentColorSpace()->profile()->copyright()  +  "</p>");
     } else {
         d->colorSpaceSelector->textProfileDescription->append("<h3>" + profileName  +  "</h3>");
     }
 
     if (currentModelStr == "RGBA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is RGB",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/RGB_color_space\">RGB (Red, Green, Blue)</a></b>, is the color model used by screens and other light-based media.<br/>"
                                                                     "RGB is an additive color model: adding colors together makes them brighter. This color "
                                                                     "model is the most extensive of all color models, and is recommended as a model for painting,"
                                                                     "that you can later convert to other spaces. RGB is also the recommended colorspace for HDR editing.")+"</p>");
     } else if (currentModelStr == "CMYKA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is CMYK",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/CMYK_color_model\">CMYK (Cyan, Magenta, Yellow, Key)</a></b>, "
                                                                     "is the model used by printers and other ink-based media.<br/>"
                                                                     "CMYK is a subtractive model, meaning that adding colors together will turn them darker. Because of CMYK "
                                                                     "profiles being very specific per printer, it is recommended to work in RGB space, and then later convert "
                                                                     "to a CMYK profile, preferably one delivered by your printer. <br/>"
                                                                     "CMYK is <b>not</b> recommended for painting."
                                                                     "Unfortunately, Krita cannot retrieve colorants or the TRC for this space.")+"</p>");
     } else if (currentModelStr == "XYZA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is XYZ",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/CIE_1931_color_space\">CIE XYZ</a></b>"
                                                                     "is the space determined by the CIE as the space that encompasses all other colors, and used to "
                                                                     "convert colors between profiles. XYZ is an additive color model, meaning that adding colors together "
                                                                     "makes them brighter. XYZ is <b>not</b> recommended for painting, but can be useful to encode in. The Tone Response "
                                                                     "Curve is assumed to be linear.")+"</p>");
     } else if (currentModelStr == "GRAYA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is Grayscale",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/Grayscale\">Grayscale</a></b> only allows for "
                                                                     "gray values and transparent values. Grayscale images use half "
                                                                     "the memory and disk space compared to an RGB image of the same bit-depth.<br/>"
-                                                                    "Grayscale is useful for inking and greyscale images. In "
+                                                                    "Grayscale is useful for inking and grayscale images. In "
                                                                     "Krita, you can mix Grayscale and RGB layers in the same image.")+"</p>");
     } else if (currentModelStr == "LABA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is LAB",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/Lab_color_space\">L*a*b</a></b>. <b>L<b> stands for Lightness, "
                                                                     "the <b>a</b> and <b>b</b> components represent color channels.<br/>"
                                                                     "L*a*b is a special model for color correction. It is based on human perception, meaning that it "
                                                                     "tries to encode the difference in lightness, red-green balance and yellow-blue balance. "
                                                                     "This makes it useful for color correction, but the vast majority of color maths in the blending "
                                                                     "modes do <b>not</b> work as expected here.<br/>"
                                                                     "Similarly, Krita does not support HDR in LAB, meaning that HDR images converted to LAB lose color "
                                                                     "information. This colorspace is <b>not</b> recommended for painting, nor for export, "
                                                                     "but best as a space to do post-processing in. The TRC is assumed to be the L* TRC.")+"</p>");
     } else if (currentModelStr == "YCbCrA") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("If the selected model is YCbCr",
                                                                     "<b><a href=\"https://en.wikipedia.org/wiki/YCbCr\">YCbCr (Luma, Blue Chroma, Red Chroma)</a></b>, is a "
                                                                     "model designed for video encoding. It is based on human perception, meaning that it tries to "
                                                                     "encode the difference in lightness, red-green balance and yellow-blue balance. Chroma in "
                                                                     "this case is then a word indicating a special type of saturation, in these cases the saturation "
                                                                     "of Red and Blue, of which the desaturated equivalents are Green and Yellow respectively. It "
                                                                     "is available to open up certain images correctly, but Krita does not currently ship a profile for "
                                                                     "this due to lack of open source ICC profiles for YCrCb.")+"</p>");
     }
 
     QString currentDepthStr = d->colorSpaceSelector->cmbColorDepth->currentItem().id();
 
     if (currentDepthStr == "U8") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 8",
                                                                     "<b>8 bit integer</b>: The default number of colors per channel. Each channel will have 256 values available, "
                                                                     "leading to a total amount of colors of 256 to the power of the number of channels. Recommended to use for images intended for the web, "
                                                                     "or otherwise simple images.")+"</p>");
     }
     else if (currentDepthStr == "U16") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 16",
                                                                     "<b>16 bit integer</b>: Also known as 'deep color'. 16 bit is ideal for editing images with a linear TRC, large "
                                                                     "color space, or just when you need more precise color blending. This does take twice as much space on "
                                                                     "the RAM and hard-drive than any given 8 bit image of the same properties, and for some devices it "
                                                                     "takes much more processing power. We recommend watching the RAM usage of the file carefully, or "
                                                                     "otherwise use 8 bit if your computer slows down. Take care to disable conversion optimization "
                                                                     "when converting from 16 bit/channel to 8 bit/channel.")+"</p>");
     }
     else if (currentDepthStr == "F16") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 16 bit float",
                                                                     "<b>16 bit floating point</b>: Also known as 'Half Floating Point', and the standard in VFX industry images. "
                                                                     "16 bit float is ideal for editing images with a linear Tone Response Curve, large color space, or just when you need "
                                                                     "more precise color blending. It being floating point is an absolute requirement for Scene Referred "
                                                                     "(HDR) images. This does take twice as much space on the RAM and hard-drive than any given 8 bit image "
                                                                     "of the same properties, and for some devices it takes much more processing power. We recommend watching "
                                                                     "the RAM usage of the file carefully, or otherwise use 8 bit if your computer slows down.")+"</p>");
     }
     else if (currentDepthStr == "F32") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 32bit float",
                                                                     "<b>32 bit float point</b>: Also known as 'Full Floating Point'. 32 bit float is ideal for editing images "
                                                                     "with a linear TRC, large color space, or just when you need more precise color blending. It being "
                                                                     "floating point is an absolute requirement for Scene Referred (HDR) images. This does take four times "
                                                                     "as much space on the RAM and hard-drive than any given 8 bit image of the same properties, and for "
                                                                     "some devices it takes much more processing power. We recommend watching the RAM usage of the file "
                                                                     "carefully, or otherwise use 8 bit if your computer slows down.")+"</p>");
     }
     else if (currentDepthStr == "F64") {
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("When the selected Bitdepth is 64bit float, but this isn't actually available in Krita at the moment.",\
                                                                     "<b>64 bit float point</b>: 64 bit float is as precise as it gets in current technology, and this depth is used "
                                                                     "most of the time for images that are generated or used as an input for software. It being floating point "
                                                                     "is an absolute requirement for Scene Referred (HDR) images. This does take eight times as much space on "
                                                                     "the RAM and hard-drive than any given 8 bit image of the same properties, and for some devices it takes "
                                                                     "much more processing power. We recommend watching the RAM usage of the file carefully, or otherwise use "
                                                                     "8 bit if your computer slows down.")+"</p>");
     }
     if (profileList.isEmpty()==false) {
         QString possibleConversionIntents = "<p>"+i18n("The following conversion intents are possible: ")+"<ul>";
         if (currentColorSpace()->profile()->supportsPerceptual()){
             possibleConversionIntents += "<li>"+i18n("Perceptual")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsRelative()){
             possibleConversionIntents +=  "<li>"+i18n("Relative Colorimetric")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsAbsolute()){
             possibleConversionIntents += "<li>"+i18n("Absolute Colorimetric")+"</li>";
         }
         if (currentColorSpace()->profile()->supportsSaturation()){
             possibleConversionIntents += "<li>"+i18n("Saturation")+"</li>";
         }
         possibleConversionIntents += "</ul></ul></p>";
         d->colorSpaceSelector->textProfileDescription->append(possibleConversionIntents);
     }
     if (profileName.contains("-elle-")) {
 
         d->colorSpaceSelector->textProfileDescription->append("<p>"+i18nc("These are Elle Stone's notes on her profiles that we ship.",
                                                                     "<p><b>Extra notes on profiles by Elle Stone:</b></p>"
                                                                     "<p><i>Krita comes with a number of high quality profiles created by "
                                                                     "<a href=\"http://ninedegreesbelow.com\">Elle Stone</a>. This is a summary. Please check "
                                                                     "<a href=\"http://ninedegreesbelow.com/photography/lcms-make-icc-profiles.html\">the full documentation</a> as well.</i></p>"));
 
                 if (profileName.contains("ACES-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Quoting Wikipedia, 'Academy Color Encoding System (ACES) is a color image "
                                                                         "encoding system proposed by the Academy of Motion Picture Arts and Sciences that will allow for "
                                                                         "a fully encompassing color accurate workflow, with 'seamless interchange of high quality motion "
                                                                         "picture images regardless of source'.</p>"));
         }
         if (profileName.contains("ACEScg-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The ACEScg color space is smaller than the ACES color space, but large enough to contain the 'Rec-2020 gamut "
                                                                         "and the DCI-P3 gamut', unlike the ACES color space it has no negative values and contains only few colors "
                                                                         "that fall just barely outside the area of real colors humans can see</p>"));
         }
         if (profileName.contains("ClayRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'ClayRGB' (following ArgyllCMS) as the base name "
                                                                         "for these profiles. As used below, 'Compatible with Adobe RGB 1998' is terminology suggested in the preamble "
                                                                         "to the AdobeRGB 1998 color space specifications.</p><p>"
                                                                         "The Adobe RGB 1998 color gamut covers a higher "
                                                                         "percentage of real-world cyans, greens, and yellow-greens than sRGB, but still doesn't include all printable "
                                                                         "cyans, greens, yellow-greens, especially when printing using today's high-end, wider gamut, ink jet printers. "
                                                                         "BetaRGB (not included in the profile pack) and Rec.2020 are better matches for the color gamuts of today's "
                                                                         "wide gamut printers.</p><p>"
                                                                         "The Adobe RGB 1998 color gamut is a reasonable approximation to some of today's "
                                                                         "high-end wide gamut monitors.</p>"));
         }
         if (profileName.contains("AllColorsRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>This profile's color gamut is roughly the same size and shape as the ACES color space gamut, "
                                                                         "and like the ACES color space, AllColorsRGB holds all possible real colors. But AllColorsRGB "
                                                                         "actually has a slightly larger color gamut (to capture some fringe colors that barely qualify "
                                                                         "as real when viewed by the standard observer) and uses the D50 white point.</p><p>"
                                                                         "Just like the ACES color space, AllColorsRGB holds a high percentage of imaginary colors. See the Completely "
                                                                         "<a href=\"http://ninedegreesbelow.com/photography/xyz-rgb.html\">"
                                                                         "Painless Programmer's Guide to XYZ, RGB, ICC, xyY, and TRCs</a> for more information about imaginary "
                                                                         "colors.</p><p>"
                                                                         "There is no particular reason why anyone would want to use this profile "
                                                                         "for editing, unless one needs to make sure your color space really does hold all "
                                                                         "possible real colors.</p>"));
         }
         if (profileName.contains("CIERGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>This profile is included mostly for its historical significance. "
                                                                         "It's the color space that was used in the original color matching experiments "
                                                                         "that led to the creation of the XYZ reference color space.</p><p>"
                                                                         "The ASTM E white point "
                                                                         "is probably the right E white point to use when making the CIERGB color space profile. "
                                                                         "It's not clear to me what the correct CIERGB primaries really are. "
                                                                         "Lindbloom gives one set. The LCMS version 1 tutorial gives a different set. "
                                                                         "Experts in the field contend that the real primaries "
                                                                         "should be calculated from the spectral wavelengths, so I did.</p>"));
         }
         if (profileName.contains("IdentityRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The IdentityRGB working space is included in the profile pack because it's a mathematically "
                                                                         "obvious way to include all possible visible colors, though it has a higher percentage of "
                                                                         "imaginary colors than the ACES and AllColorsRGB color spaces. I cannot think of any reason "
                                                                         "why you'd ever want to actually edit images in the IdentityRGB working space.</p>"));
         }
         if (profileName.contains("LargeRGB-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'LargeRGB' (following RawTherapee) "
                                                                         "as the base name for these profiles.<p>"
                                                                         "Kodak designed the RIMM/ROMM (ProPhotoRGB) color "
                                                                         "gamut to include all printable and most real world colors. It includes some imaginary colors "
                                                                         "and excludes some of the real world blues and violet blues that can be captured by digital "
                                                                         "cameras. It also excludes some very saturated 'camera-captured' yellows as interpreted by "
                                                                         "some (and probably many) camera matrix input profiles.<p>"
                                                                         "The ProPhotoRGB primaries are "
                                                                         "hard-coded into Adobe products such as Lightroom and the Dng-DCP camera 'profiles'. However, "
                                                                         "other than being large enough to hold a lot of colors, ProPhotoRGB has no particular merit "
                                                                         "as an RGB working space. Personally and for most editing purposes, I recommend BetaRGB, Rec2020, "
                                                                         "or the ACEScg profiles ProPhotoRGB.</p>"));
         }
         if (profileName.contains("Rec2020-")) {
 
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Rec.2020 is the up-and-coming replacement for the thoroughly outdated sRGB color space. As of "
                                                                         "June 2015, very few (if any) display devices (and certainly no affordable display devices) can "
                                                                         "display all of Rec.2020. However, display technology is closing in on Rec.2020, movies are "
                                                                         "already being made for Rec.2020, and various cameras offer support for Rec.2020. And in the "
                                                                         "digital darkroom Rec.2020 is much more suitable as a general RGB working space than the "
                                                                         "exceedingly small sRGB color space.</p>"));
         }
         if (profileName.contains("sRGB-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Hewlett-Packard and Microsoft designed sRGB to match the color gamut of consumer-grade CRTs "
                                                                         "from the 1990s. sRGB is the standard color space for the world wide web and is still the best "
                                                                         "choice for exporting images to the internet.</p><p>"
                                                                         "The sRGB color gamut was a good match to "
                                                                         "calibrated decent quality CRTs. But sRGB is not a good match to many consumer-grade LCD monitors, "
                                                                         "which often cannot display the more saturated sRGB blues and magentas (the good news: as technology "
                                                                         "progresses, wider gamuts are trickling down to consumer grade monitors).</p><p>"
                                                                         "Printer color gamuts can easily exceed the sRGB color gamut in cyans, greens, and yellow-greens. Colors from interpolated "
                                                                         "camera raw files also often exceed the sRGB color gamut.</p><p>"
                                                                         "As a very relevant aside, using perceptual "
                                                                         "intent when converting to sRGB does not magically makes otherwise out of gamut colors fit inside the "
                                                                         "sRGB color gamut! The standard sRGB color space (along with all the other the RGB profiles provided "
                                                                         "in my profile pack) is a matrix profile, and matrix profiles don't have perceptual intent tables.</p>"));
         }
         if (profileName.contains("WideRGB-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>To avoid possible copyright infringement issues, I used 'WideRGB' as the base name for these profiles.</p><p>"
                                                                         "WideGamutRGB was designed by Adobe to be a wide gamut color space that uses spectral colors "
                                                                         "as its primaries. Pascale's primary values produce a profile that matches old V2 Widegamut profiles "
                                                                         "from Adobe and Canon. It is an interesting color space, but shortly after its introduction, Adobe "
                                                                         "switched their emphasis to the ProPhotoRGB color space.</p>"));
         }
         if (profileName.contains("Gray-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>These profiles are for use with RGB images that have been converted to monotone gray (black and white). "
                                                                         "The main reason to convert from RGB to Gray is to save the file space needed to encode the image. "
                                                                         "Google places a premium on fast-loading web pages, and images are one of the slower-loading elements "
                                                                         "of a web page. So converting black and white images to Grayscale images does save some kilobytes. "
                                                                         " For grayscale images uploaded to the internet, convert the image to the V2 Gray profile with the sRGB TRC.</p>"));
         }
         if (profileName.contains("-g10")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-g10.icc' are linear gamma (gamma=1.0, 'linear light', etc) profiles and "
                                                                         "should only be used when editing at high bit depths (16-bit floating point, 16-bit integer, 32-bit "
                                                                         "floating point, 32-bit integer). Many editing operations produce better results in linear gamma color "
                                                                         "spaces.</p>"));
         }
         if (profileName.contains("-labl")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-labl.icc' have perceptually uniform TRCs. A few editing operations really "
                                                                         "should be done on perceptually uniform RGB. Make sure you use the V4 versions for editing high bit depth "
                                                                         "images.</p>"));
         }
         if (profileName.contains("-srgbtrc") || profileName.contains("-g22") || profileName.contains("-g18") || profileName.contains("-bt709")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>The profiles that end in '-srgbtrc.icc', '-g22.icc', and '-bt709.icc' have approximately but not exactly "
                                                                         "perceptually uniform TRCs. ProPhotoRGB's gamma=1.8 TRC is not quite as close to being perceptually uniform.</p>"));
         }
         if (d->colorSpaceSelector->cmbColorDepth->currentItem().id()=="U8") {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>When editing 8-bit images, you should use a profile with a small color gamut and an approximately or "
                                                                         "exactly perceptually uniform TRC. Of the profiles supplied in my profile pack, only the sRGB and AdobeRGB1998 "
                                                                         "(ClayRGB) color spaces are small enough for 8-bit editing. Even with the AdobeRGB1998 color space you need to "
                                                                         "be careful to not cause posterization. And of course you cannot use the linear gamma versions of these profiles "
                                                                         "for 8-bit editing.</p>"));
         }
         if (profileName.contains("-V4-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Use V4 profiles for editing images using high bit depth image editors that use LCMS as the Color Management Module. "
                                                                         "This includes Krita, digiKam/showFoto, and GIMP 2.9.</p>"));
         }
         if (profileName.contains("-V2-")) {
             d->colorSpaceSelector->textProfileDescription->append(i18nc("From Elle's notes.",
                                                                         "<p>Use V2 profiles for exporting finished images to be uploaded to the web or for use with imaging software that "
                                                                         "cannot read V4 profiles.</p>"));
         }
     }
 
 
     d->colorSpaceSelector->textProfileDescription->moveCursor(QTextCursor::Start);
 
 }
 
 QString KisAdvancedColorSpaceSelector::nameWhitePoint(QVector <double> whitePoint) {
     QString name=(QString::number(whitePoint[0]) + ", " + QString::number(whitePoint[1], 'f', 4));
     //A   (0.451170, 0.40594) (2856K)(tungsten)
     if ((whitePoint[0]>0.451170-0.005 && whitePoint[0]<0.451170 + 0.005) &&
             (whitePoint[1]>0.40594-0.005 && whitePoint[1]<0.40594 + 0.005)){
         name="A";
         return name;
     }
     //B   (0.34980, 0.35270) (4874K) (Direct Sunlight at noon)(obsolete)
     //C   (0.31039, 0.31905) (6774K) (avarage/north sky daylight)(obsolete)
     //D50 (0.34773, 0.35952) (5003K) (Horizon Light, default color of white paper, ICC profile standard illuminant)
     if ((whitePoint[0]>0.34773-0.005 && whitePoint[0]<0.34773 + 0.005) &&
             (whitePoint[1]>0.35952-0.005 && whitePoint[1]<0.35952 + 0.005)){
         name="D50";
         return name;
     }
     //D55 (0.33411,	0.34877) (5503K) (Mid-morning / Mid-afternoon Daylight)
     if ((whitePoint[0]>0.33411-0.001 && whitePoint[0]<0.33411 + 0.001) &&
             (whitePoint[1]>0.34877-0.005 && whitePoint[1]<0.34877 + 0.005)){
         name="D55";
         return name;
     }
     //D60 (0.3217, 0.3378) (~6000K) (ACES colorspace default)
     if ((whitePoint[0]>0.3217-0.001 && whitePoint[0]<0.3217 + 0.001) &&
             (whitePoint[1]>0.3378-0.005 && whitePoint[1]<0.3378 + 0.005)){
         name="D60";
         return name;
     }
     //D65 (0.31382, 0.33100) (6504K) (Noon Daylight, default for computer and tv screens, sRGB default)
     //Elle's are old school with 0.3127 and 0.3289
     if ((whitePoint[0]>0.31382-0.002 && whitePoint[0]<0.31382 + 0.002) &&
             (whitePoint[1]>0.33100-0.005 && whitePoint[1]<0.33100 + 0.002)){
         name="D65";
         return name;
     }
     //D75 (0.29968, 0.31740) (7504K) (North sky Daylight)
     if ((whitePoint[0]>0.29968-0.001 && whitePoint[0]<0.29968 + 0.001) &&
             (whitePoint[1]>0.31740-0.005 && whitePoint[1]<0.31740 + 0.005)){
         name="D75";
         return name;
     }
     //E   (1/3, 1/3)         (5454K) (Equal Energy. CIERGB default)
     if ((whitePoint[0]>(1.0/3.0)-0.001 && whitePoint[0]<(1.0/3.0) + 0.001) &&
             (whitePoint[1]>(1.0/3.0)-0.001 && whitePoint[1]<(1.0/3.0) + 0.001)){
         name="E";
         return name;
     }
     //The F series seems to sorta overlap with the D series, so I'll just leave them in comment here.//
     //F1  (0.31811, 0.33559) (6430K) (Daylight Fluorescent)
     //F2  (0.37925, 0.36733) (4230K) (Cool White Fluorescent)
     //F3  (0.41761, 0.38324) (3450K) (White Fluorescent)
     //F4  (0.44920, 0.39074) (2940K) (Warm White Fluorescent)
     //F5  (0.31975, 0.34246) (6350K) (Daylight Fluorescent)
     //F6  (0.38660, 0.37847) (4150K) (Lite White Fluorescent)
     //F7  (0.31569, 0.32960) (6500K) (D65 simulator, Daylight simulator)
     //F8  (0.34902, 0.35939) (5000K) (D50 simulator)
     //F9  (0.37829, 0.37045) (4150K) (Cool White Deluxe Fluorescent)
     //F10 (0.35090, 0.35444) (5000K) (Philips TL85, Ultralume 50)
     //F11 (0.38541, 0.37123) (4000K) (Philips TL84, Ultralume 40)
     //F12 (0.44256, 0.39717) (3000K) (Philips TL83, Ultralume 30)
 
     return name;
 }
 
 const KoColorSpace* KisAdvancedColorSpaceSelector::currentColorSpace()
 {
     QString check = "";
     if (d->colorSpaceSelector->lstProfile->currentItem()) {
         check = d->colorSpaceSelector->lstProfile->currentItem()->text();
     } else if (d->colorSpaceSelector->lstProfile->item(0)) {
         check = d->colorSpaceSelector->lstProfile->item(0)->text();
     }
     return KoColorSpaceRegistry::instance()->colorSpace(d->colorSpaceSelector->cmbColorModels->currentItem().id(),
                                                         d->colorSpaceSelector->cmbColorDepth->currentItem().id(),
                                                         check);
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorModel(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorModels->setCurrent(id);
     fillLstProfiles();
     fillCmbDepths(id);
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorDepth(const KoID& id)
 {
     d->colorSpaceSelector->cmbColorDepth->setCurrent(id);
     fillLstProfiles();
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentProfile(const QString& name)
 {
     QList<QListWidgetItem *> Items= d->colorSpaceSelector->lstProfile->findItems(name, Qt::MatchStartsWith);
     d->colorSpaceSelector->lstProfile->setCurrentItem(Items.at(0));
 }
 
 void KisAdvancedColorSpaceSelector::setCurrentColorSpace(const KoColorSpace* colorSpace)
 {
     if (!colorSpace) {
         return;
     }
     setCurrentColorModel(colorSpace->colorModelId());
     setCurrentColorDepth(colorSpace->colorDepthId());
     setCurrentProfile(colorSpace->profile()->name());
 }
 
 void KisAdvancedColorSpaceSelector::colorSpaceChanged()
 {
     bool valid = d->colorSpaceSelector->lstProfile->count() != 0;
     emit(selectionChanged(valid));
     if (valid) {
         emit colorSpaceChanged(currentColorSpace());
     }
 }
 
 void KisAdvancedColorSpaceSelector::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::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());
 
     }
 
     fillLstProfiles();
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
index a719130a46..52207e1567 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
@@ -1,560 +1,560 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  */
 
 #include "kis_color_selector_base.h"
 
 #include <QMouseEvent>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QTimer>
 #include <QCursor>
 #include <QPainter>
 #include <QMimeData>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node.h"
 #include "KisViewManager.h"
 #include <KisView.h>
 #include "kis_image.h"
 #include "kis_global.h"
 #include "kis_display_color_converter.h"
 
 #include <resources/KoGamutMask.h>
 
 class KisColorPreviewPopup : public QWidget {
 public:
     KisColorPreviewPopup(KisColorSelectorBase* parent)
         : QWidget(parent), m_parent(parent)
     {
         setWindowFlags(Qt::ToolTip | Qt::NoDropShadowWindowHint);
         setQColor(QColor(0,0,0));
         m_baseColor = QColor(0,0,0,0);
         m_previousColor = QColor(0,0,0,0);
         m_lastUsedColor = QColor(0,0,0,0);
     }
 
     void show()
     {
         updatePosition();
         QWidget::show();
     }
 
     void updatePosition()
     {
         QPoint parentPos = m_parent->mapToGlobal(QPoint(0,0));
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         QPoint targetPos;
         if ( parentPos.x() - 100 > availRect.x() ) {
             targetPos =  QPoint(parentPos.x() - 100, parentPos.y());
         } else if ( parentPos.x() + m_parent->width() + 100 < availRect.right()) {
             targetPos = m_parent->mapToGlobal(QPoint(m_parent->width(), 0));
         } else if ( parentPos.y() - 100 > availRect.y() ) {
             targetPos =  QPoint(parentPos.x(), parentPos.y() - 100);
         } else {
             targetPos =  QPoint(parentPos.x(), parentPos.y() + m_parent->height());
         }
         setGeometry(targetPos.x(), targetPos.y(), 100, 150);
         setAttribute(Qt::WA_TranslucentBackground);
     }
 
     void setQColor(const QColor& color)
     {
         m_color = color;
         update();
     }
 
     void setPreviousColor()
     {
         m_previousColor = m_baseColor;
     }
 
     void setBaseColor(const QColor& color)
     {
         m_baseColor = color;
         update();
     }
 
     void setLastUsedColor(const QColor& color)
     {
         m_lastUsedColor = color;
         update();
     }
 
 protected:
     void paintEvent(QPaintEvent *e) override {
         Q_UNUSED(e);
         QPainter p(this);
         p.fillRect(0, 0, width(), width(), m_color);
         p.fillRect(50, width(), width(), height(), m_previousColor);
         p.fillRect(0, width(), 50, height(), m_lastUsedColor);
     }
 
     void enterEvent(QEvent *e) override {
         QWidget::enterEvent(e);
         m_parent->tryHideAllPopups();
     }
 
     void leaveEvent(QEvent *e) override {
         QWidget::leaveEvent(e);
         m_parent->tryHideAllPopups();
     }
 
 private:
     KisColorSelectorBase* m_parent;
     QColor m_color;
     QColor m_baseColor;
     QColor m_previousColor;
     QColor m_lastUsedColor;
 };
 
 KisColorSelectorBase::KisColorSelectorBase(QWidget *parent) :
     QWidget(parent),
     m_canvas(0),
     m_popup(0),
     m_parent(0),
     m_colorUpdateAllowed(true),
     m_colorUpdateSelf(false),
     m_hideTimer(new QTimer(this)),
     m_popupOnMouseOver(false),
     m_popupOnMouseClick(true),
     m_colorSpace(0),
     m_isPopup(false),
     m_hideOnMouseClick(false),
     m_colorPreviewPopup(new KisColorPreviewPopup(this))
 {
     m_hideTimer->setInterval(0);
     m_hideTimer->setSingleShot(true);
     connect(m_hideTimer, SIGNAL(timeout()), this, SLOT(hidePopup()));
 
     using namespace std::placeholders; // For _1 placeholder
     auto function = std::bind(&KisColorSelectorBase::slotUpdateColorAndPreview, this, _1);
     m_updateColorCompressor.reset(new ColorCompressorType(20 /* ms */, function));
 }
 
 KisColorSelectorBase::~KisColorSelectorBase()
 {
     delete m_popup;
     delete m_colorPreviewPopup;
 }
 
 void KisColorSelectorBase::setPopupBehaviour(bool onMouseOver, bool onMouseClick)
 {
     m_popupOnMouseClick = onMouseClick;
     m_popupOnMouseOver = onMouseOver;
     if(onMouseClick) {
         m_popupOnMouseOver = false;
     }
 
     if(m_popupOnMouseOver) {
         setMouseTracking(true);
     }
 }
 
 void KisColorSelectorBase::setColorSpace(const KoColorSpace *colorSpace)
 {
     m_colorSpace = colorSpace;
 }
 
 void KisColorSelectorBase::setCanvas(KisCanvas2 *canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
     m_canvas = canvas;
     if (m_canvas) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                 SLOT(canvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(reset()), Qt::UniqueConnection);
 
         connect(canvas->imageView()->resourceProvider(), SIGNAL(sigFGColorUsed(KoColor)),
                 this,                               SLOT(updateLastUsedColorPreview(KoColor)), Qt::UniqueConnection);
 
         if (m_canvas->viewManager() && m_canvas->viewManager()->canvasResourceProvider()) {
             setColor(Acs::currentColor(m_canvas->viewManager()->canvasResourceProvider(), Acs::Foreground));
         }
     }
     if (m_popup) {
         m_popup->setCanvas(canvas);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::unsetCanvas()
 {
     if (m_popup) {
         m_popup->unsetCanvas();
     }
     m_canvas = 0;
 }
 
 
 
 void KisColorSelectorBase::mousePressEvent(QMouseEvent* event)
 {
     event->accept();
 
 
-//this boolean here is to check if the colour selector is updating the resource, so it won't update itself when the resource is updated//
+//this boolean here is to check if the color selector is updating the resource, so it won't update itself when the resource is updated//
    if (m_colorUpdateSelf==false)
    {m_colorUpdateSelf=true;}
 
     if(!m_isPopup && m_popupOnMouseClick &&
        event->button() == Qt::MidButton) {
 
         lazyCreatePopup();
 
         int x = event->globalX();
         int y = event->globalY();
         int popupsize = m_popup->width();
         x-=popupsize/2;
         y-=popupsize/2;
 
         QRect availRect = QApplication::desktop()->availableGeometry(this);
         if(x<availRect.x())
             x = availRect.x();
         if(y<availRect.y())
             y = availRect.y();
         if(x+m_popup->width()>availRect.x()+availRect.width())
             x = availRect.x()+availRect.width()-m_popup->width();
         if(y+m_popup->height()>availRect.y()+availRect.height())
             y = availRect.y()+availRect.height()-m_popup->height();
 
         m_popup->move(x, y);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
 
     } else if (m_isPopup && event->button() == Qt::MidButton) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     } else {
         showColorPreview();
         event->ignore();
     }
 }
 
 void KisColorSelectorBase::mouseReleaseEvent(QMouseEvent *e) {
 
    Q_UNUSED(e);
 
     if (e->button() == Qt::MidButton) {
         e->accept();
     } else if (m_isPopup &&
                (m_hideOnMouseClick && !m_popupOnMouseOver) &&
                !m_hideTimer->isActive()) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     }
 }
 
 void KisColorSelectorBase::enterEvent(QEvent *e)
 {
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->stop();
     }
 
     if (m_isPopup && m_hideTimer->isActive()) {
         m_hideTimer->stop();
     }
 
     // do not show the popup when boxed in
     // the configuration dialog (m_canvas == 0)
 
     if (m_canvas &&
         !m_isPopup && m_popupOnMouseOver &&
         (!m_popup || m_popup->isHidden())) {
 
         lazyCreatePopup();
 
         const QRect availRect = QApplication::desktop()->availableGeometry(this);
 
         QPoint proposedTopLeft = rect().center() - m_popup->rect().center();
         proposedTopLeft = mapToGlobal(proposedTopLeft);
 
         QRect popupRect = QRect(proposedTopLeft, m_popup->size());
         popupRect = kisEnsureInRect(popupRect, availRect);
 
         m_popup->setGeometry(popupRect);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
     }
 
     QWidget::enterEvent(e);
 }
 
 void KisColorSelectorBase::leaveEvent(QEvent *e)
 {
     tryHideAllPopups();
     QWidget::leaveEvent(e);
 }
 
 void KisColorSelectorBase::keyPressEvent(QKeyEvent *)
 {
     if (m_isPopup) {
         hidePopup();
     }
 }
 
 void KisColorSelectorBase::dragEnterEvent(QDragEnterEvent *e)
 {
     if(e->mimeData()->hasColor())
         e->acceptProposedAction();
     if(e->mimeData()->hasText() && QColor(e->mimeData()->text()).isValid())
         e->acceptProposedAction();
 }
 
 void KisColorSelectorBase::dropEvent(QDropEvent *e)
 {
     QColor color;
     if(e->mimeData()->hasColor()) {
         color = qvariant_cast<QColor>(e->mimeData()->colorData());
     }
     else if(e->mimeData()->hasText()) {
         color.setNamedColor(e->mimeData()->text());
         if(!color.isValid())
             return;
     }
 
     KoColor kocolor(color , KoColorSpaceRegistry::instance()->rgb8());
     updateColor(kocolor, Acs::Foreground, true);
 }
 
 void KisColorSelectorBase::updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset)
 {
     commitColor(color, role);
 
     if (needsExplicitColorReset) {
         setColor(color);
     }
 }
 
 void KisColorSelectorBase::requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role)
 {
     m_updateColorCompressor->start(qMakePair(color, role));
 }
 
 void KisColorSelectorBase::slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color)
 {
     updateColorPreview(color.first);
     updateColor(color.first, color.second, false);
 }
 
 void KisColorSelectorBase::setColor(const KoColor& color)
 {
     Q_UNUSED(color);
 }
 
 void KisColorSelectorBase::setHidingTime(int time)
 {
     KIS_ASSERT_RECOVER_NOOP(m_isPopup);
 
     m_hideTimer->setInterval(time);
 }
 
 void KisColorSelectorBase::lazyCreatePopup()
 {
     if (!m_popup) {
         m_popup = createPopup();
         Q_ASSERT(m_popup);
         m_popup->setParent(this);
 
         /**
          * On Linux passing Qt::X11BypassWindowManagerHint makes
          * the window never hide if one switches it with Alt+Tab
          * or something like that. The window also don't get any
          * mouse-enter/leave events. So we have to make it normal
          * window (which is visible to the window manager and
          * appears in the tasks bar). Therefore we don't use it
          * anyomore.
          */
         m_popup->setWindowFlags(Qt::FramelessWindowHint |
                                 Qt::Window |
                                 Qt::NoDropShadowWindowHint);
         m_popup->m_parent = this;
         m_popup->m_isPopup=true;
     }
     m_popup->setCanvas(m_canvas);
     m_popup->updateSettings();
 }
 
 void KisColorSelectorBase::showPopup(Move move)
 {
     // This slot may be called by some action,
     // so we need to be able to handle it
     lazyCreatePopup();
 
     QPoint cursorPos = QCursor::pos();
 
     if (move == MoveToMousePosition) {
         m_popup->move(QPoint(cursorPos.x()-m_popup->width()/2, cursorPos.y()-m_popup->height()/2));
         QRect rc = m_popup->geometry();
         if (rc.x() < 0) rc.setX(0);
         if (rc.y() < 0) rc.setY(0);
         m_popup->setGeometry(rc);
     }
 
     if (m_colorPreviewPopup) {
         m_colorPreviewPopup->hide();
     }
 
     m_popup->show();
     m_popup->m_colorPreviewPopup->show();
 }
 
 void KisColorSelectorBase::hidePopup()
 {
     KIS_ASSERT_RECOVER_RETURN(m_isPopup);
 
     m_colorPreviewPopup->hide();
     hide();
 }
 
 void KisColorSelectorBase::commitColor(const KoColor& color, Acs::ColorRole role)
 {
     if (!m_canvas)
         return;
 
     m_colorUpdateAllowed=false;
 
     if (role == Acs::Foreground)
         m_canvas->resourceManager()->setForegroundColor(color);
     else
         m_canvas->resourceManager()->setBackgroundColor(color);
 
     m_colorUpdateAllowed=true;
 }
 
 void KisColorSelectorBase::showColorPreview()
 {
     if(m_colorPreviewPopup->isHidden()) {
         m_colorPreviewPopup->show();
     }
 }
 
 void KisColorSelectorBase::updateColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setQColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::canvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoColor realColor(v.value<KoColor>());
         updateColorPreview(realColor);
         if (m_colorUpdateAllowed && !m_colorUpdateSelf) {
             setColor(realColor);
         }
     }
 }
 
 const KoColorSpace* KisColorSelectorBase::colorSpace() const
 {
     return converter()->paintingColorSpace();
 }
 
 void KisColorSelectorBase::updateSettings()
 {
     if(m_popup) {
         m_popup->updateSettings();
     }
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
 
    int zoomSelectorOptions =  (int) cfg.readEntry("zoomSelectorOptions", 0) ;
    if (zoomSelectorOptions == 0)   {
        setPopupBehaviour(false, true);   // middle mouse button click will open zoom selector
    } else if (zoomSelectorOptions == 1)   {
        setPopupBehaviour(true, false);   // move over will open the zoom selector
    }
    else
    {
         setPopupBehaviour(false, false); // do not show zoom selector
    }
 
 
     if(m_isPopup) {
         m_hideOnMouseClick = cfg.readEntry("hidePopupOnClickCheck", false);
         const int zoomSize = cfg.readEntry("zoomSize", 280);
         resize(zoomSize, zoomSize);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::reset()
 {
     update();
 }
 
 void KisColorSelectorBase::updateBaseColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setBaseColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::updatePreviousColorPreview()
 {
     m_colorPreviewPopup->setPreviousColor();
 }
 
 void KisColorSelectorBase::updateLastUsedColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setLastUsedColor(converter()->toQColor(color));
 }
 
 KisDisplayColorConverter* KisColorSelectorBase::converter() const
 {
     return m_canvas ?
         m_canvas->displayColorConverter() :
                 KisDisplayColorConverter::dumbConverterInstance();
 }
 
 void KisColorSelectorBase::tryHideAllPopups()
 {
     if (m_colorPreviewPopup->isVisible()) {
-        m_colorUpdateSelf=false; //this is for allowing advanced selector to listen to outside colour-change events.
+        m_colorUpdateSelf=false; //this is for allowing advanced selector to listen to outside color-change events.
         m_colorPreviewPopup->hide();
     }
 
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->start();
     }
 
     if (m_isPopup && !m_hideTimer->isActive()) {
         m_hideTimer->start();
     }
 }
 
 
 void KisColorSelectorBase::mouseMoveEvent(QMouseEvent *event)
 {
     event->accept();
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
index eca0b2f979..9358370992 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.h
@@ -1,132 +1,132 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  */
 
 #ifndef KIS_COLOR_SELECTOR_BASE_H
 #define KIS_COLOR_SELECTOR_BASE_H
 
 #include <QWidget>
 #include <QRgb>
 #include <QPointer>
 #include <kis_canvas2.h>
 #include "kis_acs_types.h"
 #include "kis_signal_compressor_with_param.h"
 
 
 class KoColor;
 class QTimer;
 class KoColorSpace;
 class KisCanvas2;
 class KisColorPreviewPopup;
 class KisDisplayColorConverter;
 class KoGamutMask;
 
 
 /// Base class for all color selectors, that should support color management and zooming.
 class KisColorSelectorBase : public QWidget
 {
 Q_OBJECT
 public:
     enum Move {MoveToMousePosition, DontMove};
     explicit KisColorSelectorBase(QWidget *parent = 0);
     ~KisColorSelectorBase() override;
 
     void setPopupBehaviour(bool onMouseOver, bool onMouseClick);
     void setColorSpace(const KoColorSpace* colorSpace);
     virtual void setCanvas(KisCanvas2* canvas);
     virtual void unsetCanvas();
     const KoColorSpace* colorSpace() const;
 
     KisDisplayColorConverter* converter() const;
 
     void tryHideAllPopups();
 
 public:
     void updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset);
     void updateColorPreview(const KoColor &color);
     void showColorPreview();
     void updateBaseColorPreview(const KoColor &color);
     void updatePreviousColorPreview();
 
     virtual void setColor(const KoColor& color);
 
 public Q_SLOTS:
     /**
      * Flushes caches and redraws the selectors
      */
     virtual void reset();
 
     virtual void updateSettings();
     virtual void showPopup(Move move=MoveToMousePosition);
 
 public:
     void enterEvent(QEvent *e) override;
     void leaveEvent(QEvent *e) override;
 
     void mousePressEvent(QMouseEvent *) override;
     void mouseReleaseEvent(QMouseEvent *) override;
 
 protected:
     void keyPressEvent(QKeyEvent *) override;
     virtual KisColorSelectorBase* createPopup() const = 0;
     void dragEnterEvent(QDragEnterEvent *) override;
     void dropEvent(QDropEvent *) override;
     void setHidingTime(int time);
     bool isPopup() const { return m_isPopup; }
     void mouseMoveEvent(QMouseEvent *event) override;
     void requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role);
 
 private:
     void commitColor(const KoColor& koColor, Acs::ColorRole role);
 
 
 protected Q_SLOTS:
     void hidePopup();
 
-    /// if you overwrite this, keep in mind, that you should set the colour only, if m_colorUpdateAllowed is true
+    /// if you overwrite this, keep in mind, that you should set the color only, if m_colorUpdateAllowed is true
     virtual void canvasResourceChanged(int key, const QVariant& v);
 
     void updateLastUsedColorPreview(const KoColor &color);
 
 public:
     // This is a private interface for signal compressor, don't use it.
     // Use requestUpdateColorAndPreview() instead
     void slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color);
 
 private:
     void lazyCreatePopup();
 
 protected:
     QPointer<KisCanvas2> m_canvas;
     KisColorSelectorBase* m_popup;
     QWidget* m_parent;
     bool m_colorUpdateAllowed;
     bool m_colorUpdateSelf;
 
 private:
     QTimer* m_hideTimer;
     bool m_popupOnMouseOver;
     bool m_popupOnMouseClick;
     mutable const KoColorSpace* m_colorSpace;
     bool m_isPopup; //this instance is a popup
     bool m_hideOnMouseClick;
     KisColorPreviewPopup* m_colorPreviewPopup;
 
     typedef KisSignalCompressorWithParam<QPair<KoColor, Acs::ColorRole>> ColorCompressorType;
     QScopedPointer<ColorCompressorType> m_updateColorCompressor;
 };
 
 #endif
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_component.h b/plugins/dockers/advancedcolorselector/kis_color_selector_component.h
index eca2e3e37a..79da0c12aa 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_component.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_component.h
@@ -1,131 +1,131 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  */
 
 #ifndef KIS_COLOR_SELECTOR_COMPONENT_H
 #define KIS_COLOR_SELECTOR_COMPONENT_H
 
 #include <QObject>
 #include <QColor>
 
 #include <resources/KoGamutMask.h>
 
 #include "kis_color_selector.h"
 
 class KoColorSpace;
 
 class QPainter;
 
 
 class KisColorSelectorComponent : public QObject
 {
     Q_OBJECT
 public:
     typedef KisColorSelectorConfiguration::Parameters Parameter;
     typedef KisColorSelectorConfiguration::Type Type;
 
     explicit KisColorSelectorComponent(KisColorSelector* parent);
     void setGeometry(int x, int y, int width, int height);
     void paintEvent(QPainter*);
 
     /// saves the mouse position, so that a blip can be created.
     virtual void mouseEvent(int x, int y);
 
     /// return the color, that was selected by calling mouseEvent
     KoColor currentColor();
 
     int width() const;
     int height() const;
 
     /// setConfiguration can be ignored (for instance ring and triangle, as they can have only one config)
     void setConfiguration(Parameter param, Type type);
 
     /// set the color, blibs etc
     virtual void setColor(const KoColor& color);
 
     /// force subsequent redraw of the component
     void setDirty();
 
     /// returns true, if this component wants to grab the mouse (normally true, if containsPoint returns true)
     bool wantsGrab(int x, int y) {return containsPointInComponentCoords(x-m_x, y-m_y);}
 
     void setGamutMask(KoGamutMask* gamutMask);
     void unsetGamutMask();
     void updateGamutMaskPreview();
     void toggleGamutMask(bool state);
 
 public Q_SLOTS:
     /// set hue, saturation, value or/and lightness
     /// unused parameters should be set to -1
     void setParam(qreal hue, qreal hsvSaturation, qreal value, qreal hslSaturation, qreal lightness, qreal hsiSaturation, qreal intensity, qreal hsySaturation, qreal luma);
 Q_SIGNALS:
     /// request for repaint, for instance, if the hue changes.
     void update();
     /// -1, if unaffected
     void paramChanged(qreal hue, qreal hsvSaturation, qreal value, qreal hslSaturation, qreal lightness, qreal hsiSaturation, qreal intensity, qreal hsySaturation, qreal luma);
 protected:
     const KoColorSpace* colorSpace() const;
-    /// returns true, if ether the colour space, the size or the parameters have changed since the last paint event
+    /// returns true, if ether the color space, the size or the parameters have changed since the last paint event
     bool isDirty() const;
 
-    /// this method must be overloaded to return the colour at position x/y and draw a marker on that position
+    /// this method must be overloaded to return the color at position x/y and draw a marker on that position
     virtual KoColor selectColor(int x, int y) = 0;
 
     /// paint component using given painter
     /// the component should respect width() and height() (eg. scale to width and height), but doesn't
     /// have to care about x/y coordinates (top left corner)
     virtual void paint(QPainter*) = 0;
 
     /// a subclass can implement this method, the default returns true if the coordinates are in the component rect
     /// values for the subclasses are provided in component coordinates, eg (0,0) is top left of component
     virtual bool containsPointInComponentCoords(int x, int y) const;
 
     /// a subclass can implement this method to note that the point, although it is in
     /// containsPointInComponentCoords area, still cannot be selected as a color (e.g.
     /// it is masked out). Default implementation always returns true.
     virtual bool allowsColorSelectionAtPoint(const QPoint &) const;
 
     // Workaround for Bug 287001
     void setLastMousePosition(int x, int y);
 
     qreal m_hue;
     qreal m_hsvSaturation;
     qreal m_value;
     qreal m_hslSaturation;
     qreal m_lightness;
     qreal m_hsiSaturation;
     qreal m_intensity;
     qreal m_hsySaturation;
     qreal m_luma;
     Parameter m_parameter;
     Type m_type;
     KisColorSelector* m_parent;
     bool m_gamutMaskOn;
     KoGamutMask* m_currentGamutMask;
     bool m_maskPreviewActive;
     qreal m_lastX;
     qreal m_lastY;
     int m_x;
     int m_y;
 private:
     int m_width;
     int m_height;
     bool m_dirty;
     const KoColorSpace* m_lastColorSpace;
     KoColor m_lastSelectedColor;
 };
 
 #endif // KIS_COLOR_SELECTOR_COMPONENT_H
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
index 3c3be144d0..86d688fa15 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_settings.cpp
@@ -1,632 +1,632 @@
 /*
  *  Copyright (C) 2010 Celarek Adam <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_color_selector_settings.h"
 #include "ui_wdg_color_selector_settings.h"
 
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QComboBox>
 
 #include <kconfiggroup.h>
 
 
 #include <kis_icon.h>
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 
 #include "kis_color_selector_combo_box.h"
 #include "kis_color_selector.h"
 #include "kis_config.h"
 
 
 KisColorSelectorSettings::KisColorSelectorSettings(QWidget *parent) :
     KisPreferenceSet(parent),
     ui(new Ui::KisColorSelectorSettings)
 {
     ui->setupUi(this);
 
     resize(minimumSize());
 
     ui->colorSelectorConfiguration->setColorSpace(ui->colorSpace->currentColorSpace());
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
 
     connect(ui->useDifferentColorSpaceCheckbox, SIGNAL(clicked(bool)), this, SLOT(useDifferentColorSpaceChecked(bool)));
 
     /* color docker selector drop down */
     ui->dockerColorSettingsComboBox->addItem(i18n("Advanced Color Selector"));
     //ui->dockerColorSettingsComboBox->addItem(i18n("Color Sliders"));
     ui->dockerColorSettingsComboBox->addItem(i18n("Color Hotkeys"));
     ui->dockerColorSettingsComboBox->setCurrentIndex(0); // start off seeing advanced color selector properties
 
     connect( ui->dockerColorSettingsComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedColorDocker(int)));
     changedColorDocker(0);
 
 
     /* advanced color docker options */
     ui->dockerResizeOptionsComboBox->addItem(i18n("Change to a Horizontal Layout"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Hide Shade Selector"));
     ui->dockerResizeOptionsComboBox->addItem(i18n("Do Nothing"));
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
 
 
     ui->zoomSelectorOptionComboBox->addItem(i18n("When Pressing Middle Mouse Button"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("On Mouse Over"));
     ui->zoomSelectorOptionComboBox->addItem(i18n("Never"));
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
 
 
     ui->colorSelectorTypeComboBox->addItem(i18n("HSV"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSL"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSI"));
     ui->colorSelectorTypeComboBox->addItem(i18n("HSY'"));
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
     connect( ui->colorSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSColorSelectorType(int)));
     changedACSColorSelectorType(0); // initialize everything to HSV at the start
 
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSV"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSL"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSI"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->addItem(i18n("HSY'"));
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
 
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("MyPaint"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Minimal"));
     ui->ACSShadeSelectorTypeComboBox->addItem(i18n("Do Not Show"));
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     changedACSShadeSelectorType(0); // show/hide UI elements for MyPaint settings
     connect( ui->ACSShadeSelectorTypeComboBox, SIGNAL(currentIndexChanged(int)),this, SLOT(changedACSShadeSelectorType(int)));
 
 
     ui->commonColorsAlignVertical->setChecked(true);
     ui->commonColorsAlignHorizontal->setChecked(true);
     connect( ui->commonColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSColorAlignment(bool)));
     connect( ui->lastUsedColorsAlignHorizontal, SIGNAL(toggled(bool)), this, SLOT(changedACSLastUsedColorAlignment(bool)));
 
     changedACSColorAlignment(ui->commonColorsAlignHorizontal->isChecked());
     changedACSLastUsedColorAlignment(ui->lastUsedColorsAlignHorizontal->isChecked());
 
 
     connect(ui->colorSpace,                 SIGNAL(colorSpaceChanged(const KoColorSpace*)),
             ui->colorSelectorConfiguration, SLOT(setColorSpace(const KoColorSpace*)));
 
 
     connect(this, SIGNAL(hsxchanged(int)),
             ui->colorSelectorConfiguration, SLOT(setList(int)));
 
     connect(ui->minimalShadeSelectorLineCount,      SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SLOT(setLineCount(int)));
 
     connect(ui->minimalShadeSelectorLineSettings,   SIGNAL(lineCountChanged(int)),
             ui->minimalShadeSelectorLineCount,      SLOT(setValue(int)));
 
     connect(ui->minimalShadeSelectorAsGradient,     SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setGradient(bool)));
 
     connect(ui->minimalShadeSelectorAsColorPatches, SIGNAL(toggled(bool)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatches(bool)));
 
     connect(ui->minimalShadeSelectorLineHeight,     SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setLineHeight(int)));
 
     connect(ui->minimalShadeSelectorPatchesPerLine, SIGNAL(valueChanged(int)),
             ui->minimalShadeSelectorLineSettings,   SIGNAL(setPatchCount(int)));
 }
 
 KisColorSelectorSettings::~KisColorSelectorSettings()
 {
     delete ui;
 }
 
 QString KisColorSelectorSettings::id()
 {
     return QString("advancedColorSelector");
 }
 
 QString KisColorSelectorSettings::name()
 {
     return header();
 }
 
 QString KisColorSelectorSettings::header()
 {
     return QString(i18n("Color Selector Settings"));
 }
 
 
 QIcon KisColorSelectorSettings::icon()
 {
     return KisIconUtils::loadIcon("extended_color_selector");
 }
 
 
 void KisColorSelectorSettings::savePreferences() const
 {
     // write cfg
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
     //  advanced color selector
     cfg.writeEntry("onDockerResize", ui->dockerResizeOptionsComboBox->currentIndex());
     cfg.writeEntry("zoomSelectorOptions", ui->zoomSelectorOptionComboBox->currentIndex() );
     cfg.writeEntry("zoomSize", ui->popupSize->value());
     cfg.writeEntry("showColorSelector", ui->chkShowColorSelector->isChecked());
 
     bool useCustomColorSpace =  ui->useDifferentColorSpaceCheckbox->isChecked();
     const KoColorSpace* colorSpace = useCustomColorSpace ? ui->colorSpace->currentColorSpace() : 0;
 
     KisConfig kisconfig(false);
     kisconfig.setCustomColorSelectorColorSpace(colorSpace);
 
     //color patches
     cfg.writeEntry("lastUsedColorsShow", ui->lastUsedColorsShow->isChecked());
     cfg.writeEntry("lastUsedColorsAlignment", ui->lastUsedColorsAlignVertical->isChecked());
     cfg.writeEntry("lastUsedColorsScrolling", ui->lastUsedColorsAllowScrolling->isChecked());
     cfg.writeEntry("lastUsedColorsNumCols", ui->lastUsedColorsNumCols->value());
     cfg.writeEntry("lastUsedColorsNumRows", ui->lastUsedColorsNumRows->value());
     cfg.writeEntry("lastUsedColorsCount", ui->lastUsedColorsPatchCount->value());
     cfg.writeEntry("lastUsedColorsWidth", ui->lastUsedColorsWidth->value());
     cfg.writeEntry("lastUsedColorsHeight", ui->lastUsedColorsHeight->value());
 
     cfg.writeEntry("commonColorsShow", ui->commonColorsShow->isChecked());
     cfg.writeEntry("commonColorsAlignment", ui->commonColorsAlignVertical->isChecked());
     cfg.writeEntry("commonColorsScrolling", ui->commonColorsAllowScrolling->isChecked());
     cfg.writeEntry("commonColorsNumCols", ui->commonColorsNumCols->value());
     cfg.writeEntry("commonColorsNumRows", ui->commonColorsNumRows->value());
     cfg.writeEntry("commonColorsCount", ui->commonColorsPatchCount->value());
     cfg.writeEntry("commonColorsWidth", ui->commonColorsWidth->value());
     cfg.writeEntry("commonColorsHeight", ui->commonColorsHeight->value());
     cfg.writeEntry("commonColorsAutoUpdate", ui->commonColorsAutoUpdate->isChecked());
 
     //shade selector
 
 
 
     int shadeSelectorTypeIndex =  ui->ACSShadeSelectorTypeComboBox->currentIndex();
 
     if(shadeSelectorTypeIndex == 0) {
         cfg.writeEntry("shadeSelectorType", "MyPaint");
     } else if (shadeSelectorTypeIndex == 1) {
         cfg.writeEntry("shadeSelectorType", "Minimal");
     } else {
         cfg.writeEntry("shadeSelectorType", "Hidden");
     }
 
     cfg.writeEntry("shadeSelectorUpdateOnRightClick", ui->shadeSelectorUpdateOnRightClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnForeground", ui->shadeSelectorUpdateOnForeground->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnLeftClick", ui->shadeSelectorUpdateOnLeftClick->isChecked());
     cfg.writeEntry("shadeSelectorUpdateOnBackground", ui->shadeSelectorUpdateOnBackground->isChecked());
     cfg.writeEntry("hidePopupOnClickCheck", ui->hidePopupOnClickCheck->isChecked());
 
     //mypaint model
 
     int shadeMyPaintComboBoxIndex  = ui->ACSshadeSelectorMyPaintColorModelComboBox->currentIndex();
     if (shadeMyPaintComboBoxIndex == 0 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSV");
     } else  if (shadeMyPaintComboBoxIndex == 1 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSL");
     } else  if (shadeMyPaintComboBoxIndex == 2 ) {
         cfg.writeEntry("shadeMyPaintType",   "HSI");
     } else {   // HSY
         cfg.writeEntry("shadeMyPaintType",   "HSY");
     }
 
 
 
     cfg.writeEntry("minimalShadeSelectorAsGradient", ui->minimalShadeSelectorAsGradient->isChecked());
     cfg.writeEntry("minimalShadeSelectorPatchCount", ui->minimalShadeSelectorPatchesPerLine->value());
     cfg.writeEntry("minimalShadeSelectorLineConfig",  ui->minimalShadeSelectorLineSettings->toString());
     cfg.writeEntry("minimalShadeSelectorLineHeight", ui->minimalShadeSelectorLineHeight->value());
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cfg.writeEntry("colorSelectorConfiguration", cstw->configuration().toString());
 
     cfg.writeEntry("hsxSettingType", ui->colorSelectorTypeComboBox->currentIndex());
 
     //luma//
     cfg.writeEntry("lumaR", ui->l_lumaR->value());
     cfg.writeEntry("lumaG", ui->l_lumaG->value());
     cfg.writeEntry("lumaB", ui->l_lumaB->value());
     cfg.writeEntry("gamma", ui->SP_Gamma->value());
 
     //slider//
     hsxcfg.writeEntry("hsvH", ui->csl_hsvH->isChecked());
     hsxcfg.writeEntry("hsvS", ui->csl_hsvS->isChecked());
     hsxcfg.writeEntry("hsvV", ui->csl_hsvV->isChecked());
     hsxcfg.writeEntry("hslH", ui->csl_hslH->isChecked());
     hsxcfg.writeEntry("hslS", ui->csl_hslS->isChecked());
     hsxcfg.writeEntry("hslL", ui->csl_hslL->isChecked());
     hsxcfg.writeEntry("hsiH", ui->csl_hsiH->isChecked());
     hsxcfg.writeEntry("hsiS", ui->csl_hsiS->isChecked());
     hsxcfg.writeEntry("hsiI", ui->csl_hsiI->isChecked());
     hsxcfg.writeEntry("hsyH", ui->csl_hsyH->isChecked());
     hsxcfg.writeEntry("hsyS", ui->csl_hsyS->isChecked());
     hsxcfg.writeEntry("hsyY", ui->csl_hsyY->isChecked());
 
     //hotkeys//
     hotkeycfg.writeEntry("steps_lightness", ui->sb_lightness->value());
     hotkeycfg.writeEntry("steps_saturation", ui->sb_saturation->value());
     hotkeycfg.writeEntry("steps_hue", ui->sb_hue->value());
     hotkeycfg.writeEntry("steps_redgreen", ui->sb_rg->value());
     hotkeycfg.writeEntry("steps_blueyellow", ui->sb_by->value());
 
     emit settingsChanged();
 }
 
 //void KisColorSelectorSettings::changeEvent(QEvent *e)
 //{
 //    QDialog::changeEvent(e);
 //    switch (e->type()) {
 //    case QEvent::LanguageChange:
 //        ui->retranslateUi(this);
 //        break;
 //    default:
 //        break;
 //    }
 //}
 
 
 void KisColorSelectorSettings::changedColorDocker(int index)
 {
     // having a situation where too many sections are visible makes the window too large. turn all off before turning more on
     ui->colorSliderOptions->hide();
     ui->advancedColorSelectorOptions->hide();
     ui->hotKeyOptions->hide();
 
     if (index == 0)     { // advanced color selector options selected
         ui->advancedColorSelectorOptions->show();
         ui->colorSliderOptions->hide();
         ui->hotKeyOptions->hide();
     }
 //    else if (index == 1) {  // color slider options selected
 //        ui->advancedColorSelectorOptions->hide();
 //        ui->hotKeyOptions->hide();
 //        ui->colorSliderOptions->show();
 //    }
     else {
        ui->colorSliderOptions->hide();
        ui->advancedColorSelectorOptions->hide();
        ui->hotKeyOptions->show();
     }
 }
 
 void KisColorSelectorSettings::changedACSColorSelectorType(int index)
 {
     ui->lumaCoefficientGroupbox->setVisible(false);
 
     if (index == 0)     {  // HSV
-        ui->ACSTypeDescriptionLabel->setText(i18n("Values goes from black to white, or black to the most saturated colour. Saturation, in turn, goes from the most saturated colour to white, grey or black."));
+        ui->ACSTypeDescriptionLabel->setText(i18n("Values goes from black to white, or black to the most saturated color. Saturation, in turn, goes from the most saturated color to white, gray or black."));
     }
     else if (index == 1)     {  // HSL
-        ui->ACSTypeDescriptionLabel->setText(i18n("Lightness goes from black to white, with middle grey being equal to the most saturated colour."));
+        ui->ACSTypeDescriptionLabel->setText(i18n("Lightness goes from black to white, with middle gray being equal to the most saturated color."));
     }
     else if (index == 2)     {  // HSI
         ui->ACSTypeDescriptionLabel->setText(i18n("Intensity maps to the sum of rgb components"));
     }
     else {  // HSY'
         ui->ACSTypeDescriptionLabel->setText(i18n("Luma(Y') is weighted by its coefficients which are configurable. Default values are set to 'rec 709'."));
         ui->lumaCoefficientGroupbox->setVisible(true);
     }
 
     ui->colorSelectorConfiguration->update();
     emit hsxchanged(index);
 
 }
 
 
 void KisColorSelectorSettings::changedACSColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_commonColorsNumCols->setDisabled(toggled);
     ui->commonColorsNumCols->setDisabled(toggled);
 
     ui->lbl_commonColorsNumRows->setEnabled(toggled);
     ui->commonColorsNumRows->setEnabled(toggled);
 }
 
 void KisColorSelectorSettings::changedACSLastUsedColorAlignment(bool toggled)
 {
     // this slot is tied to the horizontal radio button's state being changed
     // you can infer the vertical state
 
     ui->lbl_lastUsedNumCols->setDisabled(toggled);
     ui->lastUsedColorsNumCols->setDisabled(toggled);
 
     ui->lbl_lastUsedNumRows->setEnabled(toggled);
     ui->lastUsedColorsNumRows->setEnabled(toggled);
 }
 
 void KisColorSelectorSettings::changedACSShadeSelectorType(int index)
 {
 
     if (index == 0)     {  // MyPaint
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->show();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->show();
 
     } else if (index == 1) { // Minimal
         ui->minimalShadeSelectorGroup->show();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
 
     }else { // do not show
         ui->minimalShadeSelectorGroup->hide();
         ui->myPaintColorModelLabel->hide();
         ui->ACSshadeSelectorMyPaintColorModelComboBox->hide();
     }
 }
 
 void KisColorSelectorSettings::useDifferentColorSpaceChecked(bool enabled)
 {
     ui->colorSpace->setEnabled(enabled);
 }
 
 void KisColorSelectorSettings::loadPreferences()
 {
     //read cfg
     //don't forget to also add a new entry to the default preferences
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     KConfigGroup hsxcfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
     KConfigGroup hotkeycfg =  KSharedConfig::openConfig()->group("colorhotkeys");
 
 
     // Advanced color selector
     ui->dockerResizeOptionsComboBox->setCurrentIndex(  (int)cfg.readEntry("onDockerResize", 0) );
     ui->zoomSelectorOptionComboBox->setCurrentIndex(   (int) cfg.readEntry("zoomSelectorOptions", 0) );
     ui->popupSize->setValue(cfg.readEntry("zoomSize", 280));
     ui->chkShowColorSelector->setChecked((bool) cfg.readEntry("showColorSelector", true));
 
     {
         KisConfig kisconfig(true);
         const KoColorSpace *cs = kisconfig.customColorSelectorColorSpace();
 
         if (cs) {
             ui->useDifferentColorSpaceCheckbox->setChecked(true);
             ui->colorSpace->setEnabled(true);
             ui->colorSpace->setCurrentColorSpace(cs);
         } else {
             ui->useDifferentColorSpaceCheckbox->setChecked(false);
             ui->colorSpace->setEnabled(false);
         }
     }
 
 
     //color patches
     ui->lastUsedColorsShow->setChecked(cfg.readEntry("lastUsedColorsShow", true));
     bool a = cfg.readEntry("lastUsedColorsAlignment", true);
     ui->lastUsedColorsAlignVertical->setChecked(a);
     ui->lastUsedColorsAlignHorizontal->setChecked(!a);
     ui->lastUsedColorsAllowScrolling->setChecked(cfg.readEntry("lastUsedColorsScrolling", true));
     ui->lastUsedColorsNumCols->setValue(cfg.readEntry("lastUsedColorsNumCols", 1));
     ui->lastUsedColorsNumRows->setValue(cfg.readEntry("lastUsedColorsNumRows", 1));
     ui->lastUsedColorsPatchCount->setValue(cfg.readEntry("lastUsedColorsCount", 20));
     ui->lastUsedColorsWidth->setValue(cfg.readEntry("lastUsedColorsWidth", 16));
     ui->lastUsedColorsHeight->setValue(cfg.readEntry("lastUsedColorsHeight", 16));
 
     ui->commonColorsShow->setChecked(cfg.readEntry("commonColorsShow", true));
     a = cfg.readEntry("commonColorsAlignment", false);
     ui->commonColorsAlignVertical->setChecked(a);
     ui->commonColorsAlignHorizontal->setChecked(!a);
     ui->commonColorsAllowScrolling->setChecked(cfg.readEntry("commonColorsScrolling", true));
     ui->commonColorsNumCols->setValue(cfg.readEntry("commonColorsNumCols", 1));
     ui->commonColorsNumRows->setValue(cfg.readEntry("commonColorsNumRows", 1));
     ui->commonColorsPatchCount->setValue(cfg.readEntry("commonColorsCount", 12));
     ui->commonColorsWidth->setValue(cfg.readEntry("commonColorsWidth", 16));
     ui->commonColorsHeight->setValue(cfg.readEntry("commonColorsHeight", 16));
     ui->commonColorsAutoUpdate->setChecked(cfg.readEntry("commonColorsAutoUpdate", false));
 
     //shade selector
     QString shadeSelectorType=cfg.readEntry("shadeSelectorType", "Minimal");
 
     if ( shadeSelectorType == "MyPaint") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(0);
     } else if (shadeSelectorType == "Minimal") {
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1);
     } else {   // Hidden
         ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(2);
     }
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnRightClick", false));
     ui->shadeSelectorUpdateOnLeftClick->setChecked(cfg.readEntry("shadeSelectorUpdateOnLeftClick", false));
     ui->shadeSelectorUpdateOnForeground->setChecked(cfg.readEntry("shadeSelectorUpdateOnForeground", true));
     ui->shadeSelectorUpdateOnBackground->setChecked(cfg.readEntry("shadeSelectorUpdateOnBackground", true));
     ui->hidePopupOnClickCheck->setChecked(cfg.readEntry("hidePopupOnClickCheck", false));
 
     QString shadeMyPaintType = cfg.readEntry("shadeMyPaintType", "HSV");
 
     if (shadeMyPaintType == "HSV" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
     } else  if (shadeMyPaintType == "HSL" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(1);
     } else  if (shadeMyPaintType == "HSI" ) {
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(2);
     } else {   // HSY
         ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(3);
     }
 
 
     bool asGradient = cfg.readEntry("minimalShadeSelectorAsGradient", true);
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(cfg.readEntry("minimalShadeSelectorPatchCount", 10));
     ui->minimalShadeSelectorLineSettings->fromString(cfg.readEntry("minimalShadeSelectorLineConfig", "0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;"));
     ui->minimalShadeSelectorLineHeight->setValue(cfg.readEntry("minimalShadeSelectorLineHeight", 10));
 
     int hsxSettingType= (int)cfg.readEntry("hsxSettingType", 0);
     ui->colorSelectorTypeComboBox->setCurrentIndex(hsxSettingType);
 
 
     //color selector
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", "3|0|5|0"))); // triangle selector
 
     //luma values//
     ui->l_lumaR->setValue(cfg.readEntry("lumaR", 0.2126));
     ui->l_lumaG->setValue(cfg.readEntry("lumaG", 0.7152));
     ui->l_lumaB->setValue(cfg.readEntry("lumaB", 0.0722));
     ui->SP_Gamma->setValue(cfg.readEntry("gamma", 2.2));
 
     //color sliders//
     ui->csl_hsvH->setChecked(hsxcfg.readEntry("hsvH", false));
     ui->csl_hsvS->setChecked(hsxcfg.readEntry("hsvS", false));
     ui->csl_hsvV->setChecked(hsxcfg.readEntry("hsvV", false));
     ui->csl_hslH->setChecked(hsxcfg.readEntry("hslH", true));
     ui->csl_hslS->setChecked(hsxcfg.readEntry("hslS", true));
     ui->csl_hslL->setChecked(hsxcfg.readEntry("hslL", true));
     ui->csl_hsiH->setChecked(hsxcfg.readEntry("hsiH", false));
     ui->csl_hsiS->setChecked(hsxcfg.readEntry("hsiS", false));
     ui->csl_hsiI->setChecked(hsxcfg.readEntry("hsiI", false));
     ui->csl_hsyH->setChecked(hsxcfg.readEntry("hsyH", false));
     ui->csl_hsyS->setChecked(hsxcfg.readEntry("hsyS", false));
     ui->csl_hsyY->setChecked(hsxcfg.readEntry("hsyY", false));
 
     //hotkeys//
     ui->sb_lightness->setValue(hotkeycfg.readEntry("steps_lightness", 10));
     ui->sb_saturation->setValue(hotkeycfg.readEntry("steps_saturation", 10));
     ui->sb_hue->setValue(hotkeycfg.readEntry("steps_hue", 36));
     ui->sb_rg->setValue(hotkeycfg.readEntry("steps_redgreen", 10));
     ui->sb_by->setValue(hotkeycfg.readEntry("steps_blueyellow", 10));
 
 
 }
 
 void KisColorSelectorSettings::loadDefaultPreferences()
 {
     //set defaults
     //if you change something, don't forget that loadPreferences should be kept in sync
 
     // advanced color selector docker
     ui->dockerResizeOptionsComboBox->setCurrentIndex(0);
     ui->zoomSelectorOptionComboBox->setCurrentIndex(0);
     ui->popupSize->setValue(280);
     ui->chkShowColorSelector->setChecked(true);
 
 
     ui->useDifferentColorSpaceCheckbox->setChecked(false);
     ui->colorSpace->setCurrentColorModel(KoID("RGBA"));
     ui->colorSpace->setCurrentColorDepth(KoID("U8"));
     ui->colorSpace->setCurrentProfile(KoColorSpaceRegistry::instance()->rgb8()->profile()->name());
 
     //color patches
     ui->lastUsedColorsShow->setChecked(true);
     ui->lastUsedColorsAlignVertical->setChecked(true);
     ui->lastUsedColorsAlignHorizontal->setChecked(false);
     ui->lastUsedColorsAllowScrolling->setChecked(true);
     ui->lastUsedColorsNumCols->setValue(1);
     ui->lastUsedColorsNumRows->setValue(1);
     ui->lastUsedColorsPatchCount->setValue(20);
     ui->lastUsedColorsWidth->setValue(16);
     ui->lastUsedColorsHeight->setValue(16);
 
     ui->commonColorsShow->setChecked(true);
     ui->commonColorsAlignVertical->setChecked(false);
     ui->commonColorsAlignHorizontal->setChecked(true);
     ui->commonColorsAllowScrolling->setChecked(true);
     ui->commonColorsNumCols->setValue(1);
     ui->commonColorsNumRows->setValue(1);
     ui->commonColorsPatchCount->setValue(12);
     ui->commonColorsWidth->setValue(16);
     ui->commonColorsHeight->setValue(16);
     ui->commonColorsAutoUpdate->setChecked(false);
 
     //shade selector
     ui->ACSShadeSelectorTypeComboBox->setCurrentIndex(1); // Minimal
 
     ui->ACSshadeSelectorMyPaintColorModelComboBox->setCurrentIndex(0);
 
     ui->shadeSelectorUpdateOnRightClick->setChecked(false);
     ui->shadeSelectorUpdateOnLeftClick->setChecked(false);
     ui->shadeSelectorUpdateOnForeground->setChecked(true);
     ui->shadeSelectorUpdateOnBackground->setChecked(true);
 
     bool asGradient = true;
     if(asGradient) ui->minimalShadeSelectorAsGradient->setChecked(true);
     else ui->minimalShadeSelectorAsColorPatches->setChecked(true);
 
     ui->minimalShadeSelectorPatchesPerLine->setValue(10);
     ui->minimalShadeSelectorLineSettings->fromString("0|0.2|0|0|0|0|0;1|0|1|1|0|0|0;2|0|-1|1|0|0|0;");
     ui->minimalShadeSelectorLineHeight->setValue(10);
 
     // set advanced color selector to use HSV
     ui->colorSelectorTypeComboBox->setCurrentIndex(0);
 
     KisColorSelectorComboBox* cstw = dynamic_cast<KisColorSelectorComboBox*>(ui->colorSelectorConfiguration);
     cstw->setConfiguration(KisColorSelectorConfiguration("3|0|5|0")); // triangle selector
 
     //luma//
     ui->l_lumaR->setValue(0.2126);
     ui->l_lumaG->setValue(0.7152);
     ui->l_lumaB->setValue(0.0722);
     ui->SP_Gamma->setValue(2.2);
 
     //color sliders//
     ui->csl_hsvH->setChecked(false);
     ui->csl_hsvS->setChecked(false);
     ui->csl_hsvV->setChecked(false);
     ui->csl_hslH->setChecked(true);
     ui->csl_hslS->setChecked(true);
     ui->csl_hslL->setChecked(true);
     ui->csl_hsiH->setChecked(false);
     ui->csl_hsiS->setChecked(false);
     ui->csl_hsiI->setChecked(false);
     ui->csl_hsyH->setChecked(false);
     ui->csl_hsyS->setChecked(false);
     ui->csl_hsyY->setChecked(false);
 
     //hotkeys//
     ui->sb_lightness->setValue(10);
     ui->sb_saturation->setValue(10);
     ui->sb_hue->setValue(36);
     ui->sb_rg->setValue(10);
     ui->sb_by->setValue(10);
 
 }
 
 KisColorSelectorSettingsDialog::KisColorSelectorSettingsDialog(QWidget *parent) :
     QDialog(parent),
     m_widget(new KisColorSelectorSettings(this))
 {
     QLayout* l = new QVBoxLayout(this);
     l->addWidget(m_widget);
 
     m_widget->loadPreferences();
 
     QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::RestoreDefaults,
                                                        Qt::Horizontal,
                                                        this);
     l->addWidget(buttonBox);
 
     connect(buttonBox, SIGNAL(accepted()), m_widget, SLOT(savePreferences()));
     connect(buttonBox, SIGNAL(accepted()), this,     SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), this,     SLOT(reject()));
     connect(buttonBox->button(QDialogButtonBox::RestoreDefaults),
             SIGNAL(clicked()),  m_widget, SLOT(loadDefaultPreferences()));
 }
 
 
 
diff --git a/plugins/extensions/colorspaceconversion/wdgconvertcolorspace.ui b/plugins/extensions/colorspaceconversion/wdgconvertcolorspace.ui
index 50f1c64fa0..e04d28154f 100644
--- a/plugins/extensions/colorspaceconversion/wdgconvertcolorspace.ui
+++ b/plugins/extensions/colorspaceconversion/wdgconvertcolorspace.ui
@@ -1,163 +1,163 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgConvertColorSpace</class>
  <widget class="QWidget" name="WdgConvertColorSpace">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>487</width>
     <height>244</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Colorspace Conversion</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="KisColorSpaceSelector" name="colorSpaceSelector"/>
    </item>
    <item>
     <widget class="QGroupBox" name="grpIntent">
      <property name="toolTip">
       <string/>
      </property>
      <property name="title">
       <string>&amp;Rendering Intent</string>
      </property>
      <layout class="QGridLayout">
       <item row="0" column="0">
        <widget class="QRadioButton" name="radioPerceptual">
         <property name="toolTip">
          <string>For images</string>
         </property>
         <property name="whatsThis">
          <string>Hue hopefully maintained (but not required),
 lightness and saturation sacrificed to maintain
 the perceived color. White point changed to
 result in neutral grays. Intended for images.</string>
         </property>
         <property name="text">
          <string>Perceptual</string>
         </property>
         <property name="shortcut">
          <string/>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QRadioButton" name="radioRelativeColorimetric">
         <property name="whatsThis">
          <string>Within and outside gamut; same as Absolute
 Colorimetric. White point changed to result in
 neutral grays.
 
 If adequate table is present in profile,
 then, it is used. Else reverts to perceptual
 intent.</string>
         </property>
         <property name="text">
          <string>Relative colorimetric</string>
         </property>
         <property name="shortcut">
          <string/>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QRadioButton" name="radioSaturation">
         <property name="toolTip">
          <string>Best for graphs and charts</string>
         </property>
         <property name="whatsThis">
          <string>Hue and saturation maintained with lightness
 sacrificed to maintain saturation. White point
 changed to result in neutral grays. Intended for
 business graphics (make it colorful charts,
 graphs, overheads, ...)
 
 If adequate table is present in profile,
 then, it is used. Else reverts to perceptual
 intent.</string>
         </property>
         <property name="text">
          <string>Saturation</string>
         </property>
         <property name="shortcut">
          <string/>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QRadioButton" name="radioAbsoluteColorimetric">
         <property name="toolTip">
-         <string>Best for spot colours</string>
+         <string>Best for spot colors</string>
         </property>
         <property name="whatsThis">
          <string>Within the destination device gamut; hue,
 lightness and saturation are maintained. Outside
 the gamut; hue and lightness are maintained,
 saturation is sacrificed. White point for source
 and destination; unchanged. Intended for spot
 colors (Pantone, TruMatch, logo colors, ...)</string>
         </property>
         <property name="text">
          <string>Absolute colorimetric</string>
         </property>
         <property name="shortcut">
          <string/>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="chkBlackpointCompensation">
      <property name="text">
       <string>Use Blackpoint &amp;Compensation</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="chkAllowLCMSOptimization">
      <property name="toolTip">
       <string>Krita tries to automatically check or uncheck this based on the information it can get from the profile you are converting from and the profile you are converting to.</string>
      </property>
      <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>
    <item>
     <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>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisColorSpaceSelector</class>
    <extends>QWidget</extends>
    <header>widgets/kis_color_space_selector.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>