diff --git a/libs/libqml/plugins/kritasketchplugin/models/PaletteColorsModel.cpp b/libs/libqml/plugins/kritasketchplugin/models/PaletteColorsModel.cpp
index c59a6a0794..87c0516b6a 100644
--- a/libs/libqml/plugins/kritasketchplugin/models/PaletteColorsModel.cpp
+++ b/libs/libqml/plugins/kritasketchplugin/models/PaletteColorsModel.cpp
@@ -1,148 +1,151 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Dan Leinir Turthra Jensen <admin@leinir.dk>
  *
  *  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 "PaletteColorsModel.h"
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 
 #include <resources/KoColorSet.h>
 
 class PaletteColorsModel::Private {
 public:
     Private()
         : colorSet(0)
         , view(0)
     {}
 
     KoColorSet* colorSet;
     KisViewManager* view;
 };
 
 PaletteColorsModel::PaletteColorsModel(QObject *parent)
     : QAbstractListModel(parent)
     , d(new Private)
 {
 }
 
 PaletteColorsModel::~PaletteColorsModel()
 {
     delete d;
 }
 
 QHash<int, QByteArray> PaletteColorsModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
     roles[ImageRole] = "image";
     roles[TextRole] = "text";
 
     return roles;
 }
 
 int PaletteColorsModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid())
         return 0;
     if (!d->colorSet)
         return 0;
     return d->colorSet->colorCount();
 }
 
 QVariant PaletteColorsModel::data(const QModelIndex &index, int role) const
 {
     QVariant result;
+    /*
     QColor color;
     if (index.isValid() && d->colorSet)
     {
         switch(role)
         {
         case ImageRole:
             color = d->colorSet->getColorGlobal(index.row(), index.column()).color().toQColor();
             result = QString("image://color/%1,%2,%3,%4").arg(color.redF()).arg(color.greenF()).arg(color.blueF()).arg(color.alphaF());
             break;
         case TextRole:
             result = d->colorSet->getColorGlobal(index.row(), index.column()).name();
             break;
         default:
             break;
         }
     }
+    */
+
     return result;
 }
 
 QVariant PaletteColorsModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(orientation);
     QVariant result;
     if (section == 0)
     {
         switch(role)
         {
         case ImageRole:
             result = QString("Thumbnail");
             break;
         case TextRole:
             result = QString("Name");
             break;
         default:
             break;
         }
     }
     return result;
 }
 
 void PaletteColorsModel::setColorSet(QObject *newColorSet)
 {
     d->colorSet = qobject_cast<KoColorSet*>(newColorSet);
     beginResetModel();
     endResetModel();
     emit colorSetChanged();
 }
 
 QObject* PaletteColorsModel::colorSet() const
 {
     return d->colorSet;
 }
 
 
 QObject* PaletteColorsModel::view() const
 {
     return d->view;
 }
 
 void PaletteColorsModel::setView(QObject* newView)
 {
     d->view = qobject_cast<KisViewManager*>( newView );
     emit viewChanged();
 }
 
 void PaletteColorsModel::activateColor(int index, bool setBackgroundColor)
 {
     if ( !d->view )
         return;
 
     if (index >= 0 && index < (int)d->colorSet->colorCount()) {
         /*
         if (setBackgroundColor)
             d->view->resourceProvider()->setBGColor(d->colorSet->getColorGlobal(index).color());
         else
             d->view->resourceProvider()->setFGColor( d->colorSet->getColorGlobal(index).color());
         emit colorChanged(d->colorSet->getColorGlobal(index).color().toQColor(), setBackgroundColor);
         */
     }
 }
 
diff --git a/libs/pigment/resources/KisSwatchGroup.cpp b/libs/pigment/resources/KisSwatchGroup.cpp
index 193f26cd8c..9eb9d4755f 100644
--- a/libs/pigment/resources/KisSwatchGroup.cpp
+++ b/libs/pigment/resources/KisSwatchGroup.cpp
@@ -1,220 +1,214 @@
 /*  This file is part of the KDE project
     Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
     Copyright (c) 2016 L. E. Segovia <leo.segovia@siggraph.org>
     Copyright (c) 2018 Michael Zhou <simerixh@gmail.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
  */
 
 #include "KisSwatchGroup.h"
 
 struct KisSwatchGroup::Private {
     typedef QMap<int, KisSwatch> Column;
 
     Private()
         : name(QString())
         , colorMatrix(DEFAULT_COLUMN_COUNT)
         , colorCount(0)
         , rowCount(DEFAULT_ROW_COUNT)
     { }
 
     static quint32 DEFAULT_COLUMN_COUNT;
     static quint32 DEFAULT_ROW_COUNT;
 
     QString name;
     QVector<Column> colorMatrix;
     int colorCount;
     int rowCount;
 };
 
 quint32 KisSwatchGroup::Private::DEFAULT_COLUMN_COUNT = 16;
 quint32 KisSwatchGroup::Private::DEFAULT_ROW_COUNT = 20;
 
 KisSwatchGroup::KisSwatchGroup()
     : d(new Private)
 { }
 
 KisSwatchGroup::~KisSwatchGroup()
 { }
 
 KisSwatchGroup::KisSwatchGroup(const KisSwatchGroup &rhs)
     : d(new Private(*rhs.d))
 { }
 
 KisSwatchGroup &KisSwatchGroup::operator =(const KisSwatchGroup &rhs)
 {
     if (&rhs == this) {
         return *this;
     }
     d.reset(new Private(*rhs.d));
     return *this;
 }
 
 void KisSwatchGroup::setEntry(const KisSwatch &e, int column, int row)
 {
     Q_ASSERT(column < d->colorMatrix.size() && column >= 0 && row >= 0);
     if (row >= d->rowCount) {
         setRowCount(row);
     }
     if (!checkEntry(column, row)) {
         d->colorCount++;
     }
-    // qDebug() << "KisSwatchGroup::setEntry" << "column" << column;
-    // qDebug() << "KisSwatchGroup::setEntry" << "row" << row;
     d->colorMatrix[column][row] = e;
-    // qDebug() << "KisSwatchGroup::setEntry" << "colors" << colorCount();
 }
 
 bool KisSwatchGroup::checkEntry(int column, int row) const
 {
     if (row >= d->rowCount || column >= d->colorMatrix.size() || column < 0) {
         return false;
     }
     if (!d->colorMatrix[column].contains(row)) {
         return false;
     }
     return true;
 }
 
 bool KisSwatchGroup::removeEntry(int column, int row)
 {
     if (d->colorCount == 0) {
         return false;
     }
 
     if (row >= d->rowCount || column >= d->colorMatrix.size() || column < 0) {
         return false;
     }
 
     // QMap::remove returns 1 if key found else 0
     if (d->colorMatrix[column].remove(row)) {
         d->colorCount -= 1;
         return true;
     } else {
         return false;
     }
 }
 
 void KisSwatchGroup::setColumnCount(int columnCount)
 {
     Q_ASSERT(columnCount >= 0);
     if (columnCount < d->colorMatrix.size()) {
         for (int i = d->colorMatrix.size() - 1; i <= columnCount; i-- ) {
             d->colorCount -= d->colorMatrix[i].size();
         }
     }
     d->colorMatrix.resize(columnCount);
 }
 
 int KisSwatchGroup::columnCount() const {
     return d->colorMatrix.size();
 }
 
 KisSwatch KisSwatchGroup::getEntry(int column, int row) const
 {
     Q_ASSERT(checkEntry(column, row));
     return d->colorMatrix[column][row];
 }
 
 void KisSwatchGroup::addEntry(const KisSwatch &e)
 {
     if (columnCount() == 0) {
         setColumnCount(Private::DEFAULT_COLUMN_COUNT);
     }
 
     if (d->colorCount == 0) {
         setEntry(e, 0, 0);
         return;
     }
 
     int y = 0;
     for (const Private::Column &c : d->colorMatrix) {
         if (c.isEmpty()) { continue; }
         if (y < c.lastKey()) {
             y = c.lastKey();
         }
     }
     for (int x = d->colorMatrix.size() - 1; x >= 0; x--) {
         if (checkEntry(x, y)) {
             // if the last entry's at the rightmost column,
             // add e to the leftmost column of the next row
             // and increase row count
             if (++x == d->colorMatrix.size()) {
                 x = 0;
                 y++;
-                if (y == d->rowCount) {
-                    d->rowCount++;
-                }
             }
             // else just add it to the right
             setEntry(e, x, y);
             break;
         }
     }
 }
 
 void KisSwatchGroup::clear()
 {
     d->colorMatrix.clear();
 }
 
 void KisSwatchGroup::setRowCount(int newRowCount)
 {
     d->rowCount = newRowCount;
     for (Private::Column &c : d->colorMatrix) {
         for (int k : c.keys()) {
             if (k >= newRowCount) {
                 c.remove(k);
                 d->colorCount--;
             }
         }
     }
 }
 
 int KisSwatchGroup::rowCount() const
 {
     return d->rowCount;
 }
 
 int KisSwatchGroup::colorCount() const
 {
     return d->colorCount;
 }
 
 QList<KisSwatchGroup::SwatchInfo> KisSwatchGroup::infoList() const
 {
     QList<SwatchInfo> res;
     int column = 0;
     for (const Private::Column &c : d->colorMatrix) {
-        int row = 0;
+        int i = 0;
         for (const KisSwatch &s : c.values()) {
-            SwatchInfo i = {d->name, s, c.keys()[row++], column};
-            res.append(i);
+            SwatchInfo info = {d->name, s, c.keys()[i++], column};
+            res.append(info);
         }
         column++;
     }
     return res;
 }
 
 void KisSwatchGroup::setName(const QString &name)
 {
     d->name = name;
 }
 
 QString KisSwatchGroup::name() const
 {
     return d->name;
 }
diff --git a/libs/pigment/resources/KoColorSet.cpp b/libs/pigment/resources/KoColorSet.cpp
index 51d165da00..c6e2cc18b9 100644
--- a/libs/pigment/resources/KoColorSet.cpp
+++ b/libs/pigment/resources/KoColorSet.cpp
@@ -1,1552 +1,1554 @@
 /*  This file is part of the KDE project
    Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
    Copyright (c) 2016 L. E. Segovia <leo.segovia@siggraph.org>
 
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include <resources/KoColorSet.h>
 
 #include <sys/types.h>
 
 #include <QFile>
 #include <QFileInfo>
 #include <QBuffer>
 #include <QVector>
 #include <QTextStream>
 #include <QTextCodec>
 #include <QHash>
 #include <QList>
 #include <QByteArray>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QDomNodeList>
 #include <QString>
 #include <QStringList>
 #include <QImage>
 #include <QPainter>
 #include <QByteArray>
 #include <QXmlStreamReader>
 #include <QXmlStreamAttributes>
 #include <QtEndian> // qFromLittleEndian
 
 #include <DebugPigment.h>
 #include <klocalizedstring.h>
 
 #include <KoStore.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 #include "KisSwatch.h"
 
 #include "KoColorSet.h"
 #include "KoColorSet_p.h"
 
 const QString KoColorSet::GLOBAL_GROUP_NAME = QString();
 const QString KoColorSet::KPL_VERSION_ATTR = "version";
 const QString KoColorSet::KPL_GROUP_ROW_COUNT_ATTR = "rows";
 const QString KoColorSet::KPL_PALETTE_COLUMN_COUNT_ATTR = "columns";
 const QString KoColorSet::KPL_PALETTE_NAME_ATTR = "name";
 const QString KoColorSet::KPL_PALETTE_COMMENT_ATTR = "comment";
 const QString KoColorSet::KPL_PALETTE_FILENAME_ATTR = "filename";
 const QString KoColorSet::KPL_COLOR_MODEL_ID_ATTR = "colorModelId";
 const QString KoColorSet::KPL_COLOR_DEPTH_ID_ATTR = "colorDepthId";
 const QString KoColorSet::KPL_GROUP_NAME_ATTR = "name";
 const QString KoColorSet::KPL_SWATCH_ROW_ATTR = "row";
 const QString KoColorSet::KPL_SWATCH_COL_ATTR = "column";
 const QString KoColorSet::KPL_SWATCH_NAME_ATTR = "name";
 const QString KoColorSet::KPL_SWATCH_ID_ATTR = "id";
 const QString KoColorSet::KPL_SWATCH_SPOT_ATTR = "spot";
 const QString KoColorSet::KPL_SWATCH_BITDEPTH_ATTR = "bitdepth";
 const QString KoColorSet::KPL_PALETTE_PROFILE_TAG = "Profile";
 const QString KoColorSet::KPL_SWATCH_POS_TAG = "Position";
 const QString KoColorSet::KPL_SWATCH_TAG = "ColorSetEntry";
 const QString KoColorSet::KPL_GROUP_TAG = "Group";
 const QString KoColorSet::KPL_PALETTE_TAG = "ColorSet";
 
 KoColorSet::KoColorSet(const QString& filename)
     : KoResource(filename)
     , d(new Private(this))
 {
     if (!filename.isEmpty()) {
         setValid(true);
         QFileInfo f(filename);
         setIsEditable(f.isWritable());
     }
 }
 
 /// Create an copied palette
 KoColorSet::KoColorSet(const KoColorSet& rhs)
     : QObject(Q_NULLPTR)
     , KoResource(rhs)
     , d(new Private(this))
 {
     d->comment = rhs.d->comment;
     d->groupNames = rhs.d->groupNames;
     d->groups = rhs.d->groups;
 }
 
 KoColorSet::~KoColorSet()
 { }
 
 bool KoColorSet::load()
 {
     QFile file(filename());
     if (file.size() == 0) return false;
     if (!file.open(QIODevice::ReadOnly)) {
         warnPigment << "Can't open file " << filename();
         return false;
     }
     bool res = loadFromDevice(&file);
     file.close();
     return res;
 }
 
 bool KoColorSet::loadFromDevice(QIODevice *dev)
 {
     if (!dev->isOpen()) dev->open(QIODevice::ReadOnly);
 
     d->data = dev->readAll();
 
     Q_ASSERT(d->data.size() != 0);
 
     return d->init();
 }
 
 
 bool KoColorSet::save()
 {
     if (d->isGlobal) {
         // save to resource dir
         QFile file(filename());
         if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
             return false;
         }
         saveToDevice(&file);
         file.close();
         return true;
     } else {
         return true; // palette is not global, but still indicate that it's saved
     }
 }
 
 bool KoColorSet::saveToDevice(QIODevice *dev) const
 {
     bool res;
     switch(d->paletteType) {
     case GPL:
         res = d->saveGpl(dev);
         break;
     default:
         res = d->saveKpl(dev);
     }
     if (res) {
         KoResource::saveToDevice(dev);
     }
     return res;
 }
 
 QByteArray KoColorSet::toByteArray() const
 {
     QBuffer s;
     s.open(QIODevice::WriteOnly);
     if (!saveToDevice(&s)) {
         warnPigment << "saving palette failed:" << name();
         return QByteArray();
     }
     s.close();
     s.open(QIODevice::ReadOnly);
     QByteArray res = s.readAll();
     s.close();
     return res;
 }
 
 bool KoColorSet::fromByteArray(QByteArray &data)
 {
     QBuffer buf(&data);
     buf.open(QIODevice::ReadOnly);
     return loadFromDevice(&buf);
 }
 
 KoColorSet::PaletteType KoColorSet::paletteType() const
 {
     return d->paletteType;
 }
 
 void KoColorSet::setPaletteType(PaletteType paletteType)
 {
     d->paletteType = paletteType;
 }
 
 
 quint32 KoColorSet::colorCount() const
 {
     return d->groups[GLOBAL_GROUP_NAME].colorCount();
 }
 
 void KoColorSet::add(const KisSwatch &c, const QString &groupName)
 {
     KisSwatchGroup &modifiedGroup = d->groups.contains(groupName)
             ? d->groups[groupName] : d->global();
     modifiedGroup.addEntry(c);
 }
 
 void KoColorSet::setEntry(const KisSwatch &e, int x, int y, const QString &groupName)
 {
     KisSwatchGroup &modifiedGroup = d->groups.contains(groupName)
             ? d->groups[groupName] : d->global();
     modifiedGroup.setEntry(e, x, y);
 }
 
 void KoColorSet::clear()
 {
     d->groups.clear();
     d->groupNames.clear();
 }
 
 KisSwatch KoColorSet::getColorGlobal(quint32 x, quint32 y) const
 {
-    KisSwatch e;
     int yInGroup = y;
     QString nameGroupFoundIn;
     for (const QString &groupName : d->groupNames) {
         if (yInGroup < d->groups[groupName].rowCount()) {
             nameGroupFoundIn = groupName;
             break;
         } else {
             yInGroup -= d->groups[groupName].rowCount();
         }
     }
-    const KisSwatchGroup &groupFoundIn = nameGroupFoundIn == QString()
+    const KisSwatchGroup &groupFoundIn = nameGroupFoundIn == GLOBAL_GROUP_NAME
             ? d->global() : d->groups[nameGroupFoundIn];
     Q_ASSERT(groupFoundIn.checkEntry(x, yInGroup));
     return groupFoundIn.getEntry(x, yInGroup);
 }
 
 KisSwatch KoColorSet::getColorGroup(quint32 x, quint32 y, QString groupName)
 {
     KisSwatch e;
     const KisSwatchGroup &sourceGroup = groupName == QString()
             ? d->global() : d->groups[groupName];
     if (sourceGroup.checkEntry(x, y)) {
         e = sourceGroup.getEntry(x, y);
     }
     return e;
 }
 
 QStringList KoColorSet::getGroupNames()
 {
     if (d->groupNames.size() != d->groups.size()) {
         warnPigment << "mismatch between groups and the groupnames list.";
         return QStringList(d->groups.keys());
     }
     return d->groupNames;
 }
 
 bool KoColorSet::changeGroupName(QString oldGroupName, QString newGroupName)
 {
     if (!d->groupNames.contains(oldGroupName)) {
         return false;
     }
     d->groups[newGroupName] = d->groups[oldGroupName];
     d->groups.remove(oldGroupName);
     d->groups[newGroupName].setName(newGroupName);
     //rename the string in the stringlist;
     int index = d->groupNames.indexOf(oldGroupName);
     d->groupNames.replace(index, newGroupName);
     return true;
 }
 
 void KoColorSet::setColumnCount(int columns)
 {
     d->groups[GLOBAL_GROUP_NAME].setColumnCount(columns);
     for (KisSwatchGroup &g : d->groups.values()) {
         g.setColumnCount(columns);
     }
 }
 
 int KoColorSet::columnCount() const
 {
     return d->groups[GLOBAL_GROUP_NAME].columnCount();
 }
 
 QString KoColorSet::comment()
 {
     return d->comment;
 }
 
 void KoColorSet::setComment(QString comment)
 {
     d->comment = comment;
 }
 
 bool KoColorSet::addGroup(const QString &groupName)
 {
     if (d->groups.contains(groupName) || d->groupNames.contains(groupName)) {
         return false;
     }
     d->groupNames.append(groupName);
     d->groups[groupName] = KisSwatchGroup();
     d->groups[groupName].setName(groupName);
     return true;
 }
 
 bool KoColorSet::moveGroup(const QString &groupName, const QString &groupNameInsertBefore)
 {
     if (d->groupNames.contains(groupName)==false || d->groupNames.contains(groupNameInsertBefore)==false) {
         return false;
     }
     d->groupNames.removeAt(d->groupNames.indexOf(groupName));
     int index = d->groupNames.size();
     if (groupNameInsertBefore!=QString()) {
         index = d->groupNames.indexOf(groupNameInsertBefore);
     }
     d->groupNames.insert(index, groupName);
     return true;
 }
 
 bool KoColorSet::removeGroup(const QString &groupName, bool keepColors)
 {
     if (!d->groups.contains(groupName)) {
         return false;
     }
 
     if (groupName == GLOBAL_GROUP_NAME) {
         return false;
     }
 
     if (keepColors) {
         // put all colors directly below global
         int startingRow = d->groups[GLOBAL_GROUP_NAME].rowCount();
         for (const KisSwatchGroup::SwatchInfo &info : d->groups[groupName].infoList()) {
             d->groups[GLOBAL_GROUP_NAME].setEntry(info.swatch,
                                                   info.column,
                                                   info.row + startingRow);
         }
     }
 
     d->groupNames.removeAt(d->groupNames.indexOf(groupName));
     d->groups.remove(groupName);
     return true;
 }
 
 QString KoColorSet::defaultFileExtension() const
 {
     return QString(".kpl");
 }
 
 
 int KoColorSet::rowCount() const
 {
     int res = 0;
     for (const QString &name : d->groupNames) {
         res += d->groups[name].rowCount();
     }
     return res;
 }
 
 KisSwatchGroup *KoColorSet::getGroup(const QString &name)
 {
     if (!d->groups.contains(name)) {
         return Q_NULLPTR;
     }
     return &(d->groups[name]);
 }
 
 KisSwatchGroup *KoColorSet::getGlobalGroup()
 {
     return getGroup(GLOBAL_GROUP_NAME);
 }
 
 bool KoColorSet::isGlobal() const
 {
     return d->isGlobal;
 }
 
 void KoColorSet::setIsGlobal(bool isGlobal)
 {
     d->isGlobal = isGlobal;
 }
 
 bool KoColorSet::isEditable() const
 {
     return d->isEditable;
 }
 
 void KoColorSet::setIsEditable(bool isEditable)
 {
     d->isEditable = isEditable;
 }
 
 KisSwatchGroup::SwatchInfo KoColorSet::getClosestColorInfo(KoColor compare, bool useGivenColorSpace)
 {
     KisSwatchGroup::SwatchInfo res;
 
     quint8 highestPercentage = 0;
     quint8 testPercentage = 0;
 
     for (const QString &groupName : getGroupNames()) {
         KisSwatchGroup *group = getGroup(groupName);
         for (const KisSwatchGroup::SwatchInfo &currInfo : group->infoList()) {
             KoColor color = currInfo.swatch.color();
             if (useGivenColorSpace == true && compare.colorSpace() != color.colorSpace()) {
                 color.convertTo(compare.colorSpace());
 
             } else if (compare.colorSpace() != color.colorSpace()) {
                 compare.convertTo(color.colorSpace());
             }
             testPercentage = (255 - compare.colorSpace()->difference(compare.data(), color.data()));
             if (testPercentage > highestPercentage)
             {
                 highestPercentage = testPercentage;
                 res = currInfo;
             }
         }
     }
     return res;
 }
 
 /********************************KoColorSet::Private**************************/
 
 KoColorSet::Private::Private(KoColorSet *a_colorSet)
     : colorSet(a_colorSet)
     , isGlobal(true)
     , isEditable(false)
 {
     groups[KoColorSet::GLOBAL_GROUP_NAME] = KisSwatchGroup();
     groupNames.append(KoColorSet::GLOBAL_GROUP_NAME);
 }
 
 KoColorSet::PaletteType KoColorSet::Private::detectFormat(const QString &fileName, const QByteArray &ba)
 {
     QFileInfo fi(fileName);
 
     // .pal
     if (ba.startsWith("RIFF") && ba.indexOf("PAL data", 8)) {
         return KoColorSet::RIFF_PAL;
     }
     // .gpl
     else if (ba.startsWith("GIMP Palette")) {
         return KoColorSet::GPL;
     }
     // .pal
     else if (ba.startsWith("JASC-PAL")) {
         return KoColorSet::PSP_PAL;
     }
     else if (fi.suffix().toLower() == "aco") {
         return KoColorSet::ACO;
     }
     else if (fi.suffix().toLower() == "act") {
         return KoColorSet::ACT;
     }
     else if (fi.suffix().toLower() == "xml") {
         return KoColorSet::XML;
     }
     else if (fi.suffix().toLower() == "kpl") {
         return KoColorSet::KPL;
     }
     else if (fi.suffix().toLower() == "sbz") {
         return KoColorSet::SBZ;
     }
     return KoColorSet::UNKNOWN;
 }
 
 void KoColorSet::Private::scribusParseColor(KoColorSet *set, QXmlStreamReader *xml)
 {
     KisSwatch colorEntry;
     // It's a color, retrieve it
     QXmlStreamAttributes colorProperties = xml->attributes();
 
     QStringRef colorName = colorProperties.value("NAME");
     colorEntry.setName(colorName.isEmpty() || colorName.isNull() ? i18n("Untitled") : colorName.toString());
 
     // RGB or CMYK?
     if (colorProperties.hasAttribute("RGB")) {
         dbgPigment << "Color " << colorProperties.value("NAME") << ", RGB " << colorProperties.value("RGB");
 
         KoColor currentColor(KoColorSpaceRegistry::instance()->rgb8());
         QStringRef colorValue = colorProperties.value("RGB");
 
         if (colorValue.length() != 7 && colorValue.at(0) != '#') { // Color is a hexadecimal number
             xml->raiseError("Invalid rgb8 color (malformed): " + colorValue);
             return;
         } else {
             bool rgbOk;
             quint32 rgb = colorValue.mid(1).toUInt(&rgbOk, 16);
             if  (!rgbOk) {
                 xml->raiseError("Invalid rgb8 color (unable to convert): " + colorValue);
                 return;
             }
 
             quint8 r = rgb >> 16 & 0xff;
             quint8 g = rgb >> 8 & 0xff;
             quint8 b = rgb & 0xff;
 
             dbgPigment << "Color parsed: "<< r << g << b;
 
             currentColor.data()[0] = r;
             currentColor.data()[1] = g;
             currentColor.data()[2] = b;
             currentColor.setOpacity(OPACITY_OPAQUE_U8);
             colorEntry.setColor(currentColor);
 
             set->add(colorEntry);
 
             while(xml->readNextStartElement()) {
                 //ignore - these are all unknown or the /> element tag
                 xml->skipCurrentElement();
             }
             return;
         }
     }
     else if (colorProperties.hasAttribute("CMYK")) {
         dbgPigment << "Color " << colorProperties.value("NAME") << ", CMYK " << colorProperties.value("CMYK");
 
         KoColor currentColor(KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Integer8BitsColorDepthID.id(), QString()));
 
         QStringRef colorValue = colorProperties.value("CMYK");
         if (colorValue.length() != 9 && colorValue.at(0) != '#') { // Color is a hexadecimal number
             xml->raiseError("Invalid cmyk color (malformed): " % colorValue);
             return;
         }
         else {
             bool cmykOk;
             quint32 cmyk = colorValue.mid(1).toUInt(&cmykOk, 16); // cmyk uses the full 32 bits
             if  (!cmykOk) {
                 xml->raiseError("Invalid cmyk color (unable to convert): " % colorValue);
                 return;
             }
 
             quint8 c = cmyk >> 24 & 0xff;
             quint8 m = cmyk >> 16 & 0xff;
             quint8 y = cmyk >> 8 & 0xff;
             quint8 k = cmyk & 0xff;
 
             dbgPigment << "Color parsed: "<< c << m << y << k;
 
             currentColor.data()[0] = c;
             currentColor.data()[1] = m;
             currentColor.data()[2] = y;
             currentColor.data()[3] = k;
             currentColor.setOpacity(OPACITY_OPAQUE_U8);
             colorEntry.setColor(currentColor);
 
             set->add(colorEntry);
 
             while(xml->readNextStartElement()) {
                 //ignore - these are all unknown or the /> element tag
                 xml->skipCurrentElement();
             }
             return;
         }
     }
     else {
         xml->raiseError("Unknown color space for color " + colorEntry.name());
     }
 }
 
 bool KoColorSet::Private::loadScribusXmlPalette(KoColorSet *set, QXmlStreamReader *xml)
 {
 
     //1. Get name
     QXmlStreamAttributes paletteProperties = xml->attributes();
     QStringRef paletteName = paletteProperties.value("Name");
     dbgPigment << "Processed name of palette:" << paletteName;
     set->setName(paletteName.toString());
 
     //2. Inside the SCRIBUSCOLORS, there are lots of colors. Retrieve them
 
     while(xml->readNextStartElement()) {
         QStringRef currentElement = xml->name();
         if(QStringRef::compare(currentElement, "COLOR", Qt::CaseInsensitive) == 0) {
             scribusParseColor(set, xml);
         }
         else {
             xml->skipCurrentElement();
         }
     }
 
     if(xml->hasError()) {
         return false;
     }
 
     return true;
 }
 
 quint16 KoColorSet::Private::readShort(QIODevice *io) {
     quint16 val;
     quint64 read = io->read((char*)&val, 2);
     if (read != 2) return false;
     return qFromBigEndian(val);
 }
 
 bool KoColorSet::Private::init()
 {
     // just in case this is a reload (eg by KoEditColorSetDialog),
     groupNames.clear();
     groups.clear();
     groupNames.append(KoColorSet::GLOBAL_GROUP_NAME);
     groups[KoColorSet::GLOBAL_GROUP_NAME] = KisSwatchGroup();
 
     if (colorSet->filename().isNull()) {
         warnPigment << "Cannot load palette" << colorSet->name() << "there is no filename set";
         return false;
     }
     if (data.isNull()) {
         QFile file(colorSet->filename());
         if (file.size() == 0) {
             warnPigment << "Cannot load palette" << colorSet->name() << "there is no data available";
             return false;
         }
         file.open(QIODevice::ReadOnly);
         data = file.readAll();
         file.close();
     }
 
     bool res = false;
     paletteType = detectFormat(colorSet->filename(), data);
     switch(paletteType) {
     case GPL:
         res = loadGpl();
         break;
     case ACT:
         res = loadAct();
         break;
     case RIFF_PAL:
         res = loadRiff();
         break;
     case PSP_PAL:
         res = loadPsp();
         break;
     case ACO:
         res = loadAco();
         break;
     case XML:
         res = loadXml();
         break;
     case KPL:
         res = loadKpl();
         break;
     case SBZ:
         res = loadSbz();
         break;
     default:
         res = false;
     }
     colorSet->setValid(res);
 
     QImage img(global().columnCount() * 4, global().rowCount() * 4, QImage::Format_ARGB32);
     QPainter gc(&img);
     gc.fillRect(img.rect(), Qt::darkGray);
     for (const KisSwatchGroup::SwatchInfo &info : global().infoList()) {
         QColor c = info.swatch.color().toQColor();
         gc.fillRect(info.column * 4, info.row * 4, 4, 4, c);
     }
     colorSet->setImage(img);
     colorSet->setValid(res);
 
     data.clear();
     return res;
 }
 
 bool KoColorSet::Private::saveGpl(QIODevice *dev) const
 {
     Q_ASSERT(dev->isOpen());
     Q_ASSERT(dev->isWritable());
 
     QTextStream stream(dev);
     stream << "GIMP Palette\nName: " << colorSet->name() << "\nColumns: " << colorSet->columnCount() << "\n#\n";
 
     /*
      * Qt doesn't provide an interface to get a const reference to a QHash, that is
      * the underlying data structure of groups. Therefore, directly use
      * groups[KoColorSet::GLOBAL_GROUP_NAME] so that saveGpl can stay const
      */
 
     for (int y = 0; y < groups[KoColorSet::GLOBAL_GROUP_NAME].rowCount(); y++) {
         for (int x = 0; x < colorSet->columnCount(); x++) {
             if (!groups[KoColorSet::GLOBAL_GROUP_NAME].checkEntry(x, y)) {
                 continue;
             }
             const KisSwatch& entry = groups[KoColorSet::GLOBAL_GROUP_NAME].getEntry(x, y);
             QColor c = entry.color().toQColor();
             stream << c.red() << " " << c.green() << " " << c.blue() << "\t";
             if (entry.name().isEmpty())
                 stream << "Untitled\n";
             else
                 stream << entry.name() << "\n";
         }
     }
 
     return true;
 }
 
 bool KoColorSet::Private::loadGpl()
 {
     QString s = QString::fromUtf8(data.data(), data.count());
 
     if (s.isEmpty() || s.isNull() || s.length() < 50) {
         warnPigment << "Illegal Gimp palette file: " << colorSet->filename();
         return false;
     }
 
     quint32 index = 0;
 
     QStringList lines = s.split('\n', QString::SkipEmptyParts);
 
     if (lines.size() < 3) {
         warnPigment << "Not enough lines in palette file: " << colorSet->filename();
         return false;
     }
 
     QString columnsText;
     qint32 r, g, b;
     KisSwatch e;
 
     // Read name
     if (!lines[0].startsWith("GIMP") || !lines[1].toLower().contains("name")) {
         warnPigment << "Illegal Gimp palette file: " << colorSet->filename();
         return false;
     }
 
     colorSet->setName(i18n(lines[1].split(":")[1].trimmed().toLatin1()));
 
     index = 2;
 
     // Read columns
     int columns = 0;
     if (lines[index].toLower().contains("columns")) {
         columnsText = lines[index].split(":")[1].trimmed();
         columns = columnsText.toInt();
         global().setColumnCount(columns);
         index = 3;
     }
 
 
     for (qint32 i = index; i < lines.size(); i++) {
         if (lines[i].startsWith('#')) {
             comment += lines[i].mid(1).trimmed() + ' ';
         } else if (!lines[i].isEmpty()) {
             QStringList a = lines[i].replace('\t', ' ').split(' ', QString::SkipEmptyParts);
 
             if (a.count() < 3) {
                 break;
             }
 
             r = qBound(0, a[0].toInt(), 255);
             g = qBound(0, a[1].toInt(), 255);
             b = qBound(0, a[2].toInt(), 255);
 
             e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
 
             for (int i = 0; i != 3; i++) {
                 a.pop_front();
             }
             QString name = a.join(" ");
             e.setName(name.isEmpty() ? i18n("Untitled") : name);
 
             global().addEntry(e);
         }
     }
     return true;
 }
 
 bool KoColorSet::Private::loadAct()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.baseName());
     KisSwatch e;
     for (int i = 0; i < data.size(); i += 3) {
         quint8 r = data[i];
         quint8 g = data[i+1];
         quint8 b = data[i+2];
         e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
         global().addEntry(e);
     }
     return true;
 }
 
 bool KoColorSet::Private::loadRiff()
 {
     // http://worms2d.info/Palette_file
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.baseName());
     KisSwatch e;
 
     RiffHeader header;
     memcpy(&header, data.constData(), sizeof(RiffHeader));
     header.colorcount = qFromBigEndian(header.colorcount);
 
     for (int i = sizeof(RiffHeader);
          (i < (int)(sizeof(RiffHeader) + header.colorcount) && i < data.size());
          i += 4) {
         quint8 r = data[i];
         quint8 g = data[i+1];
         quint8 b = data[i+2];
         e.setColor(KoColor(QColor(r, g, b), KoColorSpaceRegistry::instance()->rgb8()));
         groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
     }
     return true;
 }
 
 
 bool KoColorSet::Private::loadPsp()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.baseName());
     KisSwatch e;
     qint32 r, g, b;
 
     QString s = QString::fromUtf8(data.data(), data.count());
     QStringList l = s.split('\n', QString::SkipEmptyParts);
     if (l.size() < 4) return false;
     if (l[0] != "JASC-PAL") return false;
     if (l[1] != "0100") return false;
 
     int entries = l[2].toInt();
 
     for (int i = 0; i < entries; ++i)  {
 
         QStringList a = l[i + 3].replace('\t', ' ').split(' ', QString::SkipEmptyParts);
 
         if (a.count() != 3) {
             continue;
         }
 
         r = qBound(0, a[0].toInt(), 255);
         g = qBound(0, a[1].toInt(), 255);
         b = qBound(0, a[2].toInt(), 255);
 
         e.setColor(KoColor(QColor(r, g, b),
                            KoColorSpaceRegistry::instance()->rgb8()));
 
         QString name = a.join(" ");
         e.setName(name.isEmpty() ? i18n("Untitled") : name);
 
         groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
     }
     return true;
 }
 
 bool KoColorSet::Private::loadKpl()
 {
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     QScopedPointer<KoStore> store(KoStore::createStore(&buf, KoStore::Read, "application/x-krita-palette", KoStore::Zip));
     if (!store || store->bad()) { return false; }
 
     if (store->hasFile("profiles.xml")) {
         if (!store->open("profiles.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         QDomDocument doc;
         doc.setContent(ba);
         QDomElement e = doc.documentElement();
         QDomElement c = e.firstChildElement(KPL_PALETTE_PROFILE_TAG);
         while (!c.isNull()) {
             QString name = c.attribute(KPL_PALETTE_NAME_ATTR);
             QString filename = c.attribute(KPL_PALETTE_FILENAME_ATTR);
             QString colorModelId = c.attribute(KPL_COLOR_MODEL_ID_ATTR);
             QString colorDepthId = c.attribute(KPL_COLOR_DEPTH_ID_ATTR);
             if (!KoColorSpaceRegistry::instance()->profileByName(name)) {
                 store->open(filename);
                 QByteArray data;
                 data.resize(store->size());
                 data = store->read(store->size());
                 store->close();
 
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(colorModelId, colorDepthId, data);
                 if (profile && profile->valid()) {
                     KoColorSpaceRegistry::instance()->addProfile(profile);
                 }
             }
 
             c = c.nextSiblingElement();
         }
     }
 
     {
         if (!store->open("colorset.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         QDomDocument doc;
         doc.setContent(ba);
         QDomElement e = doc.documentElement();
         colorSet->setName(e.attribute(KPL_PALETTE_NAME_ATTR));
         colorSet->setColumnCount(e.attribute(KPL_PALETTE_COLUMN_COUNT_ATTR).toInt());
         comment = e.attribute(KPL_PALETTE_COMMENT_ATTR);
 
         loadKplGroup(doc, e, colorSet->getGlobalGroup());
 
         QDomElement g = e.firstChildElement(KPL_GROUP_TAG);
         while (!g.isNull()) {
             QString groupName = g.attribute(KPL_GROUP_NAME_ATTR);
             colorSet->addGroup(groupName);
             loadKplGroup(doc, g, colorSet->getGroup(groupName));
             g = g.nextSiblingElement(KPL_GROUP_TAG);
         }
     }
 
     buf.close();
     return true;
 }
 
 bool KoColorSet::Private::loadAco()
 {
     QFileInfo info(colorSet->filename());
     colorSet->setName(info.baseName());
 
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     quint16 version = readShort(&buf);
     quint16 numColors = readShort(&buf);
     KisSwatch e;
 
     if (version == 1 && buf.size() > 4+numColors*10) {
         buf.seek(4+numColors*10);
         version = readShort(&buf);
         numColors = readShort(&buf);
     }
 
     const quint16 quint16_MAX = 65535;
 
     for (int i = 0; i < numColors && !buf.atEnd(); ++i) {
 
         quint16 colorSpace = readShort(&buf);
         quint16 ch1 = readShort(&buf);
         quint16 ch2 = readShort(&buf);
         quint16 ch3 = readShort(&buf);
         quint16 ch4 = readShort(&buf);
 
         bool skip = false;
         if (colorSpace == 0) { // RGB
             const KoColorProfile *srgb = KoColorSpaceRegistry::instance()->rgb8()->profile();
             KoColor c(KoColorSpaceRegistry::instance()->rgb16(srgb));
             reinterpret_cast<quint16*>(c.data())[0] = ch3;
             reinterpret_cast<quint16*>(c.data())[1] = ch2;
             reinterpret_cast<quint16*>(c.data())[2] = ch1;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 1) { // HSB
             QColor qc;
             qc.setHsvF(ch1 / 65536.0, ch2 / 65536.0, ch3 / 65536.0);
             KoColor c(qc, KoColorSpaceRegistry::instance()->rgb16());
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 2) { // CMYK
             KoColor c(KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Integer16BitsColorDepthID.id(), QString()));
             reinterpret_cast<quint16*>(c.data())[0] = quint16_MAX - ch1;
             reinterpret_cast<quint16*>(c.data())[1] = quint16_MAX - ch2;
             reinterpret_cast<quint16*>(c.data())[2] = quint16_MAX - ch3;
             reinterpret_cast<quint16*>(c.data())[3] = quint16_MAX - ch4;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 7) { // LAB
             KoColor c = KoColor(KoColorSpaceRegistry::instance()->lab16());
             reinterpret_cast<quint16*>(c.data())[0] = ch3;
             reinterpret_cast<quint16*>(c.data())[1] = ch2;
             reinterpret_cast<quint16*>(c.data())[2] = ch1;
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else if (colorSpace == 8) { // GRAY
             KoColor c(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer16BitsColorDepthID.id(), QString()));
             reinterpret_cast<quint16*>(c.data())[0] = ch1 * (quint16_MAX / 10000);
             c.setOpacity(OPACITY_OPAQUE_U8);
             e.setColor(c);
         }
         else {
             warnPigment << "Unsupported colorspace in palette" << colorSet->filename() << "(" << colorSpace << ")";
             skip = true;
         }
         if (version == 2) {
             quint16 v2 = readShort(&buf); //this isn't a version, it's a marker and needs to be skipped.
             Q_UNUSED(v2);
             quint16 size = readShort(&buf) -1; //then comes the length
             if (size>0) {
                 QByteArray ba = buf.read(size*2);
                 if (ba.size() == size*2) {
                     QTextCodec *Utf16Codec = QTextCodec::codecForName("UTF-16BE");
                     e.setName(Utf16Codec->toUnicode(ba));
                 } else {
                     warnPigment << "Version 2 name block is the wrong size" << colorSet->filename();
                 }
             }
             v2 = readShort(&buf); //end marker also needs to be skipped.
             Q_UNUSED(v2);
         }
         if (!skip) {
             groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(e);
         }
     }
     return true;
 }
 
 bool KoColorSet::Private::loadSbz() {
     QBuffer buf(&data);
     buf.open(QBuffer::ReadOnly);
 
     // &buf is a subclass of QIODevice
     QScopedPointer<KoStore> store(KoStore::createStore(&buf, KoStore::Read, "application/x-swatchbook", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     if (store->hasFile("swatchbook.xml")) { // Try opening...
 
         if (!store->open("swatchbook.xml")) { return false; }
         QByteArray data;
         data.resize(store->size());
         QByteArray ba = store->read(store->size());
         store->close();
 
         dbgPigment << "XML palette: " << colorSet->filename() << ", SwatchBooker format";
 
         QDomDocument doc;
         int errorLine, errorColumn;
         QString errorMessage;
         bool status = doc.setContent(ba, &errorMessage, &errorLine, &errorColumn);
         if (!status) {
             warnPigment << "Illegal XML palette:" << colorSet->filename();
             warnPigment << "Error (line" << errorLine << ", column" << errorColumn << "):" << errorMessage;
             return false;
         }
 
         QDomElement e = doc.documentElement(); // SwatchBook
 
         // Start reading properties...
         QDomElement metadata = e.firstChildElement("metadata");
 
         if (e.isNull()) {
             warnPigment << "Palette metadata not found";
             return false;
         }
 
         QDomElement title = metadata.firstChildElement("dc:title");
         QString colorName = title.text();
         colorName = colorName.isEmpty() ? i18n("Untitled") : colorName;
         colorSet->setName(colorName);
         dbgPigment << "Processed name of palette:" << colorSet->name();
         // End reading properties
 
         // Now read colors...
         QDomElement materials = e.firstChildElement("materials");
         if (materials.isNull()) {
             warnPigment << "Materials (color definitions) not found";
             return false;
         }
         // This one has lots of "color" elements
         QDomElement colorElement = materials.firstChildElement("color");
         if (colorElement.isNull()) {
             warnPigment << "Color definitions not found (line" << materials.lineNumber() << ", column" << materials.columnNumber() << ")";
             return false;
         }
 
         // Also read the swatch book...
         QDomElement book = e.firstChildElement("book");
         if (book.isNull()) {
             warnPigment << "Palette book (swatch composition) not found (line" << e.lineNumber() << ", column" << e.columnNumber() << ")";
             return false;
         }
         // Which has lots of "swatch"es (todo: support groups)
         QDomElement swatch = book.firstChildElement();
         if (swatch.isNull()) {
             warnPigment << "Swatches/groups definition not found (line" << book.lineNumber() << ", column" << book.columnNumber() << ")";
             return false;
         }
 
         // We'll store colors here, and as we process swatches
         // we'll add them to the palette
         QHash<QString, KisSwatch> materialsBook;
         QHash<QString, const KoColorSpace*> fileColorSpaces;
 
         // Color processing
         for(; !colorElement.isNull(); colorElement = colorElement.nextSiblingElement("color"))
         {
             KisSwatch currentEntry;
             // Set if color is spot
             currentEntry.setSpotColor(colorElement.attribute("usage") == "spot");
 
             // <metadata> inside contains id and name
             // one or more <values> define the color
             QDomElement currentColorMetadata = colorElement.firstChildElement("metadata");
             QDomNodeList currentColorValues = colorElement.elementsByTagName("values");
             // Get color name
             QDomElement colorTitle = currentColorMetadata.firstChildElement("dc:title");
             QDomElement colorId = currentColorMetadata.firstChildElement("dc:identifier");
             // Is there an id? (we need that at the very least for identifying a color)
             if (colorId.text().isEmpty()) {
                 warnPigment << "Unidentified color (line" << colorId.lineNumber()<< ", column" << colorId.columnNumber() << ")";
                 return false;
             }
             if (materialsBook.contains(colorId.text())) {
                 warnPigment << "Duplicated color definition (line" << colorId.lineNumber()<< ", column" << colorId.columnNumber() << ")";
                 return false;
             }
 
             // Get a valid color name
             currentEntry.setId(colorId.text());
             currentEntry.setName(colorTitle.text().isEmpty() ? colorId.text() : colorTitle.text());
 
             // Get a valid color definition
             if (currentColorValues.isEmpty()) {
                 warnPigment << "Color definitions not found (line" << colorElement.lineNumber() << ", column" << colorElement.columnNumber() << ")";
                 return false;
             }
 
             bool firstDefinition = false;
             const KoColorProfile *srgb = KoColorSpaceRegistry::instance()->rgb8()->profile();
             // Priority: Lab, otherwise the first definition found
             for(int j = 0; j < currentColorValues.size(); j++) {
                 QDomNode colorValue = currentColorValues.at(j);
                 QDomElement colorValueE = colorValue.toElement();
                 QString model = colorValueE.attribute("model", QString());
 
                 // sRGB,RGB,HSV,HSL,CMY,CMYK,nCLR: 0 -> 1
                 // YIQ: Y 0 -> 1 : IQ -0.5 -> 0.5
                 // Lab: L 0 -> 100 : ab -128 -> 127
                 // XYZ: 0 -> ~100
                 if (model == "Lab") {
                     QStringList lab = colorValueE.text().split(" ");
                     if (lab.length() != 3) {
                         warnPigment << "Invalid Lab color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float l = lab.at(0).toFloat(&status);
                     float a = lab.at(1).toFloat(&status);
                     float b = lab.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(LABAColorModelID.id(), Float32BitsColorDepthID.id(), QString()));
                     reinterpret_cast<float*>(c.data())[0] = l;
                     reinterpret_cast<float*>(c.data())[1] = a;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     firstDefinition = true;
                     currentEntry.setColor(c);
                     break; // Immediately add this one
                 }
                 else if (model == "sRGB" && !firstDefinition) {
                     QStringList rgb = colorValueE.text().split(" ");
                     if (rgb.length() != 3) {
                         warnPigment << "Invalid sRGB color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float r = rgb.at(0).toFloat(&status);
                     float g = rgb.at(1).toFloat(&status);
                     float b = rgb.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), srgb));
                     reinterpret_cast<float*>(c.data())[0] = r;
                     reinterpret_cast<float*>(c.data())[1] = g;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else if (model == "XYZ" && !firstDefinition) {
                     QStringList xyz = colorValueE.text().split(" ");
                     if (xyz.length() != 3) {
                         warnPigment << "Invalid XYZ color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float x = xyz.at(0).toFloat(&status);
                     float y = xyz.at(1).toFloat(&status);
                     float z = xyz.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     KoColor c(KoColorSpaceRegistry::instance()->colorSpace(XYZAColorModelID.id(), Float32BitsColorDepthID.id(), QString()));
                     reinterpret_cast<float*>(c.data())[0] = x;
                     reinterpret_cast<float*>(c.data())[1] = y;
                     reinterpret_cast<float*>(c.data())[2] = z;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 // The following color spaces admit an ICC profile (in SwatchBooker)
                 else if (model == "CMYK" && !firstDefinition) {
                     QStringList cmyk = colorValueE.text().split(" ");
                     if (cmyk.length() != 4) {
                         warnPigment << "Invalid CMYK color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float c = cmyk.at(0).toFloat(&status);
                     float m = cmyk.at(1).toFloat(&status);
                     float y = cmyk.at(2).toFloat(&status);
                     float k = cmyk.at(3).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), QString());
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor color(colorSpace);
                     reinterpret_cast<float*>(color.data())[0] = c;
                     reinterpret_cast<float*>(color.data())[1] = m;
                     reinterpret_cast<float*>(color.data())[2] = y;
                     reinterpret_cast<float*>(color.data())[3] = k;
                     color.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(color);
                     firstDefinition = true;
                 }
                 else if (model == "GRAY" && !firstDefinition) {
                     QString gray = colorValueE.text();
 
                     float g = gray.toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Float32BitsColorDepthID.id(), QString());
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(CMYKAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor c(colorSpace);
                     reinterpret_cast<float*>(c.data())[0] = g;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else if (model == "RGB" && !firstDefinition) {
                     QStringList rgb = colorValueE.text().split(" ");
                     if (rgb.length() != 3) {
                         warnPigment << "Invalid RGB color definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
                     float r = rgb.at(0).toFloat(&status);
                     float g = rgb.at(1).toFloat(&status);
                     float b = rgb.at(2).toFloat(&status);
                     if (!status) {
                         warnPigment << "Invalid float definition (line" << colorValueE.lineNumber() << ", column" << colorValueE.columnNumber() << ")";
                     }
 
                     QString space = colorValueE.attribute("space");
                     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), srgb);
 
                     if (!space.isEmpty()) {
                         // Try loading the profile and add it to the registry
                         if (!fileColorSpaces.contains(space)) {
                             store->enterDirectory("profiles");
                             store->open(space);
                             QByteArray data;
                             data.resize(store->size());
                             data = store->read(store->size());
                             store->close();
 
                             const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), data);
                             if (profile && profile->valid()) {
                                 KoColorSpaceRegistry::instance()->addProfile(profile);
                                 colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), profile);
                                 fileColorSpaces.insert(space, colorSpace);
                             }
                         }
                         else {
                             colorSpace = fileColorSpaces.value(space);
                         }
                     }
 
                     KoColor c(colorSpace);
                     reinterpret_cast<float*>(c.data())[0] = r;
                     reinterpret_cast<float*>(c.data())[1] = g;
                     reinterpret_cast<float*>(c.data())[2] = b;
                     c.setOpacity(OPACITY_OPAQUE_F);
                     currentEntry.setColor(c);
                     firstDefinition = true;
                 }
                 else {
                     warnPigment << "Color space not implemented:" << model << "(line" << colorValueE.lineNumber() << ", column "<< colorValueE.columnNumber() << ")";
                 }
             }
             if (firstDefinition) {
                 materialsBook.insert(currentEntry.id(), currentEntry);
             }
             else {
                 warnPigment << "No supported color  spaces for the current color (line" << colorElement.lineNumber() << ", column "<< colorElement.columnNumber() << ")";
                 return false;
             }
         }
         // End colors
         // Now decide which ones will go into the palette
 
         for(;!swatch.isNull(); swatch = swatch.nextSiblingElement()) {
             QString type = swatch.tagName();
             if (type.isEmpty() || type.isNull()) {
                 warnPigment << "Invalid swatch/group definition (no id) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                 return false;
             }
             else if (type == "swatch") {
                 QString id = swatch.attribute("material");
                 if (id.isEmpty() || id.isNull()) {
                     warnPigment << "Invalid swatch definition (no material id) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                     return false;
                 }
                 if (materialsBook.contains(id)) {
                     groups[KoColorSet::GLOBAL_GROUP_NAME].addEntry(materialsBook.value(id));
                 }
                 else {
                     warnPigment << "Invalid swatch definition (material not found) (line" << swatch.lineNumber() << ", column" << swatch.columnNumber() << ")";
                     return false;
                 }
             }
             else if (type == "group") {
                 QDomElement groupMetadata = swatch.firstChildElement("metadata");
                 if (groupMetadata.isNull()) {
                     warnPigment << "Invalid group definition (missing metadata) (line" << groupMetadata.lineNumber() << ", column" << groupMetadata.columnNumber() << ")";
                     return false;
                 }
                 QDomElement groupTitle = metadata.firstChildElement("dc:title");
                 if (groupTitle.isNull()) {
                     warnPigment << "Invalid group definition (missing title) (line" << groupTitle.lineNumber() << ", column" << groupTitle.columnNumber() << ")";
                     return false;
                 }
                 QString currentGroupName = groupTitle.text();
 
                 QDomElement groupSwatch = swatch.firstChildElement("swatch");
 
                 while(!groupSwatch.isNull()) {
                     QString id = groupSwatch.attribute("material");
                     if (id.isEmpty() || id.isNull()) {
                         warnPigment << "Invalid swatch definition (no material id) (line" << groupSwatch.lineNumber() << ", column" << groupSwatch.columnNumber() << ")";
                         return false;
                     }
                     if (materialsBook.contains(id)) {
                         groups[currentGroupName].addEntry(materialsBook.value(id));
                     }
                     else {
                         warnPigment << "Invalid swatch definition (material not found) (line" << groupSwatch.lineNumber() << ", column" << groupSwatch.columnNumber() << ")";
                         return false;
                     }
                     groupSwatch = groupSwatch.nextSiblingElement("swatch");
                 }
             }
         }
         // End palette
     }
 
     buf.close();
     return true;
 }
 
 bool KoColorSet::Private::loadXml() {
     bool res = false;
 
     QXmlStreamReader *xml = new QXmlStreamReader(data);
 
     if (xml->readNextStartElement()) {
         QStringRef paletteId = xml->name();
         if (QStringRef::compare(paletteId, "SCRIBUSCOLORS", Qt::CaseInsensitive) == 0) { // Scribus
             dbgPigment << "XML palette: " << colorSet->filename() << ", Scribus format";
             res = loadScribusXmlPalette(colorSet, xml);
         }
         else {
             // Unknown XML format
             xml->raiseError("Unknown XML palette format. Expected SCRIBUSCOLORS, found " + paletteId);
         }
     }
 
     // If there is any error (it should be returned through the stream)
     if (xml->hasError() || !res) {
         warnPigment << "Illegal XML palette:" << colorSet->filename();
         warnPigment << "Error (line"<< xml->lineNumber() << ", column" << xml->columnNumber() << "):" << xml->errorString();
         return false;
     }
     else {
         dbgPigment << "XML palette parsed successfully:" << colorSet->filename();
         return true;
     }
 }
 
 bool KoColorSet::Private::saveKpl(QIODevice *dev) const
 {
     QScopedPointer<KoStore> store(KoStore::createStore(dev, KoStore::Write, "application/x-krita-palette", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     QSet<const KoColorSpace *> colorSpaces;
 
     {
         QDomDocument doc;
         QDomElement root = doc.createElement(KPL_PALETTE_TAG);
         root.setAttribute(KPL_VERSION_ATTR, "1.0");
         root.setAttribute(KPL_PALETTE_NAME_ATTR, colorSet->name());
         root.setAttribute(KPL_PALETTE_COMMENT_ATTR, comment);
         root.setAttribute(KPL_PALETTE_COLUMN_COUNT_ATTR, colorSet->columnCount());
         root.setAttribute(KPL_GROUP_ROW_COUNT_ATTR, groups[KoColorSet::GLOBAL_GROUP_NAME].rowCount());
 
         saveKplGroup(doc, root, colorSet->getGroup(KoColorSet::GLOBAL_GROUP_NAME), colorSpaces);
 
         for (const QString &groupName : groupNames) {
             if (groupName == KoColorSet::GLOBAL_GROUP_NAME) { continue; }
             QDomElement gl = doc.createElement(KPL_GROUP_TAG);
             gl.setAttribute(KPL_GROUP_NAME_ATTR, groupName);
             root.appendChild(gl);
             saveKplGroup(doc, gl, colorSet->getGroup(groupName), colorSpaces);
         }
 
         doc.appendChild(root);
         if (!store->open("colorset.xml")) { return false; }
         QByteArray ba = doc.toByteArray();
         if (store->write(ba) != ba.size()) { return false; }
         if (!store->close()) { return false; }
     }
 
     QDomDocument doc;
     QDomElement profileElement = doc.createElement("Profiles");
 
     for (const KoColorSpace *colorSpace : colorSpaces) {
         QString fn = QFileInfo(colorSpace->profile()->fileName()).fileName();
         if (!store->open(fn)) { return false; }
         QByteArray profileRawData = colorSpace->profile()->rawData();
         if (!store->write(profileRawData)) { return false; }
         if (!store->close()) { return false; }
         QDomElement el = doc.createElement(KPL_PALETTE_PROFILE_TAG);
         el.setAttribute(KPL_PALETTE_FILENAME_ATTR, fn);
         el.setAttribute(KPL_PALETTE_NAME_ATTR, colorSpace->profile()->name());
         el.setAttribute(KPL_COLOR_MODEL_ID_ATTR, colorSpace->colorModelId().id());
         el.setAttribute(KPL_COLOR_DEPTH_ID_ATTR, colorSpace->colorDepthId().id());
         profileElement.appendChild(el);
 
     }
     doc.appendChild(profileElement);
     if (!store->open("profiles.xml")) { return false; }
     QByteArray ba = doc.toByteArray();
     if (store->write(ba) != ba.size()) { return false; }
     if (!store->close()) { return false; }
 
     return store->finalize();
 }
 
 void KoColorSet::Private::saveKplGroup(QDomDocument &doc,
                                        QDomElement &groupEle,
                                        const KisSwatchGroup *group,
                                        QSet<const KoColorSpace *> &colorSetSet) const
 {
     groupEle.setAttribute(KPL_GROUP_ROW_COUNT_ATTR, QString::number(group->rowCount()));
 
+    qDebug() << "KoColorSet:saveKplGroup" << group->name();
+    qDebug() << "color count" << group->colorCount();
+    qDebug() << "info list size" << group->infoList().size();
     for (const SwatchInfoType &info : group->infoList()) {
         const KoColorProfile *profile = info.swatch.color().colorSpace()->profile();
         // Only save non-builtin profiles.=
         if (!profile->fileName().isEmpty()) {
             colorSetSet.insert(info.swatch.color().colorSpace());
         }
         QDomElement swatchEle = doc.createElement(KPL_SWATCH_TAG);
         swatchEle.setAttribute(KPL_SWATCH_NAME_ATTR, info.swatch.name());
         swatchEle.setAttribute(KPL_SWATCH_ID_ATTR, info.swatch.id());
         swatchEle.setAttribute(KPL_SWATCH_SPOT_ATTR, info.swatch.spotColor() ? "true" : "false");
         swatchEle.setAttribute(KPL_SWATCH_BITDEPTH_ATTR, info.swatch.color().colorSpace()->colorDepthId().id());
         info.swatch.color().toXML(doc, swatchEle);
 
         QDomElement positionEle = doc.createElement(KPL_SWATCH_POS_TAG);
         positionEle.setAttribute(KPL_SWATCH_ROW_ATTR, info.row);
         positionEle.setAttribute(KPL_SWATCH_COL_ATTR, info.column);
         swatchEle.appendChild(positionEle);
 
         groupEle.appendChild(swatchEle);
     }
 }
 
 void KoColorSet::Private::loadKplGroup(const QDomDocument &doc, const QDomElement &parentEle, KisSwatchGroup *group)
 {
     Q_UNUSED(doc);
     if (!parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).isNull()) {
         group->setRowCount(parentEle.attribute(KPL_GROUP_ROW_COUNT_ATTR).toInt());
     }
 
     for (QDomElement swatchEle = parentEle.firstChildElement(KPL_SWATCH_TAG);
          !swatchEle.isNull();
          swatchEle = swatchEle.nextSiblingElement(KPL_SWATCH_TAG)) {
         QString colorDepthId = swatchEle.attribute(KPL_SWATCH_BITDEPTH_ATTR, Integer8BitsColorDepthID.id());
         KisSwatch entry;
 
         entry.setColor(KoColor::fromXML(swatchEle.firstChildElement(), colorDepthId));
         entry.setName(swatchEle.attribute(KPL_SWATCH_NAME_ATTR));
         entry.setId(swatchEle.attribute(KPL_SWATCH_ID_ATTR));
         entry.setSpotColor(swatchEle.attribute(KPL_SWATCH_SPOT_ATTR, "false") == "true" ? true : false);
         QDomElement positionEle = swatchEle.firstChildElement(KPL_SWATCH_POS_TAG);
         if (!positionEle.isNull()) {
             int rowNumber = positionEle.attribute(KPL_SWATCH_ROW_ATTR).toInt();
             int columnNumber = positionEle.attribute(KPL_SWATCH_COL_ATTR).toInt();
             if (columnNumber < 0 ||
                     columnNumber >= colorSet->columnCount() ||
                     rowNumber < 0
                     ) {
                 warnPigment << "Swatch" << entry.name()
                             << "of palette" << colorSet->name()
                             << "has invalid position.";
                 continue;
             }
             group->setEntry(entry, columnNumber, rowNumber);
         } else {
             group->addEntry(entry);
         }
     }
 }
diff --git a/libs/widgets/KisPaletteComboBox.cpp b/libs/widgets/KisPaletteComboBox.cpp
index fbabbd390b..876cd440b3 100644
--- a/libs/widgets/KisPaletteComboBox.cpp
+++ b/libs/widgets/KisPaletteComboBox.cpp
@@ -1,111 +1,114 @@
 // Qt
 #include <QPainter>
 #include <QPen>
 #include <QVector>
 
 // STL
 #include <algorithm>
 
 #include "KisPaletteComboBox.h"
 
 KisPaletteComboBox::KisPaletteComboBox(QWidget *parent)
     : QComboBox(parent)
     , m_completer(new QCompleter(QComboBox::model(), this))
     , m_model(Q_NULLPTR)
 {
     m_completer->setCompletionMode(QCompleter::PopupCompletion);
     m_completer->setCaseSensitivity(Qt::CaseInsensitive);
     m_completer->setFilterMode(Qt::MatchContains);
     setCompleter(m_completer.data());
     connect(this, SIGNAL(currentIndexChanged(int)), SLOT(slotIndexSelected(int)));
 }
 
 KisPaletteComboBox::~KisPaletteComboBox()
 { }
 
 void KisPaletteComboBox::setPaletteModel(const KisPaletteModel *paletteModel)
 {
     if (!m_model.isNull()) {
         m_model->disconnect(this);
     }
     m_model = paletteModel;
     if (m_model.isNull()) { return; }
     slotPaletteChanged();
-    connect(m_model, SIGNAL(modelReset()), SLOT(slotPaletteChanged()));
+    connect(m_model, SIGNAL(modelReset()),
+            SLOT(slotPaletteChanged()));
     connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex&, const QVector<int> &)),
             SLOT(slotPaletteChanged()));
 }
 
 void KisPaletteComboBox::slotPaletteChanged()
 {
     if (QPointer<KoColorSet>(m_model->colorSet()).isNull()) { return; }
 
     int oldIdx = currentIndex();
     clear();
-    m_posIdxMap.clear();
+    m_groupMapMap.clear();
     m_idxSwatchMap.clear();
 
-    QVector<SwatchInfoType> infoList;
     for (const QString &groupName : m_model->colorSet()->getGroupNames()) {
+        QVector<SwatchInfoType> infoList;
+        PosIdxMapType posIdxMap;
         const KisSwatchGroup *group = m_model->colorSet()->getGroup(groupName);
         for (const SwatchInfoType &info : group->infoList()) {
             infoList.append(info);
         }
-    }
-    std::sort(infoList.begin(), infoList.end(), swatchInfoLess);
-    for (int i = 0; i != infoList.size(); i++) {
-        const SwatchInfoType &info = infoList[i];
-        const KisSwatch &swatch = info.swatch;
-        QPixmap colorSquare = createColorSquare(swatch);
-        QString name = swatch.name();
-        if (!swatch.id().isEmpty()){
-            name = swatch.id() + " - " + swatch.name();
+        std::sort(infoList.begin(), infoList.end(), swatchInfoLess);
+        for (const SwatchInfoType &info : infoList) {
+            const KisSwatch &swatch = info.swatch;
+            QString name = swatch.name();
+            if (!swatch.id().isEmpty()){
+                name = swatch.id() + " - " + swatch.name();
+            }
+            addItem(QIcon(createColorSquare(swatch)), name);
+            posIdxMap[SwatchPosType(info.column, info.row)] = count() - 1;
+            m_idxSwatchMap.push_back(swatch);
         }
-        addItem(QIcon(colorSquare), name);
-        m_posIdxMap[SwatchPosType(info.column, info.row)] = i;
-        m_idxSwatchMap.push_back(swatch);
+        m_groupMapMap[group->name()] = posIdxMap;
     }
 
     setCurrentIndex(oldIdx);
 }
 
 bool KisPaletteComboBox::swatchInfoLess(const SwatchInfoType &first, const SwatchInfoType &second)
 {
     return first.swatch.name() < second.swatch.name();
 }
 
 QPixmap KisPaletteComboBox::createColorSquare(const KisSwatch &swatch) const
 {
     QPixmap colorSquare(32, 32);
     if (swatch.spotColor()) {
         QImage img = QImage(32, 32, QImage::Format_ARGB32);
         QPainter circlePainter;
         img.fill(Qt::transparent);
         circlePainter.begin(&img);
         QBrush brush = QBrush(Qt::SolidPattern);
         brush.setColor(swatch.color().toQColor());
         circlePainter.setBrush(brush);
         QPen pen = circlePainter.pen();
         pen.setColor(Qt::transparent);
         pen.setWidth(0);
         circlePainter.setPen(pen);
         circlePainter.drawEllipse(0, 0, 32, 32);
         circlePainter.end();
         colorSquare = QPixmap::fromImage(img);
     } else {
         colorSquare.fill(swatch.color().toQColor());
     }
     return colorSquare;
 }
 
 void KisPaletteComboBox::slotSwatchSelected(const QModelIndex &index)
 {
-    setCurrentIndex(m_posIdxMap[SwatchPosType(index.column(), index.row())]);
+    QString gName = qvariant_cast<QString>(index.data(KisPaletteModel::GroupNameRole));
+    int rowInGroup = qvariant_cast<int>(index.data(KisPaletteModel::RowInGroupRole));
+    setCurrentIndex(m_groupMapMap[gName][SwatchPosType(index.column(), rowInGroup)]);
 }
 
 void KisPaletteComboBox::slotIndexSelected(int idx)
 {
     if (idx >= 0 && idx < m_idxSwatchMap.size()) {
         emit sigColorSelected(m_idxSwatchMap[idx].color());
     }
 }
diff --git a/libs/widgets/KisPaletteComboBox.h b/libs/widgets/KisPaletteComboBox.h
index af006d98e0..7bfa1942a5 100644
--- a/libs/widgets/KisPaletteComboBox.h
+++ b/libs/widgets/KisPaletteComboBox.h
@@ -1,52 +1,53 @@
 #ifndef KISPALETTECOLORNAMELIST_H
 #define KISPALETTECOLORNAMELIST_H
 
 #include "kritawidgets_export.h"
 
 #include <QComboBox>
 #include <QCompleter>
 #include <QPointer>
 #include <QScopedPointer>
 #include <QPixmap>
 #include <QPair>
 #include <QHash>
 
 #include <KisPaletteModel.h>
 
 class KisPaletteView;
 
 class KRITAWIDGETS_EXPORT KisPaletteComboBox : public QComboBox
 {
     Q_OBJECT
 private /* typedef */:
     typedef KisSwatchGroup::SwatchInfo SwatchInfoType;
     typedef QPair<int, int> SwatchPosType; // first is column #, second is row #
+    typedef QHash<SwatchPosType, int> PosIdxMapType;
 
 public:
     explicit KisPaletteComboBox(QWidget *parent = Q_NULLPTR);
     ~KisPaletteComboBox();
 
 Q_SIGNALS:
     void sigColorSelected(const KoColor &);
 
 public /* methods */:
     void setPaletteModel(const KisPaletteModel *);
     void setCompanionView(KisPaletteView *);
 
 private Q_SLOTS:
     void slotPaletteChanged();
     void slotSwatchSelected(const QModelIndex &index);
     void slotIndexSelected(int);
 
 private /* methods */:
     QPixmap createColorSquare(const KisSwatch &swatch) const;
     static bool swatchInfoLess(const SwatchInfoType &, const SwatchInfoType &);
 
 private /* member variables */:
     QScopedPointer<QCompleter> m_completer;
     QPointer<const KisPaletteModel> m_model;
-    QHash<QPair<int, int>, int> m_posIdxMap; // map from pos in table to idx here
+    QHash<QString, PosIdxMapType> m_groupMapMap;
     QVector<KisSwatch> m_idxSwatchMap;
 };
 
 #endif // KISPALETTECOLORNAMELIST_H
diff --git a/libs/widgets/KisPaletteListWidget.cpp b/libs/widgets/KisPaletteListWidget.cpp
index cf1066e1a9..23967dfeeb 100644
--- a/libs/widgets/KisPaletteListWidget.cpp
+++ b/libs/widgets/KisPaletteListWidget.cpp
@@ -1,268 +1,291 @@
 #include <QPointer>
 #include <QScopedPointer>
 #include <QGridLayout>
 #include <QSet>
 #include <QStringList>
 #include <QFile>
 #include <QMessageBox>
 #include <QInputDialog>
 
 #include <kis_icon.h>
 
 #include "KisDlgPaletteEditor.h"
 
 #include <ui_WdgPaletteListWidget.h>
 #include "KisPaletteListWidget.h"
 #include "KisPaletteListWidget_p.h"
 
 /*
 bool KisPaletteView::addGroupWithDialog()
 {
     KoDialog *window = new KoDialog();
     window->setWindowTitle(i18nc("@title:window","Add a new group"));
     QFormLayout *editableItems = new QFormLayout();
     window->mainWidget()->setLayout(editableItems);
     QLineEdit *lnName = new QLineEdit();
     editableItems->addRow(i18nc("Name for a group", "Name"), lnName);
     lnName->setText(i18nc("Part of default name for a new group", "Color Group")+""+QString::number(m_d->model->colorSet()->getGroupNames().size()+1));
     if (window->exec() == KoDialog::Accepted) {
         QString groupName = lnName->text();
         m_d->model->addGroup(groupName);
         m_d->model->colorSet()->save();
         return true;
     }
     return false;
 }
 */
 
 
 KisPaletteListWidget::KisPaletteListWidget(QWidget *parent)
     : QWidget(parent)
     , m_ui(new Ui_WdgPaletteListWidget)
     , m_d(new KisPaletteListWidgetPrivate(this))
 {
+    m_d->allowModification = false;
+
     m_d->actAdd.reset(new QAction(KisIconUtils::loadIcon("list-add"),
                                   i18n("Add a new palette")));
     m_d->actRemove.reset(new QAction(KisIconUtils::loadIcon("list-remove"),
                                      i18n("Remove current palette")));
     m_d->actModify.reset(new QAction(KisIconUtils::loadIcon("edit-rename"),
                                      i18n("Rename choosen palette")));
     m_d->actImport.reset(new QAction(KisIconUtils::loadIcon("document-import"),
                                      i18n("Import a new palette from file")));
     m_d->actExport.reset(new QAction(KisIconUtils::loadIcon("document-export"),
                                      i18n("Export current palette to file")));
     m_d->model->setColumnCount(1);
 
     m_ui->setupUi(this);
     m_ui->bnAdd->setDefaultAction(m_d->actAdd.data());
     m_ui->bnRemove->setDefaultAction(m_d->actRemove.data());
     m_ui->bnEdit->setDefaultAction(m_d->actModify.data());
     m_ui->bnImport->setDefaultAction(m_d->actImport.data());
     m_ui->bnExport->setDefaultAction(m_d->actExport.data());
 
     connect(m_d->actAdd.data(), SIGNAL(triggered()), SLOT(slotAdd()));
     connect(m_d->actRemove.data(), SIGNAL(triggered()), SLOT(slotRemove()));
     connect(m_d->actModify.data(), SIGNAL(triggered()), SLOT(slotModify()));
     connect(m_d->actImport.data(), SIGNAL(triggered()), SLOT(slotImport()));
     connect(m_d->actExport.data(), SIGNAL(triggered()), SLOT(slotExport()));
 
     m_d->itemChooser->setItemDelegate(m_d->delegate.data());
     m_d->itemChooser->setRowHeight(40);
     m_d->itemChooser->setColumnCount(1);
     m_d->itemChooser->showButtons(false);
+    m_d->itemChooser->showTaggingBar(true);
     m_ui->viewPalette->setLayout(new QHBoxLayout(m_ui->viewPalette));
     m_ui->viewPalette->layout()->addWidget(m_d->itemChooser.data());
 
     connect(m_d->itemChooser.data(), SIGNAL(resourceSelected(KoResource *)), SLOT(slotPaletteResourceSelected(KoResource*)));
+    m_d->itemChooser->setCurrentItem(0, 0);
 }
 
 KisPaletteListWidget::~KisPaletteListWidget()
 { }
 
 void KisPaletteListWidget::slotPaletteResourceSelected(KoResource *r)
 {
-    emit sigPaletteSelected(static_cast<KoColorSet*>(r));
+    KoColorSet *g = static_cast<KoColorSet*>(r);
+    if (g->isEditable() && m_d->allowModification) {
+        m_ui->bnAdd->setEnabled(true);
+        m_ui->bnRemove->setEnabled(true);
+        m_ui->bnEdit->setEnabled(true);
+        m_ui->bnImport->setEnabled(true);
+        m_ui->bnExport->setEnabled(true);
+    } else {
+        m_ui->bnAdd->setEnabled(false);
+        m_ui->bnRemove->setEnabled(false);
+        m_ui->bnEdit->setEnabled(false);
+        m_ui->bnImport->setEnabled(false);
+        m_ui->bnExport->setEnabled(false);
+    }
+    emit sigPaletteSelected(g);
 }
 
 void KisPaletteListWidget::slotAdd()
 {
     KoColorSet *newColorSet = new KoColorSet(newPaletteFileName());
     newColorSet->setPaletteType(KoColorSet::KPL);
     newColorSet->setIsGlobal(false);
     newColorSet->setIsEditable(true);
     newColorSet->setName("New Palette");
     m_d->rAdapter->addResource(newColorSet);
     m_d->itemChooser->setCurrentResource(newColorSet);
 
     emit sigPaletteListChanged();
 }
 
 void KisPaletteListWidget::slotRemove()
 {
     if (m_d->itemChooser->currentResource()) {
         KoColorSet *group = static_cast<KoColorSet*>(m_d->itemChooser->currentResource());
         if (!group || !group->isEditable()) {
             return;
         }
         m_d->rAdapter->removeResource(m_d->itemChooser->currentResource());
         if (group->isGlobal()) {
             QFile::remove(m_d->itemChooser->currentResource()->filename());
         }
     }
     m_d->itemChooser->setCurrentItem(0, 0);
 
     emit sigPaletteListChanged();
 }
 
 void KisPaletteListWidget::slotModify()
 {
     KisDlgPaletteEditor dlg;
     KoColorSet *colorSet = static_cast<KoColorSet*>(m_d->itemChooser->currentResource());
     if (!colorSet) { return; }
     dlg.setPalette(colorSet);
     if (dlg.exec() != QDialog::Accepted){ return; }
     if (!dlg.isModified()) { return; }
     colorSet->setName(dlg.name());
     colorSet->setColumnCount(dlg.columnCount());
     if (dlg.isGlobal()) {
         setPaletteGlobal(colorSet);
     } else {
         setPaletteNonGlobal(colorSet);
     }
     for (const QString &newGroupName : dlg.newGroupNames()) {
         colorSet->addGroup(newGroupName);
         colorSet->getGroup(newGroupName)->setRowCount(dlg.groupRowNumber(newGroupName));
     }
     for (const QString &groupName : colorSet->getGroupNames()) {
         if (dlg.groupRemoved(groupName)) {
             colorSet->removeGroup(groupName);
             continue;
         }
         colorSet->getGroup(groupName)->setRowCount(dlg.groupRowNumber(groupName));
         if (!dlg.groupRenamedTo(groupName).isEmpty()) {
             colorSet->changeGroupName(groupName, dlg.groupRenamedTo(groupName));
         }
     }
     for (const KoResource *r : m_d->rAdapter->resources()) {
         if (r != colorSet && r->filename() == dlg.filename()) {
             QMessageBox msgFilenameDuplicate;
             msgFilenameDuplicate.setWindowTitle(i18n("Duplicate filename"));
             msgFilenameDuplicate.setText(i18n("Duplicate filename! Palette not saved."));
             msgFilenameDuplicate.exec();
             return;
         }
     }
     colorSet->setFilename(dlg.filename());
     emit sigPaletteSelected(colorSet); // to update elements in the docker
     emit sigPaletteListChanged();
 }
 
 void KisPaletteListWidget::slotImport()
 {
     emit sigPaletteListChanged();
 }
 
 void KisPaletteListWidget::slotExport()
 {
 
 }
 
 void KisPaletteListWidget::setPaletteGlobal(KoColorSet *colorSet)
 {
     if (QPointer<KoColorSet>(colorSet).isNull()) { return; }
     KoResourceServer<KoColorSet> *rserver = KoResourceServerProvider::instance()->paletteServer();
 
     QString saveLocation = rserver->saveLocation();
     QString name = colorSet->filename();
 
     QFileInfo fileInfo(saveLocation + name);
 
     colorSet->setFilename(fileInfo.filePath());
     colorSet->setIsGlobal(true);
 }
 
 void KisPaletteListWidget::setPaletteNonGlobal(KoColorSet *colorSet)
 {
     if (QPointer<KoColorSet>(colorSet).isNull()) { return; }
     QString filename = newPaletteFileName();
     QFile::remove(colorSet->filename());
     colorSet->setFilename(filename);
     colorSet->setIsGlobal(false);
 }
 
+void KisPaletteListWidget::setAllowModification(bool allowModification)
+{
+    m_d->allowModification = allowModification;
+}
+
 QString KisPaletteListWidget::newPaletteFileName()
 {
     KoColorSet tmpColorSet;
     QString result = "new_palette_";
     QSet<QString> nameSet;
     QList<KoResource*> rlist = m_d->rAdapter->resources();
     for (const KoResource *r : rlist) {
         nameSet.insert(r->filename());
     }
     int i = 0;
     while (nameSet.contains(result + QString::number(i) + tmpColorSet.defaultFileExtension())) {
         i++;
     }
     result = result + QString::number(i) + tmpColorSet.defaultFileExtension();
     return result;
 }
 
 /************************* KisPaletteListWidgetPrivate **********************/
 
 KisPaletteListWidgetPrivate::KisPaletteListWidgetPrivate(KisPaletteListWidget *a_c)
     : c(a_c)
     , rAdapter(new KoResourceServerAdapter<KoColorSet>(KoResourceServerProvider::instance()->paletteServer()))
     , itemChooser(new KoResourceItemChooser(rAdapter, a_c))
     , model(new Model(rAdapter, a_c))
     , delegate(new Delegate(a_c))
 {  }
 
 KisPaletteListWidgetPrivate::~KisPaletteListWidgetPrivate()
 { }
 
 /******************* KisPaletteListWidgetPrivate::Delegate ******************/
 
 KisPaletteListWidgetPrivate::Delegate::Delegate(QObject *parent)
     : QAbstractItemDelegate(parent)
 {  }
 
 KisPaletteListWidgetPrivate::Delegate::~Delegate()
 {  }
 
 void KisPaletteListWidgetPrivate::Delegate::paint(QPainter * painter,
                                                     const QStyleOptionViewItem & option,
                                                     const QModelIndex & index) const
 {
     painter->save();
     if (!index.isValid())
         return;
 
     KoResource* resource = static_cast<KoResource*>(index.internalPointer());
     KoColorSet* colorSet = static_cast<KoColorSet*>(resource);
 
     QRect previewRect(option.rect.x() + 2,
                       option.rect.y() + 2,
                       option.rect.height() - 4,
                       option.rect.height() - 4);
 
     painter->drawImage(previewRect, colorSet->image());
 
     if (option.state & QStyle::State_Selected) {
         painter->fillRect(option.rect, option.palette.highlight());
         painter->drawImage(previewRect, colorSet->image());
         painter->setPen(option.palette.highlightedText().color());
     } else {
         painter->setBrush(option.palette.text().color());
     }
     painter->drawText(option.rect.x() + previewRect.width() + 10,
                       option.rect.y() + painter->fontMetrics().ascent() + 5,
                       colorSet->name());
 
     painter->restore();
 }
 
 inline QSize KisPaletteListWidgetPrivate::Delegate::sizeHint(const QStyleOptionViewItem & option,
                                                                const QModelIndex &) const
 {
     return option.decorationSize;
 }
diff --git a/libs/widgets/KisPaletteListWidget.h b/libs/widgets/KisPaletteListWidget.h
index fab4984d92..336d9246e0 100644
--- a/libs/widgets/KisPaletteListWidget.h
+++ b/libs/widgets/KisPaletteListWidget.h
@@ -1,46 +1,49 @@
 #ifndef KISPALETTECHOOSER_H
 #define KISPALETTECHOOSER_H
 
 #include <QString>
 #include <QWidget>
 #include <ui_WdgPaletteListWidget.h>
 
 #include "kritawidgets_export.h"
 
 class KoResource;
 class KoColorSet;
 
 class KisPaletteListWidgetPrivate;
 
 class KRITAWIDGETS_EXPORT KisPaletteListWidget : public QWidget
 {
     Q_OBJECT
 public:
     explicit KisPaletteListWidget(QWidget *parent = nullptr);
     virtual ~KisPaletteListWidget();
 
+public:
+    void setAllowModification(bool allowModification);
+
 Q_SIGNALS:
     void sigPaletteSelected(KoColorSet*);
     void sigPaletteListChanged();
 
 public Q_SLOTS:
 
 private /* methods */:
     void setPaletteGlobal(KoColorSet *colorSet);
     void setPaletteNonGlobal(KoColorSet *colorSet);
     QString newPaletteFileName();
 
 private Q_SLOTS:
     void slotPaletteResourceSelected(KoResource *);
     void slotAdd();
     void slotRemove();
     void slotModify();
     void slotImport();
     void slotExport();
 
 private:
     QScopedPointer<Ui_WdgPaletteListWidget> m_ui;
     QScopedPointer<KisPaletteListWidgetPrivate> m_d;
 };
 
 #endif // KISPALETTECHOOSER_H
diff --git a/libs/widgets/KisPaletteListWidget_p.h b/libs/widgets/KisPaletteListWidget_p.h
index 2f561d2fce..fcf6af4cf2 100644
--- a/libs/widgets/KisPaletteListWidget_p.h
+++ b/libs/widgets/KisPaletteListWidget_p.h
@@ -1,65 +1,67 @@
 #ifndef KISPALETTELISTWIDGET_P_H
 #define KISPALETTELISTWIDGET_P_H
 
 #include <QAbstractItemDelegate>
 #include <QListView>
 #include <QAbstractListModel>
 #include <QPointer>
 #include <QCheckBox>
 #include <QAction>
 
 #include "KisPaletteListWidget.h"
 #include "KoResourceModel.h"
 #include "KoResourceItemView.h"
 #include "KoResourceItemChooser.h"
 #include "KoResourceServer.h"
 #include "KoResourceServerAdapter.h"
 #include "KoResourceServerProvider.h"
 #include "KoColorSet.h"
 
 struct KisPaletteListWidgetPrivate
 {
     class View;
     class Delegate;
     class Model;
     KisPaletteListWidgetPrivate(KisPaletteListWidget *);
     virtual ~KisPaletteListWidgetPrivate();
 
+    bool allowModification;
+
     QPointer<KisPaletteListWidget> c;
 
     QSharedPointer<KoResourceServerAdapter<KoColorSet> > rAdapter;
     QSharedPointer<KoResourceItemChooser> itemChooser;
 
     QScopedPointer<Model> model;
     QScopedPointer<Delegate> delegate;
 
     QScopedPointer<QAction> actAdd;
     QScopedPointer<QAction> actImport;
     QScopedPointer<QAction> actExport;
     QScopedPointer<QAction> actModify;
     QScopedPointer<QAction> actRemove;
 };
 
 class KisPaletteListWidgetPrivate::Delegate : public QAbstractItemDelegate
 {
 public:
     Delegate(QObject *);
     virtual ~Delegate();
     void paint(QPainter * painter,
                const QStyleOptionViewItem & option,
                const QModelIndex & index) const override;
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override;
 };
 
 class KisPaletteListWidgetPrivate::Model : public KoResourceModel
 {
 public:
     Model(const QSharedPointer<KoResourceServerAdapter<KoColorSet> > &rAdapter, QObject *parent = Q_NULLPTR)
         : KoResourceModel(rAdapter, parent)
     { }
     ~Model() override { }
 
     Qt::ItemFlags flags(const QModelIndex &index) const override
     { return KoResourceModel::flags(index) | Qt::ItemIsUserCheckable; }
 };
 #endif // KISPALETTELISTWIDGET_P_H
diff --git a/libs/widgets/KisPaletteModel.cpp b/libs/widgets/KisPaletteModel.cpp
index 777fc89595..4007f85b66 100644
--- a/libs/widgets/KisPaletteModel.cpp
+++ b/libs/widgets/KisPaletteModel.cpp
@@ -1,502 +1,520 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KisPaletteModel.h"
 
 #include <QBrush>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QMimeData>
 
 #include <KoColor.h>
 
 #include <KoColorSpace.h>
 #include <KoColorModelStandardIds.h>
 #include <resources/KoColorSet.h>
 #include <KoColorDisplayRendererInterface.h>
 
 KisPaletteModel::KisPaletteModel(QObject* parent)
     : QAbstractTableModel(parent)
     , m_colorSet(0)
     , m_displayRenderer(KoDumbColorDisplayRenderer::instance())
 {
 }
 
 KisPaletteModel::~KisPaletteModel()
 {
 }
 
 QVariant KisPaletteModel::data(const QModelIndex& index, int role) const
 {
     // row is set to -1 when it's group name row
     bool groupNameRow = index.row() != 0 && m_groupNameRows.contains(index.row());
     if (groupNameRow) {
         return dataForGroupNameRow(index, role);
     } else {
         return dataForSwatch(index, role);
     }
 }
 
 int KisPaletteModel::rowCount(const QModelIndex& /*parent*/) const
 {
     if (!m_colorSet)
         return 0;
     return m_colorSet->rowCount() // count of color rows
             + m_groupNameRows.size()  // rows for names
             - 1; // global doesn't have a name
 }
 
 int KisPaletteModel::columnCount(const QModelIndex& /*parent*/) const
 {
     if (m_colorSet && m_colorSet->columnCount() > 0) {
         return m_colorSet->columnCount();
     }
     if (!m_colorSet) {
         return 0;
     }
     return 16;
 }
 
 Qt::ItemFlags KisPaletteModel::flags(const QModelIndex& index) const
 {
     if (index.isValid()) {
         return  Qt::ItemIsSelectable |
                 Qt::ItemIsEnabled |
                 Qt::ItemIsUserCheckable |
                 Qt::ItemIsDragEnabled |
                 Qt::ItemIsDropEnabled;
     }
     return Qt::ItemIsDropEnabled;
 }
 
 QModelIndex KisPaletteModel::index(int row, int column, const QModelIndex& parent) const
 {
     Q_UNUSED(parent);
     Q_ASSERT(m_colorSet);
     KisSwatchGroup *group = Q_NULLPTR;
     int groupNameRow = groupNameRowForRow(row);
     group = m_colorSet->getGroup(m_groupNameRows[groupNameRow]);
     Q_ASSERT(group);
     return createIndex(row, column, group);
 }
 
 void KisPaletteModel::setColorSet(KoColorSet* colorSet)
 {
     beginResetModel();
     m_groupNameRows.clear();
     m_colorSet = colorSet;
     int row = -1;
     for (const QString &groupName : m_colorSet->getGroupNames()) {
         m_groupNameRows[row] = groupName;
         row += m_colorSet->getGroup(groupName)->rowCount();
         row += 1; // row for group name
     }
     endResetModel();
 }
 
 KoColorSet* KisPaletteModel::colorSet() const
 {
     return m_colorSet;
 }
 
 int KisPaletteModel::rowNumberInGroup(int rowInModel) const
 {
     if (m_groupNameRows.contains(rowInModel)) {
         return -1;
     }
     for (auto it = m_groupNameRows.keys().rbegin(); it != m_groupNameRows.keys().rend(); it++) {
         if (*it < rowInModel) {
             return rowInModel - *it - 1;
         }
     }
     return rowInModel;
 }
 
 bool KisPaletteModel::addEntry(const KisSwatch &entry, const QString &groupName)
 {
     KisSwatchGroup *group = m_colorSet->getGroup(groupName);
+    beginResetModel();
     if (group->checkEntry(m_colorSet->columnCount(), group->rowCount())) {
-        beginInsertRows(QModelIndex(), rowCount(), rowCount());
         m_colorSet->add(entry, groupName);
-        endInsertRows();
     } else {
-        beginResetModel();
         m_colorSet->add(entry, groupName);
-        endResetModel();
     }
+    endResetModel();
     m_colorSet->save();
     return true;
 }
 
 bool KisPaletteModel::removeEntry(const QModelIndex &index, bool keepColors)
 {
     if (!qvariant_cast<bool>(data(index, IsGroupNameRole))) {
         static_cast<KisSwatchGroup*>(index.internalPointer())->removeEntry(index.column(),
                                                                            rowNumberInGroup(index.row()));
         emit dataChanged(index, index);
     } else {
         beginResetModel();
         int groupNameRow = groupNameRowForRow(index.row());
         QString groupName = m_groupNameRows[groupNameRow];
         m_colorSet->removeGroup(groupName, keepColors);
         m_groupNameRows.remove(groupNameRow);
         endResetModel();
     }
     return true;
 }
 
 bool KisPaletteModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
                                    int row, int column, const QModelIndex &parent)
 {
     return true;
     /*
     if (!data->hasFormat("krita/x-colorsetentry") && !data->hasFormat("krita/x-colorsetgroup")) {
         return false;
     }
     if (action == Qt::IgnoreAction) {
         return false;
     }
 
     int endRow;
     int endColumn;
 
     if (!parent.isValid()) {
         if (row < 0) {
             endRow = indexFromId(m_colorSet->nColors()).row();
             endColumn = indexFromId(m_colorSet->nColors()).column();
         } else {
             endRow = qMin(row, indexFromId(m_colorSet->nColors()).row());
             endColumn = qMin(column, m_colorSet->columnCount());
         }
     } else {
         endRow = qMin(parent.row(), rowCount());
         endColumn = qMin(parent.column(), columnCount());
     }
 
     if (data->hasFormat("krita/x-colorsetgroup")) {
         QByteArray encodedData = data->data("krita/x-colorsetgroup");
         QDataStream stream(&encodedData, QIODevice::ReadOnly);
 
         while (!stream.atEnd()) {
             QString groupName;
             stream >> groupName;
             QModelIndex index = this->index(endRow, 0);
             if (index.isValid()) {
                 QStringList entryList = qvariant_cast<QStringList>(index.data(RetrieveEntryRole));
                 QString groupDroppedOn = QString();
                 if (!entryList.isEmpty()) {
                     groupDroppedOn = entryList.at(0);
                 }
                 int groupIndex = colorSet()->getGroupNames().indexOf(groupName);
                 beginMoveRows(  QModelIndex(), groupIndex, groupIndex, QModelIndex(), endRow);
                 m_colorSet->moveGroup(groupName, groupDroppedOn);
                 m_colorSet->save();
                 endMoveRows();
 
                 ++endRow;
             }
         }
     } else {
         QByteArray encodedData = data->data("krita/x-colorsetentry");
         QDataStream stream(&encodedData, QIODevice::ReadOnly);
 
         while (!stream.atEnd()) {
             KoColorSetEntry entry;
             QString oldGroupName;
             int indexInGroup;
             QString colorXml;
 
             QString name, id;
             bool spotColor;
             stream >> name
                     >> id
                     >> spotColor
                     >> indexInGroup
                     >> oldGroupName
                     >> colorXml;
             entry.setName(name);
             entry.setId(id);
             entry.setSpotColor(spotColor);
 
             QDomDocument doc;
             doc.setContent(colorXml);
             QDomElement e = doc.documentElement();
             QDomElement c = e.firstChildElement();
             if (!c.isNull()) {
                 QString colorDepthId = c.attribute("bitdepth", Integer8BitsColorDepthID.id());
                 entry.setColor(KoColor::fromXML(c, colorDepthId));
             }
 
             QModelIndex index = this->index(endRow, endColumn);
             if (qvariant_cast<bool>(index.data(IsGroupNameRole))){
                 endRow+=1;
             }
             if (index.isValid()) {
                 // this is to figure out the row of the old color.
                 // That way we can in turn avoid moverows from complaining the
                 // index is out of bounds when using index.
                 // Makes me wonder if we shouldn't just insert the index of the
                 // old color when requesting the mimetype...
                 int i = indexInGroup;
                 if (oldGroupName != QString()) {
                     colorSet()->nColorsGroup("");
                     //find at which position the group is.
                     int groupIndex = colorSet()->getGroupNames().indexOf(oldGroupName);
                     //add all the groupsizes onto it till we get to our group.
                     for(int g=0; g<groupIndex; g++) {
                         i+=colorSet()->nColorsGroup(colorSet()->getGroupNames().at(g));
                     }
                 }
                 QModelIndex indexOld = indexFromId(i);
                 if (action == Qt::MoveAction){
                     if (indexOld.row()!=qMax(endRow, 0) && indexOld.row()!=qMax(endRow+1,1)) {
                     beginMoveRows(QModelIndex(), indexOld.row(), indexOld.row(), QModelIndex(), qMax(endRow+1,1));
                     }
                     if (indexOld.column()!=qMax(endColumn, 0) && indexOld.column()!=qMax(endColumn+1,1)) {
                     beginMoveColumns(QModelIndex(), indexOld.column(), indexOld.column(), QModelIndex(), qMax(endColumn+1,1));
                     }
                 } else {
                     beginInsertRows(QModelIndex(), endRow, endRow);
                 }
                 QStringList entryList = qvariant_cast<QStringList>(index.data(RetrieveEntryRole));
                 QString entryInGroup = "0";
                 QString groupName = QString();
                 if (!entryList.isEmpty()) {
                     groupName = entryList.at(0);
                     entryInGroup = entryList.at(1);
                 }
 
                 int location = entryInGroup.toInt();
                 // Insert the entry
                 if (groupName==oldGroupName && qvariant_cast<bool>(index.data(IsGroupNameRole))==true) {
                     groupName=QString();
                     location=m_colorSet->nColorsGroup();
                 }
                 m_colorSet->insertBefore(entry, location, groupName);
                 if (groupName==oldGroupName && location<indexInGroup) {
                     indexInGroup+=1;
                 }
                 if (action == Qt::MoveAction){
                     m_colorSet->removeAt(indexInGroup, oldGroupName);
                 }
                 m_colorSet->save();
                 if (action == Qt::MoveAction){
                     if (indexOld.row()!=qMax(endRow, 0) && indexOld.row()!=qMax(endRow+1,1)) {
                         endMoveRows();
                     }
                     if (indexOld.column()!=qMax(endColumn, 0) && indexOld.column()!=qMax(endColumn+1,1)) {
                         endMoveColumns();
                     }
 
                 } else {
                     endInsertRows();
                 }
 
                 ++endRow;
             }
         }
     }
 
     return true;
     */
 }
 
 QMimeData *KisPaletteModel::mimeData(const QModelIndexList &indexes) const
 {
     return new QMimeData();
     /*
     QMimeData *mimeData = new QMimeData();
     QByteArray encodedData;
 
     QDataStream stream(&encodedData, QIODevice::WriteOnly);
     QString mimeTypeName = "krita/x-colorsetentry";
     //Q_FOREACH(const QModelIndex &index, indexes) {
     QModelIndex index = indexes.last();
     if (index.isValid()) {
         if (qvariant_cast<bool>(index.data(IsGroupNameRole))==false) {
             KoColorSetEntry entry = colorSetEntryFromIndex(index);
             QStringList entryList = qvariant_cast<QStringList>(index.data(RetrieveEntryRole));
             QString groupName = QString();
             int indexInGroup = 0;
             if (!entryList.isEmpty()) {
                 groupName = entryList.at(0);
                 QString iig = entryList.at(1);
                 indexInGroup = iig.toInt();
             }
 
             QDomDocument doc;
             QDomElement root = doc.createElement("Color");
             root.setAttribute("bitdepth", entry.color().colorSpace()->colorDepthId().id());
             doc.appendChild(root);
             entry.color().toXML(doc, root);
 
             stream << entry.name()
                    << entry.id()
                    << entry.spotColor()
                    << indexInGroup
                    << groupName
                    << doc.toString();
         } else {
             mimeTypeName = "krita/x-colorsetgroup";
             QStringList entryList = qvariant_cast<QStringList>(index.data(RetrieveEntryRole));
             QString groupName = QString();
             if (!entryList.isEmpty()) {
                 groupName = entryList.at(0);
             }
             stream << groupName;
         }
     }
 
     mimeData->setData(mimeTypeName, encodedData);
     return mimeData;
     */
 }
 
 QStringList KisPaletteModel::mimeTypes() const
 {
     return QStringList() << "krita/x-colorsetentry" << "krita/x-colorsetgroup";
 }
 
 Qt::DropActions KisPaletteModel::supportedDropActions() const
 {
     return Qt::MoveAction;
 }
 
 void KisPaletteModel::setEntry(const KisSwatch &entry,
                                const QModelIndex &index)
 {
     KisSwatchGroup *group = static_cast<KisSwatchGroup*>(index.internalPointer());
     Q_ASSERT(group);
     group->setEntry(entry, index.column(), rowNumberInGroup(index.row()));
-    // qDebug() << "KisPaletteModel: row number in group" << rowNumberInGroup(index.row());
     emit dataChanged(index, index);
     if (m_colorSet->isGlobal()) {
         m_colorSet->save();
     }
 }
 
 bool KisPaletteModel::renameGroup(const QString &groupName, const QString &newName)
 {
-    // emit this signal to notify stuff out of the Qt MVC frame
-    emit dataChanged(QModelIndex(), QModelIndex());
     beginResetModel();
     bool success = m_colorSet->changeGroupName(groupName, newName);
     for (auto it = m_groupNameRows.begin(); it != m_groupNameRows.end(); it++) {
         if (it.value() == groupName) {
             m_groupNameRows[it.key()] = newName;
             break;
         }
     }
     endResetModel();
     return success;
 }
 
 QVariant KisPaletteModel::dataForGroupNameRow(const QModelIndex &idx, int role) const
 {
     KisSwatchGroup *group = static_cast<KisSwatchGroup*>(idx.internalPointer());
     Q_ASSERT(group);
     QString groupName = group->name();
     switch (role) {
     case Qt::ToolTipRole:
     case Qt::DisplayRole: {
         return groupName;
     }
+    case GroupNameRole: {
+        return groupName;
+    }
     case IsGroupNameRole: {
         return true;
     }
     case CheckSlotRole: {
         return true;
     }
+    case RowInGroupRole: {
+        return -1;
+    }
     default: {
         return QVariant();
     }
     }
 }
 
 QVariant KisPaletteModel::dataForSwatch(const QModelIndex &idx, int role) const
 {
     KisSwatchGroup *group = static_cast<KisSwatchGroup*>(idx.internalPointer());
     Q_ASSERT(group);
-    bool entryPresent = group->checkEntry(idx.column(), rowNumberInGroup(idx.row()));
+    int rowInGroup = rowNumberInGroup(idx.row());
+    bool entryPresent = group->checkEntry(idx.column(), rowInGroup);
     KisSwatch entry;
     if (entryPresent) {
-        entry = group->getEntry(idx.column(), rowNumberInGroup(idx.row()));
+        entry = group->getEntry(idx.column(), rowInGroup);
     }
     switch (role) {
     case Qt::ToolTipRole:
     case Qt::DisplayRole: {
         return entryPresent ? entry.name() : i18n("Empty slot");
     }
     case Qt::BackgroundRole: {
         QColor color(0, 0, 0, 0);
         if (entryPresent) {
             color = m_displayRenderer->toQColor(entry.color());
         }
         return QBrush(color);
     }
     case IsGroupNameRole: {
         return false;
     }
+    case GroupNameRole: {
+        return group->name();
+    }
     case CheckSlotRole: {
         return entryPresent;
     }
+    case RowInGroupRole: {
+        return rowInGroup;
+    }
     default: {
         return QVariant();
     }
     }
 }
 
 void KisPaletteModel::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     if (displayRenderer) {
         if (m_displayRenderer) {
             disconnect(m_displayRenderer, 0, this, 0);
         }
         m_displayRenderer = displayRenderer;
         connect(m_displayRenderer, SIGNAL(displayConfigurationChanged()),
                 SLOT(slotDisplayConfigurationChanged()));
     } else {
         m_displayRenderer = KoDumbColorDisplayRenderer::instance();
     }
 }
 
 void KisPaletteModel::slotDisplayConfigurationChanged()
 {
     beginResetModel();
     endResetModel();
 }
 
 QModelIndex KisPaletteModel::indexForClosest(const KoColor &compare)
 {
     KisSwatchGroup::SwatchInfo info = colorSet()->getClosestColorInfo(compare);
-    return createIndex(info.row, info.column, colorSet()->getGroup(info.group));
+    return createIndex(indexRowForInfo(info), info.column, colorSet()->getGroup(info.group));
+}
+
+int KisPaletteModel::indexRowForInfo(const KisSwatchGroup::SwatchInfo &info)
+{
+    for (auto it = m_groupNameRows.begin(); it != m_groupNameRows.end(); it++) {
+        if (it.value() == info.group) {
+            return it.key() + info.row + 1;
+        }
+    }
+    return info.row;
 }
 
 KisSwatch KisPaletteModel::getEntry(const QModelIndex &index)
 {
     KisSwatchGroup *group = static_cast<KisSwatchGroup*>(index.internalPointer());
     if (!group || !group->checkEntry(index.column(), rowNumberInGroup(index.row()))) {
         return KisSwatch();
     }
     return group->getEntry(index.column(), rowNumberInGroup(index.row()));
 }
 
 int KisPaletteModel::groupNameRowForRow(int rowInModel) const
 {
     return rowInModel - rowNumberInGroup(rowInModel) - 1;
 }
diff --git a/libs/widgets/KisPaletteModel.h b/libs/widgets/KisPaletteModel.h
index 9959b7f1f2..ced1154a55 100644
--- a/libs/widgets/KisPaletteModel.h
+++ b/libs/widgets/KisPaletteModel.h
@@ -1,158 +1,161 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #ifndef KIS_PALETTEMODEL_H
 #define KIS_PALETTEMODEL_H
 
 #include <QPointer>
 #include <QModelIndex>
 #include <QMap>
 
 #include <KoColorDisplayRendererInterface.h>
 
 #include "kritawidgets_export.h"
 #include <KoColorSet.h>
 #include <QScopedPointer>
 
 class KoColorSet;
 class KisPaletteView;
 
 /**
  * @brief The KisPaletteModel class
  * This, together with KisPaletteView and KisPaletteDelegate forms a mvc way to access kocolorsets.
  * A display renderer is given to this model to convert KoColor to QColor when
  * colors are requested
  */
 class KRITAWIDGETS_EXPORT KisPaletteModel : public QAbstractTableModel
 {
     Q_OBJECT
 public:
     KisPaletteModel(QObject* parent = 0);
     ~KisPaletteModel() override;
 
     enum AdditionalRoles {
         IsGroupNameRole = Qt::UserRole + 1,
         RetrieveEntryRole,
-        CheckSlotRole
+        CheckSlotRole,
+        GroupNameRole,
+        RowInGroupRole
     };
 
 public /* overriden methods */: // QAbstractTableModel
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     int rowCount(const QModelIndex& parent = QModelIndex()) const override;
     int columnCount(const QModelIndex& parent = QModelIndex()) const override;
     /**
      * @brief index
      * @param row
      * @param column
      * @param parent
      * @return the index of for the data at row, column
      * if the data is a color entry, the internal pointer points to the group
      * the entry belongs to, and the row and column are row number and column
      * number inside the group.
      * if the data is a group, the row number and group number is Q_INFINIFY,
      * and the internal pointer also points to the group
      */
     QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
 
     Qt::ItemFlags flags(const QModelIndex& index) const override;
 
     /**
      * @brief dropMimeData
      * This is an overridden function that handles dropped mimedata.
      * right now only colorsetentries and colorsetgroups are handled.
      * @return
      */
     bool dropMimeData(const QMimeData *data, Qt::DropAction action,
                       int row, int column, const QModelIndex &parent) override;
     /**
      * @brief mimeData
      * gives the mimedata for a kocolorsetentry or a kocolorsetgroup.
      * @param indexes
      * @return the mimedata for the given indices
      */
     QMimeData *mimeData(const QModelIndexList &indexes) const override;
 
     QStringList mimeTypes() const override;
 
     Qt::DropActions supportedDropActions() const override;
     /**
      * @brief setData
      * setData is not used as KoColor is not a QVariant
      * use setEntry, addEntry and removeEntry instead
     bool setData(const QModelIndex &index, const QVariant &value, int role) override;
      */
 
 public /* methods */:
     /**
      * @brief addEntry
      * proper function to handle adding entries.
      * @return whether successful.
      */
     bool addEntry(const KisSwatch &entry,
                   const QString &groupName = KoColorSet::GLOBAL_GROUP_NAME);
 
     void setEntry(const KisSwatch &entry, const QModelIndex &index);
 
     /**
      * @brief removeEntry
      * proper function to remove the colorsetentry at the given index.
      * The consolidtes both removeentry and removegroup.
      * @param keepColors: This bool determines whether, when deleting a group,
      * the colors should be added to the default group. This is usually desirable,
      * so hence the default is true.
      * @return if successful
      */
     bool removeEntry(const QModelIndex &index, bool keepColors=true);
 
     KisSwatch getEntry(const QModelIndex &index);
 
     bool renameGroup(const QString &groupName, const QString &newName);
 
     void setColorSet(KoColorSet* colorSet);
     KoColorSet* colorSet() const;
 
     QModelIndex indexForClosest(const KoColor &compare);
+    int indexRowForInfo(const KisSwatchGroup::SwatchInfo &info);
 
 public Q_SLOTS:
 
 private Q_SLOTS:
     void slotDisplayConfigurationChanged();
 
 private /* methods */:
     QVariant dataForGroupNameRow(const QModelIndex &idx, int role) const;
     QVariant dataForSwatch(const QModelIndex &idx, int role) const;
     int rowNumberInGroup(int rowInModel) const;
     int groupNameRowForRow(int rowInModel) const;
     /**
      * Installs a display renderer object for a palette that will
      * convert the KoColor to the displayable QColor. Default is the
      * dumb renderer.
      */
     void setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer);
 
 
 private /* member variables */:
     QPointer<KoColorSet> m_colorSet;
     QPointer<const KoColorDisplayRendererInterface> m_displayRenderer;
     QMap<int, QString> m_groupNameRows;
 
 friend class KisPaletteView;
 };
 
 #endif
diff --git a/libs/widgets/WdgPaletteListWidget.ui b/libs/widgets/WdgPaletteListWidget.ui
index a15eba4f63..cccbf3235e 100644
--- a/libs/widgets/WdgPaletteListWidget.ui
+++ b/libs/widgets/WdgPaletteListWidget.ui
@@ -1,103 +1,100 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgPaletteListWidget</class>
  <widget class="QWidget" name="WdgPaletteListWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>361</width>
     <height>496</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <widget class="QWidget" name="viewPalette" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QWidget" name="ctrlLine" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <layout class="QHBoxLayout" name="horizontalLayout">
-      <item>
-       <widget class="QLineEdit" name="lineEditPaletteName"/>
-      </item>
       <item>
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item>
        <widget class="QToolButton" name="bnAdd">
         <property name="icon">
          <iconset theme="add">
           <normaloff>.</normaloff>.</iconset>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QToolButton" name="bnEdit">
         <property name="icon">
          <iconset theme="edit">
           <normaloff>.</normaloff>.</iconset>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QToolButton" name="bnExport">
         <property name="icon">
          <iconset theme="document-export">
           <normaloff>.</normaloff>.</iconset>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QToolButton" name="bnImport">
         <property name="icon">
          <iconset theme="document-open">
           <normaloff>.</normaloff>.</iconset>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QToolButton" name="bnRemove">
         <property name="icon">
          <iconset theme="list-remove">
           <normaloff>.</normaloff>.</iconset>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/widgets/kis_palette_view.cpp b/libs/widgets/kis_palette_view.cpp
index 9f01e8ef32..79a333418b 100644
--- a/libs/widgets/kis_palette_view.cpp
+++ b/libs/widgets/kis_palette_view.cpp
@@ -1,325 +1,318 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_palette_view.h"
 
 #include <QWheelEvent>
 #include <QHeaderView>
 #include <QFormLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QMenu>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include <kis_icon_utils.h>
 #include <KoDialog.h>
 #include <KoColorDisplayRendererInterface.h>
 
 #include "KisPaletteDelegate.h"
 #include "KisPaletteModel.h"
 #include "kis_color_button.h"
 #include <KisSwatch.h>
 
 int KisPaletteView::MININUM_ROW_HEIGHT = 10;
 
 struct KisPaletteView::Private
 {
     QPointer<KisPaletteModel> model;
     bool allowPaletteModification; // if modification is allowed from this widget
 };
 
 KisPaletteView::KisPaletteView(QWidget *parent)
     : QTableView(parent)
     , m_d(new Private)
 {
     m_d->allowPaletteModification = false;
 
     setItemDelegate(new KisPaletteDelegate(this));
 
     setShowGrid(true);
     setDropIndicatorShown(true);
     setDragEnabled(true);
     setAcceptDrops(true);
     setDragDropMode(QAbstractItemView::InternalMove);
     setSelectionMode(QAbstractItemView::SingleSelection);
 
     /*
      * without this, a cycle might be created:
      * the view streches to right border, and this make it need a scroll bar;
      * after the bar is added, the view shrinks to the bar, and this makes it
      * no longer need the bar any more, and the bar is removed again
      */
     setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 
     // set the size of swatches
     horizontalHeader()->setVisible(false);
     verticalHeader()->setVisible(false);
     horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
     horizontalHeader()->setMinimumSectionSize(MININUM_ROW_HEIGHT);
     verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
     verticalHeader()->setMinimumSectionSize(MININUM_ROW_HEIGHT);
 
     connect(horizontalHeader(), SIGNAL(sectionResized(int,int,int)), SLOT(slotHorizontalHeaderResized(int,int,int)));
     connect(this, SIGNAL(doubleClicked(QModelIndex)), SLOT(slotModifyEntry(QModelIndex)));
 
     setAutoFillBackground(true);
 }
 
 KisPaletteView::~KisPaletteView()
 {
 }
 
 void KisPaletteView::setCrossedKeyword(const QString &value)
 {
     /*
     KisPaletteDelegate *delegate =
         dynamic_cast<KisPaletteDelegate*>(itemDelegate());
     KIS_ASSERT_RECOVER_RETURN(delegate);
 
     delegate->setCrossedKeyword(value);
     */
 }
 
 bool KisPaletteView::addEntryWithDialog(KoColor color)
 {
     QScopedPointer<KoDialog> window(new KoDialog(this));
     window->setWindowTitle(i18nc("@title:window", "Add a new Colorset Entry"));
     QFormLayout *editableItems = new QFormLayout(window.data());
     window->mainWidget()->setLayout(editableItems);
     QComboBox *cmbGroups = new QComboBox(window.data());
     QString defaultGroupName = i18nc("Name for default group", "Default");
     cmbGroups->addItem(defaultGroupName);
     cmbGroups->addItems(m_d->model->colorSet()->getGroupNames());
     QLineEdit *lnIDName = new QLineEdit(window.data());
     QLineEdit *lnName = new QLineEdit(window.data());
     KisColorButton *bnColor = new KisColorButton(window.data());
     QCheckBox *chkSpot = new QCheckBox(window.data());
     chkSpot->setToolTip(i18nc("@info:tooltip", "A spot color is a color that the printer is able to print without mixing the paints it has available to it. The opposite is called a process color."));
     editableItems->addRow(i18n("Group"), cmbGroups);
     editableItems->addRow(i18n("ID"), lnIDName);
     editableItems->addRow(i18n("Name"), lnName);
     editableItems->addRow(i18n("Color"), bnColor);
     editableItems->addRow(i18nc("Spot color", "Spot"), chkSpot);
     cmbGroups->setCurrentIndex(0);
     lnName->setText(i18nc("Part of a default name for a color","Color")+" "+QString::number(m_d->model->colorSet()->colorCount()+1));
     lnIDName->setText(QString::number(m_d->model->colorSet()->colorCount()+1));
     bnColor->setColor(color);
     chkSpot->setChecked(false);
 
     if (window->exec() == KoDialog::Accepted) {
         QString groupName = cmbGroups->currentText();
         if (groupName == defaultGroupName) {
             groupName = QString();
         }
         KisSwatch newEntry;
         newEntry.setColor(bnColor->color());
         newEntry.setName(lnName->text());
         newEntry.setId(lnIDName->text());
         newEntry.setSpotColor(chkSpot->isChecked());
         m_d->model->addEntry(newEntry, groupName);
         return true;
     }
 
     return false;
 }
 
 bool KisPaletteView::removeEntryWithDialog(QModelIndex index)
 {
     bool keepColors = false;
     if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
         QScopedPointer<KoDialog> window(new KoDialog(this));
         window->setWindowTitle(i18nc("@title:window","Removing Group"));
         QFormLayout *editableItems = new QFormLayout(window.data());
         QCheckBox *chkKeep = new QCheckBox(window.data());
         window->mainWidget()->setLayout(editableItems);
         editableItems->addRow(i18nc("Shows up when deleting a swatch group", "Keep the Colors"), chkKeep);
         if (window->exec() != KoDialog::Accepted) { return false; }
         keepColors = chkKeep->isChecked();
-        m_d->model->removeEntry(index, keepColors);
+    }
+    m_d->model->removeEntry(index, keepColors);
+    if (m_d->model->colorSet()->isGlobal()) {
         m_d->model->colorSet()->save();
-    } else {
-        m_d->model->removeEntry(index, keepColors);
-        if (m_d->model->colorSet()->isGlobal()) {
-            m_d->model->colorSet()->save();
-        }
     }
     return true;
 }
 
 void KisPaletteView::selectClosestColor(const KoColor &color)
 {
     KoColorSet* color_set = m_d->model->colorSet();
     if (!color_set) {
         return;
     }
     //also don't select if the color is the same as the current selection
     if (m_d->model->getEntry(currentIndex()).color() == color) {
         return;
     }
 
     selectionModel()->clearSelection();
     QModelIndex index = m_d->model->indexForClosest(color);
     selectionModel()->setCurrentIndex(index, QItemSelectionModel::Select);
 }
 
 void KisPaletteView::slotFGColorChanged(const KoColor &color)
 {
     selectClosestColor(color);
 }
 
 void KisPaletteView::mouseReleaseEvent(QMouseEvent *event)
 {
     if (selectedIndexes().size() <= 0) {
         return;
     }
 
     QModelIndex index = currentIndex();
 
     if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole)) == false) {
         emit sigIndexSelected(index);
-        KisSwatch entry = m_d->model->colorSet()->getColorGlobal(index.column(), index.row());
+        KisSwatch entry = m_d->model->getEntry(index);
         emit sigColorSelected(entry.color());
     }
     QTableView::mouseReleaseEvent(event);
 }
 
 void KisPaletteView::setPaletteModel(KisPaletteModel *model)
 {
     if (m_d->model) {
         disconnect(m_d->model, 0, this, 0);
     }
     m_d->model = model;
     setModel(model);
     slotAdditionalGuiUpdate();
     connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
             SLOT(slotAdditionalGuiUpdate()));
     connect(model, SIGNAL(modelReset()),
             SLOT(slotAdditionalGuiUpdate()));
 }
 
 KisPaletteModel* KisPaletteView::paletteModel() const
 {
     return m_d->model;
 }
 
 void KisPaletteView::setAllowModification(bool allow)
 {
     m_d->allowPaletteModification = allow;
 }
 
 void KisPaletteView::modifyEntry(QModelIndex index)
 {
     if (!m_d->allowPaletteModification) { return; }
     if (!m_d->model->colorSet()->isEditable()) { return; }
 
     KoDialog *dlg = new KoDialog();
     QFormLayout *editableItems = new QFormLayout(dlg);
     dlg->mainWidget()->setLayout(editableItems);
     QLineEdit *lnGroupName = new QLineEdit(dlg);
 
     if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
         //rename the group.
         QString groupName = qvariant_cast<QString>(index.data(Qt::DisplayRole));
         editableItems->addRow(i18nc("Name for a colorgroup","Name"), lnGroupName);
         lnGroupName->setText(groupName);
         if (dlg->exec() == KoDialog::Accepted) {
-            if (lnGroupName->text().isEmpty()) {
-                return;
-            }
+            if (lnGroupName->text().isEmpty()) { return; }
             for (const QString &groupName: m_d->model->colorSet()->getGroupNames()) {
                 if (groupName == lnGroupName->text()) {
                     return;
                 }
             }
             m_d->model->renameGroup(groupName, lnGroupName->text());
         }
     } else {
         QLineEdit *lnIDName = new QLineEdit(dlg);
         KisColorButton *bnColor = new KisColorButton(dlg);
         QCheckBox *chkSpot = new QCheckBox(dlg);
-        KisSwatchGroup *group = static_cast<KisSwatchGroup*>(index.internalPointer());
-        Q_ASSERT(group);
-        KisSwatch entry = group->getEntry(index.column(), index.row());
+        KisSwatch entry = m_d->model->getEntry(index);
         chkSpot->setToolTip(i18nc("@info:tooltip", "A spot color is a color that the printer is able to print without mixing the paints it has available to it. The opposite is called a process color."));
         editableItems->addRow(i18n("ID"), lnIDName);
         editableItems->addRow(i18nc("Name for a swatch group", "Name"), lnGroupName);
         editableItems->addRow(i18n("Color"), bnColor);
         editableItems->addRow(i18n("Spot"), chkSpot);
         lnGroupName->setText(entry.name());
         lnIDName->setText(entry.id());
         bnColor->setColor(entry.color());
         chkSpot->setChecked(entry.spotColor());
         if (dlg->exec() == KoDialog::Accepted) {
             entry.setName(lnGroupName->text());
             entry.setId(lnIDName->text());
             entry.setColor(bnColor->color());
             entry.setSpotColor(chkSpot->isChecked());
             m_d->model->setEntry(entry, index);
         }
     }
 
     delete dlg;
     update(index);
 }
 
 void KisPaletteView::slotModifyEntry(const QModelIndex &index)
 {
     modifyEntry(index);
 }
 
 void KisPaletteView::slotHorizontalHeaderResized(int, int, int newSize)
 {
     resizeRows(newSize);
     slotAdditionalGuiUpdate();
 }
 
 void KisPaletteView::resizeRows(int newSize)
 {
     verticalHeader()->setDefaultSectionSize(newSize);
     verticalHeader()->resizeSections(QHeaderView::Fixed);
 }
 
 void KisPaletteView::removeSelectedEntry()
 {
     if (selectedIndexes().size() <= 0) {
         return;
     }
     m_d->model->removeEntry(currentIndex());
 }
 
 void KisPaletteView::slotAdditionalGuiUpdate()
 {
     clearSpans();
     resizeRows(verticalHeader()->defaultSectionSize());
     for (int groupNameRowNumber : m_d->model->m_groupNameRows.keys()) {
         if (groupNameRowNumber == -1) { continue; }
         setSpan(groupNameRowNumber, 0, 1, m_d->model->columnCount());
         setRowHeight(groupNameRowNumber, fontMetrics().lineSpacing() + 6);
         verticalHeader()->resizeSection(groupNameRowNumber, fontMetrics().lineSpacing() + 6);
     }
 }
 
 void KisPaletteView::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     Q_ASSERT(m_d->model);
     m_d->model->setDisplayRenderer(displayRenderer);
 }
diff --git a/plugins/dockers/palettedocker/PaletteListSaver.cpp b/plugins/dockers/palettedocker/PaletteListSaver.cpp
index 11d87c20f0..f772cbac21 100644
--- a/plugins/dockers/palettedocker/PaletteListSaver.cpp
+++ b/plugins/dockers/palettedocker/PaletteListSaver.cpp
@@ -1,51 +1,53 @@
 #include "PaletteListSaver.h"
 
 #include "palettedocker_dock.h"
 
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 #include <KisDocument.h>
 #include <KisViewManager.h>
 #include <KisPaletteModel.h>
 
 PaletteListSaver::PaletteListSaver(PaletteDockerDock *dockerDock, QObject *parent)
     : QObject(parent)
     , m_dockerDock(dockerDock)
 {
     connect(m_dockerDock->m_model, SIGNAL(dataChanged(QModelIndex, QModelIndex)),
             SLOT(slotPaletteModified()));
+    connect(m_dockerDock->m_model, SIGNAL(modelReset()),
+            SLOT(slotPaletteModified()));
 }
 
 void PaletteListSaver::slotSetPaletteList()
 {
     QList<const KoColorSet *> list;
     for (const KoResource * paletteResource :
          KoResourceServerProvider::instance()->paletteServer()->resources()) {
         const KoColorSet *palette = static_cast<const KoColorSet*>(paletteResource);
         Q_ASSERT(palette);
         if (!palette->isGlobal()) {
             list.append(palette);
         }
     }
     m_dockerDock->m_view->document()->setPaletteList(list);
     slotPaletteModified();
 }
 
 void PaletteListSaver::slotPaletteModified()
 {
     resetConnection();
     m_dockerDock->m_view->document()->setModified(true);
 }
 
 void PaletteListSaver::resetConnection()
 {
     m_dockerDock->m_view->document()->disconnect(this);
     connect(m_dockerDock->m_view->document(), SIGNAL(sigSavingFinished()),
             SLOT(slotSavingFinished()));
 }
 
 void PaletteListSaver::slotSavingFinished()
 {
     bool undoStackClean = m_dockerDock->m_view->document()->undoStack()->isClean();
     m_dockerDock->m_view->document()->setModified(!undoStackClean);
 }
diff --git a/plugins/dockers/palettedocker/palettedocker_dock.cpp b/plugins/dockers/palettedocker/palettedocker_dock.cpp
index fd8ee788ef..aded0f7df7 100644
--- a/plugins/dockers/palettedocker/palettedocker_dock.cpp
+++ b/plugins/dockers/palettedocker/palettedocker_dock.cpp
@@ -1,280 +1,280 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #include "palettedocker_dock.h"
 
 #include <QPainter>
 #include <QGridLayout>
 #include <QTableView>
 #include <QHeaderView>
 #include <QWheelEvent>
 #include <QColorDialog>
 #include <QCompleter>
 #include <QComboBox>
 #include <QAction>
 #include <QMenu>
 #include <QCheckBox>
 #include <QFormLayout>
 #include <QLineEdit>
 
 #include <klocalizedstring.h>
 #include <KoResourceServerProvider.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoFileDialog.h>
 #include <kis_icon.h>
 #include <kis_layer.h>
 #include <kis_node_manager.h>
 #include <kis_config.h>
 #include <kis_workspace_resource.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisMainWindow.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisViewManager.h>
 #include <kis_display_color_converter.h>
 #include <kis_canvas2.h>
 #include <KoDialog.h>
 #include <kis_color_button.h>
 #include <squeezedcombobox.h>
 
 #include "KisPaletteModel.h"
 #include "KisPaletteDelegate.h"
 #include "kis_palette_view.h"
 #include <KisPaletteListWidget.h>
 
 #include "ui_wdgpalettedock.h"
 
 PaletteDockerDock::PaletteDockerDock( )
     : QDockWidget(i18n("Palette"))
     , m_ui(new Ui_WdgPaletteDock())
     , m_currentColorSet(0)
     , m_view(0)
     , m_resourceProvider(0)
     , m_canvas(0)
     , m_actAdd(new QAction(KisIconUtils::loadIcon("list-add"), i18n("Add foreground color")))
     , m_actAddWithDlg(new QAction(KisIconUtils::loadIcon("list-add"), i18n("Choose a color to add")))
     , m_actSwitch(new QAction(i18n("Switch with another spot")))
     , m_actRemove(new QAction(KisIconUtils::loadIcon("edit-delete"), i18n("Delete color")))
     , m_actModify(new QAction(KisIconUtils::loadIcon("edit-rename"), i18n("Modify this spot")))
 {
     QWidget *mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_ui->setupUi(mainWidget);
 
     m_ui->bnAdd->setDefaultAction(m_actAdd.data());
     m_ui->bnRemove->setDefaultAction(m_actRemove.data());
     m_ui->bnRename->setDefaultAction(m_actModify.data());
 
     // to make sure their icons have the same size
     m_ui->bnRemove->setIconSize(QSize(16, 16));
     m_ui->bnRename->setIconSize(QSize(16, 16));
     m_ui->bnAdd->setIconSize(QSize(16, 16));
 
     m_ui->bnAdd->setEnabled(false);
     m_ui->bnRename->setEnabled(false);
     m_ui->bnRemove->setEnabled(false);
     // m_wdgPaletteDock->bnAddGroup->setIcon(KisIconUtils::loadIcon("groupLayer"));
 
     m_model = new KisPaletteModel(this);
     m_ui->paletteView->setPaletteModel(m_model);
     m_ui->paletteView->setAllowModification(true);
     m_ui->cmbNameList->setPaletteModel(m_model);
 
     connect(m_actAdd.data(), SIGNAL(triggered()), SLOT(slotAddColor()));
     connect(m_actRemove.data(), SIGNAL(triggered()), SLOT(slotRemoveColor()));
     connect(m_actModify.data(), SIGNAL(triggered()), SLOT(slotEditEntry()));
     connect(m_ui->paletteView, SIGNAL(sigIndexSelected(QModelIndex)),
             SLOT(slotPaletteIndexSelected(QModelIndex)));
     connect(m_ui->paletteView, SIGNAL(sigIndexSelected(QModelIndex)),
             m_ui->cmbNameList, SLOT(slotSwatchSelected(QModelIndex)));
     connect(m_ui->cmbNameList, SIGNAL(sigColorSelected(KoColor)),
             SLOT(slotNameListSelection(KoColor)));
 
     m_viewContextMenu.addAction(m_actAddWithDlg.data());
     m_viewContextMenu.addAction(m_actRemove.data());
     m_viewContextMenu.addAction(m_actModify.data());
     m_viewContextMenu.addAction(m_actSwitch.data());
 
     m_paletteChooser = new KisPaletteListWidget(this);
+    m_paletteChooser->setAllowModification(true);
     connect(m_paletteChooser, SIGNAL(sigPaletteSelected(KoColorSet*)), SLOT(slotSetColorSet(KoColorSet*)));
 
     m_ui->bnColorSets->setIcon(KisIconUtils::loadIcon("hi16-palette_library"));
     m_ui->bnColorSets->setToolTip(i18n("Choose palette"));
     m_ui->bnColorSets->setPopupWidget(m_paletteChooser);
 
     KisConfig cfg(true);
     QString defaultPaletteName = cfg.defaultPalette();
     KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
     KoColorSet* defaultPalette = rServer->resourceByName(defaultPaletteName);
     if (defaultPalette) {
         slotSetColorSet(defaultPalette);
     }
 
     m_saver.reset(new PaletteListSaver(this));
     connect(m_paletteChooser, SIGNAL(sigPaletteListChanged()), m_saver.data(), SLOT(slotSetPaletteList()));
 }
 
 PaletteDockerDock::~PaletteDockerDock()
 {
     if (m_currentColorSet) {
         KisConfig cfg(true);
         cfg.setDefaultPalette(m_currentColorSet->name());
     }
 
     delete m_ui;
 }
 
 void PaletteDockerDock::setViewManager(KisViewManager* kisview)
 {
     m_view = kisview;
     m_resourceProvider = kisview->resourceProvider();
     connect(m_resourceProvider, SIGNAL(sigSavingWorkspace(KisWorkspaceResource*)), SLOT(saveToWorkspace(KisWorkspaceResource*)));
     connect(m_resourceProvider, SIGNAL(sigLoadingWorkspace(KisWorkspaceResource*)), SLOT(loadFromWorkspace(KisWorkspaceResource*)));
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)),
             m_ui->paletteView, SLOT(slotFGColorChanged(KoColor)));
 
     kisview->nodeManager()->disconnect(m_model);
 }
 
 void PaletteDockerDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
     if (canvas) {
         KisCanvas2 *cv = qobject_cast<KisCanvas2*>(canvas);
         m_ui->paletteView->setDisplayRenderer(cv->displayColorConverter()->displayRendererInterface());
     }
     m_canvas = static_cast<KisCanvas2*>(canvas);
 }
 
 void PaletteDockerDock::unsetCanvas()
 {
     setEnabled(false);
     m_ui->paletteView->setDisplayRenderer(Q_NULLPTR);
     m_canvas = Q_NULLPTR;
 }
 
 void PaletteDockerDock::slotSetColorSet(KoColorSet* colorSet)
 {
     if (colorSet->isEditable()) {
         m_ui->bnAdd->setEnabled(true);
         m_ui->bnRename->setEnabled(true);
         m_ui->bnRemove->setEnabled(true);
     } else {
         m_ui->bnAdd->setEnabled(false);
         m_ui->bnRename->setEnabled(false);
         m_ui->bnRemove->setEnabled(false);
     }
 
     m_currentColorSet = colorSet;
     m_model->setColorSet(colorSet);
     m_ui->bnColorSets->setText(colorSet->name());
 }
 
 void PaletteDockerDock::slotAddColor()
 {
     if (m_currentColorSet->isEditable()) {
         if (m_resourceProvider) {
             m_ui->paletteView->addEntryWithDialog(m_resourceProvider->fgColor());
         }
     }
 }
 
 void PaletteDockerDock::slotRemoveColor()
 {
     if (m_currentColorSet->isEditable()) {
         QModelIndex index = m_ui->paletteView->currentIndex();
         if (!index.isValid()) {
             return;
         }
         m_ui->paletteView->removeEntryWithDialog(index);
         m_ui->bnRemove->setEnabled(false);
     }
 }
 
 void PaletteDockerDock::setFGColorByPalette(const KisSwatch &entry)
 {
     if (m_resourceProvider) {
         m_resourceProvider->setFGColor(entry.color());
     }
 }
 
 void PaletteDockerDock::saveToWorkspace(KisWorkspaceResource* workspace)
 {
     if (m_currentColorSet) {
         workspace->setProperty("palette", m_currentColorSet->name());
     }
 }
 
 void PaletteDockerDock::loadFromWorkspace(KisWorkspaceResource* workspace)
 {
     if (workspace->hasProperty("palette")) {
         KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
         KoColorSet* colorSet = rServer->resourceByName(workspace->getString("palette"));
         if (colorSet) {
             slotSetColorSet(colorSet);
         }
     }
 }
 
 void PaletteDockerDock::slotPaletteIndexSelected(const QModelIndex &index)
 {
     bool slotEmpty = !(qvariant_cast<bool>(index.data(KisPaletteModel::CheckSlotRole)));
     if (slotEmpty) {
         if (!m_currentColorSet->isEditable()) { return; }
         setEntryByForeground(index);
     } else {
+        m_ui->bnRemove->setEnabled(true);
         KisSwatch entry = m_model->getEntry(index);
         setFGColorByPalette(entry);
-        m_ui->bnRemove->setEnabled(true);
     }
 }
 
 void PaletteDockerDock::setEntryByForeground(const QModelIndex &index)
 {
-    qDebug() << "PaletteDockerDock" << index.row() << index.column();
     m_model->setEntry(KisSwatch(m_resourceProvider->fgColor()), index);
     if (m_currentColorSet->isEditable()) {
         m_ui->bnRemove->setEnabled(true);
     }
 }
 
 void PaletteDockerDock::slotEditEntry()
 {
     if (m_currentColorSet->isEditable()) {
         QModelIndex index = m_ui->paletteView->currentIndex();
         if (!index.isValid()) {
             return;
         }
         m_ui->paletteView->modifyEntry(index);
     }
 }
 
 void PaletteDockerDock::slotImportPalette()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "OpenColorSet");
     dialog.setDefaultDir(m_currentColorSet->filename());
     dialog.setMimeTypeFilters(QStringList() << "application/x-gimp-color-palette");
     QString fileName = dialog.filename();
     KoColorSet *colorSet = new KoColorSet(fileName);
     colorSet->load();
 }
 
 void PaletteDockerDock::slotNameListSelection(const KoColor &color)
 {
     m_resourceProvider->setFGColor(color);
 }