diff --git a/libs/ui/widgets/kis_color_filter_combo.cpp b/libs/ui/widgets/kis_color_filter_combo.cpp
index bdd96d9f99..60dac09a0a 100644
--- a/libs/ui/widgets/kis_color_filter_combo.cpp
+++ b/libs/ui/widgets/kis_color_filter_combo.cpp
@@ -1,377 +1,386 @@
 /*
  *  Copyright (c) 2015 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_color_filter_combo.h"
 
 #include <klocalizedstring.h>
 #include <QStylePainter>
 #include <QtCore/qmath.h>
 #include <QApplication>
 #include <QProxyStyle>
 #include <QStyleOption>
 #include <QSortFilterProxyModel>
 #include <QStandardItemModel>
 #include <QListView>
 #include <QMouseEvent>
 
 #include <QStyleFactory>
 
 
 
 #include "kis_node_view_color_scheme.h"
 #include "kis_debug.h"
 #include "kis_icon_utils.h"
 #include "krita_utils.h"
 #include "kis_node.h"
 
 enum AdditionalRoles {
     OriginalLabelIndex = Qt::UserRole + 1000
 };
 
 
 struct LabelFilteringModel : public QSortFilterProxyModel
 {
     LabelFilteringModel(QObject *parent) : QSortFilterProxyModel(parent) {}
 
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override {
         const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
         const int labelIndex = index.data(OriginalLabelIndex).toInt();
 
 
         return labelIndex < 0 || m_acceptedLabels.contains(labelIndex);
     }
 
     void setAcceptedLabels(const QSet<int> &value) {
         m_acceptedLabels = value;
         invalidateFilter();
     }
 
 private:
     QSet<int> m_acceptedLabels;
 };
 
 
 class ComboEventFilter : public QObject
 {
 public:
     ComboEventFilter(KisColorFilterCombo *parent) : m_parent(parent), m_buttonPressed(false) {}
 
 protected:
     bool eventFilter(QObject *obj, QEvent *event) override {
         if (event->type() == QEvent::Leave) {
             m_buttonPressed = false;
 
         } else if (event->type() == QEvent::MouseButtonPress) {
             QMouseEvent *mevent = static_cast<QMouseEvent*>(event);
             m_buttonPressed = mevent->button() == Qt::LeftButton;
 
         } else if (event->type() == QEvent::MouseButtonRelease) {
             QMouseEvent *mevent = static_cast<QMouseEvent*>(event);
             QModelIndex index = m_parent->view()->indexAt(mevent->pos());
             if (!index.isValid()) return false;
 
             /**
              * We should eat the first event that arrives exactly when
              * the drop down appears on screen.
              */
             if (!m_buttonPressed) return true;
 
             const bool toUncheckedState = index.data(Qt::CheckStateRole) == Qt::Checked;
 
             if (toUncheckedState) {
                 m_parent->model()->setData(index, Qt::Unchecked, Qt::CheckStateRole);
             } else {
                 m_parent->model()->setData(index, Qt::Checked, Qt::CheckStateRole);
             }
 
             if (index.data(OriginalLabelIndex).toInt() == -1) {
                 for (int i = 0; i < m_parent->model()->rowCount(); i++) {
                     const QModelIndex &other = m_parent->model()->index(i, 0);
                     if (other.data(OriginalLabelIndex) != -1) {
                         m_parent->model()->setData(other, toUncheckedState ? Qt::Unchecked : Qt::Checked, Qt::CheckStateRole);
                     }
                 }
             } else {
                 bool prevChecked = false;
                 bool checkedVaries = false;
                 QModelIndex allLabelsIndex;
 
                 for (int i = 0; i < m_parent->model()->rowCount(); i++) {
                     const QModelIndex &other = m_parent->model()->index(i, 0);
                     if (other.data(OriginalLabelIndex) != -1) {
                         const bool currentChecked = other.data(Qt::CheckStateRole) == Qt::Checked;
 
                         if (i == 0) {
                             prevChecked = currentChecked;
                         } else {
                             if (prevChecked != currentChecked) {
                                 checkedVaries = true;
                                 break;
                             }
                         }
                     } else {
                         allLabelsIndex = other;
                     }
                 }
 
                 const bool allLabelsIndexShouldBeChecked =
                     prevChecked && !checkedVaries;
 
                 if (allLabelsIndexShouldBeChecked !=
                     (allLabelsIndex.data(Qt::CheckStateRole) == Qt::Checked)) {
 
                     m_parent->model()->setData(allLabelsIndex, allLabelsIndexShouldBeChecked ? Qt::Checked : Qt::Unchecked, Qt::CheckStateRole);
                 }
             }
 
             emit m_parent->selectedColorsChanged();
 
             m_buttonPressed = false;
             return true;
         }
 
         return QObject::eventFilter(obj, event);
     }
 
 private:
     KisColorFilterCombo *m_parent;
     bool m_buttonPressed;
 };
 
 class FullSizedListView : public QListView
 {
 public:
     QSize sizeHint() const override {
         return contentsSize();
     }
 };
 
 class PopupComboBoxStyle : public QProxyStyle
 {
 public:
     PopupComboBoxStyle(QStyle *baseStyle = nullptr) : QProxyStyle(baseStyle) {}
 
     int styleHint(QStyle::StyleHint hint, const QStyleOption *option, const QWidget *widget, QStyleHintReturn *returnData) const override
     {
         // This flag makes ComboBox popup float ontop of its parent ComboBox, like in Fusion style.
         // Only when this hint is set will Qt respect combobox popup size hints, otherwise the popup
         // can never exceed the width of its parent ComboBox, like in Breeze style.
         if (hint == QStyle::SH_ComboBox_Popup) {
             return true;
         }
 
         return QProxyStyle::styleHint(hint, option, widget, returnData);
     }
 };
 
 struct KisColorFilterCombo::Private
 {
     LabelFilteringModel *filteringModel;
 };
 
 KisColorFilterCombo::KisColorFilterCombo(QWidget *parent)
     : QComboBox(parent),
       m_d(new Private)
 {
     QStandardItemModel *newModel = new QStandardItemModel(this);
     setModel(newModel);
 
     QStyle* newStyle = QStyleFactory::create(style()->objectName());
     // proxy style steals the ownership of the style and deletes it later
     PopupComboBoxStyle *proxyStyle = new PopupComboBoxStyle(newStyle);
 
     proxyStyle->setParent(this);
     setStyle(proxyStyle);
 
     setView(new FullSizedListView);
     m_eventFilters.append(new ComboEventFilter(this));
     m_eventFilters.append(new ComboEventFilter(this));
 
     view()->installEventFilter(m_eventFilters[0]);
     view()->viewport()->installEventFilter(m_eventFilters[1]);
 
     KisNodeViewColorScheme scm;
 
     QStandardItem* item = new QStandardItem(i18nc("combo box: show all layers", "All"));
     item->setCheckable(true);
     item->setCheckState(Qt::Unchecked);
     item->setData(QColor(Qt::transparent), Qt::BackgroundColorRole);
     item->setData(int(-1), OriginalLabelIndex);
     item->setData(QSize(30, scm.rowHeight()), Qt::SizeHintRole);
     newModel->appendRow(item);
 
     int labelIndex = 0;
     foreach (const QColor &color, scm.allColorLabels()) {
         const QString title = color.alpha() > 0 ? "" : i18nc("combo box: select all layers without a label", "No Label");
 
         QStandardItem* item = new QStandardItem(title);
         item->setCheckable(true);
         item->setCheckState(Qt::Unchecked);
         item->setData(color, Qt::BackgroundColorRole);
         item->setData(labelIndex, OriginalLabelIndex);
         item->setData(QSize(30, scm.rowHeight()), Qt::SizeHintRole);
         newModel->appendRow(item);
 
         labelIndex++;
     }
 
     m_d->filteringModel = new LabelFilteringModel(this);
     QAbstractItemModel *originalModel = model();
     originalModel->setParent(m_d->filteringModel);
 
     m_d->filteringModel->setSourceModel(originalModel);
     setModel(m_d->filteringModel);
 }
 
 KisColorFilterCombo::~KisColorFilterCombo()
 {
     qDeleteAll(m_eventFilters);
 }
 
 void collectAvailableLabels(KisNodeSP root, QSet<int> *labels)
 {
     labels->insert(root->colorLabelIndex());
 
     KisNodeSP node = root->firstChild();
     while (node) {
         collectAvailableLabels(node, labels);
         node = node->nextSibling();
     }
 }
 
 void KisColorFilterCombo::updateAvailableLabels(KisNodeSP rootNode)
 {
     QSet<int> labels;
     if (!rootNode.isNull()) {
         collectAvailableLabels(rootNode, &labels);
     }
 
     updateAvailableLabels(labels);
 }
 
 void KisColorFilterCombo::updateAvailableLabels(const QSet<int> &labels)
 {
     m_d->filteringModel->setAcceptedLabels(labels);
 }
 
 QList<int> KisColorFilterCombo::selectedColors() const
 {
     QList<int> colors;
     for (int i = 0; i < model()->rowCount(); i++) {
         const QModelIndex &other = model()->index(i, 0);
         const int label = other.data(OriginalLabelIndex).toInt();
 
         if (label != -1 &&
             other.data(Qt::CheckStateRole) == Qt::Checked) {
 
             colors << label;
         }
     }
     return colors;
 }
 
+void KisColorFilterCombo::paintColorPie(QStylePainter &painter, const QPalette& palette, const QList<int> &selectedColors, const QRect &rect, const int &baseSize)
+{
+    KisNodeViewColorScheme scm;
+
+    if (selectedColors.size() == 1) {
+        const int currentLabel = selectedColors.first();
+        QColor currentColor = scm.colorLabel(currentLabel);
+
+        if (currentColor.alpha() > 0) {
+            painter.fillRect(rect, currentColor);
+        } else if (currentLabel == 0) {
+            QPen oldPen = painter.pen();
+
+            const int border = 4;
+            QRect crossRect(0, 0, baseSize - 2 * border, baseSize - 2 * border);
+            crossRect.moveCenter(rect.center());
+
+            QColor shade = palette.dark().color();
+            painter.setPen(QPen(shade, 2));
+            painter.drawLine(crossRect.topLeft(), crossRect.bottomRight());
+            painter.drawLine(crossRect.bottomLeft(), crossRect.topRight());
+        }
+    } else {
+        const int border = 0;
+        QRect pieRect(0, 0, baseSize - 2 * border, baseSize - 2 * border);
+        pieRect.moveCenter(rect.center());
+
+        const int numColors = selectedColors.size();
+        const int step = 16 * 360 / numColors;
+
+        int currentAngle = 0;
+
+        //painter.save(); // optimize out!
+        painter.setRenderHint(QPainter::Antialiasing);
+
+        for (int i = 0; i < numColors; i++) {
+            QColor color = scm.colorLabel(selectedColors[i]);
+            QBrush brush = color.alpha() > 0 ? QBrush(color) : QBrush(Qt::black, Qt::Dense4Pattern);
+            painter.setPen(color);
+            painter.setBrush(brush);
+
+            painter.drawPie(pieRect, currentAngle, step);
+            currentAngle += step;
+        }
+    }
+}
+
+
 void KisColorFilterCombo::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event);
 
     QStylePainter painter(this);
     painter.setPen(palette().color(QPalette::Text));
 
     // draw the combobox frame, focusrect and selected etc.
     QStyleOptionComboBox opt;
     initStyleOption(&opt);
     painter.drawComplexControl(QStyle::CC_ComboBox, opt);
 
+
     {
-        KisNodeViewColorScheme scm;
         const QRect editRect = style()->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxEditField, this);
         const int size = qMin(editRect.width(), editRect.height());
 
         const QList<int> selectedColors = this->selectedColors();
 
         if (selectedColors.size() == 0 || selectedColors.size() == model()->rowCount() - 1) {
             QIcon icon = KisIconUtils::loadIcon("view-filter");
             QPixmap pixmap = icon.pixmap(QSize(size, size), !isEnabled() ? QIcon::Disabled : QIcon::Normal);
             painter.drawPixmap(editRect.right() - size, editRect.top(), pixmap);
 
-        } else if (selectedColors.size() == 1) {
-            const int currentLabel = selectedColors.first();
-            QColor currentColor = scm.colorLabel(currentLabel);
-
-            if (currentColor.alpha() > 0) {
-                painter.fillRect(editRect, currentColor);
-            } else if (currentLabel == 0) {
-                QPen oldPen = painter.pen();
-
-                const int border = 4;
-                QRect crossRect(0, 0, size - 2 * border, size - 2 * border);
-                crossRect.moveCenter(editRect.center());
-
-                QColor shade = opt.palette.dark().color();
-                painter.setPen(QPen(shade, 2));
-                painter.drawLine(crossRect.topLeft(), crossRect.bottomRight());
-                painter.drawLine(crossRect.bottomLeft(), crossRect.topRight());
-            }
         } else {
-            const int border = 0;
-            QRect pieRect(0, 0, size - 2 * border, size - 2 * border);
-            pieRect.moveCenter(editRect.center());
-
-            const int numColors = selectedColors.size();
-            const int step = 16 * 360 / numColors;
-
-            int currentAngle = 0;
-
-            //painter.save(); // optimize out!
-            painter.setRenderHint(QPainter::Antialiasing);
-
-            for (int i = 0; i < numColors; i++) {
-                QColor color = scm.colorLabel(selectedColors[i]);
-                QBrush brush = color.alpha() > 0 ? QBrush(color) : QBrush(Qt::black, Qt::Dense4Pattern);
-                painter.setPen(color);
-                painter.setBrush(brush);
-
-                painter.drawPie(pieRect, currentAngle, step);
-                currentAngle += step;
-            }
-            //painter.restore(); // optimize out!
+            KisColorFilterCombo::paintColorPie(painter, opt.palette, selectedColors, editRect, size );
         }
     }
 
     // draw the icon and text
     //painter.drawControl(QStyle::CE_ComboBoxLabel, opt);
 }
 
 QSize KisColorFilterCombo::minimumSizeHint() const
 {
     return sizeHint();
 }
 
 QSize KisColorFilterCombo::sizeHint() const
 {
     QStyleOptionComboBox opt;
     initStyleOption(&opt);
 
     const QStyleOption *baseOption = qstyleoption_cast<const QStyleOption *>(&opt);
     const int arrowSize = style()->pixelMetric(QStyle::PM_ScrollBarExtent, baseOption, this);
 
     const QSize originalHint = QComboBox::sizeHint();
     QSize sh(3 * arrowSize, originalHint.height());
 
     return sh;
 }
diff --git a/libs/ui/widgets/kis_color_filter_combo.h b/libs/ui/widgets/kis_color_filter_combo.h
index abe3c826f1..6d85fe2ead 100644
--- a/libs/ui/widgets/kis_color_filter_combo.h
+++ b/libs/ui/widgets/kis_color_filter_combo.h
@@ -1,56 +1,60 @@
 /*
  *  Copyright (c) 2015 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.
  */
 
 #ifndef __KIS_COLOR_FILTER_COMBO_H
 #define __KIS_COLOR_FILTER_COMBO_H
 
 #include <QScopedPointer>
 #include <QComboBox>
+#include <QStylePainter>
 #include "kritaui_export.h"
 #include "kis_types.h"
 
 class ComboEventFilter;
 
 class KRITAUI_EXPORT KisColorFilterCombo : public QComboBox
 {
     Q_OBJECT
 public:
     KisColorFilterCombo(QWidget *parent);
     ~KisColorFilterCombo() override;
 
     void updateAvailableLabels(KisNodeSP rootNode);
     void updateAvailableLabels(const QSet<int> &labels);
 
     QSize minimumSizeHint() const override;
     QSize sizeHint() const override;
 
     QList<int> selectedColors() const;
 
 Q_SIGNALS:
     void selectedColorsChanged();
 
+public:
+    static void paintColorPie(QStylePainter &painter, const QPalette& palette, const QList<int> &selectedColors, const QRect &rect, const int &baseSize);
+
 private:
     void paintEvent(QPaintEvent *event) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
     QList<ComboEventFilter *> m_eventFilters;
 };
 
 #endif /* __KIS_COLOR_FILTER_COMBO_H */
diff --git a/libs/ui/widgets/kis_layer_filter_widget.cpp b/libs/ui/widgets/kis_layer_filter_widget.cpp
index 42585642cc..f234097d95 100644
--- a/libs/ui/widgets/kis_layer_filter_widget.cpp
+++ b/libs/ui/widgets/kis_layer_filter_widget.cpp
@@ -1,191 +1,237 @@
 /*
  *  Copyright (c) 2020 Eoin O'Neill <eoinoneill1991@gmail.com>
  *  Copyright (c) 2020 Emmet O'Neill <emmetoneill.pdx@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_layer_filter_widget.h"
 
 #include <QApplication>
 #include <QVBoxLayout>
 #include <QLineEdit>
 #include <QCompleter>
 #include <QEvent>
 #include <QMouseEvent>
 #include <QButtonGroup>
 #include <QPushButton>
 #include <QMenu>
 #include <QScreen>
+#include <QStylePainter>
 
 #include "kis_debug.h"
 #include "kis_node.h"
 #include "kis_global.h"
+
+#include "kis_color_filter_combo.h"
 #include "kis_color_label_button.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_node_view_color_scheme.h"
 
 KisLayerFilterWidget::KisLayerFilterWidget(QWidget *parent) : QWidget(parent)
 {
     QVBoxLayout *layout = new QVBoxLayout(this);
     setLayout(layout);
     setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     textFilter = new QLineEdit(this);
     textFilter->setPlaceholderText(i18n("Filter by name..."));
     textFilter->setMinimumWidth(192);
     textFilter->setMinimumHeight(32);
     textFilter->setClearButtonEnabled(true);
 
     connect(textFilter, SIGNAL(textChanged(QString)), this, SIGNAL(filteringOptionsChanged()));
 
     KisNodeViewColorScheme colorScheme;
 
     QWidget* buttonContainer = new QWidget(this);
     buttonContainer->setToolTip(i18n("Filter by color label..."));
     buttonEventFilter = new KisColorLabelMouseDragFilter(buttonContainer);
     {
         QHBoxLayout *subLayout = new QHBoxLayout(buttonContainer);
         buttonContainer->setLayout(subLayout);
         subLayout->setContentsMargins(0,0,0,0);
         subLayout->setAlignment(Qt::AlignLeft);
         buttonGroup = new KisColorLabelFilterGroup(buttonContainer);
         buttonGroup->setExclusive(false);
         QVector<QColor> colors = colorScheme.allColorLabels();
 
         for (int id = 0; id < colors.count(); id++) {
             KisColorLabelButton* btn = new KisColorLabelButton(colors[id], 32, buttonContainer);
             buttonGroup->addButton(btn, id);
             btn->installEventFilter(buttonEventFilter);
             subLayout->addWidget(btn);
         }
 
         connect(buttonGroup, SIGNAL(buttonToggled(int,bool)), this, SIGNAL(filteringOptionsChanged()));
     }
 
     resetButton = new QPushButton(i18n("Reset Filters"), this);
     resetButton->setMinimumHeight(32);
     connect(resetButton, &QPushButton::clicked, [this](){
        this->reset();
     });
 
 
     layout->addWidget(textFilter);
     layout->addWidget(buttonContainer);
     layout->addWidget(resetButton);
 }
 
 void KisLayerFilterWidget::scanUsedColorLabels(KisNodeSP node, QSet<int> &colorLabels)
 {
     if (node->parent()) {
         colorLabels.insert(node->colorLabelIndex());
     }
 
     KisNodeSP child = node->firstChild();
     while(child) {
         scanUsedColorLabels(child, colorLabels);
         child = child->nextSibling();
     }
 }
 
 void KisLayerFilterWidget::updateColorLabels(KisNodeSP root)
 {
     QSet<int> colorLabels;
 
     scanUsedColorLabels(root, colorLabels);
     buttonGroup->setViableLabels(colorLabels);
 }
 
 bool KisLayerFilterWidget::isCurrentlyFiltering() const
 {
     const bool isFilteringText = !textFilter->text().isEmpty();
     const bool isFilteringColors = buttonGroup->getActiveLabels().count() > 0;
 
     return isFilteringText || isFilteringColors;
 }
 
 QSet<int> KisLayerFilterWidget::getActiveColors() const
 {
     QSet<int> activeColors = buttonGroup->getActiveLabels();
 
     return activeColors;
 }
 
 QString KisLayerFilterWidget::getTextFilter() const
 {
     return textFilter->text();
 }
 
 int KisLayerFilterWidget::getDesiredMinimumWidth() const {
     return qMax(textFilter->minimumWidth(), buttonGroup->countViableButtons() * 32);
 }
 
 int KisLayerFilterWidget::getDesiredMinimumHeight() const {
     QList<QAbstractButton*> viableButtons = buttonGroup->viableButtons();
     if (viableButtons.count() > 1) {
         return viableButtons[0]->sizeHint().height() + textFilter->minimumHeight() + resetButton->minimumHeight();
     } else {
         return textFilter->minimumHeight() + resetButton->minimumHeight();
     }
 }
 
 void KisLayerFilterWidget::reset()
 {
     textFilter->clear();
     buttonGroup->reset();
     filteringOptionsChanged();
 }
 
 QSize KisLayerFilterWidget::sizeHint() const
 {
     return QSize(getDesiredMinimumWidth(), getDesiredMinimumHeight());
 }
 
 void KisLayerFilterWidget::showEvent(QShowEvent *show)
 {
     QMenu *parentMenu = dynamic_cast<QMenu*>(parentWidget());
 
     if (parentMenu) {
         const int widthBefore = parentMenu->width();
         const int rightEdgeThreshold = 5;
 
         //Fake resize event needs to be made to register change in widget menu size.
         //Not doing this will cause QMenu to not resize properly!
         resize(sizeHint());
         adjustSize();
         QResizeEvent event = QResizeEvent(sizeHint(), parentMenu->size());
 
         parentMenu->resize(sizeHint());
         parentMenu->adjustSize();
         qApp->sendEvent(parentMenu, &event);
 
         QScreen *screen = QGuiApplication::screenAt(parentMenu->mapToGlobal(parentMenu->pos()));
         QRect screenGeometry = screen ? screen->geometry() : parentMenu->parentWidget()->window()->geometry();
 
         const bool onRightEdge = (parentMenu->pos().x() + widthBefore + rightEdgeThreshold) >  screenGeometry.width();
         const int widthAfter = parentMenu->width();
 
         if (onRightEdge) {
             if (widthAfter > widthBefore) {
                 const QRect newGeo = kisEnsureInRect( parentMenu->geometry(), screenGeometry );
                 const int xShift = newGeo.x() - parentMenu->pos().x();
                 parentMenu->move(parentMenu->pos().x() + xShift, parentMenu->pos().y() + 0);
             } else {
                 const int xShift = widthBefore - widthAfter;
                 parentMenu->move(parentMenu->pos().x() + xShift, parentMenu->pos().y() + 0);
             }
         }
     }
     QWidget::showEvent(show);
 }
+
+KisLayerFilterWidgetToolButton::KisLayerFilterWidgetToolButton(QWidget *parent)
+    : QToolButton(parent)
+{
+    m_textFilter = false;
+    m_selectedColors = QList<int>();
+    ENTER_FUNCTION();
+}
+
+KisLayerFilterWidgetToolButton::KisLayerFilterWidgetToolButton(const KisLayerFilterWidgetToolButton &rhs)
+    : QToolButton(rhs.parentWidget())
+    , m_textFilter(rhs.m_textFilter)
+    , m_selectedColors(rhs.m_selectedColors)
+{
+
+}
+
+void KisLayerFilterWidgetToolButton::setSelectedColors(QList<int> colors)
+{
+    m_selectedColors = colors;
+}
+
+void KisLayerFilterWidgetToolButton::paintEvent(QPaintEvent *paintEvent)
+{
+    KisNodeViewColorScheme colorScheme;
+    if (m_textFilter == false &&
+       ((m_selectedColors.count() == 0) || (m_selectedColors.count() == colorScheme.allColorLabels().count())))
+    {
+        QToolButton::paintEvent(paintEvent);
+    }
+    else
+    {
+        QStylePainter paint(this);
+        QStyleOptionToolButton opt;
+        initStyleOption(&opt);
+        paint.drawComplexControl(QStyle::CC_ToolButton, opt);
+        const QSize halfIconSize = this->iconSize() / 2;
+        const QSize halfButtonSize = this->size() / 2;
+        const QRect editRect = kisGrowRect(QRect(QPoint(halfButtonSize.width() - halfIconSize.width(), halfButtonSize.height() - halfIconSize.height()),this->iconSize()), -1);
+        const int size = qMin(editRect.width(), editRect.height());
+        KisColorFilterCombo::paintColorPie(paint, opt.palette, m_selectedColors, editRect, size );
+    }
+}
diff --git a/libs/ui/widgets/kis_layer_filter_widget.h b/libs/ui/widgets/kis_layer_filter_widget.h
index a8d03c1f74..4666aba112 100644
--- a/libs/ui/widgets/kis_layer_filter_widget.h
+++ b/libs/ui/widgets/kis_layer_filter_widget.h
@@ -1,64 +1,84 @@
 /*
  *  Copyright (c) 2020 Eoin O'Neill <eoinoneill1991@gmail.com>
  *  Copyright (c) 2020 Emmet O'Neill <emmetoneill.pdx@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 KISLAYERFILTERWIDGET_H
 #define KISLAYERFILTERWIDGET_H
 
 #include <QWidget>
+#include <QToolButton>
 #include "kis_types.h"
 
 #include "kritaui_export.h"
 
 
 class KRITAUI_EXPORT KisLayerFilterWidget : public QWidget
 {
     Q_OBJECT
 private:
     class KisColorLabelMouseDragFilter *buttonEventFilter;
     class QLineEdit *textFilter;
     class KisColorLabelFilterGroup *buttonGroup;
     class QPushButton *resetButton;
 
 public:
     KisLayerFilterWidget(QWidget *parent = nullptr);
 
     static void scanUsedColorLabels(KisNodeSP node, QSet<int> &colorLabels);
     void updateColorLabels(KisNodeSP root);
 
     bool isCurrentlyFiltering() const;
     QSet<int> getActiveColors() const;
     QString getTextFilter() const;
 
     int getDesiredMinimumWidth() const;
     int getDesiredMinimumHeight() const;
 
     void reset();
 
     QSize sizeHint() const override;
 
     /* Show Event has to be overridden to
      * correct for issues where QMenu isn't
      * correctly resizing. */
     void showEvent(QShowEvent *show) override;
 
 Q_SIGNALS:
     void filteringOptionsChanged();
 
 };
 
+class KRITAUI_EXPORT KisLayerFilterWidgetToolButton : public QToolButton
+{
+    Q_OBJECT
+public:
+    explicit KisLayerFilterWidgetToolButton(QWidget *parent = nullptr);
+    KisLayerFilterWidgetToolButton(const KisLayerFilterWidgetToolButton& rhs);
+    ~KisLayerFilterWidgetToolButton(){}
+
+    void setSelectedColors(QList<int> colors);
+
+
+private:
+    void paintEvent(QPaintEvent *paintEvent) override;
+
+private:
+    bool m_textFilter;
+    QList<int> m_selectedColors;
+};
+
 #endif // KISLAYERFILTERWIDGET_H
diff --git a/plugins/dockers/animation/onion_skins_docker.ui b/plugins/dockers/animation/onion_skins_docker.ui
index 6adb25ea2a..eddaf5ff43 100644
--- a/plugins/dockers/animation/onion_skins_docker.ui
+++ b/plugins/dockers/animation/onion_skins_docker.ui
@@ -1,199 +1,199 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>OnionSkinsDocker</class>
  <widget class="QWidget" name="OnionSkinsDocker">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>336</width>
     <height>282</height>
    </rect>
   </property>
   <property name="font">
    <font>
     <kerning>false</kerning>
    </font>
   </property>
   <property name="windowTitle">
    <string>Onion skin options</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="leftMargin">
     <number>12</number>
    </property>
    <property name="topMargin">
     <number>12</number>
    </property>
    <property name="rightMargin">
     <number>12</number>
    </property>
    <property name="bottomMargin">
     <number>12</number>
    </property>
    <item>
     <layout class="QVBoxLayout" name="slidersLayout">
      <property name="spacing">
       <number>0</number>
      </property>
     </layout>
    </item>
    <item>
     <widget class="QGroupBox" name="colorFilterGroupbox">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Filter Frames by Color</string>
      </property>
      <property name="checkable">
       <bool>true</bool>
      </property>
      <property name="checked">
       <bool>false</bool>
      </property>
      <layout class="QHBoxLayout" name="horizontalLayout_3">
       <property name="spacing">
        <number>4</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="QPushButton" name="resetFilter">
         <property name="maximumSize">
          <size>
-          <width>80</width>
+          <width>55</width>
           <height>16777215</height>
          </size>
         </property>
         <property name="text">
-         <string>Reset Filter</string>
+         <string>Reset</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="filterButtons"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <layout class="QVBoxLayout" name="buttonsLayout">
      <property name="spacing">
       <number>6</number>
      </property>
      <item>
       <layout class="QHBoxLayout" name="hideShowButtonlayout">
        <item>
         <widget class="Line" name="line">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QToolButton" name="btnShowHide">
          <property name="text">
           <string>+</string>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
          <property name="autoRaise">
           <bool>true</bool>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item>
       <widget class="KisDoubleSliderSpinBox" name="doubleTintFactor" native="true">
        <property name="minimumSize">
         <size>
          <width>50</width>
          <height>0</height>
         </size>
        </property>
       </widget>
      </item>
      <item>
       <layout class="QHBoxLayout" name="horizontalLayout_2">
        <item>
         <widget class="KisColorButton" name="btnBackwardColor">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="lblPrevColor">
          <property name="text">
           <string>Previous frames</string>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="horizontalSpacer">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>13</width>
            <height>13</height>
           </size>
          </property>
         </spacer>
        </item>
        <item>
         <widget class="QLabel" name="lblNextColor">
          <property name="text">
           <string>Next frames</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="KisColorButton" name="btnForwardColor">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
       </layout>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/dockers/layerdocker/LayerBox.cpp b/plugins/dockers/layerdocker/LayerBox.cpp
index 40c0799ad0..b16e5a6b7e 100644
--- a/plugins/dockers/layerdocker/LayerBox.cpp
+++ b/plugins/dockers/layerdocker/LayerBox.cpp
@@ -1,1150 +1,1152 @@
 /*
  *  LayerBox.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@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 "LayerBox.h"
 
 #include <QApplication>
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QBitmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 #include <QMenu>
 #include <QWidgetAction>
 #include <QProxyStyle>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_base_node.h>
 #include <kis_composite_ops_model.h>
 #include <kis_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 #include <KoProperties.h>
 
 #include <kis_action.h>
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 
 #include "canvas/kis_canvas2.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_signals_blocker.h"
 #include "kis_color_filter_combo.h"
 #include "kis_node_filter_proxy_model.h"
 
 #include "kis_selection.h"
 #include "kis_processing_applicator.h"
 #include "commands/kis_set_global_selection_command.h"
 #include "KisSelectionActionsAdapter.h"
 
 #include "kis_layer_utils.h"
 
 #include "ui_WdgLayerBox.h"
 #include "NodeView.h"
 #include "SyncButtonAndAction.h"
 
 
 class LayerBoxStyle : public QProxyStyle
 {
 public:
     LayerBoxStyle(QStyle *baseStyle = 0) : QProxyStyle(baseStyle) {}
 
     void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                        QPainter *painter, const QWidget *widget) const
     {
         if (element == QStyle::PE_IndicatorItemViewItemDrop)
         {
             QColor color(widget->palette().color(QPalette::Highlight).lighter());
 
             if (option->rect.height() == 0) {
                 QBrush brush(color);
 
                 QRect r(option->rect);
                 r.setTop(r.top() - 2);
                 r.setBottom(r.bottom() + 2);
 
                 painter->fillRect(r, brush);
             } else {
                 color.setAlpha(200);
                 QBrush brush(color);
                 painter->fillRect(option->rect, brush);
             }
         }
         else
         {
             QProxyStyle::drawPrimitive(element, option, painter, widget);
         }
     }
 };
 
 inline void LayerBox::connectActionToButton(KisViewManager* viewManager, QAbstractButton *button, const QString &id)
 {
     if (!viewManager || !button) return;
 
     KisAction *action = viewManager->actionManager()->actionByName(id);
 
     if (!action) return;
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
     connect(viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 inline void LayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     if (m_canvas) {
         menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
     }
 }
 
 LayerBox::LayerBox()
     : QDockWidget(i18n("Layers"))
     , m_canvas(0)
     , m_wdgLayerBox(new Ui_WdgLayerBox)
     , m_thumbnailCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_colorLabelCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_thumbnailSizeCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     KisConfig cfg(false);
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setStyle(new LayerBoxStyle(m_wdgLayerBox->listLayers->style()));
 
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(contextMenuRequested(QPoint,QModelIndex)),
             this, SLOT(slotContextMenuRequested(QPoint,QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(collapsed(QModelIndex)), SLOT(slotCollapsed(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(expanded(QModelIndex)), SLOT(slotExpanded(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(selectionChanged(QModelIndexList)), SLOT(selectionChanged(QModelIndexList)));
 
     slotUpdateIcons();
 
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnRaise->setEnabled(false);
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix(i18n("%"));
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_newLayerMenu = new QMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
     m_filteringModel = new KisNodeFilterProxyModel(this);
     m_filteringModel->setNodeModel(m_nodeModel);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setActivationFlags(KisAction::ACTIVE_IMAGE);
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_colorSelector = new KisColorLabelSelectorWidget(this);
     connect(m_colorSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
     m_colorSelectorAction = new QWidgetAction(this);
     m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             &m_colorLabelCompressor, SLOT(start()));
 
     m_wdgLayerBox->listLayers->setModel(m_filteringModel);
     // this connection should be done *after* the setModel() call to
     // happen later than the internal selection model
     connect(m_filteringModel.data(), &KisNodeFilterProxyModel::rowsAboutToBeRemoved,
             this, &LayerBox::slotAboutToRemoveRows);
 
 
     //LayerFilter Menu
     QMenu *layerFilterMenu = new QMenu(this);
     m_wdgLayerBox->bnLayerFilters->setMenu(layerFilterMenu);
     m_wdgLayerBox->bnLayerFilters->setPopupMode(QToolButton::InstantPopup);
 
     const QIcon filterIcon = KisIconUtils::loadIcon("view-filter");
     m_wdgLayerBox->bnLayerFilters->setIcon(filterIcon);
     QPixmap filterEnabledPixmap = filterIcon.pixmap(64,64);
     const QBitmap filterEnabledBitmask = filterEnabledPixmap.mask();
     filterEnabledPixmap.fill(palette().color(QPalette::Highlight));
     filterEnabledPixmap.setMask(filterEnabledBitmask);
     const QIcon filterEnabledIcon = QIcon(filterEnabledPixmap);
 
     layerFilterWidget = new KisLayerFilterWidget(this);
     connect(layerFilterWidget, SIGNAL(filteringOptionsChanged()), this, SLOT(updateLayerFiltering()));
     connect(layerFilterWidget, &KisLayerFilterWidget::filteringOptionsChanged, [this, filterIcon, filterEnabledIcon](){
         if(layerFilterWidget->isCurrentlyFiltering()) {
             m_wdgLayerBox->bnLayerFilters->setIcon(filterEnabledIcon);
         } else {
             m_wdgLayerBox->bnLayerFilters->setIcon(filterIcon);
         }
+
+        m_wdgLayerBox->bnLayerFilters->setSelectedColors(QList<int>::fromSet(layerFilterWidget->getActiveColors()));
     });
 
     QWidgetAction *layerFilterMenuAction = new QWidgetAction(this);
     layerFilterMenuAction->setDefaultWidget(layerFilterWidget);
     layerFilterMenu->addAction(layerFilterMenuAction);
 
     setEnabled(false);
 
     connect(&m_thumbnailCompressor, SIGNAL(timeout()), SLOT(updateThumbnail()));
     connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 
 
     // set up the configure menu for changing thumbnail size
     QMenu* configureMenu = new QMenu(this);
     configureMenu->setStyleSheet("margin: 6px");
     configureMenu->addSection(i18n("Thumbnail Size"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setMenu(configureMenu);
     m_wdgLayerBox->configureLayerDockerToolbar->setIcon(KisIconUtils::loadIcon("configure"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setPopupMode(QToolButton::InstantPopup);
 
 
     // add horizontal slider
     thumbnailSizeSlider = new QSlider(this);
     thumbnailSizeSlider->setOrientation(Qt::Horizontal);
     thumbnailSizeSlider->setRange(20, 80);
 
     thumbnailSizeSlider->setValue(cfg.layerThumbnailSize(false)); // grab this from the kritarc
 
     thumbnailSizeSlider->setMinimumHeight(20);
     thumbnailSizeSlider->setMinimumWidth(40);
     thumbnailSizeSlider->setTickInterval(5);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(thumbnailSizeSlider);
     configureMenu->addAction(sliderAction);
 
 
     connect(thumbnailSizeSlider, SIGNAL(sliderMoved(int)), &m_thumbnailSizeCompressor, SLOT(start()));
     connect(&m_thumbnailSizeCompressor, SIGNAL(timeout()), SLOT(slotUpdateThumbnailIconSize()));
 
 }
 
 LayerBox::~LayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeFilterProxyModel> filteringModel, NodeView *nodeView)
 {
     if (!root) return;
     if (filteringModel.isNull()) return;
     if (!nodeView) return;
 
     nodeView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = filteringModel->indexFromNode(node);
         if (idx.isValid()) {
             nodeView->setExpanded(idx, !node->collapsed());
         }
         if (!node->collapsed() && node->childCount() > 0) {
             expandNodesRecursively(node, filteringModel, nodeView);
         }
         node = node->nextSibling();
     }
     nodeView->blockSignals(false);
 }
 
 void LayerBox::slotAddLayerBnClicked()
 {
     if (m_canvas) {
         KisNodeList nodes = m_nodeManager->selectedNodes();
 
         if (nodes.size() == 1) {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("add_new_paint_layer");
             action->trigger();
         } else {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("create_quick_group");
             action->trigger();
         }
     }
 }
 
 void LayerBox::setViewManager(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
     Q_FOREACH (KisAction *action, m_actions) {
         kisview->actionManager()->
                 addAction(action->objectName(),
                           action);
     }
 
     connect(m_wdgLayerBox->bnAdd, SIGNAL(clicked()), this, SLOT(slotAddLayerBnClicked()));
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
     KisActionManager *actionManager = kisview->actionManager();
 
     KisAction *action = actionManager->createAction("RenameCurrentLayer");
     Q_ASSERT(action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
     m_propertiesAction = actionManager->createAction("layer_properties");
     Q_ASSERT(m_propertiesAction);
     new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
     m_removeAction = actionManager->createAction("remove_layer");
     Q_ASSERT(m_removeAction);
     new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
     action = actionManager->createAction("move_layer_up");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
     action = actionManager->createAction("move_layer_down");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 
     m_changeCloneSourceAction = actionManager->createAction("set-copy-from");
     Q_ASSERT(m_changeCloneSourceAction);
     connect(m_changeCloneSourceAction, &KisAction::triggered,
             this, &LayerBox::slotChangeCloneSourceClicked);
 }
 
 void LayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if (m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
         m_selectionActionsAdapter.reset();
 
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
             animation->disconnect(this);
         }
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         m_nodeManager->slotSetSelectedNodes(KisNodeList());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
         emit imageChanged();
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), &m_thumbnailCompressor, SLOT(start()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade =
                 static_cast<KisDummiesFacadeBase*>(kritaShapeController);
 
 
         m_selectionActionsAdapter.reset(new KisSelectionActionsAdapter(m_canvas->viewManager()->selectionManager()));
         m_nodeModel->setDummiesFacade(kritaDummiesFacade,
                                       m_image,
                                       kritaShapeController,
                                       m_selectionActionsAdapter.data(),
                                       m_nodeManager);
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
             // Connection KisNodeManager -> LayerBox
             connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                     this, SLOT(setCurrentNode(KisNodeSP)));
 
             connect(m_nodeManager,
                     SIGNAL(sigUiNeedChangeSelectedNodes(QList<KisNodeSP>)),
                     SLOT(slotNodeManagerChangedSelection(QList<KisNodeSP>)));
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection LayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                 m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         KisImageAnimationInterface *animation = m_image->animationInterface();
         connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &LayerBox::slotImageTimeChanged);
 
         expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
         updateAvailableLabels();
 
         addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
         addActionToMenu(m_newLayerMenu, "add_new_group_layer");
         addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
         addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
         addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
         addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
         addActionToMenu(m_newLayerMenu, "add_new_file_layer");
         m_newLayerMenu->addSeparator();
         addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
         addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
         addActionToMenu(m_newLayerMenu, "add_new_colorize_mask");
         addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void LayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
 
     m_filteringModel->unsetDummiesFacade();
     disconnect(m_image, 0, this, 0);
     disconnect(m_nodeManager, 0, this, 0);
     disconnect(m_nodeModel, 0, m_nodeManager, 0);
     m_nodeManager->slotSetSelectedNodes(KisNodeList());
 
     m_canvas = 0;
 }
 
 void LayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void LayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     if (activeNode != m_activeNode) {
         if( !m_activeNode.isNull() )
             m_activeNode->disconnect(this);
         m_activeNode = activeNode;
 
         if (activeNode) {
             KisKeyframeChannel *opacityChannel = activeNode->getKeyframeChannel(KisKeyframeChannel::Opacity.id(), false);
             if (opacityChannel) {
                 watchOpacityChannel(opacityChannel);
             } else {
                 watchOpacityChannel(0);
                 connect(activeNode.data(), &KisNode::keyframeChannelAdded, this, &LayerBox::slotKeyframeChannelAdded);
             }
         }
     }
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
     m_wdgLayerBox->cmbComposite->validate(m_image->colorSpace());
 
     if (activeNode) {
         if (activeNode->inherits("KisColorizeMask") || activeNode->inherits("KisLayer")) {
 
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             if (!m_wdgLayerBox->doubleOpacity->isDragging()) {
                 slotSetOpacity(activeNode->opacity() * 100.0 / 255);
             }
 
             const KoCompositeOp* compositeOp = activeNode->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         } else if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         }
     }
 }
 
 
 /**
  * This method is called *only* when non-GUI code requested the
  * change of the current node
  */
 void LayerBox::setCurrentNode(KisNodeSP node)
 {
     m_filteringModel->setActiveNode(node);
 
     QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
     m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
     updateUI();
 }
 
 void LayerBox::slotModelReset()
 {
     if(m_nodeModel->hasDummiesFacade()) {
         QItemSelection selection;
         Q_FOREACH (const KisNodeSP node, m_nodeManager->selectedNodes()) {
             const QModelIndex &idx = m_filteringModel->indexFromNode(node);
             if(idx.isValid()){
                 QItemSelectionRange selectionRange(idx);
                 selection << selectionRange;
             }
         }
 
         m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
     }
 
     updateUI();
 }
 
 void LayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 // range: 0-100
 void LayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void LayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
     KisNodeSP activeNode = m_nodeManager->activeNode();
     if (nodes.isEmpty() || !activeNode) return;
 
     if (m_canvas) {
         QMenu menu;
 
         const bool singleLayer = nodes.size() == 1;
 
         if (index.isValid()) {
             menu.addAction(m_propertiesAction);
 
             if (singleLayer) {
                 addActionToMenu(&menu, "layer_style");
             }
 
             Q_FOREACH(KisNodeSP node, nodes) {
                 if (node && node->inherits("KisCloneLayer")) {
                     menu.addAction(m_changeCloneSourceAction);
                     break;
                 }
             }
 
             {
                 KisSignalsBlocker b(m_colorSelector);
                 m_colorSelector->setCurrentIndex(singleLayer ? activeNode->colorLabelIndex() : -1);
             }
 
             menu.addAction(m_colorSelectorAction);
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "cut_layer_clipboard");
             addActionToMenu(&menu, "copy_layer_clipboard");
             addActionToMenu(&menu, "paste_layer_from_clipboard");
             menu.addAction(m_removeAction);
             addActionToMenu(&menu, "duplicatelayer");
             addActionToMenu(&menu, "merge_layer");
             addActionToMenu(&menu, "new_from_visible");
 
 
             if (singleLayer) {
                 addActionToMenu(&menu, "flatten_image");
                 addActionToMenu(&menu, "flatten_layer");
             }
 
             menu.addSeparator();
             QMenu *selectMenu = menu.addMenu(i18n("&Select"));
             addActionToMenu(selectMenu, "select_all_layers");
             addActionToMenu(selectMenu, "select_visible_layers");
             addActionToMenu(selectMenu, "select_invisible_layers");
             addActionToMenu(selectMenu, "select_locked_layers");
             addActionToMenu(selectMenu, "select_unlocked_layers");
             QMenu *groupMenu = menu.addMenu(i18n("&Group"));
             addActionToMenu(groupMenu, "create_quick_group");
             addActionToMenu(groupMenu, "create_quick_clipping_group");
             addActionToMenu(groupMenu, "quick_ungroup");
             QMenu *locksMenu = menu.addMenu(i18n("&Toggle Locks && Visibility"));
             addActionToMenu(locksMenu, "toggle_layer_visibility");
             addActionToMenu(locksMenu, "toggle_layer_lock");
             addActionToMenu(locksMenu, "toggle_layer_inherit_alpha");
             addActionToMenu(locksMenu, "toggle_layer_alpha_lock");
 
             if (singleLayer) {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_transparency_mask");
                 addActionToMenu(addLayerMenu, "add_new_filter_mask");
                 addActionToMenu(addLayerMenu, "add_new_colorize_mask");
                 addActionToMenu(addLayerMenu, "add_new_transform_mask");
                 addActionToMenu(addLayerMenu, "add_new_selection_mask");
                 addLayerMenu->addSeparator();
                 addActionToMenu(addLayerMenu, "add_new_clone_layer");
 
 
                 QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
                 addActionToMenu(convertToMenu, "convert_to_paint_layer");
                 addActionToMenu(convertToMenu, "convert_to_transparency_mask");
                 addActionToMenu(convertToMenu, "convert_to_filter_mask");
                 addActionToMenu(convertToMenu, "convert_to_selection_mask");
                 addActionToMenu(convertToMenu, "convert_to_file_layer");
 
                 QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
                 addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
                 addActionToMenu(splitAlphaMenu, "split_alpha_write");
                 addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
             } else {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_clone_layer");
             }
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "pin_to_timeline");
 
             if (singleLayer) {
                 KisNodeSP node = m_filteringModel->nodeFromIndex(index);
                 if (node && !node->inherits("KisTransformMask")) {
                     addActionToMenu(&menu, "isolate_active_layer");
                     addActionToMenu(&menu, "isolate_active_group");
                 }
 
                 addActionToMenu(&menu, "selectopaque");
 
             }
         }
         menu.exec(pos);
     }
 }
 
 void LayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::MinimalMode);
 }
 
 void LayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::DetailedMode);
 }
 
 void LayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::ThumbnailMode);
 }
 
 void LayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void LayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->raiseNode();
 }
 
 void LayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->lowerNode();
 }
 
 void LayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void LayerBox::slotChangeCloneSourceClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->changeCloneSource();
 }
 
 void LayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void LayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_blockOpacityUpdate = true;
     m_nodeManager->nodeOpacityChanged(m_newOpacity);
     m_blockOpacityUpdate = false;
 }
 
 void LayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void LayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void LayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void LayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void LayerBox::slotNodeCollapsedChanged()
 {
     expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP LayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (KisNodeManager::isNodeHidden(startNode, true) &&
             startNode->parent() &&
             !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && KisNodeManager::isNodeHidden(node, true)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void LayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
     KisSelectionMaskSP globalSelectionMask;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     globalSelectionMask = m_image->rootLayer()->selectionMask();
 
     // try to find deactivated, but visible masks
     if (!globalSelectionMask) {
         KoProperties properties;
         properties.setProperty("visible", true);
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     // try to find at least any selection mask
     if (!globalSelectionMask) {
         KoProperties properties;
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     if (globalSelectionMask) {
         if (showSelections) {
             activateNode = globalSelectionMask;
         }
     }
 
     if (activateNode != lastActiveNode) {
         m_nodeManager->slotNonUiActivatedNode(activateNode);
     } else if (lastActiveNode) {
         setCurrentNode(lastActiveNode);
     }
 
     if (showSelections && !globalSelectionMask) {
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Quick Selection Mask"));
 
         applicator.applyCommand(
             new KisLayerUtils::KeepNodesSelectedCommand(
                 m_nodeManager->selectedNodes(), KisNodeList(),
                 lastActiveNode, 0, m_image, false),
             KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisLayerUtils::SelectGlobalSelectionMask(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
 
         applicator.end();
     } else if (!showSelections &&
                globalSelectionMask &&
                globalSelectionMask->selection()->selectedRect().isEmpty()) {
 
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Cancel Quick Selection Mask"));
         applicator.applyCommand(new KisSetGlobalSelectionCommand(m_image, 0), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
 }
 
 void LayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     /**
      * When the user clears the extended selection by clicking on the
      * empty area of the docker, the selection should be reset on to
      * the active layer, which might be even unselected(!).
      */
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         QModelIndex selectedIndex =
                 m_filteringModel->indexFromNode(m_nodeManager->activeNode());
 
         m_wdgLayerBox->listLayers->selectionModel()->
                 setCurrentIndex(selectedIndex, QItemSelectionModel::ClearAndSelect);
         return;
     }
 
     QList<KisNodeSP> selectedNodes;
     Q_FOREACH (const QModelIndex &idx, selection) {
         selectedNodes << m_filteringModel->nodeFromIndex(idx);
     }
 
     m_nodeManager->slotSetSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void LayerBox::slotAboutToRemoveRows(const QModelIndex &parent, int start, int end)
 {
     /**
      * Qt has changed its behavior when deleting an item. Previously
      * the selection priority was on the next item in the list, and
      * now it has shanged to the previous item. Here we just adjust
      * the selected item after the node removal. Please take care that
      * this method overrides what was done by the corresponding method
      * of QItemSelectionModel, which *has already done* its work. That
      * is why we use (start - 1) and (end + 1) in the activation
      * condition.
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=345601
      */
 
     QModelIndex currentIndex = m_wdgLayerBox->listLayers->currentIndex();
     QAbstractItemModel *model = m_filteringModel;
 
     if (currentIndex.isValid() && parent == currentIndex.parent()
             && currentIndex.row() >= start - 1 && currentIndex.row() <= end + 1) {
         QModelIndex old = currentIndex;
 
         if (model && end < model->rowCount(parent) - 1) // there are rows left below the change
             currentIndex = model->index(end + 1, old.column(), parent);
         else if (model && start > 0) // there are rows left above the change
             currentIndex = model->index(start - 1, old.column(), parent);
         else // there are no rows left in the table
             currentIndex = QModelIndex();
 
         if (currentIndex.isValid() && currentIndex != old) {
             m_wdgLayerBox->listLayers->setCurrentIndex(currentIndex);
         }
     }
 }
 
 void LayerBox::slotNodeManagerChangedSelection(const KisNodeList &nodes)
 {
     if (!m_nodeManager) return;
 
     QModelIndexList newSelection;
     Q_FOREACH(KisNodeSP node, nodes) {
         newSelection << m_filteringModel->indexFromNode(node);
     }
 
     QItemSelectionModel *model = m_wdgLayerBox->listLayers->selectionModel();
 
     if (KritaUtils::compareListsUnordered(newSelection, model->selectedIndexes())) {
         return;
     }
 
     QItemSelection selection;
     Q_FOREACH(const QModelIndex &idx, newSelection) {
         selection.select(idx, idx);
     }
 
     model->select(selection, QItemSelectionModel::ClearAndSelect);
 }
 
 void LayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::slotRenameCurrentNode()
 {
     m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::slotColorLabelChanged(int label)
 {
     KisNodeList selectedNodes = m_nodeManager->selectedNodes();
 
     Q_FOREACH(KisNodeSP selectedNode, selectedNodes) {
         //Always apply label to selected nodes..
         selectedNode->setColorLabelIndex(label);
 
         //Apply label only to unlabelled children..
         KisNodeList children = selectedNode->childNodes(QStringList(), KoProperties());
 
         auto applyLabelFunc =
                 [label](KisNodeSP child) {
             if (child->colorLabelIndex() == 0) {
                 child->setColorLabelIndex(label);
             }
         };
 
         Q_FOREACH(KisNodeSP child, children) {
             KisLayerUtils::recursiveApplyNodes(child, applyLabelFunc);
         }
     }
 }
 
 void LayerBox::updateAvailableLabels()
 {
     if (!m_image) return;
     layerFilterWidget->updateColorLabels(m_image->root());
 }
 
 void LayerBox::updateLayerFiltering()
 {
     m_filteringModel->setAcceptedLabels(layerFilterWidget->getActiveColors());
     m_filteringModel->setTextFilter(layerFilterWidget->getTextFilter());
 }
 
 void LayerBox::slotKeyframeChannelAdded(KisKeyframeChannel *channel)
 {
     if (channel->id() == KisKeyframeChannel::Opacity.id()) {
         watchOpacityChannel(channel);
     }
 }
 
 void LayerBox::watchOpacityChannel(KisKeyframeChannel *channel)
 {
     if (m_opacityChannel) {
         m_opacityChannel->disconnect(this);
     }
 
     m_opacityChannel = channel;
     if (m_opacityChannel) {
         connect(m_opacityChannel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeMoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeMoved(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeChanged(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
     }
 }
 
 void LayerBox::slotOpacityKeyframeChanged(KisKeyframeSP keyframe)
 {
     Q_UNUSED(keyframe);
     if (m_blockOpacityUpdate) return;
     updateUI();
 }
 
 void LayerBox::slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime)
 {
     Q_UNUSED(fromTime);
     slotOpacityKeyframeChanged(keyframe);
 }
 
 void LayerBox::slotImageTimeChanged(int time)
 {
     Q_UNUSED(time);
     updateUI();
 }
 
 void LayerBox::slotUpdateIcons() {
     m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowupblr"));
     m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
     m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
     m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     // call child function about needing to update icons
     m_wdgLayerBox->listLayers->slotUpdateIcons();
 }
 
 void LayerBox::slotUpdateThumbnailIconSize()
 {
     KisConfig cfg(false);
     cfg.setLayerThumbnailSize(thumbnailSizeSlider->value());
 
     // this is a hack to force the layers list to update its display and
     // re-layout all the layers with the new thumbnail size
     resize(this->width()+1, this->height()+1);
     resize(this->width()-1, this->height()-1);
 }
 
 
 #include "moc_LayerBox.cpp"
diff --git a/plugins/dockers/layerdocker/WdgLayerBox.ui b/plugins/dockers/layerdocker/WdgLayerBox.ui
index 433353ea95..9b3ca1d4e0 100644
--- a/plugins/dockers/layerdocker/WdgLayerBox.ui
+++ b/plugins/dockers/layerdocker/WdgLayerBox.ui
@@ -1,371 +1,377 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgLayerBox</class>
  <widget class="QWidget" name="WdgLayerBox">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>220</width>
     <height>384</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>
     <layout class="QHBoxLayout" name="hbox2">
      <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="KisCompositeOpComboBox" name="cmbComposite">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>20</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Blending Mode</string>
        </property>
        <property name="whatsThis">
         <string>Select the blending mode for the layer.</string>
        </property>
       </widget>
      </item>
      <item>
-      <widget class="QToolButton" name="bnLayerFilters">
+      <widget class="KisLayerFilterWidgetToolButton" name="bnLayerFilters">
        <property name="minimumSize">
         <size>
          <width>32</width>
          <height>20</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
          <width>32</width>
          <height>20</height>
         </size>
        </property>
        <property name="text">
         <string>...</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QHBoxLayout" name="opacityLayout" stretch="0,0,0">
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item>
       <widget class="QLabel" name="opacityLabel">
        <property name="text">
         <string>Opacity:</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KisDoubleSliderSpinBox" name="doubleOpacity" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Layer Opacity</string>
        </property>
        <property name="whatsThis">
         <string>Adjust the transparency of the layer</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="configureLayerDockerToolbar">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="NodeView" name="listLayers" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Expanding">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QHBoxLayout" name="hbox1" stretch="0,0,0,0,0,1,0">
      <property name="spacing">
       <number>2</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <item>
       <widget class="KisToolButton" name="bnAdd">
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>28</height>
         </size>
        </property>
        <property name="maximumSize">
         <size>
          <width>16777215</width>
          <height>28</height>
         </size>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="bnDuplicate">
        <property name="minimumSize">
         <size>
          <width>28</width>
          <height>28</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Duplicate layer or mask</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="bnLower">
        <property name="minimumSize">
         <size>
          <width>28</width>
          <height>28</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Move layer or mask down</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="bnRaise">
        <property name="minimumSize">
         <size>
          <width>28</width>
          <height>28</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Move layer or mask up</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="bnProperties">
        <property name="minimumSize">
         <size>
          <width>28</width>
          <height>28</height>
         </size>
        </property>
        <property name="toolTip">
         <string>View or change the layer properties</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="spacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::Expanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>0</width>
          <height>28</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QToolButton" name="bnDelete">
        <property name="minimumSize">
         <size>
          <width>28</width>
          <height>28</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Delete the layer or mask</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="iconSize">
         <size>
          <width>22</width>
          <height>22</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>KisCompositeOpComboBox</class>
-   <extends>QComboBox</extends>
-   <header>widgets/kis_cmb_composite.h</header>
-  </customwidget>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>KisCompositeOpComboBox</class>
+   <extends>QComboBox</extends>
+   <header>widgets/kis_cmb_composite.h</header>
   </customwidget>
   <customwidget>
    <class>NodeView</class>
    <extends></extends>
    <header location="global">NodeView.h</header>
   </customwidget>
   <customwidget>
    <class>KisToolButton</class>
    <extends>QToolButton</extends>
    <header>kis_tool_button.h</header>
   </customwidget>
+  <customwidget>
+   <class>KisLayerFilterWidgetToolButton</class>
+   <extends>QToolButton</extends>
+   <header>libs/ui/widgets/kis_layer_filter_widget.h</header>
+  </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>cmbComposite</tabstop>
   <tabstop>bnDuplicate</tabstop>
   <tabstop>bnLower</tabstop>
   <tabstop>bnRaise</tabstop>
   <tabstop>bnProperties</tabstop>
   <tabstop>bnDelete</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>