omni::ui::RangedFloat Class Reference

A slider with float value within a minimum and maximum. More...

#include <RangedFloat.h>

Inheritance diagram for omni::ui::RangedFloat:

Collaboration diagram for omni::ui::RangedFloat:

Public Types
enum	Scale { Scale::LINEAR, Scale::RECIPROCAL }
typedef mixin::RangedValue < RangedFloat, double >	mixin_range_type
typedef QDoubleSpinBox	editor_type
Public Types inherited from omni::ui::AbstractInputWidget
typedef mixin::Editor < AbstractInputWidget, QWidget >	mixin_editor_type

Public Slots
void	setValue (double)
	Set value, valueChanged() signal will be emitted. More...
void	setMinimum (double)
	Set minimal value, rangeChanged() signal will be emitted. More...
void	setMaximum (double)
	Set maximum value, rangeChanged() signal will be emitted. More...
void	setRange (double, double)
	Set range (minimum/maximum), rangeChanged() signel will be emitted. More...
void	setEditorVisible (bool)
	Show/hide editor. More...
void	setSnap (bool)
	Toggle value snap on/off. More...
void	setGripSize (int)
void	setUseDefaultValue (bool)
	Use Default Value and show it. More...
void	setDrawTicks (bool)
void	setPrecision (int)
	Set precision. More...
void	setSuffix (QString const &)
	Set Suffix. More...
void	setPivot (double)
	Set pivot. More...
void	setDefaultValue (double)
void	setSingleStep (double)
void	setPageStep (double)
void	setScale (Scale)
Public Slots inherited from omni::ui::AbstractInputWidget
virtual void	setEditorVisible (bool)
	Set editor visible. More...
void	showEditor ()
	Show editor. More...
void	hideEditor ()
	Hide editor. More...

Signals
void	valueChanged ()
void	rangeChanged ()
Signals inherited from omni::ui::AbstractInputWidget
void	valueChanged ()
	Value changed event. More...

Public Member Functions
	RangedFloat (QWidget *=nullptr)
	Construct from parent widget. More...
	RangedFloat (QString const &_label, double _value, double _min, double _max, QWidget *=nullptr)
	Construct with input parameters. More...
virtual	~RangedFloat ()
QString	suffix () const
	Return suffix. More...
int	precision () const
	Return precision. More...
int	gripSize () const
	Return grip size. More...
bool	useDefaultValue () const
	Return flag if default value is used. More...
bool	drawTicks () const
Scale	scale () const
Public Member Functions inherited from omni::ui::AbstractInputWidget
	AbstractInputWidget (QWidget *=nullptr)
virtual	~AbstractInputWidget ()
Public Member Functions inherited from omni::ui::Widget
	Widget (QWidget *=nullptr)
	Widget (QString const &_label, QWidget *=nullptr)
virtual	~Widget ()
QString	label () const
	Return label text of widget. More...
void	setLabel (QString const &)
	Set label text of widget. More...
ColorSet const &	colorSet () const
double	zoomFactor () const
	Zoom factor of widget. More...

Protected Member Functions
void	paintEvent (QPaintEvent *)
void	keyPressEvent (QKeyEvent *)
	Show editor when enter key is pressed. More...
void	mouseMoveEvent (QMouseEvent *)
void	mousePressEvent (QMouseEvent *)
	Hide editor and set focus on click. More...
void	mouseReleaseEvent (QMouseEvent *)
void	mouseDoubleClickEvent (QMouseEvent *)
	Show editor on double click. More...
void	wheelEvent (QWheelEvent *)
void	valueChangedEvent ()
	Value changed event which is emitted on changed value. More...
void	rangeChangedEvent ()
	Handler to emit rangeChanged signal in derived widgets. More...
Protected Member Functions inherited from omni::ui::AbstractInputWidget
void	drawHandle (QPainter &_p, double _pos, double _heightFactor=1.0) const
	Draw slider handle. More...
void	drawTrack (QPainter &_p, double _pos) const
void	drawTrack (QPainter &_p, double _left, double _right) const
void	init ()
Protected Member Functions inherited from omni::ui::Widget
void	drawBorder (QPainter &)
void	drawBorder (QPainter &, bool _focus)
Protected Member Functions inherited from omni::ui::mixin::Editor< AbstractInputWidget, QWidget >
	Editor (widget_type *_widget)
T *	createEditor ()
	Create editor with type. More...
editor_type const *	editor () const
	Return pointer editor (const version) More...
editor_type *	editor ()
	Return pointer editor. More...
T *	editorAs ()
	Return editor as type T. More...
T const *	editorAs () const
	Return editor as type T (const version) More...
virtual void	setEditorVisible (bool _visible)
	Set editor visibility and set focus. More...
void	showEditor ()
	Show editor and set focus. More...
void	hideEditor ()
	Hide editor. More...

Private Member Functions
void	init ()
void	editorSetup ()
double	valueFromPos (double) const
	Get value from x mouse position. More...
double	valueToPos () const
	Calculate position from value. More...
double	valueToPos (double) const
	Calculate position from value. More...
Private Member Functions inherited from omni::ui::mixin::RangedValue< RangedFloat, double >
	RangedValue ()
	Default constructor. More...
	RangedValue (value_type _value, value_type _minimum, value_type _maximum, value_type _singleStep=1.0, value_type _pageStep=10.0)
	Constructor from user defined value and range. More...
qreal	ratio () const
	Returns ratio of current value. More...
value_type	value () const
	Return value. More...
value_type	defaultValue () const
	Return default value. More...
value_type	pivot () const
	Return pivot value. More...
void	increase ()
	Increate value by single step value. More...
void	decrease ()
	Decrease value by single step value. More...
void	setValue (value_type _value)
	Set new value and emit value changed event. More...
void	reset ()
	Reset value to default value. More...
void	setDefaultValue (value_type _value)
	Set new default value. More...
void	setPivot (value_type _pivot)
	Set pivot value (0.0 by default) More...
void	apply (WIDGET *_widget) const
	Apply ranged value to widget. More...
void	for_each_step (F f)
	Functor to apply for each step. More...
void	validate ()
	Validate minimum, maximum and value. More...
Private Member Functions inherited from omni::ui::mixin::Range< double >
	Range (value_type _minimum=0.0, value_type _maximum=100.0)
qreal	ratio (value_type _v) const
	Return ratio of value v. More...
value_type	range () const
	Return range (difference between maximum and minimum) More...
value_type	minimum () const
	Return minimum value. More...
value_type	maximum () const
	Return maximum value. More...
void	setMinimum (value_type _minimum)
	Set new minimum value and value and emit rangeChanged event. More...
void	disableMinimum ()
	Disable minimum by setting the value to infinite. More...
void	setMaximum (value_type _maximum)
	Set new maximum value and value and emit rangeChanged event. More...
void	disableMaximum ()
	Disable maximum by setting maximum to infinite value. More...
void	setRange (value_type _minimum, value_type _maximum)
	Set range and validate. More...
void	disableRange ()
	Disable range by setting minimum and maximum to infinite value. More...
bool	minimumUsed () const
bool	maximumUsed () const
void	apply (WIDGET *_widget) const
	Apply range to widget. More...
void	apply (WIDGET *_widget, V _value) const
	Applay range to widget and set value. More...
Private Member Functions inherited from omni::ui::mixin::Step< double >
	Step (value_type _singleStep=1.0, value_type _pageStep=10.0, bool _snap=false)
	Construct with a single step, page step value. More...
qreal	snapped (value_type _v) const
	Return snapped value. More...
bool	snap () const
	Snap value (align to single step value) More...
void	setSnap (bool _snap)
	Set boolean if value is to be snapped. More...
value_type	singleStep () const
	Return value for single step. More...
value_type	pageStep () const
	Return value for page step. More...
void	setSingleStep (value_type _singleStep)
	Set new single step value. More...
void	setPageStep (value_type _pageStep)
	Set new value for page step. More...
void	for_each_step (MIN _min, MAX _max, F f)
	Functor to be applied for each step between min and maximum. More...

Private Attributes
Scale	scale_ = Scale::LINEAR
bool	moving_ = false
bool	drawTicks_ = false
bool	useDefaultValue_ = false
QString	suffix_
int	gripSize_ = 0
int	precision_ = 2

Additional Inherited Members
Protected Types inherited from omni::ui::mixin::Editor< AbstractInputWidget, QWidget >
typedef AbstractInputWidget	widget_type
	Widget type. More...
typedef QWidget	editor_type
	Editor widget type, e.g. QDoubleSpinBox. More...
Protected Attributes inherited from omni::ui::AbstractInputWidget
QLabel *	valueLabel_ = nullptr
Protected Attributes inherited from omni::ui::Widget
QLabel *	label_
Private Types inherited from omni::ui::mixin::RangedValue< RangedFloat, double >
typedef Range< double >	range_type
typedef Step< double >	step_type
typedef double	value_type
Private Types inherited from omni::ui::mixin::Range< double >
typedef double	value_type
Private Types inherited from omni::ui::mixin::Step< double >
typedef double	value_type

Detailed Description

A slider with float value within a minimum and maximum.

Member Typedef Documentation

typedef QDoubleSpinBox omni::ui::RangedFloat::editor_type

typedef mixin::RangedValue<RangedFloat, double> omni::ui::RangedFloat::mixin_range_type

Member Enumeration Documentation

enum omni::ui::RangedFloat::Scale

strong

Enumerator
LINEAR
RECIPROCAL

                         {
          LINEAR,
          RECIPROCAL
        };

Constructor & Destructor Documentation

omni::ui::RangedFloat::RangedFloat

(

QWidget *

_parent = nullptr

)

Construct from parent widget.

                                                 :
            AbstractInputWidget(_parent)
        {
            init();
        }

omni::ui::RangedFloat::RangedFloat	(	QString const &	_label,
		double	_value,
		double	_min,
		double	_max,
		QWidget *	_parent = nullptr
	)

Construct with input parameters.

Parameters

_label	Label of widget
_value	Initial value
_min	Minimal value
_max	Maximal value

                                                         :
            AbstractInputWidget(_parent),
            mixin_range_type(_value, _min, _max)
        {
            init();
            setLabel(_label);
        }

omni::ui::RangedFloat::~RangedFloat ( )

virtual

        {}

Member Function Documentation

bool omni::ui::RangedFloat::drawTicks

(

)

const

        {
            return drawTicks_;
        }

void omni::ui::RangedFloat::editorSetup ( )

privatevirtual

Implements omni::ui::mixin::Editor< AbstractInputWidget, QWidget >.

                                      {
            auto _editor = this->editorAs<editor_type>();

            connect(_editor, SIGNAL(valueChanged(double)), this,
                    SLOT(setValue(double)));
            _editor->setFrame(false);
            _editor->setAlignment(Qt::AlignRight);
            _editor->setButtonSymbols(QAbstractSpinBox::PlusMinus);
            mixin_range_type::apply(_editor);
            valueChangedEvent();
        }

int omni::ui::RangedFloat::gripSize

(

)

const

Return grip size.

                                        {
            return gripSize_;
        }

void omni::ui::RangedFloat::init ( )

private

        {
            setSingleStep(1.0);
            AbstractInputWidget::createEditor<editor_type>();
        }

void omni::ui::RangedFloat::keyPressEvent ( QKeyEvent *  e )

protectedvirtual

Show editor when enter key is pressed.

Reimplemented from omni::ui::AbstractInputWidget.

                                                         {
            AbstractInputWidget::keyPressEvent(_event);
            float _step = pageStep();

            if (_event->modifiers() & Qt::ShiftModifier) {
                _step = singleStep();
            }
            if (_event->modifiers() & Qt::ControlModifier) {
                _step *= 10.0;
            }

            if (_event->key() == Qt::Key_Left) {
                setValue(value() - _step);
            }
            if (_event->key() == Qt::Key_Right) {
                setValue(value() + _step);
            }
        }

void omni::ui::RangedFloat::mouseDoubleClickEvent ( QMouseEvent *  )

protectedvirtual

Show editor on double click.

Reimplemented from omni::ui::AbstractInputWidget.

        {
            if (useDefaultValue())
            {
                if (std::abs(e->pos().x() - valueToPos(defaultValue())) <= 4)
                {
                    mixin_range_type::reset();
                    return;
                }
            }

            AbstractInputWidget::mouseDoubleClickEvent(e);
        }

void omni::ui::RangedFloat::mouseMoveEvent ( QMouseEvent *  e )

protected

        {
            if (moving_)
            {
                setValue(valueFromPos(e->pos().x()));
            }
        }

void omni::ui::RangedFloat::mousePressEvent ( QMouseEvent *  )

protectedvirtual

Hide editor and set focus on click.

Reimplemented from omni::ui::AbstractInputWidget.

        {
            AbstractInputWidget::mousePressEvent(e);

            if (std::abs(e->pos().x() - valueToPos()) <= gripSize_ || !gripSize_)
            {
                moving_ = true;
                setValue(valueFromPos(e->pos().x()));
            }
        }

void omni::ui::RangedFloat::mouseReleaseEvent ( QMouseEvent *  e )

protected

        {
            moving_ = false;
        }

void omni::ui::RangedFloat::paintEvent ( QPaintEvent *  _paintEvent )

protected

        {
            if (!isVisible()) return;

            QPainter _p(this);
            _p.setRenderHint(QPainter::Antialiasing);
            double _pos = valueToPos();

            AbstractInputWidget::drawTrack(_p, valueToPos(pivot()), _pos);

            if (useDefaultValue()) AbstractInputWidget::drawHandle(_p,
                                                                   valueToPos(
                                                                       defaultValue()),
                                                                   0.5);

            if (drawTicks())
            {
                mixin_range_type::for_each_step([&](int _step, double i,
                                                    bool _isPage)
                {
                    _p.setPen(QPen(i >= mixin_range_type::value() ?
                                   colorSet().shadow() :
                                   colorSet().windowText(), 1));

                    double _pos = valueToPos(i);
                    double _sizeFactor = _isPage ? 0.3 : 0.15;
                    _p.drawLine(
                        QPointF(_pos,
                                rect().bottom() - rect().height() * _sizeFactor),
                        QPointF(_pos, rect().bottom()));
                });
            }
            AbstractInputWidget::drawBorder(_p,
                                            hasFocus() || editor()->hasFocus());
        }

int omni::ui::RangedFloat::precision

(

)

const

Return precision.

        {
            return precision_;
        }

void omni::ui::RangedFloat::rangeChanged ( )

signal

void omni::ui::RangedFloat::rangeChangedEvent ( )

protectedvirtual

Handler to emit rangeChanged signal in derived widgets.

Reimplemented from omni::ui::mixin::Range< double >.

        {
            mixin_range_type::apply(editorAs<editor_type>());
            emit rangeChanged();
        }

RangedFloat::Scale omni::ui::RangedFloat::scale

(

)

const

                                                  {
            return scale_;
        }

void omni::ui::RangedFloat::setDefaultValue ( double  _defaultValue )

slot

        {
            mixin_range_type::setDefaultValue(_defaultValue);

            update();
        }

void omni::ui::RangedFloat::setDrawTicks ( bool  _ticks )

slot

        {
            drawTicks_ = _ticks;
            update();
        }

void omni::ui::RangedFloat::setEditorVisible ( bool  _visible )

slot

Show/hide editor.

        {
            AbstractInputWidget::setEditorVisible(_visible);
            mixin_range_type::apply(editorAs<editor_type>());
        }

void omni::ui::RangedFloat::setGripSize ( int  _gripSize )

slot

                                                   {
            gripSize_ = _gripSize;
        }

void omni::ui::RangedFloat::setMaximum ( double  _max )

slot

Set maximum value, rangeChanged() signal will be emitted.

        {
            mixin_range_type::setMaximum(_max);
        }

void omni::ui::RangedFloat::setMinimum ( double  _min )

slot

Set minimal value, rangeChanged() signal will be emitted.

        {
            mixin_range_type::setMinimum(_min);
        }

void omni::ui::RangedFloat::setPageStep ( double  _pageStep )

slot

        {
            mixin_range_type::setPageStep(_pageStep);

            update();
        }

void omni::ui::RangedFloat::setPivot ( double  _pivot )

slot

Set pivot.

        {
            mixin_range_type::setPivot(_pivot);

            update();
        }

void omni::ui::RangedFloat::setPrecision ( int  _precision )

slot

Set precision.

        {
            precision_ = _precision;
            editorAs<editor_type>()->setDecimals(_precision);
            valueChangedEvent();
        }

void omni::ui::RangedFloat::setRange ( double  _min, double  _max  )

slot

Set range (minimum/maximum), rangeChanged() signel will be emitted.

        {
            mixin_range_type::setRange(_min, _max);
        }

void omni::ui::RangedFloat::setScale ( Scale  _scale )

slot

                                               {
            scale_ = _scale;
            update();
        }

void omni::ui::RangedFloat::setSingleStep ( double  _singleStep )

slot

        {
            mixin_range_type::setSingleStep(_singleStep);

            update();
        }

void omni::ui::RangedFloat::setSnap ( bool  _snap )

slot

Toggle value snap on/off.

        {
            mixin_range_type::setSnap(_snap);
        }

void omni::ui::RangedFloat::setSuffix ( QString const &  _suffix )

slot

Set Suffix.

        {
            suffix_ = _suffix;
            editorAs<editor_type>()->setSuffix(_suffix);
            valueChangedEvent();
        }

void omni::ui::RangedFloat::setUseDefaultValue ( bool  _defaultValue )

slot

Use Default Value and show it.

        {
            useDefaultValue_ = _defaultValue;
            update();
        }

void omni::ui::RangedFloat::setValue ( double  _value )

slot

Set value, valueChanged() signal will be emitted.

        {
            mixin_range_type::setValue(_value);
        }

QString omni::ui::RangedFloat::suffix

(

)

const

Return suffix.

        {
            return suffix_;
        }

bool omni::ui::RangedFloat::useDefaultValue

(

)

const

Return flag if default value is used.

        {
            return useDefaultValue_;
        }

void omni::ui::RangedFloat::valueChanged ( )

signal

void omni::ui::RangedFloat::valueChangedEvent ( )

protectedvirtual

Value changed event which is emitted on changed value.

Reimplemented from omni::ui::mixin::RangedValue< RangedFloat, double >.

        {
            mixin_range_type::apply(editorAs<editor_type>());
            AbstractInputWidget::valueLabel_->setText(QString("%1%2")
                                                      .arg(QString::number(
                                                               value(),
                                                               'f',
                                                               precision_))
                                                      .arg(suffix()));

            update();
            emit valueChanged();
        }

double omni::ui::RangedFloat::valueFromPos ( double  _pos ) const

private

Get value from x mouse position.

Todo:

Handle RECIPROCAL mode

        {
            auto && _rect = rect();
            if (scale_ == Scale::RECIPROCAL) {
                if (minimum() <= 1.0 && maximum() >= 1.0 && minimum() > 0.0) {

                    double _recMinimum = - 1.0 / minimum();
                    double _max = maximum();
                    double _posOne = valueToPos(1.0);

                    double _v = (_pos - _rect.left()) / _rect.width() *
                            (maximum() - _recMinimum) + _recMinimum;

                    qDebug() << "valueFromPos: "<< _v;

                    if (_v < 0.0) {
                        _v = (_v - minimum()) * (1.0 / minimum() + maximum() /
                             (1.0 / minimum() - 1.0) )  - 1.0 / minimum();
                    }  else {
                        _v = (_v + 1.0) / (_max - minimum() + 1.0) * (_max - minimum());
                    }
                    return _v;

                    qDebug() << "valueFromPos: " << _recMinimum << " " << _max << " " << _posOne << " " << _pos;
                    if (_pos < _posOne) {
                        return - 1.0 / (_pos - _rect.left()) / _rect.width() *
                                    (_max - _recMinimum) + _recMinimum;
                    } else {
                        return ((_pos - _posOne) - _rect.left()) / (_rect.width() - _posOne) *
                            (maximum() - minimum()) + minimum();
                    }
                    ///@todo Handle RECIPROCAL mode
                }
            }

            return (_pos - _rect.left()) / _rect.width() *
                (maximum() - minimum()) + minimum();
        }

double omni::ui::RangedFloat::valueToPos ( ) const

private

Calculate position from value.

        {
            return valueToPos(value());
        }

double omni::ui::RangedFloat::valueToPos ( double  _value ) const

private

Calculate position from value.

        {
            auto && _rect = rect();
            double _ratio = mixin::Range<double>::ratio(_value);

            if (scale_ == Scale::RECIPROCAL) {
                if (minimum() <= 1.0 && maximum() >= 1.0 && minimum() > 0.0) {
                    double _recMinimum = - 1.0 / minimum();
                    double _max = maximum();
                    double _v = (_value - 1) / (_max -1) * _max;
                    if (_value <= 1.0) {
                        _v *= 1.0 / minimum();
                    }
                    _ratio = (_v - _recMinimum) / (_max - _recMinimum);
                }
            }

            return _rect.left() + _ratio *
                    double(_rect.width());
        }

void omni::ui::RangedFloat::wheelEvent ( QWheelEvent *  e )

protected

        {
            if (hasFocus()) setValue(
                    value() + e->delta() / 15.0 / 8.0 * singleStep());
        }

Field Documentation

bool omni::ui::RangedFloat::drawTicks_ = false

private

int omni::ui::RangedFloat::gripSize_ = 0

private

bool omni::ui::RangedFloat::moving_ = false

private

int omni::ui::RangedFloat::precision_ = 2

private

Scale omni::ui::RangedFloat::scale_ = Scale::LINEAR

private

QString omni::ui::RangedFloat::suffix_

private

bool omni::ui::RangedFloat::useDefaultValue_ = false

private

---

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

• include/omni/ui/RangedFloat.h
• src/lib/ui/RangedFloat.cpp