The KisSpinBoxUnitManager class is an abstract interface for the unitspinboxes classes to manage different type of units. More...

#include <kis_spin_box_unit_manager.h>

Inheritance diagram for KisSpinBoxUnitManager:

Public Types
enum	Constrain { NOCONSTR = 0 , REFISINT = 1 , VALISINT = 2 }

enum	UnitDimension { LENGTH = 0 , IMLENGTH = 1 , ANGLE = 2 , TIME = 3 }

Public Slots
void	clearSyncWithOtherUnitManager (KisSpinBoxUnitManager *other)

void	selectApparentUnitFromIndex (int index)

void	setApparentUnitFromSymbol (QString pSymbol)

void	setUnitDimension (UnitDimension dimension)

void	syncWithOtherUnitManager (KisSpinBoxUnitManager *other)

Signals
void	conversionConstantChanged (qreal newConversionFactor, qreal oldConversionFactor) const

void	conversionFactorChanged (qreal newConversionFactor, qreal oldConversionFactor) const

void	unitAboutToChange ()

void	unitChanged (int index)

void	unitChanged (QString symbol)

void	unitDimensionChanged (int dimCode)

void	unitListChanged ()

Public Member Functions
QVariant	data (const QModelIndex &index, int role=Qt::DisplayRole) const override

int	getApparentUnitId () const
	get the position of the apparent unit in the list of units. It is useful if we want to build a model for combo-box based unit management.

int	getApparentUnitRecommendedDecimals () const
	get a hint of how many decimals the spinbox needs to display.

QString	getApparentUnitSymbol () const

qreal	getApparentValue (double refValue) const

virtual qreal	getConversionConstant (int dim, QString symbol) const
	some units conversions are done via an affine transform, not just a linear transform. This function gives the constant of this affine transform (usually 0).

virtual qreal	getConversionFactor (int dim, QString symbol) const
	gets the conversion factor of a managed unit, or -1 in case of error. This method is the one that needs to be overridden to extend the ability of the KisSpinBoxUnitManager.

QString	getReferenceUnitSymbol () const

qreal	getReferenceValue (double apparentValue) const

virtual QStringList	getsUnitSymbolList (bool withName=false) const

int	getUnitDimensionType () const

	KisSpinBoxUnitManager (QObject *parent=0)

	Private (KisSpinBoxUnitManager::UnitDimension pDim=KisSpinBoxUnitManager::LENGTH, QString pUnitSymbol="pt", double pConv=1.0)

int	rowCount (const QModelIndex &parent=QModelIndex()) const override

	~KisSpinBoxUnitManager () override

Static Public Member Functions
static bool	isUnitId (int code)

Static Public Attributes
static const QStringList	referenceUnitSymbols = {"pt", "px", "°", "frame"}
	this list holds the symbols of the reference unit per dimension. The index is equal to the value in UnitDimension so that the dimension name can be used to index the list.

Protected Member Functions
void	grantDocumentRelativeUnits ()
	calling this method gives access to document relative units. Only subclasses that manage those units should call it.

virtual bool	hasPercent (int unitDim) const
	indicate if the unit manager has some kind of way of using a percent unit, used by the main class to add percent when necessary.

void	newUnitSymbolToUnitIndex (QString symbol)
	convert a unitChanged signal with a QString to one with an index.

void	recomputeConversionConstant () const

void	recomputeConversionFactor () const

Protected Attributes
Private *	d

Static Protected Attributes
static const QStringList	documentRelativeLengthUnitSymbols = {"px", "vw", "vh"}

static const QStringList	documentRelativeTimeUnitSymbols = {"s", "%"}

Additional Inherited Members
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Detailed Description

The KisSpinBoxUnitManager class is an abstract interface for the unitspinboxes classes to manage different type of units.

The class differentiates between unit dimension (distance, angle, time).

The class allows to convert values between reference unit and apparent unit, but also to get other information like possible units symbols.

This class doesn't allow to use relative units (units whose conversion factor is dependent of the context), even if it's private data is prepared to manage it. The reason for this is that from the library of this class it is very hard to easily access the information needed. So all will be managed by subclasses in other libs.

The class is a subclass of QAbstractListModel, so that available list of units is easily accessed by other Qt standard components, like QComboBoxes.

Definition at line 54 of file kis_spin_box_unit_manager.cpp.

Member Enumeration Documentation

◆ Constrain

enum KisSpinBoxUnitManager::Constrain

Enumerator
NOCONSTR
REFISINT
VALISINT

Definition at line 84 of file kis_spin_box_unit_manager.h.

                  {
        NOCONSTR = 0,
        REFISINT = 1,
        VALISINT = 2
 
    };

◆ UnitDimension

enum KisSpinBoxUnitManager::UnitDimension

Enumerator
LENGTH
IMLENGTH
ANGLE
TIME

Definition at line 72 of file kis_spin_box_unit_manager.h.

                      {
        LENGTH = 0, //length, print size, reference is point
        IMLENGTH = 1, //length, image size, reference is pixel. This dimension is used when the printing units must be avoided
        ANGLE = 2,
        TIME = 3
    };

Constructor & Destructor Documentation

◆ KisSpinBoxUnitManager()

KisSpinBoxUnitManager::KisSpinBoxUnitManager ( QObject * parent = 0 )

explicit

Definition at line 92 of file kis_spin_box_unit_manager.cpp.

                                                            : QAbstractListModel(parent)
{
    d = new Private();
 
    connect(this, (void (KisSpinBoxUnitManager::*)( QString )) &KisSpinBoxUnitManager::unitChanged, this, &KisSpinBoxUnitManager::newUnitSymbolToUnitIndex);
}

References connect(), d, newUnitSymbolToUnitIndex(), and unitChanged().

◆ ~KisSpinBoxUnitManager()

KisSpinBoxUnitManager::~KisSpinBoxUnitManager ( )

override

Definition at line 98 of file kis_spin_box_unit_manager.cpp.

{
    delete d;
}

References d.

Member Function Documentation

◆ clearSyncWithOtherUnitManager

void KisSpinBoxUnitManager::clearSyncWithOtherUnitManager ( KisSpinBoxUnitManager * other )

slot

Definition at line 541 of file kis_spin_box_unit_manager.cpp.

                                                                                      {
 
    int id = d->connectedUnitManagers.indexOf(other);
 
    if (id < 0) {
        return;
    }
 
    disconnect(this, SIGNAL(unitChanged(int)), other, SLOT(selectApparentUnitFromIndex(int))); //unsync units.
    disconnect(other, SIGNAL(unitChanged(int)), this, SLOT(selectApparentUnitFromIndex(int))); //unsync units.
 
    d->connectedUnitManagers.removeAt(id);
 
}

References d, dim, selectApparentUnitFromIndex(), and unitChanged().

◆ conversionConstantChanged

void KisSpinBoxUnitManager::conversionConstantChanged	(	qreal	newConversionFactor,
		qreal	oldConversionFactor ) const

signal

◆ conversionFactorChanged

void KisSpinBoxUnitManager::conversionFactorChanged	(	qreal	newConversionFactor,
		qreal	oldConversionFactor ) const

signal

◆ data()

QVariant KisSpinBoxUnitManager::data	(	const QModelIndex &	index,
		int	role = Qt::DisplayRole ) const

override

Definition at line 304 of file kis_spin_box_unit_manager.cpp.

                                                                             {
 
    if (role == Qt::DisplayRole) {
 
        return getsUnitSymbolList(false).at(index.row());
 
    } else if (role == Qt::ToolTipRole) {
 
        return getsUnitSymbolList(true).at(index.row());
 
    }
 
    return QVariant();
}

References dim, and getsUnitSymbolList().

◆ getApparentUnitId()

int KisSpinBoxUnitManager::getApparentUnitId ( ) const

get the position of the apparent unit in the list of units. It is useful if we want to build a model for combo-box based unit management.

Definition at line 118 of file kis_spin_box_unit_manager.cpp.

{
    QStringList list = getsUnitSymbolList();
    return list.indexOf(d->unitSymbol);
}

References d, and getsUnitSymbolList().

◆ getApparentUnitRecommendedDecimals()

int KisSpinBoxUnitManager::getApparentUnitRecommendedDecimals ( ) const

get a hint of how many decimals the spinbox needs to display.

Definition at line 124 of file kis_spin_box_unit_manager.cpp.

                                                                    {
 
    switch (d->dim) {
 
    case LENGTH:
        if (d->unitSymbol == "px") {
            return 0;
        } else {
            return 2;
        }
    case IMLENGTH:
        if (d->unitSymbol == "px") {
            return 0;
        } else {
            return 2;
        }
    default: //by default return 2.
        break;
    }
 
    return 2;
 
}

References d, IMLENGTH, and LENGTH.

◆ getApparentUnitSymbol()

QString KisSpinBoxUnitManager::getApparentUnitSymbol ( ) const

Definition at line 113 of file kis_spin_box_unit_manager.cpp.

{
    return d->unitSymbol;
}

References d.

◆ getApparentValue()

qreal KisSpinBoxUnitManager::getApparentValue ( double refValue ) const

Definition at line 319 of file kis_spin_box_unit_manager.cpp.

{
    if (!d->conversionFactorIsFixed) {
        recomputeConversionFactor();
    }
 
    if(!d->conversionConstantIsFixed) {
        recomputeConversionConstant();
    }
 
    qreal v = refValue*d->conversionFactor + d->conversionConstant;
 
    if (d->constrains &= VALISINT) {
        v = qFloor(v);
    }
 
    return v;
}

References d, dim, recomputeConversionConstant(), recomputeConversionFactor(), v, and VALISINT.

◆ getConversionConstant()

qreal KisSpinBoxUnitManager::getConversionConstant	(	int	dim,
		QString	symbol ) const

virtual

some units conversions are done via an affine transform, not just a linear transform. This function gives the constant of this affine transform (usually 0).

Reimplemented in KisDocumentAwareSpinBoxUnitManager.

Definition at line 269 of file kis_spin_box_unit_manager.cpp.

{
    Q_UNUSED(dim);
    Q_UNUSED(symbol);
 
    return 0; // all units managed here are transform via a linear function, so this will always be 0 in this class.
}

References dim.

◆ getConversionFactor()

qreal KisSpinBoxUnitManager::getConversionFactor	(	int	dim,
		QString	symbol ) const

virtual

gets the conversion factor of a managed unit, or -1 in case of error. This method is the one that needs to be overridden to extend the ability of the KisSpinBoxUnitManager.

Reimplemented in KisDocumentAwareSpinBoxUnitManager.

Definition at line 338 of file kis_spin_box_unit_manager.cpp.

{
 
    qreal factor = -1;
 
    switch (dim) {
 
    case LENGTH:
        do {
            if (symbol == "px") {
                break;
            }
 
            bool ok;
            KoUnit unit = KoUnit::fromSymbol(symbol, &ok);
            if (! ok) {
                break;
            }
            factor = unit.toUserValuePrecise(1.0); // use the precise function
        } while (0) ;
        break;
 
    case IMLENGTH:
        if (symbol == "px") {
            factor = 1;
        }
        break;
 
    case ANGLE:
        if (symbol == "°") {
            factor = 1.0;
            break;
        }
        if (symbol == "rad") {
            factor = acos(-1)/90.0;
            break;
        }
        if (symbol == "gon") {
            factor = 10.0/9.0;
            break;
        }
        if (symbol == "%") {
            factor = 2.5/9.0; //(25% of circle is 90°)
            break;
        }
        break;
 
    case TIME:
 
        if (symbol != "f") { //we have only frames for the moment.
            break;
        }
        factor = 1.0;
        break;
 
    default:
        break;
    }
 
    return factor;
}

References ANGLE, dim, KoUnit::fromSymbol(), IMLENGTH, LENGTH, TIME, and KoUnit::toUserValuePrecise().

◆ getReferenceUnitSymbol()

QString KisSpinBoxUnitManager::getReferenceUnitSymbol ( ) const

Definition at line 108 of file kis_spin_box_unit_manager.cpp.

{
    return referenceUnitSymbols[d->dim];
}

References d, and referenceUnitSymbols.

◆ getReferenceValue()

qreal KisSpinBoxUnitManager::getReferenceValue ( double apparentValue ) const

Definition at line 277 of file kis_spin_box_unit_manager.cpp.

{
    if (!d->conversionFactorIsFixed) {
        recomputeConversionFactor();
    }
 
    if(!d->conversionConstantIsFixed) {
        recomputeConversionConstant();
    }
 
    qreal v = (apparentValue - d->conversionConstant)/d->conversionFactor;
 
    if (d->constrains &= REFISINT) {
        v = qFloor(v);
    }
 
    return v;
 
}

References d, dim, recomputeConversionConstant(), recomputeConversionFactor(), REFISINT, and v.

◆ getsUnitSymbolList()

QStringList KisSpinBoxUnitManager::getsUnitSymbolList ( bool withName = false ) const

virtual

Definition at line 148 of file kis_spin_box_unit_manager.cpp.

                                                                        {
 
    QStringList list;
 
    if (withName) {
        if (d->unitListWithNameCached) {
            return d->unitListWithName;
        }
    } else {
        if (d->unitListCached) {
            return d->unitList;
        }
    }
 
    switch (d->dim) {
 
    case LENGTH:
 
        for (int i = 0; i < KoUnit::TypeCount; i++) {
 
            if (KoUnit::Type(i) == KoUnit::Pixel) {
                continue; //skip pixel, which is a document relative unit, in the base class.
            }
 
            if (withName) {
                list << KoUnit::unitDescription(KoUnit::Type(i));
            } else {
                list << KoUnit(KoUnit::Type(i)).symbol();
            }
        }
 
        if (hasPercent(LENGTH)) {
 
            if (withName) {
                list << percentStr();
            } else {
                list << "%";
            }
 
        }
 
        if (d->canAccessDocument) {
            // ad document relative units
            if (withName) {
                list << KoUnit::unitDescription(KoUnit::Pixel) << i18n("percent of view width (vw)") << i18n("percent of view height (vh)");
            } else {
                list << documentRelativeLengthUnitSymbols;
            }
        }
 
        break;
 
    case IMLENGTH:
 
        if (withName) {
            list << KoUnit::unitDescription(KoUnit::Pixel);
        } else {
            list << "px";
        }
 
        if (hasPercent(IMLENGTH)) {
 
            if (withName) {
                list << percentStr();
            } else {
                list << "%";
            }
 
        }
 
        if (d->canAccessDocument) {
            // ad document relative units
            if (withName) {
                list << i18n("percent of view width (vw)") << i18n("percent of view height (vh)");
            } else {
                list << "vw" << "vh";
            }
        }
        break;
 
    case ANGLE:
 
        if (withName) {
            list << i18n("degrees (°)") << i18n("radians (rad)") << i18n("gons (gon)") << i18n("percent of circle (%)");
        } else {
            list << "°" << "rad" << "gon" << "%";
        }
        break;
 
    case TIME:
 
        if (withName) {
            list << i18n("frames (f)");
        } else {
            list << "f";
        }
 
        if (d->canAccessDocument) {
            if (withName) {
                list << i18n("seconds (s)") << i18n("percent of animation (%)");
            } else {
                list << documentRelativeTimeUnitSymbols;
            }
        }
 
        break;
 
    }
 
    if (withName) {
        d->unitListWithName = list;
        d->unitListWithNameCached = true;
    } else {
        d->unitList = list;
        d->unitListCached = true;
    }
 
    return list;
 
}

References ANGLE, d, dim, documentRelativeLengthUnitSymbols, documentRelativeTimeUnitSymbols, hasPercent(), IMLENGTH, LENGTH, percentStr(), KoUnit::Pixel, KoUnit::symbol(), TIME, KoUnit::TypeCount, and KoUnit::unitDescription().

◆ getUnitDimensionType()

int KisSpinBoxUnitManager::getUnitDimensionType ( ) const

Definition at line 103 of file kis_spin_box_unit_manager.cpp.

{
    return d->dim;
}

References d.

◆ grantDocumentRelativeUnits()

void KisSpinBoxUnitManager::grantDocumentRelativeUnits ( )

protected

calling this method gives access to document relative units. Only subclasses that manage those units should call it.

Definition at line 611 of file kis_spin_box_unit_manager.cpp.

{
    d->canAccessDocument = true;
}

References d.

◆ hasPercent()

bool KisSpinBoxUnitManager::hasPercent ( int unitDim ) const

protectedvirtual

indicate if the unit manager has some kind of way of using a percent unit, used by the main class to add percent when necessary.

Reimplemented in KisDocumentAwareSpinBoxUnitManager.

Definition at line 564 of file kis_spin_box_unit_manager.cpp.

                                                        {
 
    if (unitDim == IMLENGTH || unitDim == LENGTH) {
        return false;
    }
 
    if (unitDim == TIME) {
        return d->canAccessDocument;
    }
 
    if (unitDim == ANGLE) {
        return true; //percent is fixed when considering angles.
    }
 
    return false;
}

References ANGLE, d, dim, IMLENGTH, LENGTH, and TIME.

◆ isUnitId()

static bool KisSpinBoxUnitManager::isUnitId ( int code )

inlinestatic

Definition at line 79 of file kis_spin_box_unit_manager.h.

79{ return (code == LENGTH || code == ANGLE || code == TIME); }

References TIME.

◆ newUnitSymbolToUnitIndex()

void KisSpinBoxUnitManager::newUnitSymbolToUnitIndex ( QString symbol )

protected

convert a unitChanged signal with a QString to one with an index.

Definition at line 556 of file kis_spin_box_unit_manager.cpp.

                                                                   {
    int id = getsUnitSymbolList().indexOf(symbol);
 
    if (id >= 0) {
        Q_EMIT unitChanged(id);
    }
}

References dim, getsUnitSymbolList(), and unitChanged().

◆ Private()

KisSpinBoxUnitManager::Private	(	KisSpinBoxUnitManager::UnitDimension	pDim = KisSpinBoxUnitManager::LENGTH,
		QString	pUnitSymbol = "pt",
		double	pConv = 1.0 )

inline

Definition at line 57 of file kis_spin_box_unit_manager.cpp.

                               :
        dim(pDim),
        unitSymbol(pUnitSymbol),
        conversionFactor(pConv)
    {
 
    }

◆ recomputeConversionConstant()

void KisSpinBoxUnitManager::recomputeConversionConstant ( ) const

protected

Definition at line 596 of file kis_spin_box_unit_manager.cpp.

{
    if (d->conversionConstantIsFixed) {
        return;
    }
 
    qreal oldConversionConstant = d->conversionConstant;
 
    d->conversionConstant = getConversionConstant(d->dim, d->unitSymbol);
 
    if (oldConversionConstant != d->conversionConstant) {
        Q_EMIT conversionConstantChanged(d->conversionConstant, oldConversionConstant);
    }
}

References conversionConstantChanged(), d, dim, and getConversionConstant().

◆ recomputeConversionFactor()

void KisSpinBoxUnitManager::recomputeConversionFactor ( ) const

protected

Definition at line 581 of file kis_spin_box_unit_manager.cpp.

{
    if (d->conversionFactorIsFixed) {
        return;
    }
 
    qreal oldConversionFactor = d->conversionFactor;
 
    d->conversionFactor = getConversionFactor(d->dim, d->unitSymbol);
 
    if (oldConversionFactor != d->conversionFactor) {
        Q_EMIT conversionFactorChanged(d->conversionFactor, oldConversionFactor);
    }
}

References conversionFactorChanged(), d, dim, and getConversionFactor().

◆ rowCount()

int KisSpinBoxUnitManager::rowCount ( const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 297 of file kis_spin_box_unit_manager.cpp.

                                                                   {
    if (parent == QModelIndex()) {
        return getsUnitSymbolList().size();
    }
    return 0;
}

References getsUnitSymbolList().

◆ selectApparentUnitFromIndex

void KisSpinBoxUnitManager::selectApparentUnitFromIndex ( int index )

slot

Definition at line 513 of file kis_spin_box_unit_manager.cpp.

                                                                 {
 
    if (index >= 0 && index < rowCount()) {
        setApparentUnitFromSymbol(getsUnitSymbolList().at(index));
    }
 
}

References getsUnitSymbolList(), rowCount(), and setApparentUnitFromSymbol().

◆ setApparentUnitFromSymbol

void KisSpinBoxUnitManager::setApparentUnitFromSymbol ( QString pSymbol )

slot

Definition at line 415 of file kis_spin_box_unit_manager.cpp.

{
 
    QString symbol = pSymbol.trimmed();
 
    if (symbol == d->unitSymbol) {
        return;
    }
 
    Q_EMIT unitAboutToChange();
 
    QString newSymb = "";
 
    switch (d->dim) {
 
    case ANGLE:
        if (symbol.toLower() == "deg") {
            newSymb = "°";
            break;
        }
        goto default_identifier; //always do default after handling possible special cases.
 
default_identifier:
    default:
        QStringList list = getsUnitSymbolList();
        if (list.contains(symbol, Qt::CaseInsensitive)) {
            for (QString str : list) {
                if (str.toLower() == symbol.toLower()) {
                    newSymb = str; //official symbol may contain capitals letters, so better take the official version.
                    break;
                }
            }
            break;
        }
 
    }
 
    if(newSymb.isEmpty()) {
        return; //abort if it was impossible to locate the correct symbol.
    }
 
    if (d->canAccessDocument) {
        //manage document relative units.
 
        QStringList speUnits;
 
        switch (d->dim) {
 
        case LENGTH:
            speUnits = documentRelativeLengthUnitSymbols;
            goto default_identifier_conv_fact;
 
        case IMLENGTH:
            speUnits << "vw" << "vh";
            goto default_identifier_conv_fact;
 
        case TIME:
            speUnits = documentRelativeTimeUnitSymbols;
            goto default_identifier_conv_fact;
 
default_identifier_conv_fact:
        default:
 
            if (speUnits.isEmpty()) {
                d->conversionFactorIsFixed = true;
                break;
            }
 
            if (speUnits.contains(newSymb)) {
                d->conversionFactorIsFixed = false;
                break;
            }
 
            d->conversionFactorIsFixed = true;
            break;
        }
 
        if (d->dim == TIME) {
            if (newSymb == "%") {
                d->conversionConstantIsFixed = false;
            }
        } else {
            d->conversionConstantIsFixed = true;
        }
 
    }
 
    qreal conversionFact = getConversionFactor(d->dim, newSymb);
    qreal oldConversionFact = d->conversionFactor;
 
    d->conversionFactor = conversionFact;
    Q_EMIT conversionFactorChanged(d->conversionFactor, oldConversionFact);
 
    d->unitSymbol = newSymb;
    Q_EMIT unitChanged(newSymb);
 
}

References ANGLE, conversionFactorChanged(), d, dim, documentRelativeLengthUnitSymbols, documentRelativeTimeUnitSymbols, getConversionFactor(), getsUnitSymbolList(), IMLENGTH, LENGTH, TIME, unitAboutToChange(), and unitChanged().

◆ setUnitDimension

void KisSpinBoxUnitManager::setUnitDimension ( UnitDimension dimension )

slot

Definition at line 401 of file kis_spin_box_unit_manager.cpp.

{
    if (dimension == d->dim) {
        return;
    }
 
    d->dim = dimension;
    d->unitSymbol = referenceUnitSymbols[d->dim]; //Active dim is reference dim when just changed.
    d->conversionFactor = 1.0;
 
    Q_EMIT unitDimensionChanged(d->dim);
 
}

References d, dim, referenceUnitSymbols, and unitDimensionChanged().

◆ syncWithOtherUnitManager

void KisSpinBoxUnitManager::syncWithOtherUnitManager ( KisSpinBoxUnitManager * other )

slot

Definition at line 522 of file kis_spin_box_unit_manager.cpp.

                                                                                 {
 
    if (d->connectedUnitManagers.indexOf(other) >= 0) {
        return;
    }
 
    if (other->getUnitDimensionType() == getUnitDimensionType()) { //sync only unitmanager of the same type.
        if (other->getsUnitSymbolList() == getsUnitSymbolList()) { //and if we have identical units available.
 
            connect(this, SIGNAL(unitChanged(int)), other, SLOT(selectApparentUnitFromIndex(int))); //sync units.
            connect(other, SIGNAL(unitChanged(int)), this, SLOT(selectApparentUnitFromIndex(int))); //sync units.
 
            d->connectedUnitManagers.append(other);
 
        }
    }
 
}

References connect(), d, dim, getsUnitSymbolList(), getUnitDimensionType(), selectApparentUnitFromIndex(), and unitChanged().

◆ unitAboutToChange

void KisSpinBoxUnitManager::unitAboutToChange ( )

signal

◆ unitChanged [1/2]

void KisSpinBoxUnitManager::unitChanged ( int index )

signal

◆ unitChanged [2/2]

void KisSpinBoxUnitManager::unitChanged ( QString symbol )

signal

◆ unitDimensionChanged

void KisSpinBoxUnitManager::unitDimensionChanged ( int dimCode )

signal

◆ unitListChanged

void KisSpinBoxUnitManager::unitListChanged ( )

signal

Member Data Documentation

◆ canAccessDocument

bool KisSpinBoxUnitManager::canAccessDocument {false}

Definition at line 87 of file kis_spin_box_unit_manager.cpp.

87{false};

◆ connectedUnitManagers

QVector<KisSpinBoxUnitManager*> KisSpinBoxUnitManager::connectedUnitManagers

Definition at line 89 of file kis_spin_box_unit_manager.cpp.

◆ constrains

KisSpinBoxUnitManager::Constrains KisSpinBoxUnitManager::constrains { KisSpinBoxUnitManager::NOCONSTR }

Definition at line 75 of file kis_spin_box_unit_manager.cpp.

75{ KisSpinBoxUnitManager::NOCONSTR };

◆ conversionConstant

double KisSpinBoxUnitManager::conversionConstant {0}

mutable

Definition at line 72 of file kis_spin_box_unit_manager.cpp.

72{0};

◆ conversionConstantIsFixed

bool KisSpinBoxUnitManager::conversionConstantIsFixed {true}

Definition at line 73 of file kis_spin_box_unit_manager.cpp.

73{true}; //tell if it's possible to trust the conversion constant stored or if it's needed to recompute it.

◆ conversionFactor

double KisSpinBoxUnitManager::conversionFactor

mutable

Definition at line 70 of file kis_spin_box_unit_manager.cpp.

◆ conversionFactorIsFixed

bool KisSpinBoxUnitManager::conversionFactorIsFixed {true}

Definition at line 71 of file kis_spin_box_unit_manager.cpp.

71{true}; //tell if it's possible to trust the conversion factor stored or if it's needed to recompute it.

◆ d

Private* KisSpinBoxUnitManager::d

protected

Definition at line 141 of file kis_spin_box_unit_manager.h.

◆ dim

KisSpinBoxUnitManager::UnitDimension KisSpinBoxUnitManager::dim

Definition at line 67 of file kis_spin_box_unit_manager.cpp.

◆ documentRelativeLengthUnitSymbols

const QStringList KisSpinBoxUnitManager::documentRelativeLengthUnitSymbols = {"px", "vw", "vh"}

staticprotected

Definition at line 51 of file kis_spin_box_unit_manager.h.

◆ documentRelativeTimeUnitSymbols

const QStringList KisSpinBoxUnitManager::documentRelativeTimeUnitSymbols = {"s", "%"}

staticprotected

Definition at line 52 of file kis_spin_box_unit_manager.h.

◆ hasHundredPercent

bool KisSpinBoxUnitManager::hasHundredPercent {false}

Definition at line 84 of file kis_spin_box_unit_manager.cpp.

84{false};

◆ hundredPercent

qreal KisSpinBoxUnitManager::hundredPercent {0}

Definition at line 85 of file kis_spin_box_unit_manager.cpp.

85{0};

◆ referenceUnitSymbols

const QStringList KisSpinBoxUnitManager::referenceUnitSymbols = {"pt", "px", "°", "frame"}

static

this list holds the symbols of the reference unit per dimension. The index is equal to the value in UnitDimension so that the dimension name can be used to index the list.

Definition at line 49 of file kis_spin_box_unit_manager.h.

◆ unitList

QStringList KisSpinBoxUnitManager::unitList

mutable

Definition at line 77 of file kis_spin_box_unit_manager.cpp.

◆ unitListCached

bool KisSpinBoxUnitManager::unitListCached {false}

mutable

Definition at line 78 of file kis_spin_box_unit_manager.cpp.

78{false};

◆ unitListWithName

QStringList KisSpinBoxUnitManager::unitListWithName

mutable

Definition at line 80 of file kis_spin_box_unit_manager.cpp.

◆ unitListWithNameCached

bool KisSpinBoxUnitManager::unitListWithNameCached {false}

mutable

Definition at line 81 of file kis_spin_box_unit_manager.cpp.

81{false};

◆ unitSymbol

QString KisSpinBoxUnitManager::unitSymbol

Definition at line 69 of file kis_spin_box_unit_manager.cpp.

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

libs/widgetutils/kis_spin_box_unit_manager.cpp
libs/widgetutils/kis_spin_box_unit_manager.h

Public Attributes
bool	canAccessDocument {false}

QVector< KisSpinBoxUnitManager * >	connectedUnitManagers

KisSpinBoxUnitManager::Constrains	constrains { KisSpinBoxUnitManager::NOCONSTR }

double	conversionConstant {0}

bool	conversionConstantIsFixed {true}

double	conversionFactor

bool	conversionFactorIsFixed {true}

KisSpinBoxUnitManager::UnitDimension	dim

bool	hasHundredPercent {false}

qreal	hundredPercent {0}

QStringList	unitList

bool	unitListCached {false}

QStringList	unitListWithName

bool	unitListWithNameCached {false}

QString	unitSymbol

Public Types

Public Slots

Signals

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Constrain

◆ UnitDimension

Constructor & Destructor Documentation

◆ KisSpinBoxUnitManager()

◆ ~KisSpinBoxUnitManager()

Member Function Documentation

◆ clearSyncWithOtherUnitManager

◆ conversionConstantChanged

◆ conversionFactorChanged

◆ data()

◆ getApparentUnitId()

◆ getApparentUnitRecommendedDecimals()

◆ getApparentUnitSymbol()

◆ getApparentValue()

◆ getConversionConstant()

◆ getConversionFactor()

◆ getReferenceUnitSymbol()

◆ getReferenceValue()

◆ getsUnitSymbolList()

◆ getUnitDimensionType()

◆ grantDocumentRelativeUnits()

◆ hasPercent()

◆ isUnitId()

◆ newUnitSymbolToUnitIndex()

◆ Private()

◆ recomputeConversionConstant()

◆ recomputeConversionFactor()

◆ rowCount()

◆ selectApparentUnitFromIndex

◆ setApparentUnitFromSymbol

◆ setUnitDimension

◆ syncWithOtherUnitManager

◆ unitAboutToChange

◆ unitChanged [1/2]

◆ unitChanged [2/2]

◆ unitDimensionChanged

◆ unitListChanged

Member Data Documentation

◆ canAccessDocument

◆ connectedUnitManagers

◆ constrains

◆ conversionConstant

◆ conversionConstantIsFixed

◆ conversionFactor

◆ conversionFactorIsFixed

◆ d

◆ dim

◆ documentRelativeLengthUnitSymbols

◆ documentRelativeTimeUnitSymbols

◆ hasHundredPercent

◆ hundredPercent

◆ referenceUnitSymbols

◆ unitList

◆ unitListCached

◆ unitListWithName

◆ unitListWithNameCached

◆ unitSymbol