KisDoubleParseUnitSpinBox Class Reference

The KisDoubleParseUnitSpinBox class is an evolution of the. More...

#include <kis_double_parse_unit_spin_box.h>

Inheritance diagram for KisDoubleParseUnitSpinBox:

Signals
void	valueChangedPt (qreal)
	emitted like valueChanged in the parent, but this one emits the point value, or converted to another reference unit.
Signals inherited from KisDoubleParseSpinBox
void	errorWhileParsing (const QString &expr) const
	signal emitted when the last parsed expression is not valid.
void	noMoreParsingError () const
	signal emitted when the last parsed expression is valid and the expression before was not valid.

Public Member Functions
virtual void	changeValue (double newValue)
void	changeValuePt (double newValue)
	KisDoubleParseUnitSpinBox (QWidget *parent=0)
void	preventDecimalsChangeFromUnitManager (bool prevent)
	Private (double low, double up, double step, KisSpinBoxUnitManager *unitManager)
QString	returnUnit () const
	returnUnit returns the unit in which values are returned
void	setDecimals (int prec)
virtual void	setDimensionType (int dim)
	setDimensionType set the dimension (for example length or angle) of the units the spinbox manage
void	setDisplayUnit (bool toggle)
	display the unit symbol in the spinbox or not. For example if the unit is displayed in a combobox connected to the unit manager.
void	setLineStep (double step)
	Set step size in the current unit.
void	setLineStepPt (double step)
	Set step size in points.
void	setMaximum (double max)
	Set maximum value in current unit.
void	setMaximumPt (double max)
	Set maximum value in points.
void	setMinimum (double min)
	Set minimum value in current unit.
void	setMinimumPt (double min)
	Set minimum value in points.
void	setMinMaxStep (double min, double max, double step)
	Set minimum, maximum value and the step size (in current unit)
void	setMinMaxStepPt (double min, double max, double step)
	Set minimum, maximum value and the step size (all in points)
void	setReturnUnit (const QString &symbol)
	setReturnUnit set a unit, such that the spinbox now return values in this unit instead of the reference unit for the current dimension.
void	setSingleStep (double val)
virtual void	setUnit (const KoUnit &unit)
virtual void	setUnit (const QString &symbol)
void	setUnitChangeFromOutsideBehavior (bool toggle)
void	setUnitManager (KisSpinBoxUnitManager *unitManager)
void	setValuePt (double value, bool overWriteExpression=false)
	Sets the value in points.
QString	textFromValue (double value) const override
double	value () const
double	valueFromText (const QString &str) const override
double	valuePt () const
QString	veryCleanText () const override
	get the text in the spinbox without prefix or suffix, and remove unit symbol if present.
	~KisDoubleParseUnitSpinBox () override
Public Member Functions inherited from KisDoubleParseSpinBox
bool	isLastValid () const
	Get if the last expression entered is a valid one.
	KisDoubleParseSpinBox (QWidget *parent=0)
void	setValue (double value, bool overwriteExpression=false)
	Set the value of the spinbox.
void	stepBy (int steps) override
	This is a reimplementation of QDoubleSpinBox::stepBy that uses setValue.
	~KisDoubleParseSpinBox () override

Public Attributes
bool	allowResetDecimals {true}
KisSpinBoxUnitManager *	defaultUnitManager {0}
bool	displayUnit {true}
bool	isDeleting {false}
bool	letUnitBeChangedFromOutsideMoreThanOnce {true}
double	lowerInPoints {0.0}
	minimum precision for given decimals
double	minStepForPrec {0}
bool	mustUsePreviousText {false}
QString	outPutSymbol
QString	previousSymbol
double	previousValueInPoint {0.0}
	allow to store the previous value in point, useful in some cases, even if, usually, we prefer to refer to the actual value (in selected unit) and convert it, since this is not always updated.
double	stepInPoints {0.0}
	step in points
KoUnit	unit
bool	unitHasBeenChangedFromOutSideOnce {false}
KisSpinBoxUnitManager *	unitManager {0}
double	upperInPoints {0.0}
	highest value in points

Private Slots
void	detectUnitChanges ()
void	disconnectExternalUnitManager ()
void	privateValueChanged ()

Private Member Functions
void	contextMenuEvent (QContextMenuEvent *event) override
QString	detectUnit ()
void	internalUnitChange (QString const &symbol)
	change the unit, reset the spin box every time. From the outside it's always set unit that should be called.
QString	makeTextClean (QString const &txt) const
void	prepareUnitChange ()
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	d
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Additional Inherited Members
Protected Member Functions inherited from KisDoubleParseSpinBox
QString	textFromValue (double value) const override
QValidator::State	validate (QString &input, int &pos) const override
double	valueFromText (const QString &text) const override

Detailed Description

The KisDoubleParseUnitSpinBox class is an evolution of the.

See also

KoUnitDoubleSpinBox, but inherit from

KisDoubleParseSpinBox to be able to parse math expressions.

This class store the

Definition at line 20 of file kis_double_parse_unit_spin_box.cpp.

Constructor & Destructor Documentation

KisDoubleParseUnitSpinBox()

KisDoubleParseUnitSpinBox::KisDoubleParseUnitSpinBox

(

QWidget *

parent = 0

)

Definition at line 59 of file kis_double_parse_unit_spin_box.cpp.

                                                                    :
    KisDoubleParseSpinBox(parent),
    d(new Private(-9999, 9999, 1, KisSpinBoxUnitManagerFactory::buildDefaultUnitManager(this)))
{
    setUnit( KoUnit(KoUnit::Point) );
    setAlignment( Qt::AlignRight );
 
    connect(this, SIGNAL(valueChanged(double)), this, SLOT(privateValueChanged()));
    connect(lineEdit(), SIGNAL(textChanged(QString)),
            this, SLOT(detectUnitChanges()) );
 
    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange, this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
 
    setDecimals(d->unitManager->getApparentUnitRecommendedDecimals());
}

References d, detectUnitChanges(), internalUnitChange(), KoUnit::Point, prepareUnitChange(), privateValueChanged(), setDecimals(), setUnit(), KisSpinBoxUnitManager::unitAboutToChange(), KisSpinBoxUnitManager::unitChanged(), and void().

~KisDoubleParseUnitSpinBox()

KisDoubleParseUnitSpinBox::~KisDoubleParseUnitSpinBox ( )

override

Definition at line 76 of file kis_double_parse_unit_spin_box.cpp.

{
    d->isDeleting = true;
    delete d->defaultUnitManager;
    delete d;
}

References d.

Member Function Documentation

changeValue()

void KisDoubleParseUnitSpinBox::changeValue ( double newValue )

virtual

Set the new value in points (or other reference unit) which will then be converted to the current unit for display

Parameters

newValue

the new value

See also

value()

Definition at line 155 of file kis_double_parse_unit_spin_box.cpp.

{
    double apparentValue;
    double fact = 0.0;
    double cons = 0.0;
 
    if (d->outPutSymbol.isEmpty()) {
        apparentValue = d->unitManager->getApparentValue(newValue);
    } else {
 
        fact = d->unitManager->getConversionFactor(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
        cons = d->unitManager->getConversionConstant(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
 
        apparentValue = fact*newValue + cons;
    }
 
    if (apparentValue == KisDoubleParseSpinBox::value()) {
        return;
    }
 
    if (d->outPutSymbol.isEmpty()) {
        KisDoubleParseSpinBox::setValue( apparentValue );
    } else {
        KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue((newValue - cons)/fact) );
    }
}

References d, and KisDoubleParseSpinBox::setValue().

changeValuePt()

void KisDoubleParseUnitSpinBox::changeValuePt

(

double

newValue

)

Set the new value in points whatever is the reference unit for display

Parameters

newValue

the new value

See also

valuePt()

Definition at line 182 of file kis_double_parse_unit_spin_box.cpp.

{
    double apparentValue = d->unitManager->getApparentValue(newValue);
 
    if (apparentValue == KisDoubleParseSpinBox::value()) {
        return;
    }
    KisDoubleParseSpinBox::setValue( apparentValue );
}

References d, and KisDoubleParseSpinBox::setValue().

contextMenuEvent()

void KisDoubleParseUnitSpinBox::contextMenuEvent ( QContextMenuEvent * event )

overrideprivate

Definition at line 481 of file kis_double_parse_unit_spin_box.cpp.

{
    // default standard menu for line edit, not possible to get the default menu from a QSpinBox
    QMenu* menu = lineEdit()->createStandardContextMenu();
    if (!menu)
        return;
 
    // then need to recreate "Step Up" and "Step Down" actions
    menu->addSeparator();
    const uint se = stepEnabled();
    QAction *up = menu->addAction(tr("&Step up"));
    up->setEnabled(se & StepUpEnabled);
    QAction *down = menu->addAction(tr("Step &down"));
    down->setEnabled(se & StepDownEnabled);
    menu->addSeparator();
 
    // and add expected new entries: menu/submenu with Units
    QMenu* menuUnit = menu->addMenu(i18n("Unit"));
    QActionGroup* unitActions = new QActionGroup(this);
    Q_FOREACH(QString unitSymbol, d->unitManager->getsUnitSymbolList(false)) {
        QString unitLabel = KoUnit::unitDescription(KoUnit::fromSymbol(unitSymbol).type());
 
        // need to check symbol not managed by KoUnit (return "Points (pt)" in this case...)
        switch (d->unitManager->getUnitDimensionType()) {
            case KisSpinBoxUnitManager::UnitDimension::LENGTH:
            case KisSpinBoxUnitManager::UnitDimension::IMLENGTH:
                if (unitSymbol == "%") {
                    unitLabel = i18n("Percent (%)");
                } else if (unitSymbol == "vw") {
                    unitLabel = i18n("percent of view width (vw)");
                } else if (unitSymbol == "vh") {
                    unitLabel = i18n("percent of view height (vh)");
                }
                break;
 
            case KisSpinBoxUnitManager::ANGLE:
                if (unitSymbol == "°") {
                    unitLabel = i18n("degrees (°)");
                } else if (unitSymbol == "rad") {
                    unitLabel = i18n("radians (rad)");
                } else if (unitSymbol == "gon") {
                    unitLabel = i18n("gons (gon)");
                } else if (unitSymbol == "%") {
                    unitLabel = i18n("percent of circle (%)");
                }
                break;
 
            case KisSpinBoxUnitManager::TIME:
                if (unitSymbol == "f") {
                    unitLabel = i18n("frames (f)");
                } else if (unitSymbol == "s") {
                    unitLabel = i18n("seconds (s)");
                } else if (unitSymbol == "%") {
                    unitLabel = i18n("percent of animation (%)");
                }
                break;
        }
 
        QAction *unitAction = menuUnit->addAction(unitLabel);
        unitAction->setProperty("symbol", unitSymbol);
        unitAction->setCheckable(true);
        unitAction->setActionGroup(unitActions);
        unitAction->setChecked(unitSymbol == d->unitManager->getApparentUnitSymbol());
    }
 
    const QPoint pos = (event->reason() == QContextMenuEvent::Mouse)
        ? event->globalPos() : mapToGlobal(QPoint(event->pos().x(), 0)) + QPoint(width() / 2, height() / 2);
    const QAction *action = menu->exec(pos);
 
    if (action) {
        if (action == up) {
            stepBy(1);
        } else if (action == down) {
            stepBy(-1);
        } else {
            QVariant symbol = action->property("symbol");
            if (symbol.isValid()) {
                d->unitManager->setApparentUnitFromSymbol(symbol.toString());
            }
        }
    }
 
    delete static_cast<QMenu *>(menuUnit);
    delete static_cast<QMenu *>(menu);
    event->accept();
}

References KisSpinBoxUnitManager::ANGLE, d, KoUnit::fromSymbol(), KisSpinBoxUnitManager::IMLENGTH, KisSpinBoxUnitManager::LENGTH, KisDoubleParseSpinBox::stepBy(), KisSpinBoxUnitManager::TIME, and KoUnit::unitDescription().

detectUnit()

QString KisDoubleParseUnitSpinBox::detectUnit ( )

private

Definition at line 388 of file kis_double_parse_unit_spin_box.cpp.

{
    QString str = veryCleanText().trimmed(); //text with the new unit but not the old one.
 
    QRegularExpression regexp ("([ ]*[a-zA-Z]+[ ]*)$"); // Letters or spaces at end
    int res = str.indexOf( regexp );
 
    if (res > -1) {
        QString expr ( str.right( str.size() - res ) );
        expr = expr.trimmed();
        return expr;
    }
 
    return "";
}

References veryCleanText().

detectUnitChanges

void KisDoubleParseUnitSpinBox::detectUnitChanges ( )

privateslot

Definition at line 404 of file kis_double_parse_unit_spin_box.cpp.

{
    QString unitSymb = detectUnit();
 
    if (unitSymb.isEmpty()) {
        return;
    }
 
    QString oldUnitSymb = d->unitManager->getApparentUnitSymbol();
 
    setUnit(unitSymb);
    // Quick hack
    // This function is called when the user changed the text and the call to
    // setValue will provoke a call to textFromValue which will return a new
    // text different from the current one. Since the following setValue is
    // called because of a user change, we use a flag to prevent the text from
    // changing
    d->mustUsePreviousText = true;
    // Change value keep the old value, but converted to new unit... which is
    // different from the value the user entered in the new unit. So we need
    // to set the new value.
    setValue(valueFromText(cleanText()));
    d->mustUsePreviousText = false;
 
    if (oldUnitSymb != d->unitManager->getApparentUnitSymbol()) {
        // the user has changed the unit, so we block changes from outside.
        setUnitChangeFromOutsideBehavior(false);
    }
}

References d, detectUnit(), setUnit(), setUnitChangeFromOutsideBehavior(), KisDoubleParseSpinBox::setValue(), and valueFromText().

disconnectExternalUnitManager

void KisDoubleParseUnitSpinBox::disconnectExternalUnitManager ( )

privateslot

Definition at line 452 of file kis_double_parse_unit_spin_box.cpp.

{
    // Internal disconnectExternalUnitManager() method is called when the current unit manager d->unitManager
    // has been destroyed
    // --> ensure the d->unitManager does not point to anything anymore
    d->unitManager = 0;
 
    if (!d->isDeleting)
    {
        setUnitManager(d->defaultUnitManager); //go back to default unit manager.
    }
}

References d, and setUnitManager().

internalUnitChange()

void KisDoubleParseUnitSpinBox::internalUnitChange ( QString const & symbol )

private

change the unit, reset the spin box every time. From the outside it's always set unit that should be called.

Definition at line 228 of file kis_double_parse_unit_spin_box.cpp.

                                                                        {
    //d->unitManager->setApparentUnitFromSymbol(symbol);
 
    if (d->unitManager->getApparentUnitSymbol() == d->previousSymbol) { //the setApparentUnitFromSymbol is a bit clever, for example in regard of Casesensitivity. So better check like this.
        return;
    }
 
    // decimals must be updated before value/step/min/max otherwise they'll rounded with previous unit decimal value
    if (d->allowResetDecimals) {
        setDecimals(d->unitManager->getApparentUnitRecommendedDecimals());
    }
 
    KisDoubleParseSpinBox::setMinimum( d->unitManager->getApparentValue( d->lowerInPoints ) );
    KisDoubleParseSpinBox::setMaximum( d->unitManager->getApparentValue( d->upperInPoints ) );
 
    qreal step = d->unitManager->getApparentValue( d->stepInPoints );
 
    if (symbol == KoUnit(KoUnit::Pixel).symbol()) {
        // limit the pixel step by 1.0
        step = 1.0;
    }
 
    setSingleStep( step );
    KisDoubleParseSpinBox::setValue( d->unitManager->getApparentValue( d->previousValueInPoint ) );
 
    d->unitHasBeenChangedFromOutSideOnce = true;
}

References d, KoUnit::Pixel, setDecimals(), setSingleStep(), and KisDoubleParseSpinBox::setValue().

makeTextClean()

QString KisDoubleParseUnitSpinBox::makeTextClean ( QString const & txt ) const

private

Definition at line 434 of file kis_double_parse_unit_spin_box.cpp.

{
    QString expr = txt;
    QString symbol = d->unitManager->getApparentUnitSymbol();
 
    if ( expr.endsWith(suffix()) ) {
        expr.remove(expr.size()-suffix().size(), suffix().size());
    }
 
    expr = expr.trimmed();
 
    if ( expr.endsWith(symbol) ) {
        expr.remove(expr.size()-symbol.size(), symbol.size());
    }
 
    return expr.trimmed();
}

References d.

prepareUnitChange()

void KisDoubleParseUnitSpinBox::prepareUnitChange ( )

private

Definition at line 222 of file kis_double_parse_unit_spin_box.cpp.

                                                  {
 
    d->previousValueInPoint = d->unitManager->getReferenceValue(KisDoubleParseSpinBox::value());
    d->previousSymbol = d->unitManager->getApparentUnitSymbol();
}

References d.

preventDecimalsChangeFromUnitManager()

void KisDoubleParseUnitSpinBox::preventDecimalsChangeFromUnitManager

(

bool

prevent

)

Definition at line 378 of file kis_double_parse_unit_spin_box.cpp.

{
    d->allowResetDecimals = !prevent;
}

References d.

Private()

KisDoubleParseUnitSpinBox::Private ( double low, double up, double step, KisSpinBoxUnitManager * unitManager )

inline

Definition at line 23 of file kis_double_parse_unit_spin_box.cpp.

        : lowerInPoints(low),
          upperInPoints(up),
          stepInPoints(step),
          unit(KoUnit(KoUnit::Point)),
          outPutSymbol(""),
          unitManager(unitManager),
          defaultUnitManager(unitManager)
    {
    }

privateValueChanged

void KisDoubleParseUnitSpinBox::privateValueChanged ( )

privateslot

Definition at line 383 of file kis_double_parse_unit_spin_box.cpp.

{
    Q_EMIT valueChangedPt( value() );
}

References value(), and valueChangedPt().

returnUnit()

QString KisDoubleParseUnitSpinBox::returnUnit

(

)

const

returnUnit returns the unit in which values are returned

See also

returnUnit()

Definition at line 217 of file kis_double_parse_unit_spin_box.cpp.

{
    return d->outPutSymbol;
}

References d.

setDecimals()

void KisDoubleParseUnitSpinBox::setDecimals

(

int

prec

)

Definition at line 465 of file kis_double_parse_unit_spin_box.cpp.

{
    KisDoubleParseSpinBox::setDecimals(prec);
    d->minStepForPrec = 1/qPow(10, prec);
 
    // fix current single step value is needed
    setSingleStep(singleStep());
}

References d, and setSingleStep().

setDimensionType()

void KisDoubleParseUnitSpinBox::setDimensionType ( int dim )

virtual

setDimensionType set the dimension (for example length or angle) of the units the spinbox manage

Parameters

dim	the dimension id. (if not an id in KisSpinBoxUnitManager::UnitDimension, then the function does nothing).

Definition at line 256 of file kis_double_parse_unit_spin_box.cpp.

{
    if (!KisSpinBoxUnitManager::isUnitId(dim)) {
        return;
    }
 
    d->unitManager->setUnitDimension((KisSpinBoxUnitManager::UnitDimension) dim);
}

References d, and KisSpinBoxUnitManager::isUnitId().

setDisplayUnit()

void KisDoubleParseUnitSpinBox::setDisplayUnit

(

bool

toggle

)

display the unit symbol in the spinbox or not. For example if the unit is displayed in a combobox connected to the unit manager.

Definition at line 373 of file kis_double_parse_unit_spin_box.cpp.

{
    d->displayUnit = toggle;
}

References d.

setLineStep()

void KisDoubleParseUnitSpinBox::setLineStep

(

double

step

)

Set step size in the current unit.

Definition at line 313 of file kis_double_parse_unit_spin_box.cpp.

{
    d->stepInPoints = d->unitManager->getReferenceValue(step);
    KisDoubleParseSpinBox::setSingleStep( step );
}

References d.

setLineStepPt()

void KisDoubleParseUnitSpinBox::setLineStepPt

(

double

step

)

Set step size in points.

Definition at line 319 of file kis_double_parse_unit_spin_box.cpp.

{
    d->stepInPoints = step;
    KisDoubleParseSpinBox::setSingleStep( d->unitManager->getApparentValue( step ) );
}

References d.

setMaximum()

void KisDoubleParseUnitSpinBox::setMaximum

(

double

max

)

Set maximum value in current unit.

Definition at line 301 of file kis_double_parse_unit_spin_box.cpp.

{
    d->upperInPoints = d->unitManager->getReferenceValue(max);
    KisDoubleParseSpinBox::setMaximum( max );
}

References d.

setMaximumPt()

void KisDoubleParseUnitSpinBox::setMaximumPt

(

double

max

)

Set maximum value in points.

Definition at line 307 of file kis_double_parse_unit_spin_box.cpp.

{
    d->upperInPoints = max;
    KisDoubleParseSpinBox::setMaximum( d->unitManager->getApparentValue( max ) );
}

References d.

setMinimum()

void KisDoubleParseUnitSpinBox::setMinimum

(

double

min

)

Set minimum value in current unit.

Definition at line 288 of file kis_double_parse_unit_spin_box.cpp.

{
    d->lowerInPoints = d->unitManager->getReferenceValue(min);
    KisDoubleParseSpinBox::setMinimum( min );
}

References d.

setMinimumPt()

void KisDoubleParseUnitSpinBox::setMinimumPt

(

double

min

)

Set minimum value in points.

Definition at line 294 of file kis_double_parse_unit_spin_box.cpp.

{
    d->lowerInPoints = min;
    KisDoubleParseSpinBox::setMinimum( d->unitManager->getApparentValue( min ) );
}

References d.

setMinMaxStep()

void KisDoubleParseUnitSpinBox::setMinMaxStep	(	double	min,
		double	max,
		double	step )

Set minimum, maximum value and the step size (in current unit)

Definition at line 325 of file kis_double_parse_unit_spin_box.cpp.

{
    setMinimum( min );
    setMaximum( max );
    setLineStep( step );
}

References setLineStep(), setMaximum(), and setMinimum().

setMinMaxStepPt()

void KisDoubleParseUnitSpinBox::setMinMaxStepPt	(	double	min,
		double	max,
		double	step )

Set minimum, maximum value and the step size (all in points)

Definition at line 332 of file kis_double_parse_unit_spin_box.cpp.

{
    setMinimumPt( min );
    setMaximumPt( max );
    setLineStepPt( step );
}

References setLineStepPt(), setMaximumPt(), and setMinimumPt().

setReturnUnit()

void KisDoubleParseUnitSpinBox::setReturnUnit

(

const QString &

symbol

)

setReturnUnit set a unit, such that the spinbox now return values in this unit instead of the reference unit for the current dimension.

Parameters

symbol

the symbol of the new unit.

See also

returnUnit()

Definition at line 212 of file kis_double_parse_unit_spin_box.cpp.

{
    d->outPutSymbol = symbol;
}

References d.

setSingleStep()

void KisDoubleParseUnitSpinBox::setSingleStep

(

double

val

)

Definition at line 474 of file kis_double_parse_unit_spin_box.cpp.

{
    // ensure step value is never below minimal value for precision
    KisDoubleParseSpinBox::setSingleStep(qMax(d->minStepForPrec, val));
}

References d.

setUnit() [1/2]

void KisDoubleParseUnitSpinBox::setUnit ( const KoUnit & unit )

virtual

This spinbox shows the internal value after a conversion to the unit set here.

Definition at line 193 of file kis_double_parse_unit_spin_box.cpp.

{
    if (d->unitHasBeenChangedFromOutSideOnce && !d->letUnitBeChangedFromOutsideMoreThanOnce) {
        return;
    }
 
    if (d->unitManager->getUnitDimensionType() != KisSpinBoxUnitManager::LENGTH) {
        d->unitManager->setUnitDimension(KisSpinBoxUnitManager::LENGTH); //setting the unit using a KoUnit mean you want to use a length.
    }
 
    setUnit(unit.symbol());
    d->unit = unit;
}

References d, KisSpinBoxUnitManager::LENGTH, setUnit(), KoUnit::symbol(), and unit.

setUnit() [2/2]

void KisDoubleParseUnitSpinBox::setUnit ( const QString & symbol )

virtual

Definition at line 207 of file kis_double_parse_unit_spin_box.cpp.

{
    d->unitManager->setApparentUnitFromSymbol(symbol); //via signals and slots, the correct functions should be called.
}

References d.

setUnitChangeFromOutsideBehavior()

void KisDoubleParseUnitSpinBox::setUnitChangeFromOutsideBehavior

(

bool

toggle

)

Definition at line 368 of file kis_double_parse_unit_spin_box.cpp.

{
    d->letUnitBeChangedFromOutsideMoreThanOnce = toggle;
}

References d.

setUnitManager()

void KisDoubleParseUnitSpinBox::setUnitManager

(

KisSpinBoxUnitManager *

unitManager

)

Definition at line 83 of file kis_double_parse_unit_spin_box.cpp.

{
    if (unitManager == d->unitManager) {
        // just in case we're trying to set manager with the current one...
        return;
    }
 
    KisSpinBoxUnitManager* oldUnitManager = 0;
 
    if (d->unitManager) {
        // current unit manager is still here (then setUnitManager not call because it has been destroyed)
        //
        oldUnitManager = d->unitManager;
 
        disconnect(oldUnitManager, &QObject::destroyed,
                this, &KisDoubleParseUnitSpinBox::disconnectExternalUnitManager); //there's no dependence anymore.
        disconnect(oldUnitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange,
                this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
        disconnect(oldUnitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged,
                this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
    }
 
    d->unitManager = unitManager;
 
 
    // decimals must be set before value, otherwise value/step/min/max values will be rounded to previous unit decimals value
    if (d->allowResetDecimals) { //if the user has not fixed the number of decimals.
        setDecimals(d->unitManager->getApparentUnitRecommendedDecimals());
    }
 
    qreal newVal = 0.0;
 
    double newMin;
    double newMax;
    double newStep;
 
    if (oldUnitManager == 0 ||
        (oldUnitManager &&
        (d->unitManager->getApparentUnitSymbol() != oldUnitManager->getApparentUnitSymbol() ||
         d->unitManager->getUnitDimensionType() == oldUnitManager->getUnitDimensionType()))) {
 
        if (oldUnitManager && d->unitManager->getUnitDimensionType() == oldUnitManager->getUnitDimensionType()) {
            //dimension is the same, calculate the new value
            newVal = d->unitManager->getApparentValue(oldUnitManager->getReferenceValue(KisDoubleParseSpinBox::value()));
        } else {
            newVal = d->unitManager->getApparentValue(d->lowerInPoints);
        }
 
        newMin = d->unitManager->getApparentValue(d->lowerInPoints);
        newMax = d->unitManager->getApparentValue(d->upperInPoints);
        newStep = d->unitManager->getApparentValue(d->stepInPoints);
 
        if (d->unitManager->getApparentUnitSymbol() == KoUnit(KoUnit::Pixel).symbol()) {
            // limit the pixel step by 1.0
            newStep = 1.0;
        }
 
        KisDoubleParseSpinBox::setMinimum(newMin);
        KisDoubleParseSpinBox::setMaximum(newMax);
        KisDoubleParseSpinBox::setSingleStep(newStep);
    }
 
    connect(d->unitManager, &QObject::destroyed,
            this, &KisDoubleParseUnitSpinBox::disconnectExternalUnitManager);
    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)()) &KisSpinBoxUnitManager::unitAboutToChange,
            this, (void (KisDoubleParseUnitSpinBox::*)()) &KisDoubleParseUnitSpinBox::prepareUnitChange);
    connect(d->unitManager, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged,
            this, (void (KisDoubleParseUnitSpinBox::*)( QString const& )) &KisDoubleParseUnitSpinBox::internalUnitChange);
 
    KisDoubleParseSpinBox::setValue(newVal);
}

References d, disconnectExternalUnitManager(), KisSpinBoxUnitManager::getApparentUnitSymbol(), KisSpinBoxUnitManager::getReferenceValue(), KisSpinBoxUnitManager::getUnitDimensionType(), internalUnitChange(), KoUnit::Pixel, prepareUnitChange(), setDecimals(), KisDoubleParseSpinBox::setValue(), KisSpinBoxUnitManager::unitAboutToChange(), KisSpinBoxUnitManager::unitChanged(), unitManager, and void().

setValuePt()

void KisDoubleParseUnitSpinBox::setValuePt	(	double	value,
		bool	overWriteExpression = false )

Sets the value in points.

Definition at line 283 of file kis_double_parse_unit_spin_box.cpp.

{
    KisDoubleParseSpinBox::setValue(d->unitManager->getApparentValue(value), overwriteExpression);
}

References d, KisDoubleParseSpinBox::setValue(), and value().

textFromValue()

QString KisDoubleParseUnitSpinBox::textFromValue ( double value ) const

override

Transform the double in a nice text, using locale symbols

Parameters

value

the number as double

Returns

the resulting string

Definition at line 340 of file kis_double_parse_unit_spin_box.cpp.

{
    // Just return the current value (for example when the user is editing)
    if (d->mustUsePreviousText) {
        return cleanText();
    }
    // Construct a new value
    QString txt = KisDoubleParseSpinBox::textFromValue(value);
    if (d->displayUnit) {
        if (!txt.endsWith(d->unitManager->getApparentUnitSymbol())) {
            txt += " " + d->unitManager->getApparentUnitSymbol();
        }
    }
    return txt;
}

References d, KisDoubleParseSpinBox::textFromValue(), and value().

value()

double KisDoubleParseUnitSpinBox::value

(

)

const

Returns

the current value, converted in "return unit"

Definition at line 265 of file kis_double_parse_unit_spin_box.cpp.

{
    if (d->outPutSymbol.isEmpty()) {
        return d->unitManager->getReferenceValue( KisDoubleParseSpinBox::value() );
    }
 
    double ref = d->unitManager->getReferenceValue( KisDoubleParseSpinBox::value() );
    double fact = d->unitManager->getConversionFactor(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
    double cons = d->unitManager->getConversionConstant(d->unitManager->getUnitDimensionType(), d->outPutSymbol);
 
    return fact*ref + cons;
}

References d.

valueChangedPt

void KisDoubleParseUnitSpinBox::valueChangedPt ( qreal )

signal

emitted like valueChanged in the parent, but this one emits the point value, or converted to another reference unit.

valueFromText()

double KisDoubleParseUnitSpinBox::valueFromText ( const QString & str ) const

override

Transform a string into a double, while taking care of locale specific symbols.

Parameters

str	the string to transform into a number

Returns

the value as double

Definition at line 361 of file kis_double_parse_unit_spin_box.cpp.

{
    QString txt = makeTextClean(str);
    //this function will take care of prefix (and don't mind if suffix has been removed.
    return KisDoubleParseSpinBox::valueFromText(txt);
}

References makeTextClean(), and KisDoubleParseSpinBox::valueFromText().

valuePt()

double KisDoubleParseUnitSpinBox::valuePt

(

)

const

Returns

the current value as Point, whatever is "return unit"

Definition at line 278 of file kis_double_parse_unit_spin_box.cpp.

{
    return d->unitManager->getReferenceValue( KisDoubleParseSpinBox::value() );
}

References d.

veryCleanText()

QString KisDoubleParseUnitSpinBox::veryCleanText ( ) const

overridevirtual

get the text in the spinbox without prefix or suffix, and remove unit symbol if present.

Reimplemented from KisDoubleParseSpinBox.

Definition at line 356 of file kis_double_parse_unit_spin_box.cpp.

{
    return makeTextClean(cleanText());
}

References makeTextClean().

Member Data Documentation

allowResetDecimals

bool KisDoubleParseUnitSpinBox::allowResetDecimals {true}

Definition at line 54 of file kis_double_parse_unit_spin_box.cpp.

{true};

d

Private* const KisDoubleParseUnitSpinBox::d

private

Definition at line 141 of file kis_double_parse_unit_spin_box.h.

defaultUnitManager

KisSpinBoxUnitManager* KisDoubleParseUnitSpinBox::defaultUnitManager {0}

Definition at line 45 of file kis_double_parse_unit_spin_box.cpp.

{0}; //the default unit manager is the one the spinbox rely on and go back to if a connected unit manager is destroyed before the spinbox.

displayUnit

bool KisDoubleParseUnitSpinBox::displayUnit {true}

Definition at line 52 of file kis_double_parse_unit_spin_box.cpp.

{true};

isDeleting

bool KisDoubleParseUnitSpinBox::isDeleting {false}

Definition at line 47 of file kis_double_parse_unit_spin_box.cpp.

{false};

letUnitBeChangedFromOutsideMoreThanOnce

bool KisDoubleParseUnitSpinBox::letUnitBeChangedFromOutsideMoreThanOnce {true}

Definition at line 50 of file kis_double_parse_unit_spin_box.cpp.

{true};

lowerInPoints

double KisDoubleParseUnitSpinBox::lowerInPoints {0.0}

minimum precision for given decimals

lowest value in points

Definition at line 35 of file kis_double_parse_unit_spin_box.cpp.

{0.0}; 

minStepForPrec

double KisDoubleParseUnitSpinBox::minStepForPrec {0}

Definition at line 34 of file kis_double_parse_unit_spin_box.cpp.

{0};  

mustUsePreviousText

bool KisDoubleParseUnitSpinBox::mustUsePreviousText {false}

Definition at line 56 of file kis_double_parse_unit_spin_box.cpp.

{false};

outPutSymbol

QString KisDoubleParseUnitSpinBox::outPutSymbol

Definition at line 42 of file kis_double_parse_unit_spin_box.cpp.

previousSymbol

QString KisDoubleParseUnitSpinBox::previousSymbol

Definition at line 41 of file kis_double_parse_unit_spin_box.cpp.

previousValueInPoint

double KisDoubleParseUnitSpinBox::previousValueInPoint {0.0}

allow to store the previous value in point, useful in some cases, even if, usually, we prefer to refer to the actual value (in selected unit) and convert it, since this is not always updated.

Definition at line 40 of file kis_double_parse_unit_spin_box.cpp.

{0.0}; 

stepInPoints

double KisDoubleParseUnitSpinBox::stepInPoints {0.0}

step in points

Definition at line 37 of file kis_double_parse_unit_spin_box.cpp.

{0.0};  

unit

KoUnit KisDoubleParseUnitSpinBox::unit

Definition at line 38 of file kis_double_parse_unit_spin_box.cpp.

unitHasBeenChangedFromOutSideOnce

bool KisDoubleParseUnitSpinBox::unitHasBeenChangedFromOutSideOnce {false}

Definition at line 49 of file kis_double_parse_unit_spin_box.cpp.

{false}; //in some part of the code the unit is reset. We want to prevent this overriding the unit defined by the user. We use this switch to do so.

unitManager

KisSpinBoxUnitManager* KisDoubleParseUnitSpinBox::unitManager {0}

Definition at line 44 of file kis_double_parse_unit_spin_box.cpp.

{0}; //manage more units than permitted by KoUnit.

upperInPoints

double KisDoubleParseUnitSpinBox::upperInPoints {0.0}

highest value in points

Definition at line 36 of file kis_double_parse_unit_spin_box.cpp.

{0.0}; 

---

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

• libs/widgetutils/kis_double_parse_unit_spin_box.cpp
• libs/widgetutils/kis_double_parse_unit_spin_box.h