diff --git a/libs/ui/KisPaletteModel.cpp b/libs/ui/KisPaletteModel.cpp
index d489a585d6..fc18a79964 100644
--- a/libs/ui/KisPaletteModel.cpp
+++ b/libs/ui/KisPaletteModel.cpp
@@ -1,617 +1,625 @@
 /*
  *  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 <resources/KoColorSet.h>
 #include <KoColorDisplayRendererInterface.h>
 
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 
 KisPaletteModel::KisPaletteModel(QObject* parent)
     : QAbstractTableModel(parent),
       m_colorSet(0),
       m_displayRenderer(KoDumbColorDisplayRenderer::instance())
 {
 }
 
 KisPaletteModel::~KisPaletteModel()
 {
 }
 
 void KisPaletteModel::setDisplayRenderer(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()
 {
     reset();
 }
 
 QModelIndex KisPaletteModel::getLastEntryIndex()
 {
     int endRow = rowCount();
     int endColumn = columnCount();
     if (m_colorSet->nColors()>0) {
         QModelIndex i = this->index(endRow, endColumn, QModelIndex());
         while (qVariantValue<QStringList>(i.data(RetrieveEntryRole)).isEmpty()) {
             i = this->index(endRow, endColumn);
             endColumn -=1;
             if (endColumn<0) {
                 endColumn = columnCount();
                 endRow-=1;
             }
         }
         return i;
     }
     return QModelIndex();
 }
 
 QVariant KisPaletteModel::data(const QModelIndex& index, int role) const
 {
     KoColorSetEntry entry;
     if (m_colorSet && m_displayRenderer) {
         //now to figure out whether we have a groupname row or not.
         bool groupNameRow = false;
         quint32 indexInGroup = 0;
         QString indexGroupName = QString();
 
         int rowstotal = m_colorSet->nColorsGroup()/columnCount();
         if (index.row()<=rowstotal && (quint32)(index.row()*columnCount()+index.column())<m_colorSet->nColorsGroup()) {
             indexInGroup = (quint32)(index.row()*columnCount()+index.column());
         }
         if (m_colorSet->nColorsGroup()==0) {
             rowstotal+=1; //always add one for the default group when considering groups.
         }
         Q_FOREACH (QString groupName, m_colorSet->getGroupNames()){
             //we make an int for the rows added by the current group.
             int newrows = 1+m_colorSet->nColorsGroup(groupName)/columnCount();
             if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
                 newrows+=1;
             }
             if (newrows==0) {
                 newrows+=1; //always add one for the group when considering groups.
             }
             quint32 tempIndex = (quint32)((index.row()-(rowstotal+2))*columnCount()+index.column());
             if (index.row() == rowstotal+1) {
                 //rowstotal+1 is taken up by the groupname.
                 indexGroupName = groupName;
                 groupNameRow = true;
             } else if (index.row() > (rowstotal+1) && index.row() <= rowstotal+newrows &&
                        tempIndex<m_colorSet->nColorsGroup(groupName)){
                 //otherwise it's an index to the colors in the group.
                 indexGroupName = groupName;
                 indexInGroup = tempIndex;
             }
             //add the new rows to the totalrows we've looked at.
             rowstotal += newrows;
         }
         if (groupNameRow) {
             switch (role) {
             case Qt::ToolTipRole:
             case Qt::DisplayRole: {
                 return indexGroupName;
             }
             case IsHeaderRole: {
                 return true;
             }
             case RetrieveEntryRole: {
                 QStringList entryList;
                 entryList.append(indexGroupName);
                 entryList.append(QString::number(0));
                 return entryList;
             }
             }
         } else {
             if (indexInGroup < m_colorSet->nColorsGroup(indexGroupName)) {
                 entry = m_colorSet->getColorGroup(indexInGroup, indexGroupName);
                 switch (role) {
                 case Qt::ToolTipRole:
                 case Qt::DisplayRole: {
                     return entry.name;
                 }
                 case Qt::BackgroundRole: {
                     QColor color = m_displayRenderer->toQColor(entry.color);
                     return QBrush(color);
                 }
                 case IsHeaderRole: {
                     return false;
                 }
                 case RetrieveEntryRole: {
                     QStringList entryList;
                     entryList.append(indexGroupName);
                     entryList.append(QString::number(indexInGroup));
                     return entryList;
                 }
                 }
             }
         }
     }
     return QVariant();
 }
 
 int KisPaletteModel::rowCount(const QModelIndex& /*parent*/) const
 {
     if (!m_colorSet) {
         return 0;
     }
     if (columnCount() > 0) {
         int countedrows = m_colorSet->nColorsGroup("")/columnCount();
         if (m_colorSet->nColorsGroup()%columnCount() > 0) {
             countedrows+=1;
         }
         if (m_colorSet->nColorsGroup()==0) {
             countedrows+=1;
         }
         Q_FOREACH (QString groupName, m_colorSet->getGroupNames()) {
             countedrows += 1; //add one for the name;
             countedrows += 1+(m_colorSet->nColorsGroup(groupName)/ columnCount());
             if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
                 countedrows+=1;
             }
             if (m_colorSet->nColorsGroup(groupName)==0) {
                 countedrows+=1;
             }
         }
         countedrows +=1; //Our code up till now doesn't take 0 into account.
         return countedrows;
     }
     return m_colorSet->nColors()/15 + 1;
 }
 
 int KisPaletteModel::columnCount(const QModelIndex& /*parent*/) const
 {
     if (m_colorSet && m_colorSet->columnCount() > 0) {
         return m_colorSet->columnCount();
     }
     return 15;
 }
 
 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
 {
     if (m_colorSet) {
 
         //make an int to hold the amount of rows we've looked at. The initial is the total rows in the default group.
         int rowstotal = m_colorSet->nColorsGroup()/columnCount();
         if (row<=rowstotal && (quint32)(row*columnCount()+column)<m_colorSet->nColorsGroup()) {
             //if the total rows are in the default group, we just return an index.
             return QAbstractTableModel::index(row, column, parent);
         } else if(row<0 && column<0) {
             return QAbstractTableModel::index(0, 0, parent);
         }
         if (m_colorSet->nColorsGroup()==0) {
             rowstotal+=1; //always add one for the default group when considering groups.
         }
         Q_FOREACH (QString groupName, m_colorSet->getGroupNames()){
             //we make an int for the rows added by the current group.
             int newrows = 1+m_colorSet->nColorsGroup(groupName)/columnCount();
             if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
                 newrows+=1;
             }
             if (m_colorSet->nColorsGroup(groupName)==0) {
                 newrows+=1; //always add one for the group when considering groups.
             }
             if (rowstotal + newrows>rowCount()) {
                 newrows = rowCount() - rowstotal;
             }
             quint32 tempIndex = (quint32)((row-(rowstotal+2))*columnCount()+column);
             if (row == rowstotal+1) {
                 //rowstotal+1 is taken up by the groupname.
                 return QAbstractTableModel::index(row, 0, parent);
             } else if (row > (rowstotal+1) && row <= rowstotal+newrows && tempIndex<m_colorSet->nColorsGroup(groupName)){
                 //otherwise it's an index to the colors in the group.
                 return QAbstractTableModel::index(row, column, parent);
             }
             //add the new rows to the totalrows we've looked at.
             rowstotal += newrows;
         }
     }
     return QModelIndex();
 }
 
 void KisPaletteModel::setColorSet(KoColorSet* colorSet)
 {
     m_colorSet = colorSet;
     reset();
 }
 
 KoColorSet* KisPaletteModel::colorSet() const
 {
     return m_colorSet;
 }
 
 QModelIndex KisPaletteModel::indexFromId(int i) const
 {
     QModelIndex index = QModelIndex();
+    if (colorSet()->nColors()==0) {
+        return index;
+    }
     if (i > colorSet()->nColors()) {
-        qWarning()<<"index is too big"<<i;
+        qWarning()<<"index is too big"<<i<<"/"<<colorSet()->nColors();
         index = this->index(0,0);
     }
     if (i < (int)colorSet()->nColorsGroup(0)) {
         index = QAbstractTableModel::index(i/columnCount(), i%columnCount());
         if (!index.isValid()) {
             index = QAbstractTableModel::index(0,0,QModelIndex());
         }
         return index;
     } else {
         int rowstotal = 1+m_colorSet->nColorsGroup()/columnCount();
         if (m_colorSet->nColorsGroup()==0) {
             rowstotal +=1;
         }
         int totalIndexes = colorSet()->nColorsGroup();
         Q_FOREACH (QString groupName, m_colorSet->getGroupNames()){
             if (i+1<=totalIndexes+colorSet()->nColorsGroup(groupName) && i+1>totalIndexes) {
                 int col = (i-totalIndexes)%columnCount();
                 int row = rowstotal+1+((i-totalIndexes)/columnCount());
                 index = this->index(row, col);
                 return index;
             } else {
                 rowstotal += 1+m_colorSet->nColorsGroup(groupName)/columnCount();
                 totalIndexes += colorSet()->nColorsGroup(groupName);
                 if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
                     rowstotal+=1;
                 }
                 if (m_colorSet->nColorsGroup(groupName)==0) {
                     rowstotal+=1; //always add one for the group when considering groups.
                 }
             }
         }
     }
     return index;
 }
 
 int KisPaletteModel::idFromIndex(const QModelIndex &index) const
 {
-    if (index.isValid()==false || qVariantValue<bool>(index.data(IsHeaderRole))) {
+    if (index.isValid()==false) {
         return -1;
+        qWarning()<<"invalid index";
     }
     int i=0;
     QStringList entryList = qVariantValue<QStringList>(data(index, RetrieveEntryRole));
+    if (entryList.isEmpty()) {
+        return -1;
+        qWarning()<<"invalid index, there's no data to retreive here";
+    }
     if (entryList.at(0)==QString()) {
         return entryList.at(1).toUInt();
     }
 
     i = colorSet()->nColorsGroup("");
     //find at which position the group is.
     int groupIndex = colorSet()->getGroupNames().indexOf(entryList.at(0));
     //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));
     }
     //then add the index.
     i += entryList.at(1).toUInt();
     return i;
 }
 
 KoColorSetEntry KisPaletteModel::colorSetEntryFromIndex(const QModelIndex &index) const
 {
     QStringList entryList = qVariantValue<QStringList>(data(index, RetrieveEntryRole));
     QString groupName = entryList.at(0);
     quint32 indexInGroup = entryList.at(1).toUInt();
     return m_colorSet->getColorGroup(indexInGroup, groupName);
 }
 
 bool KisPaletteModel::addColorSetEntry(KoColorSetEntry entry, QString groupName)
 {
     int col = m_colorSet->nColorsGroup(groupName)%columnCount();
     QModelIndex i = getLastEntryIndex();
     if (col+1>columnCount()) {
         beginInsertRows(QModelIndex(), i.row(), i.row()+1);
     }
     if (m_colorSet->nColors()<columnCount()) {
         beginInsertColumns(QModelIndex(), m_colorSet->nColors(), m_colorSet->nColors()+1);
     }
     m_colorSet->add(entry, groupName);
     if (col+1>columnCount()) {
         endInsertRows();
     }
     if (m_colorSet->nColors()<columnCount()) {
         endInsertColumns();
     }
     return true;
 }
 
 bool KisPaletteModel::removeEntry(QModelIndex index, bool keepColors)
 {
     QStringList entryList =  qVariantValue<QStringList>(index.data(RetrieveEntryRole));
     if (entryList.empty()) {
         return false;
     }
     QString groupName = entryList.at(0);
     quint32 indexInGroup = entryList.at(1).toUInt();
 
     if (qVariantValue<bool>(index.data(IsHeaderRole))==false) {
         if (index.column()-1<0
                 && m_colorSet->nColorsGroup(groupName)%columnCount() <1
                 && index.row()-1>0
                 && m_colorSet->nColorsGroup(groupName)/columnCount()>0) {
             beginRemoveRows(QModelIndex(), index.row(), index.row()-1);
         }
         m_colorSet->removeAt(indexInGroup, groupName);
         if (index.column()-1<0
                 && m_colorSet->nColorsGroup(groupName)%columnCount() <1
                 && index.row()-1>0
                 && m_colorSet->nColorsGroup(groupName)/columnCount()>0) {
             endRemoveRows();
         }
     } else {
         beginRemoveRows(QModelIndex(), index.row(), index.row()-1);
         m_colorSet->removeGroup(groupName, keepColors);
         endRemoveRows();
     }
     return true;
 }
 
 bool KisPaletteModel::addGroup(QString groupName)
 {
     QModelIndex i = getLastEntryIndex();
     beginInsertRows(QModelIndex(), i.row(), i.row()+1);
     m_colorSet->addGroup(groupName);
     endInsertRows();
     return true;
 }
 
 bool KisPaletteModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     Q_ASSERT(!parent.isValid());
 
     int beginRow = qMax(0, row);
     int endRow = qMin(row + count - 1, (int)m_colorSet->nColors() - 1);
     beginRemoveRows(parent, beginRow, endRow);
 
     // Find the palette entry at row, count, remove from KoColorSet
 
     endRemoveRows();
     return true;
 }
 
 bool KisPaletteModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
                                    int row, int column, const QModelIndex &parent)
 {
     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 = qVariantValue<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;
 
             stream >> entry.name
                     >> entry.id
                     >> entry.spotColor
                     >> indexInGroup
                     >> oldGroupName
                     >> colorXml;
 
             QDomDocument doc;
             doc.setContent(colorXml);
             QDomElement e = doc.documentElement();
             QDomElement c = e.firstChildElement();
             if (!c.isNull()) {
                 QString colorDepthId = c.attribute("bitdepth", Integer8BitsColorDepthID.id());
                 entry.color = KoColor::fromXML(c, colorDepthId);
             }
 
             QModelIndex index = this->index(endRow, endColumn);
             if (qVariantValue<bool>(index.data(IsHeaderRole))){
                 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 = qVariantValue<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 && qVariantValue<bool>(index.data(IsHeaderRole))==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
 {
     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 (qVariantValue<bool>(index.data(IsHeaderRole))==false) {
             KoColorSetEntry entry = colorSetEntryFromIndex(index);
             QStringList entryList = qVariantValue<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 = qVariantValue<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;
 }
diff --git a/libs/ui/kis_palette_view.cpp b/libs/ui/kis_palette_view.cpp
index 085587af55..d206ba4347 100644
--- a/libs/ui/kis_palette_view.cpp
+++ b/libs/ui/kis_palette_view.cpp
@@ -1,321 +1,338 @@
 /*
  *  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 "kis_palette_delegate.h"
 #include "KisPaletteModel.h"
 #include "kis_config.h"
 #include <KLocalizedString>
 #include <KoDialog.h>
 #include <QFormLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <kis_color_button.h>
 #include <QCheckBox>
 #include <QComboBox>
 
 
 struct KisPaletteView::Private
 {
     KisPaletteModel *model = 0;
     bool allowPaletteModification = true;
 };
 
 
 KisPaletteView::KisPaletteView(QWidget *parent)
     : KoTableView(parent),
       m_d(new Private)
 {
     setShowGrid(false);
     horizontalHeader()->setVisible(false);
     verticalHeader()->setVisible(false);
     setItemDelegate(new KisPaletteDelegate());
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::InternalMove);
     setDropIndicatorShown(true);
 
     KisConfig cfg;
-    QPalette pal(palette());
-    pal.setColor(QPalette::Base, cfg.getMDIBackgroundColor());
-    setAutoFillBackground(true);
-    setPalette(pal);
+    //QPalette pal(palette());
+    //pal.setColor(QPalette::Base, cfg.getMDIBackgroundColor());
+    //setAutoFillBackground(true);
+    //setPalette(pal);
 
     int defaultSectionSize = cfg.paletteDockerPaletteViewSectionSize();
     horizontalHeader()->setDefaultSectionSize(defaultSectionSize);
     verticalHeader()->setDefaultSectionSize(defaultSectionSize);
     connect(this, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(modifyEntry(QModelIndex)));
 }
 
 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)
 {
     KoDialog *window = new KoDialog();
     window->setWindowTitle(i18nc("@title:window", "Add a new Colorset Entry"));
     QFormLayout *editableItems = new QFormLayout();
     window->mainWidget()->setLayout(editableItems);
     QComboBox *cmbGroups = new QComboBox();
     QString defaultGroupName = i18nc("Name for default group", "Default");
     cmbGroups->addItem(defaultGroupName);
     cmbGroups->addItems(m_d->model->colorSet()->getGroupNames());
     QLineEdit *lnIDName = new QLineEdit();
     QLineEdit *lnName = new QLineEdit();
     KisColorButton *bnColor = new KisColorButton();
     QCheckBox *chkSpot = new QCheckBox();
     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(i18n("Spot"), chkSpot);
     cmbGroups->setCurrentIndex(0);
     lnName->setText(i18nc("Part of a default name for a color","Color")+" "+QString::number(m_d->model->colorSet()->nColors()+1));
     lnIDName->setText(QString::number(m_d->model->colorSet()->nColors()+1));
     bnColor->setColor(color);
     chkSpot->setChecked(false);
 
     //
     if (window->exec() == KoDialog::Accepted) {
         QString groupName = cmbGroups->currentText();
         if (groupName == defaultGroupName) {
             groupName = QString();
         }
         KoColorSetEntry newEntry;
         newEntry.color = bnColor->color();
         newEntry.name = lnName->text();
         newEntry.id = lnIDName->text();
         newEntry.spotColor = chkSpot->isChecked();
         m_d->model->addColorSetEntry(newEntry, groupName);
         m_d->model->colorSet()->save();
         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) {
         QString groupName = lnName->text();
         m_d->model->addGroup(groupName);
         m_d->model->colorSet()->save();
         return true;
     }
     return false;
 }
 
 bool KisPaletteView::removeEntryWithDialog(QModelIndex index)
 {
     bool keepColors = true;
     if (qVariantValue<bool>(index.data(KisPaletteModel::IsHeaderRole))) {
         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();
     }
     return true;
 }
 
 void KisPaletteView::trySelectClosestColor(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 (selectedIndexes().size()>0) {
+        QModelIndex currentI = currentIndex();
+        if (!currentI.isValid()) {
+            currentI = selectedIndexes().last();
+        }
+        if (!currentI.isValid()) {
+            currentI = selectedIndexes().first();
+        }
+        if (currentI.isValid()) {
+            if (m_d->model->colorSetEntryFromIndex(currentI).color==color) {
+                return;
+            }
+        }
+    }
     quint32 i = color_set->getIndexClosestColor(color);
     QModelIndex index = m_d->model->indexFromId(i);
     this->selectionModel()->clearSelection();
     this->selectionModel()->setCurrentIndex(index, QItemSelectionModel::Select);
 }
 
 void KisPaletteView::mouseReleaseEvent(QMouseEvent *event)
 {
     bool foreground = false;
     if (event->button()== Qt::LeftButton) {
         foreground = true;
     }
     entrySelection(foreground);
 }
 
 void KisPaletteView::paletteModelChanged()
 {
     updateView();
     updateRows();
 }
 
 void KisPaletteView::setPaletteModel(KisPaletteModel *model)
 {
     if (m_d->model) {
         disconnect(m_d->model, 0, this, 0);
     }
     m_d->model = model;
     setModel(model);
     paletteModelChanged();
     connect(m_d->model, SIGNAL(layoutChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)), this, SLOT(paletteModelChanged()));
     connect(m_d->model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), this, SLOT(paletteModelChanged()));
     connect(m_d->model, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(paletteModelChanged()));
     connect(m_d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(paletteModelChanged()));
     connect(m_d->model, SIGNAL(modelReset()), this, SLOT(paletteModelChanged()));
 
 }
 
 KisPaletteModel* KisPaletteView::paletteModel() const
 {
     return m_d->model;
 }
 
 void KisPaletteView::updateRows()
 {
     this->clearSpans();
     if (m_d->model) {
         for (int r=0; r<=m_d->model->rowCount(); r++) {
             QModelIndex index = m_d->model->index(r, 0);
             if (qVariantValue<bool>(index.data(KisPaletteModel::IsHeaderRole))) {
                 setSpan(r, 0, 1, m_d->model->columnCount());
                 setRowHeight(r, this->fontMetrics().lineSpacing()+6);
             } else {
                 this->setRowHeight(r, this->columnWidth(0));
             }
         }
     }
 }
 
 void KisPaletteView::setAllowModification(bool allow)
 {
     m_d->allowPaletteModification = allow;
 }
 
 
 void KisPaletteView::wheelEvent(QWheelEvent *event)
 {
     if (event->modifiers() & Qt::ControlModifier) {
         int numDegrees = event->delta() / 8;
         int numSteps = numDegrees / 7;
         int curSize = horizontalHeader()->sectionSize(0);
         int setSize = numSteps + curSize;
 
         if ( setSize >= 12 ) {
             horizontalHeader()->setDefaultSectionSize(setSize);
             verticalHeader()->setDefaultSectionSize(setSize);
             KisConfig cfg;
             cfg.setPaletteDockerPaletteViewSectionSize(setSize);
         }
 
         event->accept();
     } else {
         KoTableView::wheelEvent(event);
     }
 }
 
 void KisPaletteView::entrySelection(bool foreground) {
     QModelIndex index;
     if (selectedIndexes().size()<=0) {
         return;
     }
     if (selectedIndexes().last().isValid()) {
         index = selectedIndexes().last();
     } else if (selectedIndexes().first().isValid()) {
         index = selectedIndexes().first();
     } else {
         return;
     }
     if (qVariantValue<bool>(index.data(KisPaletteModel::IsHeaderRole))==false) {
         KoColorSetEntry entry = m_d->model->colorSetEntryFromIndex(index);
         if (foreground) {
             emit(entrySelected(entry));
+            emit(indexEntrySelected(index));
         } else {
             emit(entrySelectedBackGround(entry));
+            emit(indexEntrySelected(index));
         }
     }
 }
 
 void KisPaletteView::modifyEntry(QModelIndex index) {
     if (m_d->allowPaletteModification) {
         KoDialog *group = new KoDialog();
         QFormLayout *editableItems = new QFormLayout();
         group->mainWidget()->setLayout(editableItems);
         QLineEdit *lnIDName = new QLineEdit();
         QLineEdit *lnGroupName = new QLineEdit();
         KisColorButton *bnColor = new KisColorButton();
         QCheckBox *chkSpot = new QCheckBox();
 
         if (qVariantValue<bool>(index.data(KisPaletteModel::IsHeaderRole))) {
             QString groupName = qVariantValue<QString>(index.data(Qt::DisplayRole));
             editableItems->addRow(i18nc("Name for a colorgroup","Name"), lnGroupName);
             lnGroupName->setText(groupName);
             if (group->exec() == KoDialog::Accepted) {
                 m_d->model->colorSet()->changeGroupName(groupName, lnGroupName->text());
                 m_d->model->colorSet()->save();
                 updateRows();
             }
             //rename the group.
         } else {
             KoColorSetEntry entry = m_d->model->colorSetEntryFromIndex(index);
             QStringList entryList = qVariantValue<QStringList>(index.data(KisPaletteModel::RetrieveEntryRole));
             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(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 (group->exec() == KoDialog::Accepted) {
                 entry.name = lnGroupName->text();
                 entry.id = lnIDName->text();
                 entry.color = bnColor->color();
                 entry.spotColor = chkSpot->isChecked();
                 m_d->model->colorSet()->changeColorSetEntry(entry, entryList.at(0), entryList.at(1).toUInt());
                 m_d->model->colorSet()->save();
             }
         }
     }
 }
diff --git a/libs/ui/kis_palette_view.h b/libs/ui/kis_palette_view.h
index 9aee6b9621..86f0f49e98 100644
--- a/libs/ui/kis_palette_view.h
+++ b/libs/ui/kis_palette_view.h
@@ -1,112 +1,113 @@
 /*
  *  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 <KoTableView.h>
 #include <KoColorSet.h>
 #include "kritaui_export.h"
 
 class KisPaletteModel;
 class QWheelEvent;
 
 
 class KRITAUI_EXPORT KisPaletteView : public KoTableView
 {
     Q_OBJECT
 public:
     KisPaletteView(QWidget *parent = 0);
     ~KisPaletteView() override;
 
     void setPaletteModel(KisPaletteModel *model);
     KisPaletteModel* paletteModel() const;
 
     /**
      * @brief updateRows
      * update the rows so they have the proper columnspanning.
      */
     void updateRows();
 
     /**
      * @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);
 
     /**
      * @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);
 
 public Q_SLOTS:
     void paletteModelChanged();
     /**
      * add an entry with a dialog window.
      */
     bool addEntryWithDialog(KoColor color);
     /**
      * @brief addGroupWithDialog
      * summons a little dialog to name the new group.
      */
     bool addGroupWithDialog();
     /**
      * remove entry with a dialog window.(Necessary for groups.
      */
     bool removeEntryWithDialog(QModelIndex index);
     /**
      *  This tries to select the closest color in the palette.
      *  This doesn't update the foreground color, just the visual selection.
      */
     void trySelectClosestColor(KoColor color);
 Q_SIGNALS:
     /**
      * @brief entrySelected
      * signals when an entry is selected.
      * @param entry the selected entry.
      */
     void entrySelected(KoColorSetEntry entry);
     void entrySelectedBackGround(KoColorSetEntry entry);
+    void indexEntrySelected(QModelIndex index);
 protected:
     void mouseReleaseEvent(QMouseEvent *event);
     void wheelEvent(QWheelEvent *event) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 private Q_SLOTS:
     /**
      * @brief entrySelection
      * the function that will emit entrySelected when the entry changes.
      */
     void entrySelection(bool foreground = true);
     /**
      * @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);
 };
 
 #endif /* __KIS_PALETTE_VIEW_H */
diff --git a/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp b/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp
index 1aec473778..2cd5dab9c5 100644
--- a/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp
+++ b/plugins/tools/tool_lazybrush/kis_tool_lazy_brush_options_widget.cpp
@@ -1,291 +1,294 @@
 /*
  *  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_tool_lazy_brush_options_widget.h"
 
 #include "ui_kis_tool_lazy_brush_options_widget.h"
 
 #include <KoColorSpaceRegistry.h>
 #include "KisPaletteModel.h"
 
 #include "kis_config.h"
 #include <resources/KoColorSet.h>
 #include "kis_canvas_resource_provider.h"
 #include "kis_signal_auto_connection.h"
 #include "lazybrush/kis_colorize_mask.h"
 #include "kis_image.h"
 #include "kis_signals_blocker.h"
 #include "kis_signal_compressor.h"
 #include "kis_layer_properties_icons.h"
 
 
 struct KisToolLazyBrushOptionsWidget::Private
 {
     Private()
         : transparentColorIndex(-1),
           baseNodeChangedCompressor(500, KisSignalCompressor::FIRST_ACTIVE)
     {
     }
 
     Ui_KisToolLazyBrushOptionsWidget *ui;
     KisPaletteModel *colorModel;
     KisCanvasResourceProvider *provider;
 
     KisSignalAutoConnectionsStore providerSignals;
     KisSignalAutoConnectionsStore maskSignals;
     KisColorizeMaskSP activeMask;
 
     KoColorSet colorSet;
     int transparentColorIndex = -1;
 
     KisSignalCompressor baseNodeChangedCompressor;
 };
 
 KisToolLazyBrushOptionsWidget::KisToolLazyBrushOptionsWidget(KisCanvasResourceProvider *provider, QWidget *parent)
     : QWidget(parent),
       m_d(new Private)
 {
     m_d->ui = new Ui_KisToolLazyBrushOptionsWidget();
     m_d->ui->setupUi(this);
 
     m_d->colorModel = new KisPaletteModel(this);
     m_d->ui->colorView->setPaletteModel(m_d->colorModel);
     m_d->ui->colorView->setAllowModification(false); //people proly shouldn't be able to edit the colorentries themselves.
     m_d->ui->colorView->setCrossedKeyword("transparent");
 
-    connect(m_d->ui->colorView, SIGNAL(clicked(QModelIndex)), this, SLOT(entrySelected(QModelIndex)));
+    connect(m_d->ui->colorView, SIGNAL(indexEntrySelected(QModelIndex)), this, SLOT(entrySelected(QModelIndex)));
     connect(m_d->ui->btnTransparent, SIGNAL(toggled(bool)), this, SLOT(slotMakeTransparent(bool)));
     connect(m_d->ui->btnRemove, SIGNAL(clicked()), this, SLOT(slotRemove()));
 
     connect(m_d->ui->chkAutoUpdates, SIGNAL(toggled(bool)), m_d->ui->btnUpdate, SLOT(setDisabled(bool)));
 
     connect(m_d->ui->btnUpdate, SIGNAL(clicked()), this, SLOT(slotUpdate()));
     connect(m_d->ui->chkAutoUpdates, SIGNAL(toggled(bool)), this, SLOT(slotSetAutoUpdates(bool)));
     connect(m_d->ui->chkShowKeyStrokes, SIGNAL(toggled(bool)), this, SLOT(slotSetShowKeyStrokes(bool)));
     connect(m_d->ui->chkShowOutput, SIGNAL(toggled(bool)), this, SLOT(slotSetShowOutput(bool)));
 
     connect(&m_d->baseNodeChangedCompressor, SIGNAL(timeout()), this, SLOT(slotUpdateNodeProperties()));
 
 
     m_d->provider = provider;
 
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
 
     m_d->colorSet.add(KoColorSetEntry(KoColor(Qt::red, cs), "color1"));
     m_d->colorSet.add(KoColorSetEntry(KoColor(Qt::green, cs), "color2"));
     m_d->colorSet.add(KoColorSetEntry(KoColor(Qt::blue, cs), "color3"));
 
     m_d->colorModel->setColorSet(&m_d->colorSet);
 }
 
 KisToolLazyBrushOptionsWidget::~KisToolLazyBrushOptionsWidget()
 {
 }
 
 void KisToolLazyBrushOptionsWidget::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     m_d->providerSignals.addConnection(
         m_d->provider, SIGNAL(sigNodeChanged(KisNodeSP)),
         this, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
     m_d->providerSignals.addConnection(
         m_d->provider, SIGNAL(sigFGColorChanged(const KoColor&)),
         this, SLOT(slotCurrentFgColorChanged(const KoColor&)));
 
     slotCurrentNodeChanged(m_d->provider->currentNode());
     slotCurrentFgColorChanged(m_d->provider->fgColor());
 }
 
 void KisToolLazyBrushOptionsWidget::hideEvent(QHideEvent *event)
 {
     QWidget::hideEvent(event);
 
     m_d->providerSignals.clear();
 }
 
 void KisToolLazyBrushOptionsWidget::entrySelected(QModelIndex index)
 {
+    qDebug()<<"triggered";
     if (!index.isValid()) return;
 
+    qDebug()<<index;
     const int i = m_d->colorModel->idFromIndex(index);
+    qDebug()<<i;
 
     if (i >= 0 && i < (int)m_d->colorSet.nColors()) {
-        KoColorSetEntry entry = m_d->colorSet.getColorGlobal(i);
+        KoColorSetEntry entry = m_d->colorModel->colorSetEntryFromIndex(index);
         m_d->provider->setFGColor(entry.color);
     }
 
     const bool transparentChecked = i >= 0 && i == m_d->transparentColorIndex;
     KisSignalsBlocker b(m_d->ui->btnTransparent);
     m_d->ui->btnTransparent->setChecked(transparentChecked);
 }
 
 void KisToolLazyBrushOptionsWidget::slotCurrentFgColorChanged(const KoColor &color)
 {
     int selectedIndex = -1;
 
     for (quint32 i = 0; i < m_d->colorSet.nColors(); i++) {
         KoColorSetEntry entry = m_d->colorSet.getColorGlobal(i);
         if (entry.color == color) {
             selectedIndex = (int)i;
             break;
         }
     }
 
     m_d->ui->btnRemove->setEnabled(selectedIndex >= 0);
     m_d->ui->btnTransparent->setEnabled(selectedIndex >= 0);
 
     if (selectedIndex < 0) {
         KisSignalsBlocker b(m_d->ui->btnTransparent);
         m_d->ui->btnTransparent->setChecked(false);
     }
 
     QModelIndex newIndex = m_d->colorModel->indexFromId(selectedIndex);
 
     if (newIndex != m_d->ui->colorView->currentIndex()) {
         m_d->ui->colorView->setCurrentIndex(newIndex);
     }
 }
 
 void KisToolLazyBrushOptionsWidget::slotColorLabelsChanged()
 {
     m_d->colorSet.clear();
     m_d->transparentColorIndex = -1;
 
     if (m_d->activeMask) {
         KisColorizeMask::KeyStrokeColors colors = m_d->activeMask->keyStrokesColors();
         m_d->transparentColorIndex = colors.transparentIndex;
 
         for (int i = 0; i < colors.colors.size(); i++) {
             const QString name = i == m_d->transparentColorIndex ? "transparent" : "";
             m_d->colorSet.add(KoColorSetEntry(colors.colors[i], name));
         }
     }
 
     m_d->colorModel->setColorSet(&m_d->colorSet);
     slotCurrentFgColorChanged(m_d->provider->fgColor());
 }
 
 void KisToolLazyBrushOptionsWidget::slotUpdateNodeProperties()
 {
     KisSignalsBlocker b(m_d->ui->chkAutoUpdates,
                         m_d->ui->btnUpdate,
                         m_d->ui->chkShowKeyStrokes,
                         m_d->ui->chkShowOutput);
 
     // not implemented yet!
     //m_d->ui->chkAutoUpdates->setEnabled(m_d->activeMask);
     m_d->ui->chkAutoUpdates->setEnabled(false);
 
     bool value = false;
 
     value = m_d->activeMask && !KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeNeedsUpdate, true).toBool();
     m_d->ui->btnUpdate->setEnabled(m_d->activeMask && !m_d->ui->chkAutoUpdates->isChecked());
     m_d->ui->btnUpdate->setChecked(value);
 
     value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool();
     m_d->ui->chkShowKeyStrokes->setEnabled(m_d->activeMask);
     m_d->ui->chkShowKeyStrokes->setChecked(value);
 
     value = m_d->activeMask && KisLayerPropertiesIcons::nodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeShowColoring, true).toBool();
     m_d->ui->chkShowOutput->setEnabled(m_d->activeMask);
     m_d->ui->chkShowOutput->setChecked(value);
 }
 
 void KisToolLazyBrushOptionsWidget::slotCurrentNodeChanged(KisNodeSP node)
 {
     m_d->maskSignals.clear();
 
     KisColorizeMask *mask = dynamic_cast<KisColorizeMask*>(node.data());
     m_d->activeMask = mask;
 
     if (m_d->activeMask) {
         m_d->maskSignals.addConnection(
             m_d->activeMask, SIGNAL(sigKeyStrokesListChanged()),
             this, SLOT(slotColorLabelsChanged()));
 
         m_d->maskSignals.addConnection(
             m_d->provider->currentImage(), SIGNAL(sigNodeChanged(KisNodeSP)),
             this, SLOT(slotUpdateNodeProperties()));
     }
 
     slotColorLabelsChanged();
     slotUpdateNodeProperties();
     m_d->ui->colorView->setEnabled(m_d->activeMask);
 }
 
 void KisToolLazyBrushOptionsWidget::slotMakeTransparent(bool value)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->activeMask);
 
     QModelIndex index = m_d->ui->colorView->currentIndex();
     if (!index.isValid()) return;
 
     const int activeIndex = m_d->colorModel->idFromIndex(index);
     KIS_ASSERT_RECOVER_RETURN(activeIndex >= 0);
 
     KisColorizeMask::KeyStrokeColors colors;
 
     for (quint32 i = 0; i < m_d->colorSet.nColors(); i++) {
         colors.colors << m_d->colorSet.getColorGlobal(i).color;
     }
 
     colors.transparentIndex = value ? activeIndex : -1;
 
     m_d->activeMask->setKeyStrokesColors(colors);
 }
 
 void KisToolLazyBrushOptionsWidget::slotRemove()
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->activeMask);
 
     QModelIndex index = m_d->ui->colorView->currentIndex();
     if (!index.isValid()) return;
 
     const int activeIndex = m_d->colorModel->idFromIndex(index);
     KIS_ASSERT_RECOVER_RETURN(activeIndex >= 0);
 
 
     const KoColor color = m_d->colorSet.getColorGlobal((quint32)activeIndex).color;
     m_d->activeMask->removeKeyStroke(color);
 }
 
 void KisToolLazyBrushOptionsWidget::slotUpdate()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     KisLayerPropertiesIcons::setNodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeNeedsUpdate, false, m_d->provider->currentImage());
 }
 
 void KisToolLazyBrushOptionsWidget::slotSetAutoUpdates(bool value)
 {
     ENTER_FUNCTION() << ppVar(value);
 }
 
 void KisToolLazyBrushOptionsWidget::slotSetShowKeyStrokes(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     KisLayerPropertiesIcons::setNodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, value, m_d->provider->currentImage());
 }
 
 void KisToolLazyBrushOptionsWidget::slotSetShowOutput(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->activeMask);
     KisLayerPropertiesIcons::setNodeProperty(m_d->activeMask, KisLayerPropertiesIcons::colorizeShowColoring, value, m_d->provider->currentImage());
 }