diff --git a/libs/pigment/resources/KisSwatchGroup.cpp b/libs/pigment/resources/KisSwatchGroup.cpp
index be9b88eb08..faba9a1981 100644
--- a/libs/pigment/resources/KisSwatchGroup.cpp
+++ b/libs/pigment/resources/KisSwatchGroup.cpp
@@ -1,155 +1,155 @@
 /*  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"
 
 quint32 KisSwatchGroup::DEFAULT_COLUMN_COUNT = 16;
 quint32 KisSwatchGroup::DEFAULT_ROW_COUNT = 20;
 
 KisSwatchGroup::KisSwatchGroup()
     : m_colorMatrix(DEFAULT_COLUMN_COUNT)
     , m_colorCount(0)
     , m_rowCount(DEFAULT_ROW_COUNT)
 { }
 
 void KisSwatchGroup::setEntry(const KisSwatch &e, int x, int y)
 {
     Q_ASSERT(x < m_colorMatrix.size() && x >= 0 && y >= 0);
     if (y >= m_rowCount) {
         setRowCount(y);
     }
     if (!checkEntry(x, y)) {
         m_colorCount++;
     }
     m_colorMatrix[x][y] = e;
 }
 
 bool KisSwatchGroup::checkEntry(int x, int y) const
 {
     if (y >= m_rowCount || x >= m_colorMatrix.size() || x < 0) {
         return false;
     }
     if (!m_colorMatrix[x].contains(y)) {
         return false;
     }
     return true;
 }
 
 bool KisSwatchGroup::removeEntry(int x, int y)
 {
     if (m_colorCount == 0) {
         return false;
     }
 
-    if (x >= m_rowCount || x >= m_colorMatrix.size() || x < 0) {
+    if (y >= m_rowCount || x >= m_colorMatrix.size() || x < 0) {
         return false;
     }
 
     // QMap::remove returns 1 if key found else 0
     if (m_colorMatrix[x].remove(y)) {
         m_colorCount -= 1;
         return true;
     } else {
         return false;
     }
 }
 
 void KisSwatchGroup::setColumnCount(int columnCount)
 {
     Q_ASSERT(columnCount >= 0);
     if (columnCount < m_colorMatrix.size()) {
         for (int i = m_colorMatrix.size() - 1; i <= columnCount; i-- ) {
             m_colorCount -= m_colorMatrix[i].size();
         }
     }
     m_colorMatrix.resize(columnCount);
 }
 
 KisSwatch KisSwatchGroup::getEntry(int x, int y) const
 {
     Q_ASSERT(checkEntry(x, y));
     return m_colorMatrix[x][y];
 }
 
 void KisSwatchGroup::addEntry(const KisSwatch &e)
 {
     if (columnCount() == 0) {
         setColumnCount(DEFAULT_COLUMN_COUNT);
     }
 
     if (m_colorCount == 0) {
         setEntry(e, 0, 0);
         return;
     }
 
     int y = 0;
     for (const Column &c : m_colorMatrix) {
         if (c.isEmpty()) { continue; }
         if (y < c.lastKey()) {
             y = c.lastKey();
         }
     }
     for (int x = m_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 == m_colorMatrix.size()) {
                 x = 0;
                 y++;
                 if (y == m_rowCount) {
                     m_rowCount++;
                 }
             }
             // else just add it to the right
             setEntry(e, x, y);
             break;
         }
     }
 }
 
 void KisSwatchGroup::setRowCount(int newRowCount)
 {
     m_rowCount = newRowCount;
     for (Column &c : m_colorMatrix) {
         for (int k : c.keys()) {
             if (k >= newRowCount) {
                 c.remove(k);
                 m_colorCount--;
             }
         }
     }
 }
 
 QList<KisSwatchGroup::SwatchInfo> KisSwatchGroup::infoList() const
 {
     QList<SwatchInfo> res;
     int column = 0;
     for (const Column &c : m_colorMatrix) {
         int row = 0;
         for (const KisSwatch &s : c.values()) {
             SwatchInfo i = {m_name, s, c.keys()[row++], column};
             res.append(i);
         }
         column++;
     }
     return res;
 }
diff --git a/libs/widgets/KisPaletteModel.cpp b/libs/widgets/KisPaletteModel.cpp
index 0397037547..5c1701f09c 100644
--- a/libs/widgets/KisPaletteModel.cpp
+++ b/libs/widgets/KisPaletteModel.cpp
@@ -1,476 +1,484 @@
 /*
  *  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 = row - rowNumberInGroup(row) - 1;
     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;
 }
 
 KisSwatch KisPaletteModel::colorSetEntryFromIndex(const QModelIndex &index) const
 {
     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::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(KisSwatch entry, QString groupName)
+bool KisPaletteModel::addEntry(const KisSwatch &entry, const QString &groupName)
 {
     KisSwatchGroup *group = m_colorSet->getGroup(groupName);
     if (group->checkEntry(group->columnCount(), group->rowCount())) {
         beginInsertRows(QModelIndex(), rowCount(), rowCount());
         m_colorSet->add(entry, groupName);
         endInsertRows();
     } else {
         beginResetModel();
         m_colorSet->add(entry, groupName);
         endResetModel();
     }
     m_colorSet->save();
     return true;
 }
 
-bool KisPaletteModel::removeEntry(QModelIndex index, bool keepColors)
+bool KisPaletteModel::removeEntry(const QModelIndex &index, bool keepColors)
 {
-    if (qvariant_cast<bool>(data(index, IsGroupNameRole))==false) {
+    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 = index.row() - rowNumberInGroup(index.row()) - 1;
         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()));
     emit dataChanged(index, index);
 }
 
 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 IsGroupNameRole: {
         return true;
     }
     case CheckSlotRole: {
         return true;
     }
     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()));
     KisSwatch entry;
     if (entryPresent) {
         entry = group->getEntry(idx.column(), rowNumberInGroup(idx.row()));
     }
     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 CheckSlotRole: {
         return entryPresent;
     }
     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));
 }
+
+KisSwatch KisPaletteModel::getEntry(const QModelIndex &index)
+{
+    KisSwatchGroup *group = static_cast<KisSwatchGroup*>(index.internalPointer());
+    Q_ASSERT(group);
+    return group->getEntry(index.column(), rowNumberInGroup(index.row()));
+}
diff --git a/libs/widgets/KisPaletteModel.h b/libs/widgets/KisPaletteModel.h
index ec06205c14..bf872bb28f 100644
--- a/libs/widgets/KisPaletteModel.h
+++ b/libs/widgets/KisPaletteModel.h
@@ -1,161 +1,162 @@
 /*
  *  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  = Qt::UserRole + 3,
         CheckSlotRole = Qt::UserRole + 4
     };
 
 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(KisSwatch entry, QString groupName=QString());
+    bool addEntry(const KisSwatch &entry, const QString &groupName=QString());
 
     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(QModelIndex index, bool keepColors=true);
+    bool removeEntry(const QModelIndex &index, bool keepColors=true);
+    KisSwatch getEntry(const QModelIndex &index);
 
     void setColorSet(KoColorSet* colorSet);
     KoColorSet* colorSet() const;
 
     /**
      * @brief colorSetEntryFromIndex
      * This gives the colorset entry for the given table model index.
      * @param index the QModelIndex
      * @return the kocolorsetentry
      */
     KisSwatch colorSetEntryFromIndex(const QModelIndex &index) const;
 
     QModelIndex indexForClosest(const KoColor &compare);
 
 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 groupNameRowForIndex(const QModelIndex &);
     /**
      * 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/kis_palette_view.cpp b/libs/widgets/kis_palette_view.cpp
index 8ee1e0413f..d4d69d25e9 100644
--- a/libs/widgets/kis_palette_view.cpp
+++ b/libs/widgets/kis_palette_view.cpp
@@ -1,323 +1,323 @@
 /*
  *  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 = true;
     if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
         KoDialog *window = new KoDialog();
         window->setWindowTitle(i18nc("@title:window","Removing Group"));
         QFormLayout *editableItems = new QFormLayout();
         QCheckBox *chkKeep = new QCheckBox();
         window->mainWidget()->setLayout(editableItems);
         editableItems->addRow(i18nc("Shows up when deleting a group","Keep the Colors"), chkKeep);
         chkKeep->setChecked(keepColors);
         if (window->exec() == KoDialog::Accepted) {
             keepColors = chkKeep->isChecked();
             m_d->model->removeEntry(index, keepColors);
             m_d->model->colorSet()->save();
         }
     } else {
         m_d->model->removeEntry(index, keepColors);
-        m_d->model->colorSet()->save();
+        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;
     }
+    qDebug() << "KisPaletteView::selectClosestColor" << "triggered";
     //also don't select if the color is the same as the current selection
-    if (selectedIndexes().size() > 0) {
-        QModelIndex currentI = currentIndex();
-        if (m_d->model->colorSetEntryFromIndex(currentI).color() == color) {
-            return;
-        }
+    if (m_d->model->colorSetEntryFromIndex(currentIndex()).color() == color) {
+        return;
     }
 
     selectionModel()->clearSelection();
     QModelIndex index = m_d->model->indexForClosest(color);
     selectionModel()->setCurrentIndex(index, QItemSelectionModel::Select);
 }
 
-void KisPaletteView::slotChosenColorChanged(const KoColor &color)
+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());
         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))) {
         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) {
             m_d->model->colorSet()->changeGroupName(groupName, lnGroupName->text());
             emit m_d->model->dataChanged(index, index);
         }
         //rename the group.
     } 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());
         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(i18n("Name"), lnGroupName);
+        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->colorSet()->setEntry(entry, index.column(), index.row());
             m_d->model->colorSet()->save();
             emit m_d->model->dataChanged(index, 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() + 20);
         verticalHeader()->resizeSection(groupNameRowNumber, fontMetrics().lineSpacing() + 20);
     }
 }
 
 void KisPaletteView::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     Q_ASSERT(m_d->model);
     m_d->model->setDisplayRenderer(displayRenderer);
 }
diff --git a/libs/widgets/kis_palette_view.h b/libs/widgets/kis_palette_view.h
index b18f13321f..bfbd672c11 100644
--- a/libs/widgets/kis_palette_view.h
+++ b/libs/widgets/kis_palette_view.h
@@ -1,116 +1,115 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *  Copyright (c) 2017 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_PALETTE_VIEW_H
 #define __KIS_PALETTE_VIEW_H
 
 #include <QScopedPointer>
-
+#include <QTableView>
 #include <QColorDialog>
 #include <QPushButton>
 #include <QPixmap>
 #include <QIcon>
 
-#include <KoTableView.h>
 #include <KoColorSet.h>
 #include "kritawidgets_export.h"
 
 class KisPaletteModel;
 class QWheelEvent;
 class KoColorDisplayRendererInterface;
 
 class KRITAWIDGETS_EXPORT KisPaletteView : public QTableView
 {
     Q_OBJECT
 private:
     static int MININUM_ROW_HEIGHT;
 public:
     KisPaletteView(QWidget *parent = 0);
     ~KisPaletteView() override;
 
     void setPaletteModel(KisPaletteModel *model);
     KisPaletteModel* paletteModel() const;
 
 public:
 
     /**
      * @brief setAllowModification
      * Set whether doubleclick calls up a modification window. This is to prevent users from editing
      * the palette when the palette is intended to be a list of items.
      */
     void setAllowModification(bool allow);
     void setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer);
 
     /**
      * @brief setCrossedKeyword
      * this apparently allows you to set keywords that can cross out colors.
      * This is implemented to mark the lazybrush "transparent" color.
      * @param value
      */
     void setCrossedKeyword(const QString &value);
     /**
      * add an entry with a dialog window.
      */
     bool addEntryWithDialog(KoColor color);
     /**
      * remove entry with a dialog window.(Necessary for groups.
      */
     bool removeEntryWithDialog(QModelIndex index);
     void removeSelectedEntry();
     /**
      * @brief modifyEntry
      * function for changing the entry at the given index.
      * if modification isn't allow(@see setAllowModification), this does nothing.
      */
     void modifyEntry(QModelIndex index);
     /**
      * @brief selectClosestColor
      * select a color that's closest to parameter color
      * @param color
      */
     void selectClosestColor(const KoColor &color);
 
 Q_SIGNALS:
     void sigIndexSelected(const QModelIndex &index);
     void sigColorSelected(const KoColor &);
 
 public Q_SLOTS:
     /**
      *  This tries to select the closest color in the palette.
      *  This doesn't update the foreground color, just the visual selection.
      */
     void slotModifyEntry(const QModelIndex &);
-    void slotChosenColorChanged(const KoColor &);
+    void slotFGColorChanged(const KoColor &);
 
 protected:
     void mouseReleaseEvent(QMouseEvent *event) override;
 
 private Q_SLOTS:
     void slotHorizontalHeaderResized(int, int, int newSize);
     void slotAdditionalGuiUpdate();
 
 private:
     void resizeRows(int newSize);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_PALETTE_VIEW_H */
diff --git a/plugins/dockers/palettedocker/palettedocker_dock.cpp b/plugins/dockers/palettedocker/palettedocker_dock.cpp
index 28c6c96994..e2024b2480 100644
--- a/plugins/dockers/palettedocker/palettedocker_dock.cpp
+++ b/plugins/dockers/palettedocker/palettedocker_dock.cpp
@@ -1,279 +1,279 @@
 /*
  *  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_saver(new PaletteListSaver(this))
     , 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);
     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);
     }
 
     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(slotChosenColorChanged(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);
     }
 }
 
 void PaletteDockerDock::slotSetFGColorByPalette(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; }
         slotSetEntryByForeground(index);
     } else {
-        KisSwatch entry = m_currentColorSet->getColorGlobal(index.column(), index.row());
+        KisSwatch entry = m_model->getEntry(index);
         slotSetFGColorByPalette(entry);
     }
 }
 
 void PaletteDockerDock::slotSetEntryByForeground(const QModelIndex &index)
 {
     m_model->setEntry(KisSwatch(m_resourceProvider->fgColor()), index);
     if (m_currentColorSet->isEditable()) {
         m_ui->bnRemove->setEnabled(true);
         emit sigPaletteSelected(m_currentColorSet);
     }
 }
 
 void PaletteDockerDock::slotEditEntry()
 {
     if (m_currentColorSet->isEditable()) {
         QModelIndex index = m_ui->paletteView->currentIndex();
         if (!index.isValid()) {
             return;
         }
         m_ui->paletteView->modifyEntry(index);
         emit sigPaletteSelected(m_currentColorSet);
     }
 }
 
 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);
 }