diff --git a/libs/widgets/squeezedcombobox.cpp b/libs/widgets/squeezedcombobox.cpp
index f66889a0a3..b1172295ef 100644
--- a/libs/widgets/squeezedcombobox.cpp
+++ b/libs/widgets/squeezedcombobox.cpp
@@ -1,180 +1,180 @@
 /* ============================================================
  * Author: Tom Albers <tomalbers@kde.nl>
  * Date  : 2005-01-01
  * Description :
  *
  * Copyright 2005 by Tom Albers <tomalbers@kde.nl>
  *
  * 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, 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.
  *
  * ============================================================ */
 
 #include "squeezedcombobox.h"
 /** @file squeezedcombobox.cpp */
 
 // Qt includes.
 
 #include <QComboBox>
 #include <QPair>
 #include <QTimer>
 #include <QStyle>
 #include <QApplication>
 #include <QResizeEvent>
 
 SqueezedComboBox::SqueezedComboBox(QWidget *parent, const char *name)
         : QComboBox(parent)
 {
     setObjectName(name);
     setMinimumWidth(100);
     m_timer = new QTimer(this);
     m_timer->setSingleShot(true);
     connect(m_timer, SIGNAL(timeout()),
             SLOT(slotTimeOut()));
 }
 
 SqueezedComboBox::~SqueezedComboBox()
 {
     delete m_timer;
 }
 
 bool SqueezedComboBox::contains(const QString& _text) const
 {
     if (_text.isEmpty())
         return false;
 
     for (QMap<int, QString>::const_iterator it = m_originalItems.begin() ; it != m_originalItems.end();
             ++it) {
         if (it.value() == _text) {
             return true;
         }
     }
     return false;
 }
 
 qint32 SqueezedComboBox::findOriginalText(const QString& text) const
 {
     for (int i = 0; i < m_originalItems.size(); i++) {
         if(m_originalItems.value(i) == text) {
             return i;
         }
     }
     return -1;
 }
 
 QStringList SqueezedComboBox::originalTexts() const
 {
     return m_originalItems.values();
 }
 
 void SqueezedComboBox::resetOriginalTexts(const QStringList &texts)
 {
     if (texts == m_originalItems.values()) return;
 
     clear();
     m_originalItems.clear();
 
     Q_FOREACH (const QString &item, texts) {
         addSqueezedItem(item);
     }
 }
 
 QSize SqueezedComboBox::sizeHint() const
 {
     ensurePolished();
     QFontMetrics fm = fontMetrics();
 
     int maxW = count() ? 18 : 7 * fm.width(QChar('x')) + 18;
     int maxH = qMax(fm.lineSpacing(), 14) + 2;
 
     QStyleOptionComboBox options;
     options.initFrom(this);
 
     return style()->sizeFromContents(QStyle::CT_ComboBox, &options,
                                      QSize(maxW, maxH), this).expandedTo(QApplication::globalStrut());
 }
 
 void SqueezedComboBox::insertSqueezedItem(const QString& newItem, int index, QVariant userData)
 {
     m_originalItems[index] = newItem;
-    QComboBox::insertItem(index, squeezeText(newItem), userData);
+    QComboBox::insertItem(index, squeezeText(newItem, this), userData);
 }
 
 void SqueezedComboBox::insertSqueezedItem(const QIcon &icon, const QString &newItem, int index, QVariant userData)
 {
     m_originalItems[index] = newItem;
-    QComboBox::insertItem(index, icon, squeezeText(newItem), userData);
+    QComboBox::insertItem(index, icon, squeezeText(newItem, this), userData);
 }
 
 void SqueezedComboBox::addSqueezedItem(const QString& newItem, QVariant userData)
 {
     insertSqueezedItem(newItem, count(), userData);
 }
 
 void SqueezedComboBox::addSqueezedItem(const QIcon &icon, const QString &newItem, QVariant userData)
 {
     insertSqueezedItem(icon, newItem, count(), userData);
 }
 
 void SqueezedComboBox::setCurrent(const QString& itemText)
 {
     qint32 itemIndex = findOriginalText(itemText);
     if (itemIndex >= 0) {
         setCurrentIndex(itemIndex);
     }
 }
 
 void SqueezedComboBox::resizeEvent(QResizeEvent *)
 {
     m_timer->start(200);
 }
 
 void SqueezedComboBox::slotTimeOut()
 {
     for (QMap<int, QString>::iterator it = m_originalItems.begin() ; it != m_originalItems.end();
             ++it) {
-        setItemText(it.key(), squeezeText(it.value()));
+        setItemText(it.key(), squeezeText(it.value(), this));
     }
 }
 
-QString SqueezedComboBox::squeezeText(const QString& original)
+QString SqueezedComboBox::squeezeText(const QString& original, const QWidget *widget)
 {
     // not the complete widgetSize is usable. Need to compensate for that.
-    int widgetSize = width() - 30;
-    QFontMetrics fm(fontMetrics());
+    int widgetSize = widget->width() - 30;
+    QFontMetrics fm(widget->fontMetrics());
 
     // If we can fit the full text, return that.
     if (fm.width(original) < widgetSize)
         return(original);
 
     // We need to squeeze.
     QString sqItem = original; // prevent empty return value;
     widgetSize = widgetSize - fm.width("...");
     for (int i = 0 ; i != original.length(); ++i) {
         if ((int)fm.width(original.right(i)) > widgetSize) {
             sqItem = QString("..." + original.right(--i));
             break;
         }
     }
     return sqItem;
 }
 
 QString SqueezedComboBox::itemHighlighted()
 {
     int curItem = currentIndex();
     return m_originalItems[curItem];
 }
 
 void SqueezedComboBox::removeSqueezedItem(int index)
 {
     removeItem(index);
     m_originalItems.remove(index);
 }
 
diff --git a/libs/widgets/squeezedcombobox.h b/libs/widgets/squeezedcombobox.h
index d74e231159..beaa3934f4 100644
--- a/libs/widgets/squeezedcombobox.h
+++ b/libs/widgets/squeezedcombobox.h
@@ -1,157 +1,158 @@
 /* ============================================================
  * Author: Tom Albers <tomalbers@kde.nl>
  * Date  : 2005-01-01
  * Description :
  *
  * Copyright 2005 by Tom Albers <tomalbers@kde.nl>
  *
  * 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, 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.
  *
  * ============================================================ */
 
 /** @file squeezedcombobox.h */
 
 #ifndef SQUEEZEDCOMBOBOX_H
 #define SQUEEZEDCOMBOBOX_H
 
 class QTimer;
 class QResizeEvent;
 class QWidget;
 
 // Qt includes.
 
 #include <QComboBox>
 #include <QWidget>
 #include <QIcon>
 
 #include "kritawidgets_export.h"
 
 /** @class SqueezedComboBox
  *
  * This widget is a QComboBox, but then a little bit
  * different. It only shows the right part of the items
  * depending on de size of the widget. When it is not
  * possible to show the complete item, it will be shortened
  * and "..." will be prepended.
  *
  * @image html squeezedcombobox.png "This is how it looks"
  * @author Tom Albers
  */
 class KRITAWIDGETS_EXPORT SqueezedComboBox : public QComboBox
 {
     Q_OBJECT
 
 public:
 
     /**
      * Constructor
      * @param parent parent widget
      * @param name name to give to the widget
      */
     SqueezedComboBox(QWidget *parent = 0, const char *name = 0);
     /**
      * destructor
      */
     ~SqueezedComboBox() override;
 
     /**
      *
      * Returns true if the combobox contains the original (not-squeezed)
      * version of text.
      * @param text the original (not-squeezed) text to check for
      */
     bool contains(const QString & text) const;
 
     /**
      * Returns index of a orinal text, -1 if the text isn't found
      * @param text the original (not-squeezed) text to search for
      */
     qint32 findOriginalText(const QString & text) const;
 
 
     /**
      * Return the list of original text items
      */
     QStringList originalTexts() const;
 
     /**
      * Reset the combo box and initialize it with the list of (original) text items
      */
     void resetOriginalTexts(const QStringList &texts);
 
     /**
      * This inserts a item to the list. See QComboBox::insertItem()
      * for detaills. Please do not use QComboBox::insertItem() to this
      * widget, as that will fail.
      * @param newItem the original (long version) of the item which needs
      *                to be added to the combobox
      * @param index the position in the widget.
      */
     void insertSqueezedItem(const QString& newItem, int index, QVariant userData = QVariant());
     void insertSqueezedItem(const QIcon &icon, const QString& newItem, int index, QVariant userData = QVariant());
 
     /**
      * Append an item.
      * @param newItem the original (long version) of the item which needs
      *                to be added to the combobox
      */
     void addSqueezedItem(const QString& newItem, QVariant userData = QVariant());
 
     /**
      * Append an item.
      * @param newItem the original (long version) of the item which needs
      *                to be added to the combobox
      */
     void addSqueezedItem(const QIcon &icon, const QString& newItem, QVariant userData = QVariant());
 
     /**
      * Set the current item to the one matching the given text.
      *
      * @param itemText the original (long version) of the item text
      */
     void setCurrent(const QString& itemText);
 
     /**
      * This method returns the full text (not squeezed) of the currently
      * highlighted item.
      * @return full text of the highlighted item
      */
     QString itemHighlighted();
 
     /**
      * remove the squeezed item at index
      */
     void removeSqueezedItem(int index);
 
     /**
      * Sets the sizeHint() of this widget.
      */
     QSize sizeHint() const override;
 
+    static QString squeezeText(const QString& original, const QWidget *widget);
+
 private Q_SLOTS:
     void slotTimeOut();
 
 private:
     void resizeEvent(QResizeEvent *) override;
-    QString squeezeText(const QString& original);
 
     // Prevent these from being used.
     void setCurrentText(const QString& itemText);
     void insertItem(const QString &text);
     void insertItem(qint32 index, const QString &text);
     void addItem(const QString &text);
 
     QMap<int, QString> m_originalItems;
     QTimer *m_timer;
 
 };
 
 #endif // SQUEEZEDCOMBOBOX_H
diff --git a/plugins/dockers/palettedocker/palettedocker_dock.cpp b/plugins/dockers/palettedocker/palettedocker_dock.cpp
index 441af29974..386c23b24c 100644
--- a/plugins/dockers/palettedocker/palettedocker_dock.cpp
+++ b/plugins/dockers/palettedocker/palettedocker_dock.cpp
@@ -1,369 +1,371 @@
 /*
  *  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 <squeezedcombobox.h>
 #include <klocalizedstring.h>
 #include <KoResourceServerProvider.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoFileDialog.h>
 #include <kis_icon.h>
 #include <kis_config.h>
 #include <kis_node_manager.h>
 #include <kis_workspace_resource.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisMainWindow.h>
 #include <KisViewManager.h>
 #include <kis_display_color_converter.h>
 #include <kis_canvas2.h>
 #include <KoDialog.h>
 #include <kis_color_button.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 
 #include <KisPaletteModel.h>
 #include <KisPaletteDelegate.h>
 #include <kis_palette_view.h>
 #include <KisPaletteListWidget.h>
 
 #include <KisPaletteEditor.h>
 #include <dialogs/KisDlgPaletteEditor.h>
 
 #include "ui_wdgpalettedock.h"
 
 PaletteDockerDock::PaletteDockerDock( )
     : QDockWidget(i18n("Palette"))
     , m_ui(new Ui_WdgPaletteDock())
     , m_model(new KisPaletteModel(this))
     , m_paletteChooser(new KisPaletteListWidget(this))
     , m_view(Q_NULLPTR)
     , m_resourceProvider(Q_NULLPTR)
     , m_rServer(KoResourceServerProvider::instance()->paletteServer())
     , m_activeDocument(Q_NULLPTR)
     , m_paletteEditor(new KisPaletteEditor)
     , m_actAdd(new QAction(KisIconUtils::loadIcon("list-add"), i18n("Add a color")))
     , m_actRemove(new QAction(KisIconUtils::loadIcon("edit-delete"), i18n("Delete color")))
     , m_actModify(new QAction(KisIconUtils::loadIcon("edit-rename"), i18n("Modify this spot")))
     , m_actEditPalette(new QAction(KisIconUtils::loadIcon("groupLayer"), i18n("Edit this palette")))
 {
     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());
     m_ui->bnEditPalette->setDefaultAction(m_actEditPalette.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->bnEditPalette->setIconSize(QSize(16, 16));
 
     m_ui->paletteView->setPaletteModel(m_model);
     m_ui->paletteView->setAllowModification(true);
     m_ui->cmbNameList->setCompanionView(m_ui->paletteView);
 
     m_paletteEditor->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_actEditPalette.data(), SIGNAL(triggered()), SLOT(slotEditPalette()));
     connect(m_ui->paletteView, SIGNAL(sigIndexSelected(QModelIndex)),
             SLOT(slotPaletteIndexSelected(QModelIndex)));
     connect(m_ui->paletteView, SIGNAL(clicked(QModelIndex)),
             SLOT(slotPaletteIndexClicked(QModelIndex)));
     connect(m_ui->paletteView, SIGNAL(doubleClicked(QModelIndex)),
             SLOT(slotPaletteIndexDoubleClicked(QModelIndex)));
 
     m_viewContextMenu.addAction(m_actModify.data());
     m_viewContextMenu.addAction(m_actRemove.data());
     connect(m_ui->paletteView, SIGNAL(pressed(QModelIndex)), SLOT(slotContextMenu(QModelIndex)));
 
     m_paletteChooser->setAllowModification(true);
     connect(m_paletteChooser, SIGNAL(sigPaletteSelected(KoColorSet*)), SLOT(slotSetColorSet(KoColorSet*)));
     connect(m_paletteChooser, SIGNAL(sigAddPalette()), SLOT(slotAddPalette()));
     connect(m_paletteChooser, SIGNAL(sigImportPalette()), SLOT(slotImportPalette()));
     connect(m_paletteChooser, SIGNAL(sigRemovePalette(KoColorSet*)), SLOT(slotRemovePalette(KoColorSet*)));
     connect(m_paletteChooser, SIGNAL(sigExportPalette(KoColorSet*)), SLOT(slotExportPalette(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();
     KoColorSet* defaultPalette = m_rServer->resourceByName(defaultPaletteName);
     if (defaultPalette) {
         slotSetColorSet(defaultPalette);
     } else {
         m_ui->bnAdd->setEnabled(false);
         m_ui->bnRename->setEnabled(false);
         m_ui->bnRemove->setEnabled(false);
         m_ui->bnEditPalette->setEnabled(false);
         m_ui->paletteView->setAllowModification(false);
     }
 }
 
 PaletteDockerDock::~PaletteDockerDock()
 { }
 
 void PaletteDockerDock::setViewManager(KisViewManager* kisview)
 {
     m_view = kisview;
     m_resourceProvider = kisview->resourceProvider();
     connect(m_resourceProvider, SIGNAL(sigSavingWorkspace(KisWorkspaceResource*)),
             SLOT(saveToWorkspace(KisWorkspaceResource*)));
     connect(m_resourceProvider, SIGNAL(sigLoadingWorkspace(KisWorkspaceResource*)),
             SLOT(loadFromWorkspace(KisWorkspaceResource*)));
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)),
             m_ui->paletteView, SLOT(slotFGColorChanged(KoColor)));
 
     kisview->nodeManager()->disconnect(m_model);
 }
 
 void PaletteDockerDock::slotContextMenu(const QModelIndex &)
 {
     if (QApplication::mouseButtons() == Qt::RightButton) {
         m_viewContextMenu.exec(QCursor::pos());
     }
 }
 
 void PaletteDockerDock::slotAddPalette()
 {
     m_paletteEditor->addPalette();
 }
 
 void PaletteDockerDock::slotRemovePalette(KoColorSet *cs)
 {
     m_paletteEditor->removePalette(cs);
 }
 
 void PaletteDockerDock::slotImportPalette()
 {
     m_paletteEditor->importPalette();
 }
 
 void PaletteDockerDock::slotExportPalette(KoColorSet *palette)
 {
     KoFileDialog dialog(this, KoFileDialog::SaveFile, "Save Palette");
     dialog.setDefaultDir(palette->filename());
     dialog.setMimeTypeFilters(QStringList() << "krita/x-colorset");
     QString newPath;
     bool isStandAlone = palette->isGlobal();
     QString oriPath = palette->filename();
     if ((newPath = dialog.filename()).isEmpty()) { return; }
     palette->setFilename(newPath);
     palette->setIsGlobal(true);
     palette->save();
     palette->setFilename(oriPath);
     palette->setIsGlobal(isStandAlone);
 }
 
 void PaletteDockerDock::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != Q_NULLPTR);
     if (canvas) {
         KisCanvas2 *cv = qobject_cast<KisCanvas2*>(canvas);
         m_ui->paletteView->setDisplayRenderer(cv->displayColorConverter()->displayRendererInterface());
     }
 
     if (m_activeDocument) {
         for (KoColorSet * &cs : m_activeDocument->paletteList()) {
             KoColorSet *tmpAddr = cs;
             cs = new KoColorSet(*cs);
             m_rServer->removeResourceFromServer(tmpAddr);
         }
     }
 
     if (m_view && m_view->document()) {
         m_activeDocument = m_view->document();
         m_paletteEditor->setView(m_view);
 
         for (KoColorSet *cs : m_activeDocument->paletteList()) {
             m_rServer->addResource(cs);
         }
     }
 
     if (!m_currentColorSet) {
         slotSetColorSet(Q_NULLPTR);
     }
 }
 
 void PaletteDockerDock::unsetCanvas()
 {
     setEnabled(false);
     m_ui->paletteView->setDisplayRenderer(Q_NULLPTR);
     m_paletteEditor->setView(Q_NULLPTR);
 
     for (KoResource *r : m_rServer->resources()) {
         KoColorSet *c = static_cast<KoColorSet*>(r);
         if (!c->isGlobal()) {
             m_rServer->removeResourceFromServer(c);
         }
     }
     if (!m_currentColorSet) {
         slotSetColorSet(Q_NULLPTR);
     }
 }
 
 void PaletteDockerDock::slotSetColorSet(KoColorSet* colorSet)
 {
     if (colorSet && colorSet->isEditable()) {
         m_ui->bnAdd->setEnabled(true);
         m_ui->bnRename->setEnabled(true);
         m_ui->bnRemove->setEnabled(true);
         m_ui->bnEditPalette->setEnabled(true);
         m_ui->paletteView->setAllowModification(true);
     } else {
         m_ui->bnAdd->setEnabled(false);
         m_ui->bnRename->setEnabled(false);
         m_ui->bnRemove->setEnabled(false);
         m_ui->bnEditPalette->setEnabled(false);
         m_ui->paletteView->setAllowModification(false);
     }
 
     m_currentColorSet = colorSet;
     m_model->setPalette(colorSet);
     if (colorSet) {
         KisConfig cfg(true);
         cfg.setDefaultPalette(colorSet->name());
-        m_ui->bnColorSets->setText(colorSet->name());
+        m_ui->lblPaletteName->setTextElideMode(Qt::ElideLeft);
+        m_ui->lblPaletteName->setText(colorSet->name());
     } else {
-        m_ui->bnColorSets->setText("");
+        m_ui->lblPaletteName->setText("");
     }
 }
 
 void PaletteDockerDock::slotEditPalette()
 {
     KisDlgPaletteEditor dlg;
     if (!m_currentColorSet) { return; }
     dlg.setPaletteModel(m_model);
     dlg.setView(m_view);
     if (dlg.exec() != QDialog::Accepted){ return; }
 
     slotSetColorSet(m_currentColorSet); // update GUI
 }
 
 
 void PaletteDockerDock::slotAddColor()
 {
     if (m_resourceProvider) {
         m_paletteEditor->addEntry(m_resourceProvider->fgColor());
     }
 }
 
 void PaletteDockerDock::slotRemoveColor()
 {
     QModelIndex index = m_ui->paletteView->currentIndex();
     if (!index.isValid()) {
         return;
     }
     m_paletteEditor->removeEntry(index);
     m_ui->bnRemove->setEnabled(false);
 }
 
 void PaletteDockerDock::setFGColorByPalette(const KisSwatch &entry)
 {
     if (m_resourceProvider) {
         m_resourceProvider->setFGColor(entry.color());
     }
 }
 
 void PaletteDockerDock::saveToWorkspace(KisWorkspaceResource* workspace)
 {
     if (!m_currentColorSet.isNull()) {
         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 occupied = qvariant_cast<bool>(index.data(KisPaletteModel::CheckSlotRole));
     if (occupied) {
         if (!qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
             m_ui->bnRemove->setEnabled(true);
             KisSwatch entry = m_model->getEntry(index);
             setFGColorByPalette(entry);
         }
     }
     if (!m_currentColorSet->isEditable()) { return; }
     m_ui->bnRemove->setEnabled(occupied);
 }
 
 void PaletteDockerDock::slotPaletteIndexClicked(const QModelIndex &index)
 {
     if (!(qvariant_cast<bool>(index.data(KisPaletteModel::CheckSlotRole)))) {
         setEntryByForeground(index);
     }
 }
 
 void PaletteDockerDock::slotPaletteIndexDoubleClicked(const QModelIndex &index)
 {
     m_paletteEditor->modifyEntry(index);
 }
 
 void PaletteDockerDock::setEntryByForeground(const QModelIndex &index)
 {
     m_paletteEditor->setEntry(m_resourceProvider->fgColor(), index);
     if (m_currentColorSet->isEditable()) {
         m_ui->bnRemove->setEnabled(true);
     }
 }
 
 void PaletteDockerDock::slotEditEntry()
 {
     QModelIndex index = m_ui->paletteView->currentIndex();
     if (!index.isValid()) {
         return;
     }
     m_paletteEditor->modifyEntry(index);
 }
 
 void PaletteDockerDock::slotNameListSelection(const KoColor &color)
 {
     m_resourceProvider->setFGColor(color);
 }
diff --git a/plugins/dockers/palettedocker/wdgpalettedock.ui b/plugins/dockers/palettedocker/wdgpalettedock.ui
index f937f1fcd1..d5f4d88aeb 100644
--- a/plugins/dockers/palettedocker/wdgpalettedock.ui
+++ b/plugins/dockers/palettedocker/wdgpalettedock.ui
@@ -1,161 +1,180 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgPaletteDock</class>
  <widget class="QWidget" name="WdgPaletteDock">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>647</width>
     <height>422</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>1</number>
    </property>
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <widget class="KisPaletteView" name="paletteView">
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>16</height>
       </size>
      </property>
     </widget>
    </item>
    <item>
     <widget class="KisPaletteComboBox" name="cmbNameList">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
      <property name="editable">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout">
-     <item row="2" column="3">
-      <widget class="QToolButton" name="bnAdd">
+     <item row="2" column="7">
+      <widget class="QToolButton" name="bnRemove">
        <property name="toolTip">
-        <string>Add foreground color</string>
+        <string>Delete color</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="icon">
-        <iconset theme="list-add">
+        <iconset theme="list-remove">
          <normaloff>.</normaloff>.</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>false</bool>
        </property>
       </widget>
      </item>
-     <item row="2" column="6">
-      <widget class="QToolButton" name="bnRemove">
+     <item row="2" column="2">
+      <spacer name="hBottomSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item row="2" column="5">
+      <widget class="QToolButton" name="bnRename">
+       <property name="text">
+        <string/>
+       </property>
+       <property name="icon">
+        <iconset theme="edit-rename">
+         <normaloff>.</normaloff>.</iconset>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="0">
+      <widget class="KisPopupButton" name="bnColorSets">
+       <property name="text">
+        <string/>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="4">
+      <widget class="QToolButton" name="bnAdd">
        <property name="toolTip">
-        <string>Delete color</string>
+        <string>Add foreground color</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="icon">
-        <iconset theme="list-remove">
+        <iconset theme="list-add">
          <normaloff>.</normaloff>.</iconset>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>false</bool>
        </property>
       </widget>
      </item>
-     <item row="2" column="4">
-      <widget class="QToolButton" name="bnRename">
+     <item row="2" column="6">
+      <widget class="QToolButton" name="bnEditPalette">
        <property name="text">
-        <string/>
+        <string>...</string>
        </property>
        <property name="icon">
-        <iconset theme="edit-rename">
+        <iconset theme="document-layer">
          <normaloff>.</normaloff>.</iconset>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
-      <spacer name="hBottomSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item row="2" column="0">
-      <widget class="KisPopupButton" name="bnColorSets">
+      <widget class="KSqueezedTextLabel" name="lblPaletteName">
        <property name="text">
-        <string/>
-       </property>
-      </widget>
-     </item>
-     <item row="2" column="5">
-      <widget class="QToolButton" name="bnEditPalette">
-       <property name="text">
-        <string>...</string>
-       </property>
-       <property name="icon">
-        <iconset theme="document-layer"/>
+        <string>TextLabel</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisPopupButton</class>
    <extends>QPushButton</extends>
    <header>kis_popup_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisPaletteView</class>
    <extends>QTableView</extends>
    <header location="global">kis_palette_view.h</header>
   </customwidget>
   <customwidget>
    <class>KisPaletteComboBox</class>
    <extends>QComboBox</extends>
    <header>KisPaletteComboBox.h</header>
   </customwidget>
+  <customwidget>
+   <class>KSqueezedTextLabel</class>
+   <extends>QLabel</extends>
+   <header location="global">ksqueezedtextlabel.h</header>
+  </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>bnRemove</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>