geometrize::dialog::RangeSlider Class Reference

#include <rangeslider.h>

Inheritance diagram for geometrize::dialog::RangeSlider:

Collaboration diagram for geometrize::dialog::RangeSlider:

Public Types
enum	Option { NoHandle = 0x0, LeftHandle = 0x1, RightHandle = 0x2, DoubleHandles = LeftHandle | RightHandle }

Public Slots
void	setLowerValue (int aLowerValue)
void	setUpperValue (int aUpperValue)
void	setMinimum (int aMinimum)
void	setMaximum (int aMaximum)

Signals
void	lowerValueChanged (int aLowerValue)
void	upperValueChanged (int aUpperValue)
void	rangeChanged (int aMin, int aMax)

Public Member Functions
	RangeSlider (QWidget *aParent=Q_NULLPTR)
	RangeSlider (Qt::Orientation ori, Options t=DoubleHandles, QWidget *aParent=Q_NULLPTR)
QSize	minimumSizeHint () const override
int	GetMinimum () const
void	SetMinimum (int aMinimum)
int	GetMaximum () const
void	SetMaximum (int aMaximum)
int	GetLowerValue () const
void	SetLowerValue (int aLowerValue)
int	GetUpperValue () const
void	SetUpperValue (int aUpperValue)
void	SetRange (int aMinimum, int aMaximum)

Protected Member Functions
void	paintEvent (QPaintEvent *aEvent) override
void	mousePressEvent (QMouseEvent *aEvent) override
void	mouseMoveEvent (QMouseEvent *aEvent) override
void	mouseReleaseEvent (QMouseEvent *aEvent) override
void	changeEvent (QEvent *aEvent) override
QRectF	firstHandleRect () const
QRectF	secondHandleRect () const
QRectF	handleRect (int aValue) const

Private Member Functions
float	currentPercentage ()
int	validLength () const

Private Attributes
int	mMinimum
int	mMaximum
int	mLowerValue
int	mUpperValue
bool	mFirstHandlePressed
bool	mSecondHandlePressed
int	mInterval
int	mDelta
QColor	mBackgroudColorEnabled
QColor	mBackgroudColorDisabled
QColor	mBackgroudColor
Qt::Orientation	orientation
Options	type

Member Enumeration Documentation

Option

enum geometrize::dialog::RangeSlider::Option

Enumerator
NoHandle
LeftHandle
RightHandle
DoubleHandles

                {
        NoHandle = 0x0,
        LeftHandle = 0x1,
        RightHandle = 0x2,
        DoubleHandles = LeftHandle | RightHandle
    };

Constructor & Destructor Documentation

RangeSlider() [1/2]

geometrize::dialog::RangeSlider::RangeSlider

(

QWidget *

aParent = Q_NULLPTR

)

    : QWidget(aParent),
      mMinimum(0),
      mMaximum(100),
      mLowerValue(0),
      mUpperValue(100),
      mFirstHandlePressed(false),
      mSecondHandlePressed(false),
      mInterval(mMaximum - mMinimum),
      mBackgroudColorEnabled(QColor(0x1E, 0x90, 0xFF)),
      mBackgroudColorDisabled(Qt::darkGray),
      mBackgroudColor(mBackgroudColorEnabled),
      orientation(Qt::Horizontal)
{
    setMouseTracking(true);
}

RangeSlider() [2/2]

geometrize::dialog::RangeSlider::RangeSlider	(	Qt::Orientation	ori,
		Options	t = DoubleHandles,
		QWidget *	aParent = Q_NULLPTR
	)

    : QWidget(aParent),
      mMinimum(0),
      mMaximum(100),
      mLowerValue(0),
      mUpperValue(100),
      mFirstHandlePressed(false),
      mSecondHandlePressed(false),
      mInterval(mMaximum - mMinimum),
      mBackgroudColorEnabled(QColor(0x1E, 0x90, 0xFF)),
      mBackgroudColorDisabled(Qt::darkGray),
      mBackgroudColor(mBackgroudColorEnabled),
      orientation(ori),
      type(t)
{
    setMouseTracking(true);
}

Member Function Documentation

changeEvent()

void geometrize::dialog::RangeSlider::changeEvent ( QEvent *  aEvent )

overrideprotected

{
    if(aEvent->type() == QEvent::EnabledChange)
    {
        if(isEnabled())
        {
            mBackgroudColor = mBackgroudColorEnabled;
        }
        else
        {
            mBackgroudColor = mBackgroudColorDisabled;
        }
        update();
    }
}

currentPercentage()

float geometrize::dialog::RangeSlider::currentPercentage ( )

private

firstHandleRect()

QRectF geometrize::dialog::RangeSlider::firstHandleRect ( ) const

protected

{
    float percentage = (mLowerValue - mMinimum) * 1.0 / mInterval;
    return handleRect(percentage * validLength() + scLeftRightMargin);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetLowerValue()

int geometrize::dialog::RangeSlider::GetLowerValue

(

)

const

{
    return mLowerValue;
}

Here is the caller graph for this function:

GetMaximum()

int geometrize::dialog::RangeSlider::GetMaximum

(

)

const

{
    return mMaximum;
}

Here is the caller graph for this function:

GetMinimum()

int geometrize::dialog::RangeSlider::GetMinimum

(

)

const

{
    return mMinimum;
}

Here is the caller graph for this function:

GetUpperValue()

int geometrize::dialog::RangeSlider::GetUpperValue

(

)

const

{
    return mUpperValue;
}

Here is the caller graph for this function:

handleRect()

QRectF geometrize::dialog::RangeSlider::handleRect ( int  aValue ) const

protected

{
    if(orientation == Qt::Horizontal)
        return QRect(aValue, (height()-scHandleSideLength) / 2, scHandleSideLength, scHandleSideLength);
    else
        return QRect((width()-scHandleSideLength) / 2, aValue, scHandleSideLength, scHandleSideLength);
}

Here is the caller graph for this function:

lowerValueChanged

void geometrize::dialog::RangeSlider::lowerValueChanged ( int  aLowerValue )

signal

Here is the caller graph for this function:

minimumSizeHint()

QSize geometrize::dialog::RangeSlider::minimumSizeHint ( ) const

override

{
    return QSize(scHandleSideLength * 2 + scLeftRightMargin * 2, scHandleSideLength);
}

mouseMoveEvent()

void geometrize::dialog::RangeSlider::mouseMoveEvent ( QMouseEvent *  aEvent )

overrideprotected

{
    if(aEvent->buttons() & Qt::LeftButton)
    {
        int posValue, firstHandleRectPosValue, secondHandleRectPosValue;
        posValue = (orientation == Qt::Horizontal) ? aEvent->pos().x() : aEvent->pos().y();
        firstHandleRectPosValue = (orientation == Qt::Horizontal) ? firstHandleRect().x() : firstHandleRect().y();
        secondHandleRectPosValue = (orientation == Qt::Horizontal) ? secondHandleRect().x() : secondHandleRect().y();
 
        if(mFirstHandlePressed && type.testFlag(LeftHandle))
        {
            if(posValue - mDelta + scHandleSideLength / 2 <= secondHandleRectPosValue)
            {
                setLowerValue((posValue - mDelta - scLeftRightMargin - scHandleSideLength / 2) * 1.0 / validLength() * mInterval + mMinimum);
            }
            else
            {
                setLowerValue(mUpperValue);
            }
        }
        else if(mSecondHandlePressed && type.testFlag(RightHandle))
        {
            if(firstHandleRectPosValue + scHandleSideLength * (type.testFlag(DoubleHandles) ? 1.5 : 0.5) <= posValue - mDelta)
            {
                setUpperValue((posValue - mDelta - scLeftRightMargin - scHandleSideLength / 2 - (type.testFlag(DoubleHandles) ? scHandleSideLength : 0)) * 1.0 / validLength() * mInterval + mMinimum);
            }
            else
            {
                setUpperValue(mLowerValue);
            }
        }
    }
}

Here is the call graph for this function:

mousePressEvent()

void geometrize::dialog::RangeSlider::mousePressEvent ( QMouseEvent *  aEvent )

overrideprotected

{
    if(aEvent->button() & Qt::RightButton)
    {
        const int min = GetMinimum();
        const int max = GetMaximum();
        const int lower = GetLowerValue();
        const int upper = GetUpperValue();
 
        // Flips the space in the slider
        setLowerValue(min + (max - upper));
        setUpperValue(max - (lower - min));
    }
 
    if(aEvent->buttons() & Qt::LeftButton)
    {
        int posCheck, posMax, posValue, firstHandleRectPosValue, secondHandleRectPosValue;
        posCheck = (orientation == Qt::Horizontal) ? aEvent->pos().y() : aEvent->pos().x();
        posMax = (orientation == Qt::Horizontal) ? height() : width();
        posValue = (orientation == Qt::Horizontal) ? aEvent->pos().x() : aEvent->pos().y();
        firstHandleRectPosValue = (orientation == Qt::Horizontal) ? firstHandleRect().x() : firstHandleRect().y();
        secondHandleRectPosValue = (orientation == Qt::Horizontal) ? secondHandleRect().x() : secondHandleRect().y();
 
        mSecondHandlePressed = secondHandleRect().contains(aEvent->pos());
        mFirstHandlePressed = !mSecondHandlePressed && firstHandleRect().contains(aEvent->pos());
        if(mFirstHandlePressed)
        {
            mDelta = posValue - (firstHandleRectPosValue + scHandleSideLength / 2);
        }
        else if(mSecondHandlePressed)
        {
            mDelta = posValue - (secondHandleRectPosValue + scHandleSideLength / 2);
        }
 
        else if(posCheck >= 2
                && posCheck <= posMax - 2)
        {
            int step = mInterval / 10 < 1 ? 1 : mInterval / 10;
            if(posValue < firstHandleRectPosValue)
                setLowerValue(mLowerValue - step);
            else if(posValue > secondHandleRectPosValue + scHandleSideLength)
                setUpperValue(mUpperValue + step);
            else if(((posValue > firstHandleRectPosValue + scHandleSideLength) || !type.testFlag(LeftHandle))
                    && ((posValue < secondHandleRectPosValue) || !type.testFlag(RightHandle)))
            {
                if(type.testFlag(DoubleHandles))
                    if(posValue - (firstHandleRectPosValue + scHandleSideLength) <
                            (secondHandleRectPosValue - (firstHandleRectPosValue + scHandleSideLength)) / 2)
                        setLowerValue((mLowerValue + step < mUpperValue) ? mLowerValue + step : mUpperValue);
                    else
                        setUpperValue((mUpperValue - step > mLowerValue) ? mUpperValue - step : mLowerValue);
                else if(type.testFlag(LeftHandle))
                    setLowerValue((mLowerValue + step < mUpperValue) ? mLowerValue + step : mUpperValue);
                else if(type.testFlag(RightHandle))
                    setUpperValue((mUpperValue - step > mLowerValue) ? mUpperValue - step : mLowerValue);
            }
        }
    }
}

Here is the call graph for this function:

mouseReleaseEvent()

void geometrize::dialog::RangeSlider::mouseReleaseEvent ( QMouseEvent *  aEvent )

overrideprotected

{
    Q_UNUSED(aEvent);
 
    mFirstHandlePressed = false;
    mSecondHandlePressed = false;
}

paintEvent()

void geometrize::dialog::RangeSlider::paintEvent ( QPaintEvent *  aEvent )

overrideprotected

{
    Q_UNUSED(aEvent);
    QPainter painter(this);
 
    // Background
    QRectF backgroundRect;
    if(orientation == Qt::Horizontal)
        backgroundRect = QRectF(scLeftRightMargin, (height() - scSliderBarHeight) / 2, width() - scLeftRightMargin * 2, scSliderBarHeight);
    else
        backgroundRect = QRectF((width() - scSliderBarHeight) / 2, scLeftRightMargin, scSliderBarHeight, height() - scLeftRightMargin*2);
 
    QPen pen(Qt::gray, 0.8);
    painter.setPen(pen);
    QBrush backgroundBrush(QColor(0xD0, 0xD0, 0xD0));
    painter.setBrush(backgroundBrush);
    painter.drawRoundedRect(backgroundRect, 1, 1);
 
    // First value handle rect
    pen.setColor(Qt::darkGray);
    pen.setWidth(0.5);
    painter.setPen(pen);
    painter.setRenderHint(QPainter::Antialiasing);
    QBrush handleBrush(QColor(0xFA, 0xFA, 0xFA));
    painter.setBrush(handleBrush);
    QRectF leftHandleRect = firstHandleRect();
    if(type.testFlag(LeftHandle))
        painter.drawRoundedRect(leftHandleRect, 2, 2);
 
    // Second value handle rect
    QRectF rightHandleRect = secondHandleRect();
    if(type.testFlag(RightHandle))
        painter.drawRoundedRect(rightHandleRect, 2, 2);
 
    // Handles
    painter.setRenderHint(QPainter::Antialiasing, false);
    QRectF selectedRect(backgroundRect);
    if(orientation == Qt::Horizontal) {
        selectedRect.setLeft((type.testFlag(LeftHandle) ? leftHandleRect.right() : leftHandleRect.left()) + 0.5);
        selectedRect.setRight((type.testFlag(RightHandle) ? rightHandleRect.left() : rightHandleRect.right()) - 0.5);
    } else {
        selectedRect.setTop((type.testFlag(LeftHandle) ? leftHandleRect.bottom() : leftHandleRect.top()) + 0.5);
        selectedRect.setBottom((type.testFlag(RightHandle) ? rightHandleRect.top() : rightHandleRect.bottom()) - 0.5);
    }
    QBrush selectedBrush(mBackgroudColor);
    painter.setBrush(selectedBrush);
    painter.drawRect(selectedRect);
}

Here is the call graph for this function:

rangeChanged

void geometrize::dialog::RangeSlider::rangeChanged ( int  aMin, int  aMax  )

signal

Here is the caller graph for this function:

secondHandleRect()

QRectF geometrize::dialog::RangeSlider::secondHandleRect ( ) const

protected

{
    float percentage = (mUpperValue - mMinimum) * 1.0 / mInterval;
    return handleRect(percentage * validLength() + scLeftRightMargin + (type.testFlag(LeftHandle) ? scHandleSideLength : 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetLowerValue()

void geometrize::dialog::RangeSlider::SetLowerValue

(

int

aLowerValue

)

{
    setLowerValue(aLowerValue);
}

Here is the call graph for this function:

setLowerValue

void geometrize::dialog::RangeSlider::setLowerValue ( int  aLowerValue )

slot

{
    if(aLowerValue > mMaximum)
    {
        aLowerValue = mMaximum;
    }
 
    if(aLowerValue < mMinimum)
    {
        aLowerValue = mMinimum;
    }
 
    mLowerValue = aLowerValue;
    emit lowerValueChanged(mLowerValue);
 
    update();
}

Here is the caller graph for this function:

SetMaximum()

void geometrize::dialog::RangeSlider::SetMaximum

(

int

aMaximum

)

{
    setMaximum(aMaximum);
}

Here is the call graph for this function:

setMaximum

void geometrize::dialog::RangeSlider::setMaximum ( int  aMaximum )

slot

{
    if(aMaximum >= mMinimum)
    {
        mMaximum = aMaximum;
    }
    else
    {
        int oldMin = mMinimum;
        mMaximum = oldMin;
        mMinimum = aMaximum;
    }
    mInterval = mMaximum - mMinimum;
    update();
 
    setLowerValue(mMinimum);
    setUpperValue(mMaximum);
 
    emit rangeChanged(mMinimum, mMaximum);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetMinimum()

void geometrize::dialog::RangeSlider::SetMinimum

(

int

aMinimum

)

{
    setMinimum(aMinimum);
}

Here is the call graph for this function:

setMinimum

void geometrize::dialog::RangeSlider::setMinimum ( int  aMinimum )

slot

{
    if(aMinimum <= mMaximum)
    {
        mMinimum = aMinimum;
    }
    else
    {
        int oldMax = mMaximum;
        mMinimum = oldMax;
        mMaximum = aMinimum;
    }
    mInterval = mMaximum - mMinimum;
    update();
 
    setLowerValue(mMinimum);
    setUpperValue(mMaximum);
 
    emit rangeChanged(mMinimum, mMaximum);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetRange()

void geometrize::dialog::RangeSlider::SetRange	(	int	aMinimum,
		int	aMaximum
	)

{
    setMinimum(aMinimum);
    setMaximum(mMaximum);
}

Here is the call graph for this function:

SetUpperValue()

void geometrize::dialog::RangeSlider::SetUpperValue

(

int

aUpperValue

)

{
    setUpperValue(aUpperValue);
}

Here is the call graph for this function:

setUpperValue

void geometrize::dialog::RangeSlider::setUpperValue ( int  aUpperValue )

slot

{
    if(aUpperValue > mMaximum)
    {
        aUpperValue = mMaximum;
    }
 
    if(aUpperValue < mMinimum)
    {
        aUpperValue = mMinimum;
    }
 
    mUpperValue = aUpperValue;
    emit upperValueChanged(mUpperValue);
 
    update();
}

Here is the caller graph for this function:

upperValueChanged

void geometrize::dialog::RangeSlider::upperValueChanged ( int  aUpperValue )

signal

Here is the caller graph for this function:

validLength()

int geometrize::dialog::RangeSlider::validLength ( ) const

private

{
    int len = (orientation == Qt::Horizontal) ? width() : height();
    return len - scLeftRightMargin * 2 - scHandleSideLength * (type.testFlag(DoubleHandles) ? 2 : 1);
}

Here is the caller graph for this function:

Member Data Documentation

mBackgroudColor

QColor geometrize::dialog::RangeSlider::mBackgroudColor

private

mBackgroudColorDisabled

QColor geometrize::dialog::RangeSlider::mBackgroudColorDisabled

private

mBackgroudColorEnabled

QColor geometrize::dialog::RangeSlider::mBackgroudColorEnabled

private

mDelta

int geometrize::dialog::RangeSlider::mDelta

private

mFirstHandlePressed

bool geometrize::dialog::RangeSlider::mFirstHandlePressed

private

mInterval

int geometrize::dialog::RangeSlider::mInterval

private

mLowerValue

int geometrize::dialog::RangeSlider::mLowerValue

private

mMaximum

int geometrize::dialog::RangeSlider::mMaximum

private

mMinimum

int geometrize::dialog::RangeSlider::mMinimum

private

mSecondHandlePressed

bool geometrize::dialog::RangeSlider::mSecondHandlePressed

private

mUpperValue

int geometrize::dialog::RangeSlider::mUpperValue

private

orientation

Qt::Orientation geometrize::dialog::RangeSlider::orientation

private

type

Options geometrize::dialog::RangeSlider::type

private

---

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

• /home/appveyor/projects/geometrize-docs/geometrize/geometrize/dialog/rangeslider.h
• /home/appveyor/projects/geometrize-docs/geometrize/geometrize/dialog/rangeslider.cpp