The KisDocumentAwareSpinBoxUnitManager class is a KisSpinBoxUnitManager that is able to connect to the current document to compute transformation for document relative units (the ones that depend of the resolution, or the size in pixels of the image). More...

#include <kis_document_aware_spin_box_unit_manager.h>

Inheritance diagram for KisDocumentAwareSpinBoxUnitManager:

Public Types
enum	PixDir { PIX_DIR_X , PIX_DIR_Y }

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

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

Public Member Functions
qreal	getConversionConstant (int dim, QString symbol) const override

qreal	getConversionFactor (int dim, QString psymbol) const override

	KisDocumentAwareSpinBoxUnitManager (QObject *parent=0, int pPixDir=PIX_DIR_X)

Public Member Functions inherited from KisSpinBoxUnitManager
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

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 KisDoubleParseUnitSpinBox *	createUnitSpinBoxWithDocumentAwareness (QWidget *parent=0)
	create a unitSpinBox that is already document aware.

static void	setDocumentAwarenessToExistingUnitSpinBox (KisDoubleParseUnitSpinBox *spinBox, bool setUnitFromOutsideToggle=false)
	configure a KisDocumentAwareSpinBoxUnitManager for the given spinbox (make the manager a child of the spinbox and attach it to the spinbox).

Static Public Member Functions inherited from KisSpinBoxUnitManager
static bool	isUnitId (int code)

Protected Member Functions
virtual bool	hasPercent (int unitDim) const override

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

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

void	recomputeConversionConstant () const

void	recomputeConversionFactor () const

Protected Attributes
PixDir	pixDir

Protected Attributes inherited from KisSpinBoxUnitManager
Private *	d

Additional Inherited Members
Public Slots inherited from KisSpinBoxUnitManager
void	clearSyncWithOtherUnitManager (KisSpinBoxUnitManager *other)

void	selectApparentUnitFromIndex (int index)

void	setApparentUnitFromSymbol (QString pSymbol)

void	setUnitDimension (UnitDimension dimension)

void	syncWithOtherUnitManager (KisSpinBoxUnitManager *other)

Signals inherited from KisSpinBoxUnitManager
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 Attributes inherited from KisSpinBoxUnitManager
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

Static Public Attributes inherited from KisSpinBoxUnitManager
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.

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

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

Detailed Description

The KisDocumentAwareSpinBoxUnitManager class is a KisSpinBoxUnitManager that is able to connect to the current document to compute transformation for document relative units (the ones that depend of the resolution, or the size in pixels of the image).

See also: KisSpinBoxUnitManager

Definition at line 26 of file kis_document_aware_spin_box_unit_manager.h.

Member Enumeration Documentation

◆ PixDir

enum KisDocumentAwareSpinBoxUnitManager::PixDir

Enumerator
PIX_DIR_X
PIX_DIR_Y

Definition at line 32 of file kis_document_aware_spin_box_unit_manager.h.

                {
        PIX_DIR_X,
        PIX_DIR_Y
    }; //in case the image has not the same x and y resolution, indicate on which direction get the resolution.

Constructor & Destructor Documentation

◆ KisDocumentAwareSpinBoxUnitManager()

KisDocumentAwareSpinBoxUnitManager::KisDocumentAwareSpinBoxUnitManager	(	QObject *	parent = 0,
		int	pPixDir = PIX_DIR_X )

Definition at line 39 of file kis_document_aware_spin_box_unit_manager.cpp.

                                                                                                  :
    KisSpinBoxUnitManager(parent)
{
    if (pPixDir == PIX_DIR_Y) {
        pixDir = PIX_DIR_Y;
    } else {
        pixDir = PIX_DIR_X;
    }
 
    grantDocumentRelativeUnits(); //the purpose of this class is to manage document relative units.
}

References KisSpinBoxUnitManager::dim, KisSpinBoxUnitManager::grantDocumentRelativeUnits(), PIX_DIR_X, PIX_DIR_Y, and pixDir.

Member Function Documentation

◆ createUnitSpinBoxWithDocumentAwareness()

KisDoubleParseUnitSpinBox * KisDocumentAwareSpinBoxUnitManager::createUnitSpinBoxWithDocumentAwareness ( QWidget * parent = 0 )

static

create a unitSpinBox that is already document aware.

Definition at line 31 of file kis_document_aware_spin_box_unit_manager.cpp.

{
    KisDoubleParseUnitSpinBox* spinBox = new KisDoubleParseUnitSpinBox(parent);
    setDocumentAwarenessToExistingUnitSpinBox(spinBox);
 
    return spinBox;
}

References setDocumentAwarenessToExistingUnitSpinBox().

◆ getConversionConstant()

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

overridevirtual

See also: KisSpinBoxUnitManager

Reimplemented from KisSpinBoxUnitManager.

Definition at line 154 of file kis_document_aware_spin_box_unit_manager.cpp.

{
    if (dim == TIME && symbol == "%") {
        KisImage* img = KisPart::instance()->currentMainwindow()->activeView()->document()->image().data();
        const KisTimeSpan & time_range = img->animationInterface()->documentPlaybackRange();
        qreal n_frame = time_range.end() - time_range.start();
 
        return -time_range.start()*100.0/n_frame;
    }
 
    return KisSpinBoxUnitManager::getConversionConstant(dim, symbol);
}

References KisMainWindow::activeView, KisPart::currentMainwindow(), KisSpinBoxUnitManager::dim, KisTimeSpan::end(), KisSpinBoxUnitManager::getConversionConstant(), KisPart::instance(), and KisSpinBoxUnitManager::TIME.

◆ getConversionFactor()

qreal KisDocumentAwareSpinBoxUnitManager::getConversionFactor	(	int	dim,
		QString	psymbol ) const

overridevirtual

See also: KisSpinBoxUnitManager

Reimplemented from KisSpinBoxUnitManager.

Definition at line 52 of file kis_document_aware_spin_box_unit_manager.cpp.

{
    QString symbol = psymbol;
 
    if (symbol == "%") { //percent can be seen as vw or vh depending of the reference side in the image.
        if (pixDir == PIX_DIR_X) {
            symbol = "vw";
        } else {
            symbol = "vh";
        }
    }
 
    qreal factor = KisSpinBoxUnitManager::getConversionFactor(dim, symbol);
 
    if (factor > 0) {
        //no errors occurred at a lower level, so the conversion factor has been get.
        return factor;
    }
 
    factor = 1; //fall back to something natural in case document is unreachable (1 px = 1 pt = 1vw = 1vh). So a virtual document of 100x100 with a resolution of 1.
 
    if (!KisPart::instance()->currentMainwindow()) {
        return factor;
    }
 
    KisView* view = KisPart::instance()->currentMainwindow()->activeView();
 
    if (view == nullptr) {
        return factor;
    }
 
    KisDocument* doc = view->document();
 
    if (doc == nullptr) {
        return factor;
    }
 
    KisImage* img = doc->image().data();
 
    if (img == nullptr) {
        return factor;
    }
 
    qreal resX = img->xRes();
    qreal resY = img->yRes();
    qreal sizeX = img->width();
    qreal sizeY = img->height();
 
    switch (dim) {
 
    case LENGTH:
        if (symbol == "px") {
 
            if (pixDir == PIX_DIR_X) {
                factor = resX;
            } else {
                factor = resY;
            }
        } else if (symbol == "vw") {
            qreal docWidth = sizeX/resX;
 
            factor = 100.0/docWidth; //1 vw is 1% of document width, 1 vw in point is docWidth/100 so 1 point in vw is the inverse.
        } else if (symbol == "vh") {
            qreal docHeight = sizeY/resY;
 
            factor = 100.0/docHeight;
        }
        break;
 
    case IMLENGTH:
 
        if (symbol == "vw") {
            factor = 100.0/sizeX; //1 vw is 1% of document width, 1 vw in pixel is sizeX/100 so 1 pixel in vw is the inverse.
 
        } else if (symbol == "vh") {
            factor = 100.0/sizeY;
        }
        break;
 
    case TIME:
    {
        if (symbol == "s") {
            qreal fps = img->animationInterface()->framerate();
 
            factor = 1/fps;
        } else if (symbol == "%") {
            const KisTimeSpan & time_range = img->animationInterface()->documentPlaybackRange();
            qreal n_frame = time_range.end() - time_range.start();
 
            factor = 100/n_frame;
        }
    }
        break;
 
    default:
        break;
 
    }
 
    return factor;
}

References KisMainWindow::activeView, KisPart::currentMainwindow(), KisSharedPtr< T >::data(), KisSpinBoxUnitManager::dim, KisView::document, KisTimeSpan::end(), KisSpinBoxUnitManager::getConversionFactor(), KisDocument::image, KisSpinBoxUnitManager::IMLENGTH, KisPart::instance(), KisSpinBoxUnitManager::LENGTH, PIX_DIR_X, pixDir, KisSpinBoxUnitManager::TIME, and KisImage::xRes().

◆ hasPercent()

bool KisDocumentAwareSpinBoxUnitManager::hasPercent ( int unitDim ) const

overrideprotectedvirtual

See also: KisSpinBoxUnitManager

Reimplemented from KisSpinBoxUnitManager.

Definition at line 168 of file kis_document_aware_spin_box_unit_manager.cpp.

                                                                     {
 
    if (unitDim == IMLENGTH || unitDim == LENGTH) {
        return true;
    }
 
    return KisSpinBoxUnitManager::hasPercent(unitDim);
}

References KisSpinBoxUnitManager::dim, KisSpinBoxUnitManager::hasPercent(), KisSpinBoxUnitManager::IMLENGTH, and KisSpinBoxUnitManager::LENGTH.

◆ setDocumentAwarenessToExistingUnitSpinBox()

void KisDocumentAwareSpinBoxUnitManager::setDocumentAwarenessToExistingUnitSpinBox	(	KisDoubleParseUnitSpinBox *	spinBox,
		bool	setUnitFromOutsideToggle = false )

static

configure a KisDocumentAwareSpinBoxUnitManager for the given spinbox (make the manager a child of the spinbox and attach it to the spinbox).

Definition at line 24 of file kis_document_aware_spin_box_unit_manager.cpp.

{
    KisDocumentAwareSpinBoxUnitManager* manager = new KisDocumentAwareSpinBoxUnitManager(spinBox);
    spinBox->setUnitManager(manager);
    spinBox->setUnitChangeFromOutsideBehavior(setUnitFromOutsideToggle);
}

References KisSpinBoxUnitManager::dim, KisDocumentAwareSpinBoxUnitManager(), KisDoubleParseUnitSpinBox::setUnitChangeFromOutsideBehavior(), and KisDoubleParseUnitSpinBox::setUnitManager().

Member Data Documentation

◆ pixDir

PixDir KisDocumentAwareSpinBoxUnitManager::pixDir

protected

Definition at line 55 of file kis_document_aware_spin_box_unit_manager.h.

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

libs/ui/utils/kis_document_aware_spin_box_unit_manager.h
libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ PixDir

Constructor & Destructor Documentation

◆ KisDocumentAwareSpinBoxUnitManager()

Member Function Documentation

◆ createUnitSpinBoxWithDocumentAwareness()

◆ getConversionConstant()

◆ getConversionFactor()

◆ hasPercent()

◆ setDocumentAwarenessToExistingUnitSpinBox()

Member Data Documentation

◆ pixDir