diff --git a/libs/widgets/KisPaletteModel.cpp b/libs/widgets/KisPaletteModel.cpp
index 16d8da9ef0..f106d10d39 100644
--- a/libs/widgets/KisPaletteModel.cpp
+++ b/libs/widgets/KisPaletteModel.cpp
@@ -1,507 +1,508 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2018 Michael Zhou <simeirxh@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(Q_NULLPTR)
     , m_displayRenderer(KoDumbColorDisplayRenderer::instance())
 {
     connect(this, SIGNAL(sigPaletteModified()), SLOT(slotPaletteModified()));
 }
 
 KisPaletteModel::~KisPaletteModel()
 {
 }
 
 QVariant KisPaletteModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid()) { return QVariant(); }
-    bool groupNameRow = m_groupNameRows.contains(index.row());
+    bool groupNameRow = m_rowGroupNameMap.contains(index.row());
     if (role == IsGroupNameRole) {
         return groupNameRow;
     }
     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
+            + m_rowGroupNameMap.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);
     int groupNameRow = groupNameRowForRow(row);
-    KisSwatchGroup *group = m_colorSet->getGroup(m_groupNameRows[groupNameRow]);
+    KisSwatchGroup *group = m_colorSet->getGroup(m_rowGroupNameMap[groupNameRow]);
     Q_ASSERT(group);
     return createIndex(row, column, group);
 }
 
 void KisPaletteModel::resetGroupNameRows()
 {
-    m_groupNameRows.clear();
+    m_rowGroupNameMap.clear();
     int row = -1;
     for (const QString &groupName : m_colorSet->getGroupNames()) {
-        m_groupNameRows[row] = groupName;
+        m_rowGroupNameMap[row] = groupName;
         row += m_colorSet->getGroup(groupName)->rowCount();
         row += 1; // row for group name
     }
 }
 
 void KisPaletteModel::setPalette(KoColorSet* palette)
 {
     beginResetModel();
     m_colorSet = palette;
     if (palette) {
         resetGroupNameRows();
     }
     endResetModel();
     emit sigPaletteChanged();
 }
 
 KoColorSet* KisPaletteModel::colorSet() const
 {
     return m_colorSet;
 }
 
 int KisPaletteModel::rowNumberInGroup(int rowInModel) const
 {
-    if (m_groupNameRows.contains(rowInModel)) {
+    if (m_rowGroupNameMap.contains(rowInModel)) {
         return -1;
     }
-    for (auto it = m_groupNameRows.keys().rbegin(); it != m_groupNameRows.keys().rend(); it++) {
+    QList<int> rowNumberList = m_rowGroupNameMap.keys();
+    for (auto it = rowNumberList.rbegin(); it != rowNumberList.rend(); it++) {
         if (*it < rowInModel) {
             return rowInModel - *it - 1;
         }
     }
     return rowInModel;
 }
 
 int KisPaletteModel::groupNameRowForName(const QString &groupName)
 {
-    for (auto it = m_groupNameRows.begin(); it != m_groupNameRows.end(); it++) {
+    for (auto it = m_rowGroupNameMap.begin(); it != m_rowGroupNameMap.end(); it++) {
         if (it.value() == groupName) {
             return it.key();
         }
     }
     return -1;
 }
 
 bool KisPaletteModel::addEntry(const KisSwatch &entry, const QString &groupName)
 {
     beginInsertRows(QModelIndex(), rowCount(), rowCount() + 1);
     m_colorSet->add(entry, groupName);
     endInsertRows();
     if (m_colorSet->isGlobal()) {
         m_colorSet->save();
     }
     emit sigPaletteModified();
     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 {
         int groupNameRow = groupNameRowForRow(index.row());
-        QString groupName = m_groupNameRows[groupNameRow];
+        QString groupName = m_rowGroupNameMap[groupNameRow];
         removeGroup(groupName, keepColors);
     }
     emit sigPaletteModified();
     return true;
 }
 
 void KisPaletteModel::removeGroup(const QString &groupName, bool keepColors)
 {
     int removeStart = groupNameRowForName(groupName);
     int removedRowCount = m_colorSet->getGroup(groupName)->rowCount();
     int insertStart = m_colorSet->getGlobalGroup()->rowCount();
     beginRemoveRows(QModelIndex(),
                     removeStart,
                     removeStart + removedRowCount);
     m_colorSet->removeGroup(groupName, keepColors);
     resetGroupNameRows();
     endRemoveRows();
     beginInsertRows(QModelIndex(),
 		    insertStart, m_colorSet->getGlobalGroup()->rowCount());
     endInsertRows();
     emit sigPaletteModified();
 }
 
 bool KisPaletteModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
                                    int row, int column, const QModelIndex &parent)
 {
     Q_UNUSED(row);
     Q_UNUSED(column);
     if (!data->hasFormat("krita/x-colorsetentry") && !data->hasFormat("krita/x-colorsetgroup")) {
         return false;
     }
     if (action == Qt::IgnoreAction) {
         return false;
     }
 
     QModelIndex finalIndex = parent;
     if (!finalIndex.isValid()) { return false; }
 
     if (data->hasFormat("krita/x-colorsetgroup")) {
         // dragging group not supported for now
         QByteArray encodedData = data->data("krita/x-colorsetgroup");
         QDataStream stream(&encodedData, QIODevice::ReadOnly);
 
         while (!stream.atEnd()) {
             QString groupNameDroppedOn = qvariant_cast<QString>(finalIndex.data(GroupNameRole));
             if (groupNameDroppedOn == KoColorSet::GLOBAL_GROUP_NAME) {
                 return false;
             }
             QString groupNameDragged;
             stream >> groupNameDragged;
             KisSwatchGroup *groupDragged = m_colorSet->getGroup(groupNameDragged);
             int start = groupNameRowForName(groupNameDragged);
             int end = start + groupDragged->rowCount();
             if (!beginMoveRows(QModelIndex(), start, end, QModelIndex(), groupNameRowForName(groupNameDroppedOn))) {
                 return false;
             }
             m_colorSet->moveGroup(groupNameDragged, groupNameDroppedOn);
             resetGroupNameRows();
             endMoveRows();
             emit sigPaletteModified();
             if (m_colorSet->isGlobal()) {
                 m_colorSet->save();
             }
         }
         return true;
     }
 
     if (qvariant_cast<bool>(finalIndex.data(KisPaletteModel::IsGroupNameRole))) {
         return true;
     }
 
     QByteArray encodedData = data->data("krita/x-colorsetentry");
     QDataStream stream(&encodedData, QIODevice::ReadOnly);
 
     while (!stream.atEnd()) {
         KisSwatch entry;
 
         QString name, id;
         bool spotColor;
         QString oldGroupName;
         int oriRow;
         int oriColumn;
         QString colorXml;
 
         stream >> name >> id >> spotColor
                 >> oriRow >> oriColumn
                 >> 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));
         }
 
         if (action == Qt::MoveAction){
             KisSwatchGroup *g = m_colorSet->getGroup(oldGroupName);
             if (g) {
                 if (qvariant_cast<bool>(finalIndex.data(KisPaletteModel::CheckSlotRole))) {
                     g->setEntry(getEntry(finalIndex), oriColumn, oriRow);
                 } else {
                     g->removeEntry(oriColumn, oriRow);
                 }
             }
             setEntry(entry, finalIndex);
             emit sigPaletteModified();
             if (m_colorSet->isGlobal()) {
                 m_colorSet->save();
             }
         }
     }
 
     return true;
 }
 
 QMimeData *KisPaletteModel::mimeData(const QModelIndexList &indexes) const
 {
     QMimeData *mimeData = new QMimeData();
     QByteArray encodedData;
 
     QDataStream stream(&encodedData, QIODevice::WriteOnly);
     QModelIndex index = indexes.last();
     if (index.isValid() && qvariant_cast<bool>(index.data(CheckSlotRole))) {
         QString mimeTypeName = "krita/x-colorsetentry";
         if (qvariant_cast<bool>(index.data(IsGroupNameRole))==false) {
             KisSwatch entry = getEntry(index);
 
             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()
                    << rowNumberInGroup(index.row()) << index.column()
                    << qvariant_cast<QString>(index.data(GroupNameRole))
                    << doc.toString();
         } else {
             mimeTypeName = "krita/x-colorsetgroup";
             QString groupName = qvariant_cast<QString>(index.data(GroupNameRole));
             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 sigPaletteModified();
     emit dataChanged(index, index);
     if (m_colorSet->isGlobal()) {
         m_colorSet->save();
     }
 }
 
 bool KisPaletteModel::renameGroup(const QString &groupName, const QString &newName)
 {
     beginResetModel();
     bool success = m_colorSet->changeGroupName(groupName, newName);
-    for (auto it = m_groupNameRows.begin(); it != m_groupNameRows.end(); it++) {
+    for (auto it = m_rowGroupNameMap.begin(); it != m_rowGroupNameMap.end(); it++) {
         if (it.value() == groupName) {
-            m_groupNameRows[it.key()] = newName;
+            m_rowGroupNameMap[it.key()] = newName;
             break;
         }
     }
     endResetModel();
     emit sigPaletteModified();
     return success;
 }
 
 void KisPaletteModel::addGroup(const KisSwatchGroup &group)
 {
     beginInsertRows(QModelIndex(), rowCount(), rowCount() + group.rowCount());
     m_colorSet->addGroup(group.name());
     *m_colorSet->getGroup(group.name()) = group;
     endInsertColumns();
 
     emit sigPaletteModified();
 }
 
 void KisPaletteModel::setRowNumber(const QString &groupName, int rowCount)
 {
     beginResetModel();
     KisSwatchGroup *g = m_colorSet->getGroup(groupName);
     if (g) {
         g->setRowCount(rowCount);
     }
     endResetModel();
 }
 
 void KisPaletteModel::clear()
 {
     beginResetModel();
     m_colorSet->clear();
     endResetModel();
 }
 
 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 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);
     int rowInGroup = rowNumberInGroup(idx.row());
     bool entryPresent = group->checkEntry(idx.column(), rowInGroup);
     KisSwatch entry;
     if (entryPresent) {
         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 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();
 }
 
 void KisPaletteModel::slotPaletteModified() {
     m_colorSet->setPaletteType(KoColorSet::KPL);
 }
 
 QModelIndex KisPaletteModel::indexForClosest(const KoColor &compare)
 {
     KisSwatchGroup::SwatchInfo info = colorSet()->getClosestColorInfo(compare);
     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++) {
+    for (auto it = m_rowGroupNameMap.begin(); it != m_rowGroupNameMap.end(); it++) {
         if (it.value() == info.group) {
             return it.key() + info.row + 1;
         }
     }
     return info.row;
 }
 
 KisSwatch KisPaletteModel::getEntry(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::groupNameRowForRow(int rowInModel) const
 {
     return rowInModel - rowNumberInGroup(rowInModel) - 1;
 }
diff --git a/libs/widgets/KisPaletteModel.h b/libs/widgets/KisPaletteModel.h
index 1659c138fa..9bbdf0a570 100644
--- a/libs/widgets/KisPaletteModel.h
+++ b/libs/widgets/KisPaletteModel.h
@@ -1,179 +1,179 @@
 /*
  *  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:
     explicit KisPaletteModel(QObject* parent = Q_NULLPTR);
     ~KisPaletteModel() override;
 
     enum AdditionalRoles {
         IsGroupNameRole = Qt::UserRole + 1,
         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
      */
     // TODO Used QVariant::setValue and QVariant.value<KoColor> to implement this
     // bool setData(const QModelIndex &index, const QVariant &value, int role) override;
 
 Q_SIGNALS:
     /**
      * @brief sigPaletteModified
      * emitted when palette associated with the model is modified
      */
     void sigPaletteModified();
     /**
      * @brief sigPaletteChanged
      * emitted when the palette associated with the model is made another one
      */
     void sigPaletteChanged();
 
 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);
     void removeGroup(const QString &groupName, bool keepColors);
     bool renameGroup(const QString &groupName, const QString &newName);
     void addGroup(const KisSwatchGroup &group);
     void setRowNumber(const QString &groupName, int rowCount);
     void clear();
 
     KisSwatch getEntry(const QModelIndex &index) const;
 
     void setPalette(KoColorSet* colorSet);
     KoColorSet* colorSet() const;
 
     QModelIndex indexForClosest(const KoColor &compare);
     int indexRowForInfo(const KisSwatchGroup::SwatchInfo &info);
 
 public Q_SLOTS:
 
 private Q_SLOTS:
     void slotDisplayConfigurationChanged();
     void slotPaletteModified();
 
 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;
     int groupNameRowForName(const QString &groupName);
     void resetGroupNameRows();
     /**
      * 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;
+    QMap<int, QString> m_rowGroupNameMap;
 
 friend class KisPaletteView;
 };
 
 #endif
diff --git a/libs/widgets/kis_palette_view.cpp b/libs/widgets/kis_palette_view.cpp
index a0d966ff62..134b56f003 100644
--- a/libs/widgets/kis_palette_view.cpp
+++ b/libs/widgets/kis_palette_view.cpp
@@ -1,281 +1,281 @@
 /*
  *  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);
     setDragDropMode(QAbstractItemView::InternalMove);
     setSelectionMode(QAbstractItemView::SingleSelection);
     setDragEnabled(false);
     setAcceptDrops(false);
 
     /*
      * 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)));
     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::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) {
         KisSwatchGroup group;
         group.setName(lnName->text());
         m_d->model->addGroup(group);
         m_d->model->colorSet()->save();
         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);
     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::setPaletteModel(KisPaletteModel *model)
 {
     if (m_d->model) {
         disconnect(m_d->model, Q_NULLPTR, this, Q_NULLPTR);
     }
     m_d->model = model;
     setModel(model);
     slotAdditionalGuiUpdate();
     connect(model, SIGNAL(sigPaletteModified()),
             SLOT(slotAdditionalGuiUpdate()));
     connect(model, SIGNAL(sigPaletteChanged()),
             SLOT(slotAdditionalGuiUpdate()));
 
     connect(selectionModel(), SIGNAL(currentChanged(QModelIndex, QModelIndex)),
             SLOT(slotCurrentSelectionChanged(QModelIndex)));
 }
 
 KisPaletteModel* KisPaletteView::paletteModel() const
 {
     return m_d->model;
 }
 
 void KisPaletteView::setAllowModification(bool allow)
 {
     m_d->allowPaletteModification = allow;
     setDragEnabled(allow);
     setAcceptDrops(allow);
 }
 
 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()) {
+    for (int groupNameRowNumber : m_d->model->m_rowGroupNameMap.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::slotCurrentSelectionChanged(const QModelIndex &newCurrent)
 {
     if (!newCurrent.isValid()) { return; }
 
     emit sigIndexSelected(newCurrent);
     if (qvariant_cast<bool>(newCurrent.data(KisPaletteModel::IsGroupNameRole))) {
         return;
     }
     if (qvariant_cast<bool>(newCurrent.data(KisPaletteModel::CheckSlotRole))) {
         KisSwatch entry = m_d->model->getEntry(newCurrent);
         emit sigColorSelected(entry.color());
     }
 }
 
 void KisPaletteView::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     Q_ASSERT(m_d->model);
     m_d->model->setDisplayRenderer(displayRenderer);
 }