diff --git a/libs/pigment/resources/KoStopGradient.h b/libs/pigment/resources/KoStopGradient.h
index e9a4f31ab4..4c4d653809 100644
--- a/libs/pigment/resources/KoStopGradient.h
+++ b/libs/pigment/resources/KoStopGradient.h
@@ -1,97 +1,104 @@
 /*
     Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef KOSTOPGRADIENT_H
 #define KOSTOPGRADIENT_H
 
 #include <QPair>
 #include <QGradient>
 
 #include "KoColor.h"
 #include <resources/KoAbstractGradient.h>
 #include <resources/KoResource.h>
 #include <kritapigment_export.h>
 #include <boost/operators.hpp>
 
 typedef QPair<qreal, KoColor> KoGradientStop;
 
+struct KoGradientStopValueSort
+{
+    inline bool operator() (const KoGradientStop& a, const KoGradientStop& b) {
+        return (a.second.toQColor().valueF() < b.second.toQColor().valueF());
+    }
+};
+
 /**
  * Resource for colorstop based gradients like SVG gradients
  */
 class KRITAPIGMENT_EXPORT KoStopGradient : public KoAbstractGradient, public boost::equality_comparable<KoStopGradient>
 {
 
 public:
     explicit KoStopGradient(const QString &filename = QString());
     ~KoStopGradient() override;
 
     bool operator==(const KoStopGradient &rhs) const;
 
     KoAbstractGradient* clone() const override;
 
     bool load() override;
     bool loadFromDevice(QIODevice *dev) override;
     bool save() override;
     bool saveToDevice(QIODevice* dev) const override;
 
     /// reimplemented
     QGradient* toQGradient() const override;
 
     /// Find stops surrounding position, returns false if position outside gradient
     bool stopsAt(KoGradientStop& leftStop, KoGradientStop& rightStop, qreal t) const;
 
     /// reimplemented
     void colorAt(KoColor&, qreal t) const override;
 
     /// Creates KoStopGradient from a QGradient
     static KoStopGradient * fromQGradient(const QGradient * gradient);
 
     /// Sets the gradient stops
     void setStops(QList<KoGradientStop> stops);
     QList<KoGradientStop> stops() const;
 
     /// reimplemented
     QString defaultFileExtension() const override;
 
     /**
      * @brief toXML
      * Convert the gradient to an XML string.
      */
     void toXML(QDomDocument& doc, QDomElement& gradientElt) const;
     /**
      * @brief fromXML
      * convert a gradient from xml.
      * @return a gradient.
      */
     static KoStopGradient fromXML(const QDomElement& elt);
 
 protected:
 
     QList<KoGradientStop> m_stops;
     QPointF m_start;
     QPointF m_stop;
     QPointF m_focalPoint;
 
 private:
 
     void loadSvgGradient(QIODevice *file);
     void parseSvgGradient(const QDomElement& element);
     void parseSvgColor(QColor &color, const QString &s);
 };
 
 #endif // KOSTOPGRADIENT_H
 
diff --git a/libs/ui/kis_stopgradient_editor.cpp b/libs/ui/kis_stopgradient_editor.cpp
index bdfbdd47a9..91acaab7a4 100644
--- a/libs/ui/kis_stopgradient_editor.cpp
+++ b/libs/ui/kis_stopgradient_editor.cpp
@@ -1,197 +1,257 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *                2016 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 "kis_stopgradient_editor.h"
 #include <QPainter>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
+#include <QPoint>
+#include <QMenu>
 
 #include <KoColorSpace.h>
 #include <resources/KoStopGradient.h>
 
 #include "kis_debug.h"
 
 #include <kis_icon_utils.h>
 
 /****************************** KisStopGradientEditor ******************************/
 
 KisStopGradientEditor::KisStopGradientEditor(QWidget *parent)
     : QWidget(parent),
       m_gradient(0)
 {
     setupUi(this);
 
     connect(gradientSlider, SIGNAL(sigSelectedStop(int)), this, SLOT(stopChanged(int)));
     connect(nameedit, SIGNAL(editingFinished()), this, SLOT(nameChanged()));
     connect(colorButton, SIGNAL(changed(KoColor)), SLOT(colorChanged(KoColor)));
 
     opacitySlider->setPrefix(i18n("Opacity: "));
     opacitySlider->setRange(0.0, 1.0, 2);
     connect(opacitySlider, SIGNAL(valueChanged(qreal)), this, SLOT(opacityChanged(qreal)));
 
 
     buttonReverse->setIcon(KisIconUtils::loadIcon("view-refresh"));
     buttonReverse->setToolTip(i18n("Flip Gradient"));
     KisIconUtils::updateIcon(buttonReverse);
     connect(buttonReverse, SIGNAL(pressed()), SLOT(reverse()));
 
     buttonReverseSecond->setIcon(KisIconUtils::loadIcon("view-refresh"));
     buttonReverseSecond->setToolTip(i18n("Flip Gradient"));
     KisIconUtils::updateIcon(buttonReverseSecond);
     connect(buttonReverseSecond, SIGNAL(clicked()), SLOT(reverse()));
 
+    this->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(this, SIGNAL(customContextMenuRequested(const QPoint &)),
+            this, SLOT(showContextMenu(const QPoint &)));
+
     setCompactMode(false);
 
     setGradient(0);
     stopChanged(-1);
 }
 
 KisStopGradientEditor::KisStopGradientEditor(KoStopGradient* gradient, QWidget *parent, const char* name, const QString& caption)
     : KisStopGradientEditor(parent)
 {
     setObjectName(name);
     setWindowTitle(caption);
     setGradient(gradient);
 }
 
 void KisStopGradientEditor::setCompactMode(bool value)
 {
     lblName->setVisible(!value);
     buttonReverse->setVisible(!value);
     nameedit->setVisible(!value);
 
     buttonReverseSecond->setVisible(value);
 }
 
 void KisStopGradientEditor::setGradient(KoStopGradient *gradient)
 {
     m_gradient = gradient;
     setEnabled(m_gradient);
 
     if (m_gradient) {
         gradientSlider->setGradientResource(m_gradient);
         nameedit->setText(gradient->name());
         stopChanged(gradientSlider->selectedStop());
     }
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::notifyGlobalColorChanged(const KoColor &color)
 {
     if (colorButton->isEnabled() &&
         color != colorButton->color()) {
 
         colorButton->setColor(color);
     }
 }
 
 boost::optional<KoColor> KisStopGradientEditor::currentActiveStopColor() const
 {
     if (!colorButton->isEnabled()) return boost::none;
     return colorButton->color();
 }
 
 void KisStopGradientEditor::stopChanged(int stop)
 {
     if (!m_gradient) return;
 
     const bool hasStopSelected = stop >= 0;
 
     opacitySlider->setEnabled(hasStopSelected);
     colorButton->setEnabled(hasStopSelected);
     stopLabel->setEnabled(hasStopSelected);
 
     if (hasStopSelected) {
         KoColor color = m_gradient->stops()[stop].second;
         opacitySlider->setValue(color.opacityF());
    
         color.setOpacity(1.0);
         colorButton->setColor(color);
     }
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::colorChanged(const KoColor& color)
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
 
     int currentStop = gradientSlider->selectedStop();
     double t = stops[currentStop].first;
     
     KoColor c(color, stops[currentStop].second.colorSpace());
     c.setOpacity(stops[currentStop].second.opacityU8());
     
     stops.removeAt(currentStop);
     stops.insert(currentStop, KoGradientStop(t, c));
     
     m_gradient->setStops(stops);
     gradientSlider->update();
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::opacityChanged(qreal value)
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
 
     int currentStop = gradientSlider->selectedStop();
     double t = stops[currentStop].first;
     
     KoColor c = stops[currentStop].second;
     c.setOpacity(value);
     
     stops.removeAt(currentStop);
     stops.insert(currentStop, KoGradientStop(t, c));
     
     m_gradient->setStops(stops);
     gradientSlider->update();
 
     emit sigGradientChanged();
 }
 
 
 void KisStopGradientEditor::nameChanged()
 {
     if (!m_gradient) return;
 
     m_gradient->setName(nameedit->text());
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::reverse()
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
     QList<KoGradientStop> reversedStops;
     for(const KoGradientStop& stop : stops) {
         reversedStops.push_front(KoGradientStop(1 - stop.first, stop.second));
     }
     m_gradient->setStops(reversedStops);
     gradientSlider->setSelectedStop(stops.size() - 1 - gradientSlider->selectedStop());
 
     emit sigGradientChanged();
 }
 
+void KisStopGradientEditor::sortByValue( SortFlags flags = SORT_ASCENDING )
+{
+    if (!m_gradient) return;
+
+    bool ascending = (flags & SORT_ASCENDING) > 0;
+    bool evenDistribution = (flags & EVEN_DISTRIBUTION) > 0;
+
+    QList<KoGradientStop> stops = m_gradient->stops();
+    const int stopCount = stops.size();
+
+    QList<KoGradientStop> sortedStops;
+    std::sort(stops.begin(), stops.end(), KoGradientStopValueSort());
+
+    int stopIndex = 0;
+    for (const KoGradientStop& stop : stops) {
+        const float value = evenDistribution ? (float)stopIndex / (float)(stopCount - 1) : stop.second.toQColor().valueF();
+        const float position = ascending ? value : 1.f - value;
+
+        if (ascending) {
+            sortedStops.push_back(KoGradientStop(position, stop.second));
+        } else {
+            sortedStops.push_front(KoGradientStop(position, stop.second));
+        }
+
+        stopIndex++;
+    }
+
+    m_gradient->setStops(sortedStops);
+    gradientSlider->setSelectedStop(stopCount - 1);
+    gradientSlider->update();
+
+    emit sigGradientChanged();
+}
+
+void KisStopGradientEditor::showContextMenu(const QPoint &origin)
+{
+    QMenu contextMenu(i18n("Options"), this);
+
+    QAction reverseValues(i18n("Reverse Values"), this);
+    connect(&reverseValues, &QAction::triggered, this, &KisStopGradientEditor::reverse);
+
+    QAction sortAscendingValues(i18n("Sort by Value"), this);
+    connect(&sortAscendingValues, &QAction::triggered, this, [this]{ this->sortByValue(SORT_ASCENDING); } );
+    QAction sortAscendingDistributed(i18n("Sort by Value (Even Distribution)"), this);
+    connect(&sortAscendingDistributed, &QAction::triggered, this, [this]{ this->sortByValue(SORT_ASCENDING | EVEN_DISTRIBUTION);} );
+
+    contextMenu.addAction(&reverseValues);
+    contextMenu.addSeparator();
+    contextMenu.addAction(&sortAscendingValues);
+    contextMenu.addAction(&sortAscendingDistributed);
+
+    contextMenu.exec(mapToGlobal(origin));
+}
+
diff --git a/libs/ui/kis_stopgradient_editor.h b/libs/ui/kis_stopgradient_editor.h
index 65dfb4d335..7560e5feda 100644
--- a/libs/ui/kis_stopgradient_editor.h
+++ b/libs/ui/kis_stopgradient_editor.h
@@ -1,58 +1,68 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *                2016 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_STOPGRADIENT_EDITOR_H_
 #define _KIS_STOPGRADIENT_EDITOR_H_ 
 
 #include "kritaui_export.h"
 #include "ui_wdgstopgradienteditor.h"
 #include <boost/optional.hpp>
 
 class KoStopGradient;
 
 class KRITAUI_EXPORT KisStopGradientEditor : public QWidget, public Ui::KisWdgStopGradientEditor
 {
     Q_OBJECT
 
 public:
+    enum SortFlag {
+        SORT_ASCENDING = 1 << 0,
+        EVEN_DISTRIBUTION = 1 << 1
+    };
+    Q_DECLARE_FLAGS( SortFlags, SortFlag);
+
+
     KisStopGradientEditor(QWidget *parent);
     KisStopGradientEditor(KoStopGradient* gradient, QWidget *parent, const char* name, const QString& caption);
 
     void setCompactMode(bool value);
 
     void setGradient(KoStopGradient* gradient);
 
     void notifyGlobalColorChanged(const KoColor &color);
 
     boost::optional<KoColor> currentActiveStopColor() const;
 
 Q_SIGNALS:
     void sigGradientChanged();
 
 private:
      KoStopGradient* m_gradient;
 private Q_SLOTS:
     void stopChanged(int stop);
     void colorChanged(const KoColor& color);
     void opacityChanged(qreal value);
     void nameChanged();
     void reverse();
+    void sortByValue(SortFlags flags);
+    void showContextMenu( const class QPoint& origin );
 };
 
+Q_DECLARE_OPERATORS_FOR_FLAGS(KisStopGradientEditor::SortFlags);
 #endif
diff --git a/libs/ui/widgets/kis_stopgradient_slider_widget.cpp b/libs/ui/widgets/kis_stopgradient_slider_widget.cpp
index f319e708f6..df43af3e4b 100644
--- a/libs/ui/widgets/kis_stopgradient_slider_widget.cpp
+++ b/libs/ui/widgets/kis_stopgradient_slider_widget.cpp
@@ -1,363 +1,368 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *                2016 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 "widgets/kis_stopgradient_slider_widget.h"
 #include <QWindow>
 #include <QPainter>
 #include <QPixmap>
 #include <QMouseEvent>
 #include <QPolygon>
 #include <QPaintEvent>
 #include <QFontMetrics>
 #include <QStyle>
 #include <QApplication>
 #include <QStyleOptionToolButton>
 
 #include "kis_global.h"
 #include "kis_debug.h"
 #include "krita_utils.h"
 
 KisStopGradientSliderWidget::KisStopGradientSliderWidget(QWidget *parent, Qt::WindowFlags f)
     : QWidget(parent, f)
     , m_selectedStop(0)
     , m_drag(0)
 {
     QLinearGradient defaultGradient;
     m_defaultGradient.reset(KoStopGradient::fromQGradient(&defaultGradient));
 
     setGradientResource(0);
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
 
     setMouseTracking(true);
 
     QWindow *window = this->window()->windowHandle();
     if (window) {
         connect(window, SIGNAL(screenChanged(QScreen*)), SLOT(updateHandleSize()));
     }
     updateHandleSize();
 }
 
 void KisStopGradientSliderWidget::updateHandleSize()
 {
     QFontMetrics fm(font());
     const int h = fm.height();
     m_handleSize = QSize(0.34 * h, h);
 }
 
 int KisStopGradientSliderWidget::handleClickTolerance() const
 {
     // the size of the default text!
     return m_handleSize.width();
 }
 
 void KisStopGradientSliderWidget::setGradientResource(KoStopGradient* gradient)
 {
     m_gradient = gradient ? gradient : m_defaultGradient.data();
 
     if (m_gradient && m_selectedStop >= 0) {
         m_selectedStop = qBound(0, m_selectedStop, m_gradient->stops().size() - 1);
         emit sigSelectedStop(m_selectedStop);
     } else {
         m_selectedStop = -1;
     }
 
 }
 
 void KisStopGradientSliderWidget::paintHandle(qreal position, const QColor &color, bool isSelected, QPainter *painter)
 {
     const QRect handlesRect = this->handlesStipeRect();
 
     const int handleCenter = handlesRect.left() + position * handlesRect.width();
     const int handlesHalfWidth = handlesRect.height() * 0.26; // = 1.0 / 0.66 * 0.34 / 2.0 <-- golden ratio
 
     QPolygon triangle(3);
     triangle[0] = QPoint(handleCenter, handlesRect.top());
     triangle[1] = QPoint(handleCenter - handlesHalfWidth, handlesRect.bottom());
     triangle[2] = QPoint(handleCenter + handlesHalfWidth, handlesRect.bottom());
 
     const qreal lineWidth = 1.0;
 
     if (!isSelected) {
         painter->setPen(QPen(palette().text(), lineWidth));
         painter->setBrush(QBrush(color));
         painter->setRenderHint(QPainter::Antialiasing);
         painter->drawPolygon(triangle);
     } else {
         painter->setPen(QPen(palette().highlight(), 1.5 * lineWidth));
         painter->setBrush(QBrush(color));
         painter->setRenderHint(QPainter::Antialiasing);
         painter->drawPolygon(triangle);
     }
 }
 
 void KisStopGradientSliderWidget::paintEvent(QPaintEvent* pe)
 {
     QWidget::paintEvent(pe);
     QPainter painter(this);
     painter.setPen(Qt::black);
 
     const QRect previewRect = gradientStripeRect();
     KritaUtils::renderExactRect(&painter, kisGrowRect(previewRect, 1));
 
     painter.drawRect(previewRect);
     if (m_gradient) {
         QImage image = m_gradient->generatePreview(previewRect.width(), previewRect.height());
         if (!image.isNull()) {
             painter.drawImage(previewRect.topLeft(), image);
         }
 
         QList<KoGradientStop> handlePositions = m_gradient->stops();
         for (int i = 0; i < handlePositions.count(); i++) {
             if (i == m_selectedStop) continue;
             paintHandle(handlePositions[i].first,
                         handlePositions[i].second.toQColor(),
                         false, &painter);
         }
 
         if (m_selectedStop >= 0) {
             paintHandle(handlePositions[m_selectedStop].first,
                         handlePositions[m_selectedStop].second.toQColor(),
                         true, &painter);
         }
     }
 }
 
 int findNearestHandle(qreal t, const qreal tolerance, const QList<KoGradientStop> &stops)
 {
     int result = -1;
     qreal minDistance = tolerance;
 
     for (int i = 0; i < stops.size(); i++) {
         const KoGradientStop &stop = stops[i];
 
         const qreal distance = qAbs(t - stop.first);
         if (distance < minDistance) {
             minDistance = distance;
             result = i;
         }
     }
 
     return result;
 }
 
 
 void KisStopGradientSliderWidget::mousePressEvent(QMouseEvent * e)
 {
     if (!allowedClickRegion(handleClickTolerance()).contains(e->pos())) {
         QWidget::mousePressEvent(e);
         return;
     }
 
+    if (e->buttons() != Qt::LeftButton ) {
+        QWidget::mousePressEvent(e);
+        return;
+    }
+
     const QRect handlesRect = this->handlesStipeRect();
     const qreal t = (qreal(e->x()) - handlesRect.x()) / handlesRect.width();
     const QList<KoGradientStop> stops = m_gradient->stops();
 
     const int clickedStop = findNearestHandle(t, qreal(handleClickTolerance()) / handlesRect.width(), stops);
 
     if (clickedStop >= 0) {
         if (m_selectedStop != clickedStop) {
             m_selectedStop = clickedStop;
             emit sigSelectedStop(m_selectedStop);
         }
         m_drag = true;
     } else {
         insertStop(qBound(0.0, t, 1.0));
         m_drag = true;
     }
 
     update();
     updateCursor(e->pos());
 }
 
 void KisStopGradientSliderWidget::mouseReleaseEvent(QMouseEvent * e)
 {
      Q_UNUSED(e);
      m_drag = false;
      updateCursor(e->pos());
 }
 
 int getNewInsertPosition(const KoGradientStop &stop, const QList<KoGradientStop> &stops)
 {
     int result = 0;
 
     for (int i = 0; i < stops.size(); i++) {
         if (stop.first <= stops[i].first) break;
 
         result = i + 1;
     }
 
     return result;
 }
 
 void KisStopGradientSliderWidget::mouseMoveEvent(QMouseEvent * e)
 {
     updateCursor(e->pos());
 
     if (m_drag) {
         const QRect handlesRect = this->handlesStipeRect();
         double t = (qreal(e->x()) - handlesRect.x()) / handlesRect.width();
 
         QList<KoGradientStop> stops = m_gradient->stops();
 
         if (t < -0.1 || t > 1.1) {
             if (stops.size() > 2 && m_selectedStop >= 0) {
                 m_removedStop = stops[m_selectedStop];
                 stops.removeAt(m_selectedStop);
                 m_selectedStop = -1;
             }
         } else {
             if (m_selectedStop < 0) {
                 m_removedStop.first = qBound(0.0, t, 1.0);
                 const int newPos = getNewInsertPosition(m_removedStop, stops);
                 stops.insert(newPos, m_removedStop);
                 m_selectedStop = newPos;
             } else {
                 KoGradientStop draggedStop = stops[m_selectedStop];
                 draggedStop.first = qBound(0.0, t, 1.0);
 
                 stops.removeAt(m_selectedStop);
                 const int newPos = getNewInsertPosition(draggedStop, stops);
                 stops.insert(newPos, draggedStop);
                 m_selectedStop = newPos;
             }
         }
 
         m_gradient->setStops(stops);
         emit sigSelectedStop(m_selectedStop);
 
         update();
 
     } else {
         QWidget::mouseMoveEvent(e);
     }
 
 
 }
 
 void KisStopGradientSliderWidget::updateCursor(const QPoint &pos)
 {
     const bool isInAllowedRegion =
             allowedClickRegion(handleClickTolerance()).contains(pos);
 
     QCursor currentCursor;
 
     if (isInAllowedRegion) {
         const QRect handlesRect = this->handlesStipeRect();
         const qreal t = (qreal(pos.x()) - handlesRect.x()) / handlesRect.width();
         const QList<KoGradientStop> stops = m_gradient->stops();
 
         const int clickedStop = findNearestHandle(t, qreal(handleClickTolerance()) / handlesRect.width(), stops);
 
         if (clickedStop >= 0) {
             currentCursor = m_drag ? Qt::ClosedHandCursor : Qt::OpenHandCursor;
         }
     }
 
     if (currentCursor.shape() != Qt::ArrowCursor) {
         setCursor(currentCursor);
     } else {
         unsetCursor();
     }
 }
 
 void KisStopGradientSliderWidget::insertStop(double t)
 {
     KIS_ASSERT_RECOVER(t >= 0 && t <= 1.0 ) {
         t = qBound(0.0, t, 1.0);
     }
 
     QList<KoGradientStop> stops = m_gradient->stops();
 
     KoColor color;
     m_gradient->colorAt(color, t);
 
     const KoGradientStop stop(t, color);
     const int newPos = getNewInsertPosition(stop, stops);
 
     stops.insert(newPos, stop);
     m_gradient->setStops(stops);
 
     m_selectedStop = newPos;
     emit sigSelectedStop(m_selectedStop);
 }
 
 QRect KisStopGradientSliderWidget::sliderRect() const
 {
     return QRect(QPoint(), size()).adjusted(m_handleSize.width(), 1, -m_handleSize.width(), -1);
 }
 
 QRect KisStopGradientSliderWidget::gradientStripeRect() const
 {
     const QRect rc = sliderRect();
     return rc.adjusted(0, 0, 0, -m_handleSize.height());
 }
 
 QRect KisStopGradientSliderWidget::handlesStipeRect() const
 {
     const QRect rc = sliderRect();
     return rc.adjusted(0, rc.height() - m_handleSize.height(), 0, 0);
 }
 
 QRegion KisStopGradientSliderWidget::allowedClickRegion(int tolerance) const
 {
     QRegion result;
     result += sliderRect();
     result += handlesStipeRect().adjusted(-tolerance, 0, tolerance, 0);
     return result;
 }
 
 int KisStopGradientSliderWidget::selectedStop()
 {
     return m_selectedStop;
 }
 
 void KisStopGradientSliderWidget::setSelectedStop(int selected)
 {
     m_selectedStop = selected;
     emit sigSelectedStop(m_selectedStop);
 
     update();
 }
 
 int KisStopGradientSliderWidget::minimalHeight() const
 {
     QFontMetrics fm(font());
     const int h = fm.height();
 
     QStyleOptionToolButton opt;
     QSize sz = (style()->sizeFromContents(QStyle::CT_ToolButton, &opt, QSize(h, h), this).
                       expandedTo(QApplication::globalStrut()));
 
     return sz.height() + m_handleSize.height();
 }
 
 QSize KisStopGradientSliderWidget::sizeHint() const
 {
     const int h = minimalHeight();
     return QSize(2 * h, h);
 }
 
 QSize KisStopGradientSliderWidget::minimumSizeHint() const
 {
     const int h = minimalHeight();
     return QSize(h, h);
 }