KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP > Class Template Reference

#include <kis_slider_spin_box_p.h>

Inheritance diagram for KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >:

Public Types
using	BaseSpinBoxType = BaseSpinBoxTypeTP
using	SpinBoxType = SpinBoxTypeTP
using	ValueType = decltype(std::declval<SpinBoxType>().value())
enum	ValueUpdateMode { ValueUpdateMode_NoChange , ValueUpdateMode_UseLastValidValue , ValueUpdateMode_UseValueBeforeEditing }

Public Member Functions
bool	blockInputMethodQuery (QInputMethodQueryEvent *e)
double	computeSliderWidth (double min, double max, double value) const
void	emitSignals () const
void	endEditing (ValueUpdateMode updateMode=ValueUpdateMode_UseLastValidValue)
bool	eventFilter (QObject *o, QEvent *e) override
ValueType	fastSliderStep () const
bool	isDragging () const
bool	isEditModeActive () const
bool	isSoftRangeValid () const
	KisSliderSpinBoxPrivate (SpinBoxType *q)
bool	lineEditMouseMoveEvent (QMouseEvent *e)
bool	lineEditMousePressEvent (QMouseEvent *e, bool edit)
bool	lineEditMouseReleaseEvent (QMouseEvent *e)
bool	lineEditPaintEvent (QPaintEvent *)
void	makeHardRangeActive ()
void	makeSoftRangeActive ()
QSize	minimumSizeHint () const
void	paintGenericSliderText (QPainter &painter, const QString &text, const QRectF &rect, const QRectF &sliderRect)
void	paintSlider (QPainter &painter, const QString &text, double slider01Width, double slider02Width=-1.0)
void	paintSliderRect (QPainter &painter, const QRectF &rect, const QBrush &brush)
void	paintSliderText (QPainter &painter, const QString &text, const QRectF &rect, const QRectF &clipRect, const QColor &color, const QTextOption &textOption)
QPoint	pointForValue (ValueType value) const
bool	qContextMenuEvent (QContextMenuEvent *e)
bool	qFocusOutEvent (QFocusEvent *)
bool	qKeyPressEvent (QKeyEvent *e)
bool	qMousePressEvent (QMouseEvent *)
bool	qResizeEvent (QResizeEvent *)
void	resetRangeMode ()
void	setBlockUpdateSignalOnDrag (bool newBlockUpdateSignalOnDrag)
void	setExponentRatio (double newExponentRatio)
void	setFastSliderStep (ValueType newFastSliderStep)
template<typename U = SpinBoxTypeTP, typename = typename std::enable_if<std::is_same<ValueType, double>::value, U>::type>
void	setRange (double newMinimum, double newMaximum, int newNumberOfDecimals, bool computeNewFastSliderStep)
template<typename U = SpinBoxTypeTP, typename = typename std::enable_if<std::is_same<ValueType, int>::value, U>::type>
void	setRange (int newMinimum, int newMaximum, bool computeNewFastSliderStep)
void	setSoftRange (ValueType newSoftMinimum, ValueType newSoftMaximum)
void	setValue (ValueType newValue, bool blockSignals=false, bool emitSignalsEvenWhenValueNotChanged=false, bool overwriteExpression=false)
QSize	sizeHint () const
ValueType	softMaximum () const
ValueType	softMinimum () const
void	startEditing ()
void	updateWidgetRangeToggleTooltip ()
ValueType	valueForPoint (const QPoint &p, Qt::KeyboardModifiers modifiers) const
bool	widgetRangeToggleEnterEvent (QEvent *)
bool	widgetRangeToggleLeaveEvent (QEvent *)
bool	widgetRangeToggleMouseReleaseEvent (QMouseEvent *e)
bool	widgetRangeTogglePaintEvent (QPaintEvent *)

Private Types
enum	SoftRangeViewMode { SoftRangeViewMode_AlwaysShowSoftRange , SoftRangeViewMode_ShowBothRanges }

Private Attributes
bool	m_blockUpdateSignalOnDrag {false}
double	m_exponentRatio {1.0}
ValueType	m_fastSliderStep {static_cast<ValueType>(5)}
bool	m_focusLostDueToMenu {false}
bool	m_isDragging {false}
bool	m_isSoftRangeActive {true}
QPoint	m_lastMousePressPosition
QLineEdit *	m_lineEdit {nullptr}
SpinBoxType *	m_q {nullptr}
QVariantAnimation	m_rangeToggleHoverAnimation
int	m_relativeDraggingOffset {0}
int	m_rightClickCounter {0}
QVariantAnimation	m_sliderAnimation
ValueType	m_softMaximum {static_cast<ValueType>(0)}
ValueType	m_softMinimum {static_cast<ValueType>(0)}
SignalToFunctionProxy	m_startEditingSignalProxy
bool	m_useRelativeDragging {false}
ValueType	m_valueBeforeEditing {static_cast<ValueType>(0)}
QWidget *	m_widgetRangeToggle {nullptr}
enum KisSliderSpinBoxPrivate::SoftRangeViewMode	SoftRangeViewMode_ShowBothRanges

Static Private Attributes
static constexpr double	constantDraggingMargin {32.0}
static constexpr double	fullAnimationDuration {200.0}
static constexpr double	heightOfCollapsedSlider {3.0}
static constexpr double	heightOfSpaceBetweenSliders {0.0}
static constexpr double	widthOfRangeModeToggle {16.0}

Detailed Description

template<typename SpinBoxTypeTP, typename BaseSpinBoxTypeTP>
class KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >

Definition at line 44 of file kis_slider_spin_box_p.h.

Member Typedef Documentation

BaseSpinBoxType

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

using KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::BaseSpinBoxType = BaseSpinBoxTypeTP

Definition at line 48 of file kis_slider_spin_box_p.h.

SpinBoxType

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

using KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::SpinBoxType = SpinBoxTypeTP

Definition at line 47 of file kis_slider_spin_box_p.h.

ValueType

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

using KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::ValueType = decltype(std::declval<SpinBoxType>().value())

Definition at line 49 of file kis_slider_spin_box_p.h.

Member Enumeration Documentation

SoftRangeViewMode

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

enum KisSliderSpinBoxPrivate::SoftRangeViewMode

private

Enumerator
SoftRangeViewMode_AlwaysShowSoftRange
SoftRangeViewMode_ShowBothRanges

Definition at line 953 of file kis_slider_spin_box_p.h.

    {
        SoftRangeViewMode_AlwaysShowSoftRange,
        SoftRangeViewMode_ShowBothRanges
    } m_softRangeViewMode{SoftRangeViewMode_ShowBothRanges};

ValueUpdateMode

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

enum KisSliderSpinBoxPrivate::ValueUpdateMode

Enumerator
ValueUpdateMode_NoChange
ValueUpdateMode_UseLastValidValue
ValueUpdateMode_UseValueBeforeEditing

Definition at line 51 of file kis_slider_spin_box_p.h.

    {
        ValueUpdateMode_NoChange,
        ValueUpdateMode_UseLastValidValue,
        ValueUpdateMode_UseValueBeforeEditing
    };

Constructor & Destructor Documentation

KisSliderSpinBoxPrivate()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::KisSliderSpinBoxPrivate ( SpinBoxType * q )

inline

Definition at line 58 of file kis_slider_spin_box_p.h.

        : m_q(q)
        , m_lineEdit(m_q->lineEdit())
        , m_startEditingSignalProxy(std::bind(&KisSliderSpinBoxPrivate::startEditing, this))
    {
        m_q->installEventFilter(this);
 
        m_lineEdit->setReadOnly(true);
        m_lineEdit->setAlignment(Qt::AlignCenter);
        m_lineEdit->setAutoFillBackground(false);
        m_lineEdit->setCursor(KisCursor::splitHCursor());
        m_lineEdit->installEventFilter(this);
 
        m_widgetRangeToggle = new QWidget(m_q);
        m_widgetRangeToggle->hide();
        m_widgetRangeToggle->installEventFilter(this);
 
        m_sliderAnimation.setStartValue(0.0);
        m_sliderAnimation.setEndValue(1.0);
        m_sliderAnimation.setEasingCurve(QEasingCurve(QEasingCurve::InOutCubic));
        connect(&m_sliderAnimation, &QVariantAnimation::valueChanged, m_lineEdit, QOverload<>::of(&QLineEdit::update));
        connect(&m_sliderAnimation, &QVariantAnimation::valueChanged, m_widgetRangeToggle, QOverload<>::of(&QLineEdit::update));
 
        m_rangeToggleHoverAnimation.setStartValue(0.0);
        m_rangeToggleHoverAnimation.setEndValue(1.0);
        m_rangeToggleHoverAnimation.setEasingCurve(QEasingCurve(QEasingCurve::InOutCubic));
        connect(&m_rangeToggleHoverAnimation, &QVariantAnimation::valueChanged, m_widgetRangeToggle, QOverload<>::of(&QLineEdit::update));
    }

References KisCursor::splitHCursor().

Member Function Documentation

blockInputMethodQuery()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::blockInputMethodQuery ( QInputMethodQueryEvent * e )

inline

Definition at line 580 of file kis_slider_spin_box_p.h.

    {
        // On Android, pressing on a text input shows text selection handles,
        // see QAndroidInputContext::updateSelectionHandles. We don't want that
        // if a slider is not in edit mode, so we respond with "not enabled".
        if (e->queries().testFlag(Qt::ImEnabled) && !isEditModeActive()) {
            e->setValue(Qt::ImEnabled, false);
            e->accept();
            return true;
        } else {
            return false;
        }
    }

computeSliderWidth()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

double KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::computeSliderWidth ( double min, double max, double value ) const

inline

Definition at line 679 of file kis_slider_spin_box_p.h.

    {
        const double rangeSize = max - min;
        const double localPosition = value - min;
        const double normalizedValue = std::pow(localPosition / rangeSize, 1.0 / m_exponentRatio);
        const double width = static_cast<double>(m_lineEdit->width());
        return qBound(0.0, std::round(normalizedValue * width), width);
    }

References value().

emitSignals()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::emitSignals ( ) const

inline

Definition at line 400 of file kis_slider_spin_box_p.h.

    {
#if QT_VERSION >= QT_VERSION_CHECK(5,14,0)
        Q_EMIT m_q->textChanged(m_q->text());
#else
        Q_EMIT m_q->valueChanged(m_q->text());
#endif
        Q_EMIT m_q->valueChanged(m_q->value());
    }

endEditing()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::endEditing ( ValueUpdateMode updateMode = ValueUpdateMode_UseLastValidValue )

inline

Definition at line 100 of file kis_slider_spin_box_p.h.

    {
        if (!isEditModeActive()) {
            return;
        }
        if (updateMode == ValueUpdateMode_UseLastValidValue) {
            setValue(m_q->value(), false, false, true);
        } else if (updateMode == ValueUpdateMode_UseValueBeforeEditing) {
            setValue(m_valueBeforeEditing, false, false, true);
        }
        // Restore palette colors
        QPalette pal = m_lineEdit->palette();
        pal.setBrush(QPalette::Text, m_q->palette().text());
        m_lineEdit->setPalette(pal);
        m_rightClickCounter = 0;
        m_lineEdit->setReadOnly(true);
        m_lineEdit->setCursor(KisCursor::splitHCursor());
        m_lineEdit->update();
        m_q->update();
    }

References KisCursor::splitHCursor().

eventFilter()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::eventFilter ( QObject * o, QEvent * e )

inlineoverride

Definition at line 883 of file kis_slider_spin_box_p.h.

    {
        if (!o || !e) {
            return false;
        }
        if (o == m_q) {
            switch (e->type()) {
                case QEvent::Resize : return qResizeEvent(static_cast<QResizeEvent*>(e));
                case QEvent::FocusOut : return qFocusOutEvent(static_cast<QFocusEvent*>(e));
                case QEvent::MouseButtonPress : return qMousePressEvent(static_cast<QMouseEvent*>(e));
                case QEvent::KeyPress : return qKeyPressEvent(static_cast<QKeyEvent*>(e));
                case QEvent::ContextMenu : return qContextMenuEvent(static_cast<QContextMenuEvent*>(e));
                case QEvent::InputMethodQuery: return blockInputMethodQuery(static_cast<QInputMethodQueryEvent *>(e));
                default: break;
            }
        } else if (o == m_lineEdit) {
            switch (e->type()) {
                case QEvent::Paint : return lineEditPaintEvent(static_cast<QPaintEvent*>(e));
                case QEvent::MouseButtonPress : return lineEditMousePressEvent(static_cast<QMouseEvent*>(e), false);
                case QEvent::MouseButtonDblClick : return lineEditMousePressEvent(static_cast<QMouseEvent*>(e), true);
                case QEvent::MouseButtonRelease : return lineEditMouseReleaseEvent(static_cast<QMouseEvent*>(e));
                case QEvent::MouseMove : return lineEditMouseMoveEvent(static_cast<QMouseEvent*>(e));
                default: break;
            }
        } else if (o == m_widgetRangeToggle) {
            switch (e->type()) {
                case QEvent::Paint : return widgetRangeTogglePaintEvent(static_cast<QPaintEvent*>(e));
                case QEvent::MouseButtonRelease: return widgetRangeToggleMouseReleaseEvent(static_cast<QMouseEvent*>(e));
                case QEvent::Enter: return widgetRangeToggleEnterEvent(e);
                case QEvent::Leave: return widgetRangeToggleLeaveEvent(e);
                case QEvent::InputMethodQuery: return blockInputMethodQuery(static_cast<QInputMethodQueryEvent *>(e));
                default: break;
            }
        }
        return false;
    }

fastSliderStep()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::fastSliderStep ( ) const

inline

Definition at line 316 of file kis_slider_spin_box_p.h.

    {
        return m_fastSliderStep;
    }

isDragging()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::isDragging ( ) const

inline

Definition at line 331 of file kis_slider_spin_box_p.h.

    {
        return m_isDragging;
    }

isEditModeActive()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::isEditModeActive ( ) const

inline

Definition at line 121 of file kis_slider_spin_box_p.h.

    {
        return !m_lineEdit->isReadOnly();
    }

isSoftRangeValid()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::isSoftRangeValid ( ) const

inline

Definition at line 311 of file kis_slider_spin_box_p.h.

    {
        return m_softMaximum > m_softMinimum;
    }

lineEditMouseMoveEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::lineEditMouseMoveEvent ( QMouseEvent * e )

inline

Definition at line 791 of file kis_slider_spin_box_p.h.

    {
        if (!m_q->isEnabled()) {
            return false;
        }
        if (!isEditModeActive()) {
            if (e->buttons() & Qt::LeftButton) {
                m_isDragging = true;
                // At this point we are dragging so record the position and set
                // the value
                const QPoint p(m_useRelativeDragging ? e->pos().x() + m_relativeDraggingOffset : e->pos().x(),
                               e->pos().y());
                setValue(valueForPoint(p, e->modifiers()), m_blockUpdateSignalOnDrag);
                return true;
            }
        }
        return false;
    }

References p.

lineEditMousePressEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::lineEditMousePressEvent ( QMouseEvent * e, bool edit )

inline

Definition at line 733 of file kis_slider_spin_box_p.h.

    {
        if (!m_q->isEnabled()) {
            return false;
        }
        if (!isEditModeActive()) {
            if (e->button() == Qt::LeftButton) {
                m_lastMousePressPosition = e->pos();
                const QPoint currentValuePosition = pointForValue(m_q->value());
                m_relativeDraggingOffset = currentValuePosition.x() - e->x();
                m_useRelativeDragging = (e->modifiers() & Qt::ShiftModifier);
                if (edit) {
                    QTimer::singleShot(0, &m_startEditingSignalProxy, SLOT(start()));
                } else {
                    lineEditMouseMoveEvent(e);
                }
            }
            return true;
        }
        return false;
    }

lineEditMouseReleaseEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::lineEditMouseReleaseEvent ( QMouseEvent * e )

inline

Definition at line 755 of file kis_slider_spin_box_p.h.

    {
        if (!m_q->isEnabled()) {
            return false;
        }
        if (!isEditModeActive()) {
            // Releasing the right mouse button makes the lineedit enter
            // the edition mode if we are not editing
            if (e->button() == Qt::RightButton) {
                // If we call startEditing() right from the eventFilter(),
                // then the mouse release event will be somehow be passed
                // to Qt further and generate ContextEvent on Windows.
                // Therefore we should call it from a normal timer event.
                QTimer::singleShot(0, &m_startEditingSignalProxy, SLOT(start()));
            // Releasing the left mouse button stops the dragging. If signals
            // must be blocked when dragging then we set the value here and
            // Q_EMIT a signal
            } else if (e->button() == Qt::LeftButton) {
                if (m_blockUpdateSignalOnDrag) {
                    const QPoint p(m_useRelativeDragging ? e->pos().x() + m_relativeDraggingOffset : e->pos().x(),
                                   e->pos().y());
                    setValue(valueForPoint(p, e->modifiers()), false, true);
                } else {
                    if (!m_isDragging) {
                        setValue(valueForPoint(e->pos(), e->modifiers()), false, true);
                    }
                }
 
                m_isDragging = false;
                Q_EMIT m_q->draggingFinished();
            }
            return true;
        }
        return false;
    }

References p.

lineEditPaintEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::lineEditPaintEvent ( QPaintEvent * )

inline

Definition at line 688 of file kis_slider_spin_box_p.h.

    {
        QPainter painter(m_lineEdit);
        painter.setRenderHint(QPainter::Antialiasing, true);
 
        const double value = m_q->value();
        
        // If we are not editing, just draw the text, otherwise draw a 
        // semi-transparent rect to dim the background and let the QLineEdit
        // draw the rest (text, selection, cursor, etc.)
        const double hardSliderWidth = computeSliderWidth(static_cast<double>(m_q->minimum()), static_cast<double>(m_q->maximum()), value);
        const double softSliderWidth = computeSliderWidth(m_softMinimum, m_softMaximum, value);
        if (!isEditModeActive()) {
            QString text = m_q->text();
            if (isSoftRangeValid()) {
                if (m_softRangeViewMode == SoftRangeViewMode_AlwaysShowSoftRange) {
                    paintSlider(painter, text, softSliderWidth);
                } else {
                    paintSlider(painter, text, hardSliderWidth, softSliderWidth);
                }
            } else {
                // Draw the slider
                paintSlider(painter, text, hardSliderWidth);
            }
        } else {
            // Draw the slider
            if (isSoftRangeValid()) {
                if (m_softRangeViewMode == SoftRangeViewMode_AlwaysShowSoftRange) {
                    paintSlider(painter, QString(), softSliderWidth);
                } else {
                    paintSlider(painter, QString(), hardSliderWidth, softSliderWidth);
                }
            } else {
                paintSlider(painter, QString(), hardSliderWidth);
            }
            // Paint the overlay with the base color
            QColor color = m_q->palette().base().color();
            color.setAlpha(128);
            paintSliderRect(painter, m_lineEdit->rect(), color);
        }
        // If we are editing the text then return false and let the QLineEdit
        // paint all the edit related stuff (e.g. selection)
        return !isEditModeActive();
    }

References value().

makeHardRangeActive()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::makeHardRangeActive ( )

inline

Definition at line 349 of file kis_slider_spin_box_p.h.

    {
        m_sliderAnimation.stop();
        m_isSoftRangeActive = false;
        // scale the duration in case the animation is in the middle
        const int animationDuration =
            static_cast<int>(std::round((1.0 - m_sliderAnimation.currentValue().toReal()) * fullAnimationDuration));
        m_sliderAnimation.setStartValue(m_sliderAnimation.currentValue());
        m_sliderAnimation.setEndValue(1.0);
        m_sliderAnimation.setDuration(animationDuration);
        m_sliderAnimation.start();
    }

makeSoftRangeActive()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::makeSoftRangeActive ( )

inline

Definition at line 336 of file kis_slider_spin_box_p.h.

    {
        m_sliderAnimation.stop();
        m_isSoftRangeActive = true;
        // scale the animation duration in case the animation is in the middle
        const int animationDuration =
            static_cast<int>(std::round(m_sliderAnimation.currentValue().toReal() * fullAnimationDuration));
        m_sliderAnimation.setStartValue(m_sliderAnimation.currentValue());
        m_sliderAnimation.setEndValue(0.0);
        m_sliderAnimation.setDuration(animationDuration);
        m_sliderAnimation.start();
    }

minimumSizeHint()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QSize KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::minimumSizeHint ( ) const

inline

Definition at line 391 of file kis_slider_spin_box_p.h.

    {
        QSize hint = m_q->BaseSpinBoxType::minimumSizeHint();
        return
            (isSoftRangeValid() && m_softRangeViewMode == SoftRangeViewMode_ShowBothRanges)
            ? QSize(hint.width() + widthOfRangeModeToggle, hint.height())
            : hint;
    }

paintGenericSliderText()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::paintGenericSliderText ( QPainter & painter, const QString & text, const QRectF & rect, const QRectF & sliderRect )

inline

Definition at line 618 of file kis_slider_spin_box_p.h.

    {
        QTextOption textOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter);
        textOption.setWrapMode(QTextOption::NoWrap);
        // Draw portion of the text that is over the background
        paintSliderText(painter, text, rect, rect.adjusted(sliderRect.width(), 0, 0, 0), m_lineEdit->palette().text().color(), textOption);
        // Draw portion of the text that is over the progress bar
        paintSliderText(painter, text, rect, sliderRect, m_lineEdit->palette().highlightedText().color(), textOption);
    };

paintSlider()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::paintSlider ( QPainter & painter, const QString & text, double slider01Width, double slider02Width = -1.0 )

inline

Definition at line 628 of file kis_slider_spin_box_p.h.

    {
        const QRectF rect = m_lineEdit->rect();
        const QColor highlightColor = m_q->palette().highlight().color();
        if (slider02Width < 0.0) {
            const QRectF sliderRect = rect.adjusted(0, 0, -(rect.width() - slider01Width), 0);
            paintSliderRect(painter, sliderRect, highlightColor);
            if (!text.isNull()) {
                paintGenericSliderText(painter, text, rect, sliderRect);
            }
        } else {
            static constexpr double heightOfCollapsedSliderPlusSpace = heightOfCollapsedSlider + heightOfSpaceBetweenSliders;
            const double heightBetween = rect.height() - 2.0 * heightOfCollapsedSlider - heightOfSpaceBetweenSliders;
            const double animationPos = m_sliderAnimation.currentValue().toReal();
            const double a = heightOfCollapsedSliderPlusSpace;
            const double b = heightOfCollapsedSliderPlusSpace + heightBetween;
            // Paint background text
            QTextOption textOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter);
            textOption.setWrapMode(QTextOption::NoWrap);
            paintSliderText(painter, text, rect, rect, m_lineEdit->palette().text().color(), textOption);
            // Paint soft range slider
            const QColor softSliderColor = KisPaintingTweaks::blendColors(highlightColor, m_q->palette().base().color(), 1.0 - 0.25);
            const double softSliderAdjustment = -KisAlgebra2D::lerp(a, b, animationPos);
            paintSliderRect(
                painter,
                rect.adjusted(0, 0, -(rect.width() - slider02Width), softSliderAdjustment),
                softSliderColor
            );
            // Paint hard range slider
            const double hardSliderAdjustment = KisAlgebra2D::lerp(a, b, 1.0 - animationPos);
            paintSliderRect(
                painter,
                rect.adjusted(0, hardSliderAdjustment, -(rect.width() - slider01Width), 0),
                highlightColor
            );
            // Paint text in the sliders
            paintSliderText(
                painter, text, rect,
                rect.adjusted(0, 0, -(rect.width() - slider02Width), softSliderAdjustment),
                m_lineEdit->palette().highlightedText().color(),
                textOption
            );
            paintSliderText(
                painter, text, rect,
                rect.adjusted(0, hardSliderAdjustment, -(rect.width() - slider01Width), 0),
                m_lineEdit->palette().highlightedText().color(),
                textOption
            );
        }
    }

References KisPaintingTweaks::blendColors(), and KisAlgebra2D::lerp().

paintSliderRect()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::paintSliderRect ( QPainter & painter, const QRectF & rect, const QBrush & brush )

inline

Definition at line 595 of file kis_slider_spin_box_p.h.

    {
        painter.save();
        painter.setBrush(brush);
        painter.setPen(Qt::NoPen);
        if (qApp->property(currentUnderlyingStyleNameProperty).toString().toLower() == "fusion") {
            painter.drawRoundedRect(rect, 1, 1);
        } else {
            painter.drawRoundedRect(rect, 0, 0);
        }
        painter.restore();
    }

References currentUnderlyingStyleNameProperty.

paintSliderText()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::paintSliderText ( QPainter & painter, const QString & text, const QRectF & rect, const QRectF & clipRect, const QColor & color, const QTextOption & textOption )

inline

Definition at line 608 of file kis_slider_spin_box_p.h.

    {
        painter.setBrush(Qt::NoBrush);
        painter.setPen(color);
        painter.setClipping(true);
        painter.setClipRect(clipRect);
        painter.drawText(rect, text, textOption);
        painter.setClipping(false);
    };

pointForValue()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QPoint KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::pointForValue ( ValueType value ) const

inline

Definition at line 186 of file kis_slider_spin_box_p.h.

    {
        ValueType min, max;
        if (isSoftRangeValid()) {
            if (m_softRangeViewMode == SoftRangeViewMode_ShowBothRanges) {
                if (m_isSoftRangeActive) {
                    min = softMinimum();
                    max = softMaximum();
                } else {
                    min = m_q->minimum();
                    max = m_q->maximum();
                }
            } else {
                min = softMinimum();
                max = softMaximum();
            }
        } else {
            min = m_q->minimum();
            max = m_q->maximum();
        }
        return QPoint(static_cast<int>(qRound(computeSliderWidth(min, max, value))), 0);
    }

References value().

qContextMenuEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::qContextMenuEvent ( QContextMenuEvent * e )

inline

Definition at line 518 of file kis_slider_spin_box_p.h.

    {
        // Shows a menu. Code inspired by the QAbstractSpinBox
        // contextMenuEvent function
        
        // Return if we are in slider mode and the mouse is in the line edit
        if (!isEditModeActive() && m_lineEdit->rect().contains(e->pos())) {
            return true;
        }
        // Create the menu
        QPointer<QMenu> menu;
        // If we are in edit mode, then add the line edit
        // actions
        if (isEditModeActive()) {
            menu = m_lineEdit->createStandardContextMenu();
            m_focusLostDueToMenu = true;
        } else {
            menu = new QMenu;
        }
        if (!menu) {
            return true;
        }
        // Override select all action
        QAction *selectAllAction = nullptr;
        if (isEditModeActive()) {
            selectAllAction = new QAction(i18nc("Menu action to select all text in the slider spin box", "&Select All"), menu);
#if QT_CONFIG(shortcut)
            selectAllAction->setShortcut(QKeySequence::SelectAll);
#endif
            menu->removeAction(menu->actions().last());
            menu->addAction(selectAllAction);
            menu->addSeparator();
        }
        // Add step up and step down actions
        const uint stepEnabled = m_q->stepEnabled();
        QAction *stepUpAction = menu->addAction(i18nc("Menu action to step up in the slider spin box", "&Step up"));
        stepUpAction->setEnabled(stepEnabled & SpinBoxType::StepUpEnabled);
        QAction *stepDown = menu->addAction(i18nc("Menu action to step down in the slider spin box", "Step &down"));
        stepDown->setEnabled(stepEnabled & SpinBoxType::StepDownEnabled);
        menu->addSeparator();
        // This code is taken from QAbstractSpinBox. Use a QPointer in case the
        // spin box is destroyed while the menu is shown??
        const QPointer<SpinBoxType> spinbox = m_q;
        const QPoint pos =
            (e->reason() == QContextMenuEvent::Mouse)
            ? e->globalPos()
            : m_q->mapToGlobal(QPoint(e->pos().x(), 0)) + QPoint(m_q->width() / 2, m_q->height() / 2);
        const QAction *action = menu->exec(pos);
        delete static_cast<QMenu *>(menu);
        if (spinbox && action) {
            if (action == stepUpAction) {
                m_q->stepBy(static_cast<ValueType>(1));
            } else if (action == stepDown) {
                m_q->stepBy(static_cast<ValueType>(-1));
            } else if (action == selectAllAction) {
                m_q->selectAll();
            }
        }
        e->accept();
        return true;
    }

qFocusOutEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::qFocusOutEvent ( QFocusEvent * )

inline

Definition at line 438 of file kis_slider_spin_box_p.h.

    {
        // If the focus is lost then the edition stops, unless the focus
        // was lost because the menu was shown
        if (m_focusLostDueToMenu) {
            m_focusLostDueToMenu = false;
        } else {
            if (m_q->isLastValid()) {
                endEditing();
            }
        }
        return false;
    }

qKeyPressEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::qKeyPressEvent ( QKeyEvent * e )

inline

Definition at line 460 of file kis_slider_spin_box_p.h.

    {
        switch (e->key()) {
            // If the lineedit is not in edition mode, make the left and right
            // keys have the same effect as the down and up keys. This replicates
            // the behaviour of the old slider spinbox
            case Qt::Key_Right:
                if (!isEditModeActive()) {
                    qApp->postEvent(m_q, new QKeyEvent(QEvent::KeyPress, Qt::Key_Up, e->modifiers()));
                    return true;
                }
                break;
            case Qt::Key_Left:
                if (!isEditModeActive()) {
                    qApp->postEvent(m_q, new QKeyEvent(QEvent::KeyPress, Qt::Key_Down, e->modifiers()));
                    return true;
                }
                break;
            // The enter key can be used to enter the edition mode if the
            // lineedit is not in it or to commit the entered value and leave
            // the edition mode if we are in it
            case Qt::Key_Enter:
            case Qt::Key_Return:
                if (!e->isAutoRepeat()) {
                    if (!isEditModeActive()) {
                        startEditing();
                    } else {
                        if (m_q->isLastValid()) {
                            endEditing();
                        } else {
                            return false;
                        }
                    }
                }
                return true;
            // The escape key can be used to leave the edition mode rejecting
            // the written value 
            case Qt::Key_Escape:
                if (isEditModeActive()) {
                    endEditing(ValueUpdateMode_UseValueBeforeEditing);
                    return true;
                }
                break;
            // If we press a number key when in slider mode, then start the edit
            // mode and resend the key event so that the key is processed again
            // in edit mode. Since entering edit mode selects all text, the new
            // event will replace the text by the new key text
            default:
                if (!isEditModeActive() && e->key() >= Qt::Key_0 && e->key() <= Qt::Key_9) {
                    startEditing();
                    qApp->postEvent(m_q, new QKeyEvent(QEvent::KeyPress, e->key(), e->modifiers(), e->text(), e->isAutoRepeat()));
                    return true;
                }
                break;
        }
        return false;
    }

qMousePressEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::qMousePressEvent ( QMouseEvent * )

inline

Definition at line 452 of file kis_slider_spin_box_p.h.

    {
        // If we click in any part of the spinbox outside the lineedit
        // then the edition stops
        endEditing();
        return false;
    }

qResizeEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::qResizeEvent ( QResizeEvent * )

inline

Definition at line 410 of file kis_slider_spin_box_p.h.

    {
        // When resizing the spinbox, perform style specific positioning
        // of the lineedit
        
        // Get the default rect for the lineedit widget
        QStyleOptionSpinBox spinBoxOptions;
        m_q->initStyleOption(&spinBoxOptions);
        QRect rect = m_q->style()->subControlRect(QStyle::CC_SpinBox, &spinBoxOptions, QStyle::SC_SpinBoxEditField);
        // Offset the rect to make it take all the available space inside the
        // spinbox, without overlapping the buttons
        QString style = qApp->property(currentUnderlyingStyleNameProperty).toString().toLower();
        if (style == "breeze") {
            rect.adjust(-4, -4, 0, 4);
        } else if (style == "fusion") {
            rect.adjust(-2, -1, 2, 1);
        }
        // Set the rect
        if (isSoftRangeValid() && m_softRangeViewMode == SoftRangeViewMode_ShowBothRanges) {
            m_lineEdit->setGeometry(rect.adjusted(0, 0, -widthOfRangeModeToggle, 0));
            m_widgetRangeToggle->setGeometry(rect.adjusted(rect.width() - widthOfRangeModeToggle, 0, 0, 0));
        } else {
            m_lineEdit->setGeometry(rect);
        }
 
        return true;
    }

References currentUnderlyingStyleNameProperty.

resetRangeMode()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::resetRangeMode ( )

inline

Definition at line 231 of file kis_slider_spin_box_p.h.

    {
        if (isSoftRangeValid() && m_softRangeViewMode == SoftRangeViewMode_ShowBothRanges) {
            if (m_isSoftRangeActive) {
                makeSoftRangeActive();
            } else {
                makeHardRangeActive();
            }
            updateWidgetRangeToggleTooltip();
            m_widgetRangeToggle->show();
        } else {
            m_sliderAnimation.stop();
            m_widgetRangeToggle->hide();
        }
        qResizeEvent(nullptr);
    }

setBlockUpdateSignalOnDrag()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::setBlockUpdateSignalOnDrag ( bool newBlockUpdateSignalOnDrag )

inline

Definition at line 287 of file kis_slider_spin_box_p.h.

    {
        m_blockUpdateSignalOnDrag = newBlockUpdateSignalOnDrag;
    }

setExponentRatio()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::setExponentRatio ( double newExponentRatio )

inline

Definition at line 362 of file kis_slider_spin_box_p.h.

    {
        m_exponentRatio = newExponentRatio;
        m_lineEdit->update();
    }

setFastSliderStep()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::setFastSliderStep ( ValueType newFastSliderStep )

inline

Definition at line 292 of file kis_slider_spin_box_p.h.

    {
        m_fastSliderStep = newFastSliderStep;
    }

setRange() [1/2]

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

template<typename U = SpinBoxTypeTP, typename = typename std::enable_if<std::is_same<ValueType, double>::value, U>::type>

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::setRange ( double newMinimum, double newMaximum, int newNumberOfDecimals, bool computeNewFastSliderStep )

inline

Definition at line 266 of file kis_slider_spin_box_p.h.

    {
        m_q->setDecimals(newNumberOfDecimals);
        m_q->BaseSpinBoxType::setRange(newMinimum, newMaximum);
        if (computeNewFastSliderStep) {
            // Behavior taken from the old slider. Kind of arbitrary
            const double rangeSize = m_q->maximum() - m_q->minimum();
            if (rangeSize >= 2.0 || newNumberOfDecimals <= 0) {
                m_fastSliderStep = 1.0;
            } else if (newNumberOfDecimals == 1) {
                m_fastSliderStep = rangeSize / 10.0;
            } else {
                m_fastSliderStep = rangeSize / 20.0;
            }
        }
        m_softMinimum = qBound(m_q->minimum(), m_softMinimum, m_q->maximum());
        m_softMaximum = qBound(m_q->minimum(), m_softMaximum, m_q->maximum());
        resetRangeMode();
        m_lineEdit->update();
    }

setRange() [2/2]

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

template<typename U = SpinBoxTypeTP, typename = typename std::enable_if<std::is_same<ValueType, int>::value, U>::type>

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::setRange ( int newMinimum, int newMaximum, bool computeNewFastSliderStep )

inline

Definition at line 249 of file kis_slider_spin_box_p.h.

    {
        m_q->BaseSpinBoxType::setRange(newMinimum, newMaximum);
        if (computeNewFastSliderStep) {
            // Behavior taken from the old slider spinbox. Kind of arbitrary
            m_fastSliderStep = (m_q->maximum() - m_q->minimum()) / 20;
            if (m_fastSliderStep == 0) {
                m_fastSliderStep = 1;
            }
        }
        m_softMinimum = qBound(m_q->minimum(), m_softMinimum, m_q->maximum());
        m_softMaximum = qBound(m_q->minimum(), m_softMaximum, m_q->maximum());
        resetRangeMode();
        m_q->update();
    }

setSoftRange()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::setSoftRange ( ValueType newSoftMinimum, ValueType newSoftMaximum )

inline

Definition at line 299 of file kis_slider_spin_box_p.h.

    {
        if ((newSoftMinimum != newSoftMaximum) &&
            (newSoftMinimum > newSoftMaximum || newSoftMinimum < m_q->minimum() || newSoftMaximum > m_q->maximum())) {
            return;
        }
        m_softMinimum = newSoftMinimum;
        m_softMaximum = newSoftMaximum;
        resetRangeMode();
        m_lineEdit->update();
    }

setValue()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::setValue ( ValueType newValue, bool blockSignals = false, bool emitSignalsEvenWhenValueNotChanged = false, bool overwriteExpression = false )

inline

Definition at line 210 of file kis_slider_spin_box_p.h.

    {
        if (blockSignals) {
            m_q->blockSignals(true);
            m_q->BaseSpinBoxType::setValue(newValue, overwriteExpression);
            m_q->blockSignals(false);
        } else {
            ValueType v = m_q->value();
            m_q->BaseSpinBoxType::setValue(newValue, overwriteExpression);
            if (v == m_q->value() && emitSignalsEvenWhenValueNotChanged) {
                emitSignals();
            }
        }
        if (!m_q->hasFocus()) {
            endEditing(ValueUpdateMode_NoChange);
        }
    }

References v.

sizeHint()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QSize KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::sizeHint ( ) const

inline

Definition at line 382 of file kis_slider_spin_box_p.h.

    {
        QSize hint = m_q->BaseSpinBoxType::sizeHint();
        return
            (isSoftRangeValid() && m_softRangeViewMode == SoftRangeViewMode_ShowBothRanges)
            ? QSize(hint.width() + widthOfRangeModeToggle, hint.height())
            : hint;
    }

softMaximum()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::softMaximum ( ) const

inline

Definition at line 326 of file kis_slider_spin_box_p.h.

    {
        return m_softMaximum;
    }

softMinimum()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::softMinimum ( ) const

inline

Definition at line 321 of file kis_slider_spin_box_p.h.

    {
        return m_softMinimum;
    }

startEditing()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::startEditing ( )

inline

Definition at line 87 of file kis_slider_spin_box_p.h.

    {
        if (isEditModeActive()) {
            return;
        }
        // Store the current value
        m_valueBeforeEditing = m_q->value();
        m_lineEdit->setReadOnly(false);
        m_q->selectAll();
        m_lineEdit->setFocus(Qt::OtherFocusReason);
        m_lineEdit->setCursor(KisCursor::ibeamCursor());
    }

References KisCursor::ibeamCursor().

updateWidgetRangeToggleTooltip()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

void KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::updateWidgetRangeToggleTooltip ( )

inline

Definition at line 368 of file kis_slider_spin_box_p.h.

    {
        m_widgetRangeToggle->setToolTip(
            i18nc(
                "@info:tooltip toggle between soft and hard range in the slider spin box",
                "Toggle between full range and subrange.\nFull range: [%1, %2]\nSubrange: [%3, %4]",
                QString::number(m_q->minimum()),
                QString::number(m_q->maximum()),
                QString::number(m_softMinimum),
                QString::number(m_softMaximum)
            )
        );
    }

valueForPoint()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::valueForPoint ( const QPoint & p, Qt::KeyboardModifiers modifiers ) const

inline

Definition at line 128 of file kis_slider_spin_box_p.h.

    {
        const QRectF rect(m_lineEdit->rect());
        const QPointF center(
            static_cast<double>(
                m_lastMousePressPosition.x() + (m_useRelativeDragging ? m_relativeDraggingOffset : 0)
             ),
            rect.height() / 2.0
        );
        const bool useSoftRange = isSoftRangeValid() && (m_softRangeViewMode == SoftRangeViewMode_AlwaysShowSoftRange || m_isSoftRangeActive);
        const double minimum = static_cast<double>(useSoftRange ? m_softMinimum : m_q->minimum());
        const double maximum = static_cast<double>(useSoftRange ? m_softMaximum : m_q->maximum());
        const double rangeSize = maximum - minimum;
        // Get the distance relative to the line edit center and transformed
        // so that it starts counting 32px away from the widget. If the position
        // is inside the widget or that 32px area the distance will be 0 so that
        // the value change will be the same near the widget
        const double distanceY =
            std::max(
                0.0,
                std::abs(static_cast<double>(p.y()) - center.y()) - center.y() - constantDraggingMargin
            );
        // Get the scale
        double scale;
        if (modifiers & Qt::ShiftModifier) {
            // If the shift key is pressed we scale the distanceY value to make the scale
            // have a stronger effect and also offset it so that the minimum
            // scale will be 5x (1x + 4x).
            // function
            scale = (rect.width() + 2.0 * distanceY * 10.0) / rect.width() + 4.0;
        } else {
            // Get the scale as a function of the vertical position
            scale = (rect.width() + 2.0 * distanceY * 2.0) / rect.width();
        }
        // Scale the horizontal coordinates around where we first clicked 
        // as a function of the y coordinate
        const double scaledRectLeft = (0.0 - center.x()) * scale + center.x();
        const double scaledRectRight = (rect.width() - center.x()) * scale + center.x();
        // Map the current horizontal position to the new rect
        const double scaledRectWidth = scaledRectRight - scaledRectLeft;
        const double posX = static_cast<double>(p.x()) - scaledRectLeft;
        // Normalize
        const double normalizedPosX = qBound(0.0, posX / scaledRectWidth, 1.0);
        // Final value
        const double normalizedValue = std::pow(normalizedPosX, m_exponentRatio);
        double value = normalizedValue * rangeSize + minimum;
        // If key CTRL is pressed, round to the closest step.
        if (modifiers & Qt::ControlModifier) {
            value = std::round(value / m_fastSliderStep) * m_fastSliderStep;
        }
        //Return the value
        if (std::is_same<ValueType, double>::value) {
            return value;
        } else {
            return static_cast<ValueType>(std::round(value));
        }
    }

References p, and value().

widgetRangeToggleEnterEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::widgetRangeToggleEnterEvent ( QEvent * )

inline

Definition at line 857 of file kis_slider_spin_box_p.h.

    {
        m_rangeToggleHoverAnimation.stop();
        // scale the animation duration in case the animation is in the middle
        const int animationDuration =
            static_cast<int>(std::round(m_rangeToggleHoverAnimation.currentValue().toReal() * fullAnimationDuration));
        m_rangeToggleHoverAnimation.setStartValue(m_rangeToggleHoverAnimation.currentValue());
        m_rangeToggleHoverAnimation.setEndValue(1.0);
        m_rangeToggleHoverAnimation.setDuration(animationDuration);
        m_rangeToggleHoverAnimation.start();
        return false;
    }

widgetRangeToggleLeaveEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::widgetRangeToggleLeaveEvent ( QEvent * )

inline

Definition at line 870 of file kis_slider_spin_box_p.h.

    {
        m_rangeToggleHoverAnimation.stop();
        // scale the animation duration in case the animation is in the middle
        const int animationDuration =
            static_cast<int>(std::round(m_rangeToggleHoverAnimation.currentValue().toReal() * fullAnimationDuration));
        m_rangeToggleHoverAnimation.setStartValue(m_rangeToggleHoverAnimation.currentValue());
        m_rangeToggleHoverAnimation.setEndValue(0.0);
        m_rangeToggleHoverAnimation.setDuration(animationDuration);
        m_rangeToggleHoverAnimation.start();
        return false;
    }

widgetRangeToggleMouseReleaseEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::widgetRangeToggleMouseReleaseEvent ( QMouseEvent * e )

inline

Definition at line 841 of file kis_slider_spin_box_p.h.

    {
        if (!m_q->isEnabled()) {
            return false;
        }
        if (e->button() == Qt::LeftButton) {
            if (!m_isSoftRangeActive) {
                makeSoftRangeActive();
            } else {
                makeHardRangeActive();
            }
            return true;
        }
        return false;
    }

widgetRangeTogglePaintEvent()

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::widgetRangeTogglePaintEvent ( QPaintEvent * )

inline

Definition at line 810 of file kis_slider_spin_box_p.h.

    {
        QPainter painter(m_widgetRangeToggle);
        painter.setRenderHint(QPainter::Antialiasing, true);
        // Compute sizes and positions
        const double width = static_cast<double>(m_widgetRangeToggle->width());
        const double height = static_cast<double>(m_widgetRangeToggle->height());
        constexpr double marginX = 4.0;
        const double toggleWidth = width - 2.0 * marginX;
        const double centerX = width * 0.5;
        const double centerY = height * 0.5;
        const double bigRadius = centerX - std::floor(centerX - (toggleWidth * 0.5)) + 0.5;
        const double smallRadius = bigRadius * 0.5;
        const double sliderAnimationPos = m_sliderAnimation.currentValue().toReal();
        const double radius = smallRadius + sliderAnimationPos * (bigRadius - smallRadius);
        // Compute color
        const double rangeToggleHoverAnimationPos = m_rangeToggleHoverAnimation.currentValue().toReal();
        const QColor baseColor = m_q->palette().base().color();
        const QColor textColor = m_q->palette().text().color();
        const QColor color = KisPaintingTweaks::blendColors(baseColor, textColor, 1.0 - (0.60 + 0.40 * rangeToggleHoverAnimationPos));
        // Paint outer circle
        painter.setPen(color);
        painter.setBrush(Qt::NoBrush);
        painter.drawEllipse(QPointF(centerX, centerY), bigRadius, bigRadius);
        // Paint dot
        painter.setPen(Qt::NoPen);
        painter.setBrush(color);
        painter.drawEllipse(QPointF(centerX, centerY), radius, radius);
        return true;
    }

References KisPaintingTweaks::blendColors().

Member Data Documentation

constantDraggingMargin

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

constexpr double KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::constantDraggingMargin {32.0}

staticconstexprprivate

Definition at line 923 of file kis_slider_spin_box_p.h.

{32.0};

fullAnimationDuration

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

constexpr double KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::fullAnimationDuration {200.0}

staticconstexprprivate

Definition at line 931 of file kis_slider_spin_box_p.h.

{200.0};

heightOfCollapsedSlider

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

constexpr double KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::heightOfCollapsedSlider {3.0}

staticconstexprprivate

Definition at line 925 of file kis_slider_spin_box_p.h.

{3.0};

heightOfSpaceBetweenSliders

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

constexpr double KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::heightOfSpaceBetweenSliders {0.0}

staticconstexprprivate

Definition at line 927 of file kis_slider_spin_box_p.h.

{0.0};

m_blockUpdateSignalOnDrag

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_blockUpdateSignalOnDrag {false}

private

Definition at line 939 of file kis_slider_spin_box_p.h.

{false};

m_exponentRatio

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

double KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_exponentRatio {1.0}

private

Definition at line 938 of file kis_slider_spin_box_p.h.

{1.0};

m_fastSliderStep

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_fastSliderStep {static_cast<ValueType>(5)}

private

Definition at line 940 of file kis_slider_spin_box_p.h.

{static_cast<ValueType>(5)};

m_focusLostDueToMenu

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_focusLostDueToMenu {false}

private

Definition at line 947 of file kis_slider_spin_box_p.h.

{false};

m_isDragging

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_isDragging {false}

private

Definition at line 942 of file kis_slider_spin_box_p.h.

{false};

m_isSoftRangeActive

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_isSoftRangeActive {true}

private

Definition at line 948 of file kis_slider_spin_box_p.h.

{true};

m_lastMousePressPosition

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QPoint KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_lastMousePressPosition

private

Definition at line 945 of file kis_slider_spin_box_p.h.

m_lineEdit

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QLineEdit* KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_lineEdit {nullptr}

private

Definition at line 934 of file kis_slider_spin_box_p.h.

{nullptr};

m_q

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

SpinBoxType* KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_q {nullptr}

private

Definition at line 933 of file kis_slider_spin_box_p.h.

{nullptr};

m_rangeToggleHoverAnimation

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QVariantAnimation KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_rangeToggleHoverAnimation

private

Definition at line 950 of file kis_slider_spin_box_p.h.

m_relativeDraggingOffset

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

int KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_relativeDraggingOffset {0}

private

Definition at line 944 of file kis_slider_spin_box_p.h.

{0};

m_rightClickCounter

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

int KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_rightClickCounter {0}

private

Definition at line 946 of file kis_slider_spin_box_p.h.

{0};

m_sliderAnimation

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QVariantAnimation KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_sliderAnimation

private

Definition at line 949 of file kis_slider_spin_box_p.h.

m_softMaximum

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_softMaximum {static_cast<ValueType>(0)}

private

Definition at line 937 of file kis_slider_spin_box_p.h.

{static_cast<ValueType>(0)};

m_softMinimum

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_softMinimum {static_cast<ValueType>(0)}

private

Definition at line 936 of file kis_slider_spin_box_p.h.

{static_cast<ValueType>(0)};

m_startEditingSignalProxy

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

SignalToFunctionProxy KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_startEditingSignalProxy

private

Definition at line 951 of file kis_slider_spin_box_p.h.

m_useRelativeDragging

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

bool KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_useRelativeDragging {false}

private

Definition at line 943 of file kis_slider_spin_box_p.h.

{false};

m_valueBeforeEditing

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

ValueType KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_valueBeforeEditing {static_cast<ValueType>(0)}

mutableprivate

Definition at line 941 of file kis_slider_spin_box_p.h.

{static_cast<ValueType>(0)};

m_widgetRangeToggle

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

QWidget* KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::m_widgetRangeToggle {nullptr}

private

Definition at line 935 of file kis_slider_spin_box_p.h.

{nullptr};

SoftRangeViewMode_ShowBothRanges

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

enum KisSliderSpinBoxPrivate::SoftRangeViewMode KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::SoftRangeViewMode_ShowBothRanges

private

widthOfRangeModeToggle

template<typename SpinBoxTypeTP , typename BaseSpinBoxTypeTP >

constexpr double KisSliderSpinBoxPrivate< SpinBoxTypeTP, BaseSpinBoxTypeTP >::widthOfRangeModeToggle {16.0}

staticconstexprprivate

Definition at line 929 of file kis_slider_spin_box_p.h.

{16.0};

---

The documentation for this class was generated from the following files:

• libs/libkis/SliderSpinBox.h
• libs/widgetutils/kis_slider_spin_box_p.h