WdgImageSize Class Reference

#include <wdg_imagesize.h>

Inheritance diagram for WdgImageSize:

Signals
void	sigDesiredSizeChanged (qint32 width, qint32 height, double resolution)

Public Member Functions
qint32	desiredHeight ()
double	desiredResolution ()
qint32	desiredWidth ()
KisFilterStrategy *	filterType ()
	WdgImageSize (QWidget *parent, int width, int height, double resolution)
	~WdgImageSize () override

Static Public Attributes
static const QString	PARAM_IMSIZE_UNIT = WdgImageSize::PARAM_PREFIX + "_imsizeunit"
static const QString	PARAM_PREFIX = "imagesizedlg"
static const QString	PARAM_PRINT_SIZE_SEPARATE = WdgImageSize::PARAM_PREFIX + "_printSizeSeparatly"
static const QString	PARAM_RATIO_LOCK = WdgImageSize::PARAM_PREFIX + "_ratioLock"
static const QString	PARAM_RES_UNIT = WdgImageSize::PARAM_PREFIX + "_resunit"
static const QString	PARAM_SIZE_UNIT = WdgImageSize::PARAM_PREFIX + "_sizeunit"

Private Slots
void	slotAdjustSeparatelySwitched (bool value)
void	slotLockAllRatioSwitched (bool value)
void	slotLockPixelRatioSwitched (bool value)
void	slotLockPrintRatioSwitched (bool value)
void	slotPrintResolutionChanged ()
void	slotPrintResolutionUnitChanged ()
void	slotSyncPixelToPrintSize ()
void	slotSyncPrintToPixelSize ()

Private Member Functions
qreal	currentResolutionPPI () const
void	setCurrentResolutionPPI (qreal value)
void	updatePrintSizeMaximum ()

Private Attributes
KisDocumentAwareSpinBoxUnitManager *	m_heightUnitManager
QSize	m_originalSize
PageImageSize *	m_page
KisAspectRatioLocker *	m_pixelSizeLocker
KisAspectRatioLocker *	m_printSizeLocker
KisSpinBoxUnitManager *	m_printSizeUnitManager
KisDocumentAwareSpinBoxUnitManager *	m_widthUnitManager

Detailed Description

Definition at line 20 of file wdg_imagesize.h.

Constructor & Destructor Documentation

WdgImageSize()

WdgImageSize::WdgImageSize	(	QWidget *	parent,
		int	width,
		int	height,
		double	resolution )

Initialize Pixel Width and Height fields

configure the unit to image length, default unit is pixel and printing units are forbidden.

add custom units

Connect Pixel Unit switching controls

Initialize Print Width, Height and Resolution fields

Initialize labels and layout

Initialize aspect ratio buttons and lockers

Connect Keep Aspect Lock buttons

Connect Print Unit switching controls

connect resolution

Create syncing connections between Pixel and Print values

Initialize printing values from the predefined image values

Initialize aspect ratio lockers with the current proportion.

Definition at line 64 of file wdg_imagesize.cc.

    : QWidget(parent)
{
    // Store original size.
    m_originalSize.setWidth(width);
    m_originalSize.setHeight(height);
 
    m_page = new PageImageSize(this);
 
    Q_CHECK_PTR(m_page);
    m_page->layout()->setContentsMargins(0, 0, 0, 0);
    m_page->setObjectName("image_size");
 
    m_page->pixelFilterCmb->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
    m_page->pixelFilterCmb->allowAuto(true);
    m_page->pixelFilterCmb->setToolTip(KisFilterStrategyRegistry::instance()->formattedDescriptions());
 
    if (lastUsedFilter) { // Restore or Init..
        m_page->pixelFilterCmb->setCurrent(lastUsedFilter->id());
    } else {
        m_page->pixelFilterCmb->setCurrent(KisCmbIDList::AutoOptionID);
    }
 
    connect(this, &WdgImageSize::sigDesiredSizeChanged, [this](qint32 width, qint32 height, double){
        KisFilterStrategy *filterStrategy = KisFilterStrategyRegistry::instance()->autoFilterStrategy(m_originalSize, QSize(width, height));
        m_page->pixelFilterCmb->setAutoHint(filterStrategy->name());
    });
 
    m_widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
    m_heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
    KisConfig cfg(true);
 
    m_widthUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
    m_heightUnitManager->setUnitDimension(KisSpinBoxUnitManager::IMLENGTH);
 
    m_widthUnitManager->syncWithOtherUnitManager(m_heightUnitManager); //sync the two managers, so that the units will be the same, but each manager will know a different reference for percents.
 
    m_widthUnitManager->setApparentUnitFromSymbol("px"); //set unit to pixel.
 
    m_page->pixelWidthDouble->setUnitManager(m_widthUnitManager);
    m_page->pixelHeightDouble->setUnitManager(m_heightUnitManager);
    m_page->pixelWidthDouble->setMaximum(maxImagePixelSize);
    m_page->pixelHeightDouble->setMaximum(maxImagePixelSize);
    m_page->pixelWidthDouble->changeValue(width);
    m_page->pixelHeightDouble->changeValue(height);
    m_page->pixelWidthDouble->setDisplayUnit(false);
    m_page->pixelHeightDouble->setDisplayUnit(false);
    m_page->pixelWidthDouble->setFocus();
 
    connect(m_page->pixelWidthDouble, qOverload<double>(&KisDoubleParseUnitSpinBox::valueChanged), [this](){
        Q_EMIT sigDesiredSizeChanged(desiredWidth(), desiredHeight(), desiredResolution());
    });
    connect(m_page->pixelHeightDouble, qOverload<double>(&KisDoubleParseUnitSpinBox::valueChanged), [this](){
        Q_EMIT sigDesiredSizeChanged(desiredWidth(), desiredHeight(), desiredResolution());
    });
 
 
    int unitId = m_widthUnitManager->getApparentUnitId();
 
    m_page->pixelSizeUnit->setModel(m_widthUnitManager);
    m_page->pixelSizeUnit->setCurrentIndex(unitId);
 
    KisAcyclicSignalConnector *pixelUnitConnector = new KisAcyclicSignalConnector(this);
    pixelUnitConnector->connectForwardInt(m_page->pixelSizeUnit, SIGNAL(currentIndexChanged(int)),
                                          m_widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
    pixelUnitConnector->connectBackwardInt(m_widthUnitManager, SIGNAL(unitChanged(int)),
                                           m_page->pixelSizeUnit, SLOT(setCurrentIndex(int)));
 
    QString imSizeUnit = cfg.readEntry<QString>(PARAM_IMSIZE_UNIT, "px");
 
    m_widthUnitManager->setApparentUnitFromSymbol(imSizeUnit);
 
    m_printSizeUnitManager = new KisSpinBoxUnitManager(this);
 
    m_page->printWidth->setUnitManager(m_printSizeUnitManager);
    m_page->printHeight->setUnitManager(m_printSizeUnitManager);
    m_page->printWidth->setDisplayUnit(false);
    m_page->printHeight->setDisplayUnit(false);
    m_page->printResolution->setAlignment(Qt::AlignRight);
 
    m_page->printWidthUnit->setModel(m_printSizeUnitManager);
 
    //TODO: create a resolution dimension in the unit manager.
    m_page->printResolutionUnit->addItem(pixelsInchStr());
    m_page->printResolutionUnit->addItem(pixelsCentimeterStr());
 
 
    KisSizeGroup *labelsGroup = new KisSizeGroup(this);
    labelsGroup->addWidget(m_page->lblPixelWidth);
    labelsGroup->addWidget(m_page->lblPixelHeight);
    labelsGroup->addWidget(m_page->lblPixelFilter);
    labelsGroup->addWidget(m_page->lblPrintWidth);
    labelsGroup->addWidget(m_page->lblPrintHeight);
    labelsGroup->addWidget(m_page->lblResolution);
 
    KisSizeGroup *spinboxesGroup = new KisSizeGroup(this);
    spinboxesGroup->addWidget(m_page->pixelWidthDouble);
    spinboxesGroup->addWidget(m_page->pixelHeightDouble);
    spinboxesGroup->addWidget(m_page->printWidth);
    spinboxesGroup->addWidget(m_page->printHeight);
    spinboxesGroup->addWidget(m_page->printResolution);
 
    KisSizeGroup *comboboxesGroup = new KisSizeGroup(this);
    comboboxesGroup->addWidget(m_page->pixelSizeUnit);
    comboboxesGroup->addWidget(m_page->printWidthUnit);
    comboboxesGroup->addWidget(m_page->printResolutionUnit);
    connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
    m_page->pixelAspectRatioBtn->setKeepAspectRatio(true);
    m_page->printAspectRatioBtn->setKeepAspectRatio(true);
    m_page->constrainProportionsCkb->setChecked(true);
 
    m_pixelSizeLocker = new KisAspectRatioLocker(this);
    m_pixelSizeLocker->connectSpinBoxes(m_page->pixelWidthDouble, m_page->pixelHeightDouble, m_page->pixelAspectRatioBtn);
 
    m_printSizeLocker = new KisAspectRatioLocker(this);
    m_printSizeLocker->connectSpinBoxes(m_page->printWidth, m_page->printHeight, m_page->printAspectRatioBtn);
 
    KisAcyclicSignalConnector *constrainsConnector = new KisAcyclicSignalConnector(this);
    constrainsConnector->connectBackwardBool(
        m_page->constrainProportionsCkb, SIGNAL(toggled(bool)),
        this, SLOT(slotLockAllRatioSwitched(bool)));
 
    constrainsConnector->connectForwardBool(
        m_pixelSizeLocker, SIGNAL(aspectButtonToggled(bool)),
        this, SLOT(slotLockPixelRatioSwitched(bool)));
 
    constrainsConnector->createCoordinatedConnector()->connectBackwardBool(
        m_printSizeLocker, SIGNAL(aspectButtonToggled(bool)),
        this, SLOT(slotLockPrintRatioSwitched(bool)));
 
    constrainsConnector->createCoordinatedConnector()->connectBackwardBool(
        m_page->adjustPrintSizeSeparatelyCkb, SIGNAL(toggled(bool)),
        this, SLOT(slotAdjustSeparatelySwitched(bool)));
 
    KisAcyclicSignalConnector *printUnitConnector = new KisAcyclicSignalConnector(this);
    printUnitConnector->connectForwardInt(
        m_page->printWidthUnit, SIGNAL(currentIndexChanged(int)),
        m_printSizeUnitManager, SLOT(selectApparentUnitFromIndex(int)));
 
    printUnitConnector->connectBackwardInt(
        m_printSizeUnitManager, SIGNAL(unitChanged(int)),
        m_page->printWidthUnit, SLOT(setCurrentIndex(int)));
 
    connect(m_page->printResolutionUnit, SIGNAL(currentIndexChanged(int)),
            this, SLOT(slotPrintResolutionUnitChanged()));
 
    KisAcyclicSignalConnector *syncConnector = new KisAcyclicSignalConnector(this);
    syncConnector->connectForwardVoid(
        m_pixelSizeLocker, SIGNAL(sliderValueChanged()),
        this, SLOT(slotSyncPixelToPrintSize()));
 
    syncConnector->connectBackwardVoid(
        m_printSizeLocker, SIGNAL(sliderValueChanged()),
        this, SLOT(slotSyncPrintToPixelSize()));
 
    syncConnector->createCoordinatedConnector()->connectBackwardVoid(
        m_page->printResolution, SIGNAL(valueChanged(double)),
        this, SLOT(slotPrintResolutionChanged()));
 
 
    QString printSizeUnit;
 
    if (QLocale().measurementSystem() == QLocale::MetricSystem) {
        printSizeUnit = "cm";
    } else { // Imperial
        printSizeUnit = "in";
    }
 
    printSizeUnit = cfg.readEntry<QString>(PARAM_SIZE_UNIT, printSizeUnit);
 
    m_printSizeUnitManager->setApparentUnitFromSymbol(printSizeUnit);
 
    setCurrentResolutionPPI(resolution);
    slotSyncPixelToPrintSize();
 
    m_pixelSizeLocker->updateAspect();
    m_printSizeLocker->updateAspect();
 
    QString printResUnit = cfg.readEntry<QString>(PARAM_RES_UNIT, "");
    m_page->printResolutionUnit->setCurrentText(printResUnit);
 
    m_page->constrainProportionsCkb->setChecked(cfg.readEntry<bool>(PARAM_RATIO_LOCK, true));
    m_page->adjustPrintSizeSeparatelyCkb->setChecked(cfg.readEntry<bool>(PARAM_PRINT_SIZE_SEPARATE, false));
 
    QHBoxLayout *l = new QHBoxLayout();
    l->addWidget(m_page);
    this->setLayout(l);
 
    m_page->pixelWidthDouble->setFocus();
}

References KisSizeGroup::addWidget(), KisFilterStrategyRegistry::autoFilterStrategy(), KisCmbIDList::AutoOptionID, connect(), KisAcyclicSignalConnector::connectBackwardBool(), KisAcyclicSignalConnector::connectBackwardInt(), KisAcyclicSignalConnector::connectBackwardVoid(), KisAcyclicSignalConnector::connectForwardBool(), KisAcyclicSignalConnector::connectForwardInt(), KisAcyclicSignalConnector::connectForwardVoid(), KisAspectRatioLocker::connectSpinBoxes(), KisAcyclicSignalConnector::createCoordinatedConnector(), KisSpinBoxUnitManager::getApparentUnitId(), KisFilterStrategy::id(), KisSpinBoxUnitManager::IMLENGTH, KisFilterStrategyRegistry::instance(), lastUsedFilter, m_heightUnitManager, m_originalSize, m_page, m_pixelSizeLocker, m_printSizeLocker, m_printSizeUnitManager, m_widthUnitManager, maxImagePixelSize, KisFilterStrategy::name(), PARAM_IMSIZE_UNIT, PARAM_PRINT_SIZE_SEPARATE, PARAM_RATIO_LOCK, PARAM_RES_UNIT, PARAM_SIZE_UNIT, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y, pixelsCentimeterStr(), pixelsInchStr(), KisConfig::readEntry(), KisSpinBoxUnitManager::setApparentUnitFromSymbol(), setCurrentResolutionPPI(), KisSpinBoxUnitManager::setUnitDimension(), sigDesiredSizeChanged(), slotAdjustSeparatelySwitched(), slotLockAllRatioSwitched(), slotLockPixelRatioSwitched(), slotLockPrintRatioSwitched(), slotPrintResolutionChanged(), slotPrintResolutionUnitChanged(), slotSyncPixelToPrintSize(), slotSyncPrintToPixelSize(), KisSpinBoxUnitManager::syncWithOtherUnitManager(), and KisAspectRatioLocker::updateAspect().

~WdgImageSize()

WdgImageSize::~WdgImageSize ( )

override

Definition at line 296 of file wdg_imagesize.cc.

{
    KisConfig cfg(false);
    cfg.writeEntry<bool>(PARAM_PRINT_SIZE_SEPARATE, m_page->adjustPrintSizeSeparatelyCkb->isChecked());
    cfg.writeEntry<bool>(PARAM_RATIO_LOCK, m_page->constrainProportionsCkb->isChecked());
 
    cfg.writeEntry<QString>(PARAM_IMSIZE_UNIT, m_widthUnitManager->getApparentUnitSymbol());
    cfg.writeEntry<QString>(PARAM_SIZE_UNIT, m_printSizeUnitManager->getApparentUnitSymbol());
    cfg.writeEntry<QString>(PARAM_RES_UNIT, m_page->printResolutionUnit->currentText());
 
    delete m_page;
}

References KisSpinBoxUnitManager::getApparentUnitSymbol(), m_page, m_printSizeUnitManager, m_widthUnitManager, PARAM_IMSIZE_UNIT, PARAM_PRINT_SIZE_SEPARATE, PARAM_RATIO_LOCK, PARAM_RES_UNIT, PARAM_SIZE_UNIT, and KisConfig::writeEntry().

Member Function Documentation

currentResolutionPPI()

qreal WdgImageSize::currentResolutionPPI ( ) const

private

Definition at line 425 of file wdg_imagesize.cc.

{
    qreal resolution = m_page->printResolution->value();
 
    if (m_page->printResolutionUnit->currentText() == pixelsInchStr()) {
        resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Point), KoUnit(KoUnit::Inch));
    } else {
        resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Point), KoUnit(KoUnit::Centimeter));
    }
 
    return resolution;
}

References KoUnit::Centimeter, KoUnit::convertFromUnitToUnit(), KoUnit::Inch, m_page, pixelsInchStr(), and KoUnit::Point.

desiredHeight()

qint32 WdgImageSize::desiredHeight

(

)

Definition at line 314 of file wdg_imagesize.cc.

{
    return qRound(m_page->pixelHeightDouble->value());
}

References m_page.

desiredResolution()

double WdgImageSize::desiredResolution

(

)

Definition at line 319 of file wdg_imagesize.cc.

{
    return currentResolutionPPI();
}

References currentResolutionPPI().

desiredWidth()

qint32 WdgImageSize::desiredWidth

(

)

Definition at line 309 of file wdg_imagesize.cc.

{
    return qRound(m_page->pixelWidthDouble->value());
}

References m_page.

filterType()

KisFilterStrategy * WdgImageSize::filterType

(

)

Definition at line 324 of file wdg_imagesize.cc.

{
    KoID filterID = m_page->pixelFilterCmb->currentItem();
 
    KisFilterStrategy *filter;
    if (filterID == KisCmbIDList::AutoOptionID) {
        filter = KisFilterStrategyRegistry::instance()->autoFilterStrategy(m_originalSize, QSize(desiredWidth(), desiredHeight()));
    } else {
        filter = KisFilterStrategyRegistry::instance()->value(filterID.id());
        lastUsedFilter = filter;  // Save for next time!
    }
 
    return filter;
}

References KisFilterStrategyRegistry::autoFilterStrategy(), KisCmbIDList::AutoOptionID, desiredHeight(), desiredWidth(), KoID::id(), KisFilterStrategyRegistry::instance(), lastUsedFilter, m_originalSize, m_page, and KoGenericRegistry< T >::value().

setCurrentResolutionPPI()

void WdgImageSize::setCurrentResolutionPPI ( qreal value )

private

Definition at line 438 of file wdg_imagesize.cc.

{
    qreal newValue = value;
 
    if (m_page->printResolutionUnit->currentText() == pixelsInchStr()) {
        newValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Point));
    } else {
        newValue = KoUnit::convertFromUnitToUnit(value, KoUnit(KoUnit::Centimeter), KoUnit(KoUnit::Point));
    }
 
    {
        KisSignalsBlocker b(m_page->printResolution);
        m_page->printResolution->setValue(newValue);
    }
 
    updatePrintSizeMaximum();
}

References KoUnit::Centimeter, KoUnit::convertFromUnitToUnit(), KoUnit::Inch, m_page, pixelsInchStr(), KoUnit::Point, updatePrintSizeMaximum(), and value().

sigDesiredSizeChanged

void WdgImageSize::sigDesiredSizeChanged ( qint32 width, qint32 height, double resolution )

signal

slotAdjustSeparatelySwitched

void WdgImageSize::slotAdjustSeparatelySwitched ( bool value )

privateslot

Definition at line 419 of file wdg_imagesize.cc.

{
    m_page->printAspectRatioBtn->setEnabled(!value);
    m_page->printAspectRatioBtn->setKeepAspectRatio(!value ? m_page->constrainProportionsCkb->isChecked() : true);
}

References m_page, and value().

slotLockAllRatioSwitched

void WdgImageSize::slotLockAllRatioSwitched ( bool value )

privateslot

Definition at line 408 of file wdg_imagesize.cc.

{
    const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
    m_page->pixelAspectRatioBtn->setKeepAspectRatio(value);
 
    if (!printIsSeparate) {
        m_page->printAspectRatioBtn->setKeepAspectRatio(value);
    }
}

References m_page, and value().

slotLockPixelRatioSwitched

void WdgImageSize::slotLockPixelRatioSwitched ( bool value )

privateslot

Definition at line 392 of file wdg_imagesize.cc.

{
    const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
    if (!printIsSeparate) {
        m_page->printAspectRatioBtn->setKeepAspectRatio(value);
    }
    m_page->constrainProportionsCkb->setChecked(value);
}

References m_page, and value().

slotLockPrintRatioSwitched

void WdgImageSize::slotLockPrintRatioSwitched ( bool value )

privateslot

Definition at line 402 of file wdg_imagesize.cc.

{
    m_page->pixelAspectRatioBtn->setKeepAspectRatio(value);
    m_page->constrainProportionsCkb->setChecked(value);
}

References m_page, and value().

slotPrintResolutionChanged

void WdgImageSize::slotPrintResolutionChanged ( )

privateslot

Definition at line 363 of file wdg_imagesize.cc.

{
    const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
    if (printIsSeparate) {
        slotSyncPixelToPrintSize();
    } else {
        slotSyncPrintToPixelSize();
    }
 
    updatePrintSizeMaximum();
}

References m_page, slotSyncPixelToPrintSize(), slotSyncPrintToPixelSize(), and updatePrintSizeMaximum().

slotPrintResolutionUnitChanged

void WdgImageSize::slotPrintResolutionUnitChanged ( )

privateslot

Definition at line 376 of file wdg_imagesize.cc.

{
    qreal resolution = m_page->printResolution->value();
 
    if (m_page->printResolutionUnit->currentText() == pixelsInchStr()) {
        resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Inch), KoUnit(KoUnit::Centimeter));
    } else {
        resolution = KoUnit::convertFromUnitToUnit(resolution, KoUnit(KoUnit::Centimeter), KoUnit(KoUnit::Inch));
    }
 
    {
        KisSignalsBlocker b(m_page->printResolution);
        m_page->printResolution->setValue(resolution);
    }
}

References KoUnit::Centimeter, KoUnit::convertFromUnitToUnit(), KoUnit::Inch, m_page, and pixelsInchStr().

slotSyncPixelToPrintSize

void WdgImageSize::slotSyncPixelToPrintSize ( )

privateslot

Definition at line 353 of file wdg_imagesize.cc.

{
    const qreal resolution = currentResolutionPPI();
    if (resolution != 0.0) {
        KisSignalsBlocker b(m_page->printWidth, m_page->printHeight);
        m_page->printWidth->changeValue(m_page->pixelWidthDouble->value() / resolution);
        m_page->printHeight->changeValue(m_page->pixelHeightDouble->value() / resolution);
    }
}

References currentResolutionPPI(), and m_page.

slotSyncPrintToPixelSize

void WdgImageSize::slotSyncPrintToPixelSize ( )

privateslot

Definition at line 339 of file wdg_imagesize.cc.

{
    const bool printIsSeparate = m_page->adjustPrintSizeSeparatelyCkb->isChecked();
 
    if (!printIsSeparate) {
        KisSignalsBlocker b(m_page->pixelWidthDouble, m_page->pixelHeightDouble);
        m_page->pixelWidthDouble->changeValue(m_page->printWidth->value() * currentResolutionPPI());
        m_page->pixelHeightDouble->changeValue(m_page->printHeight->value() * currentResolutionPPI());
    } else if (m_page->pixelWidthDouble->value() != 0.0) {
        const qreal resolution = qMax(0.001, m_page->pixelWidthDouble->value() / m_page->printWidth->value());
        setCurrentResolutionPPI(resolution);
    }
}

References currentResolutionPPI(), m_page, and setCurrentResolutionPPI().

updatePrintSizeMaximum()

void WdgImageSize::updatePrintSizeMaximum ( )

private

Definition at line 456 of file wdg_imagesize.cc.

{
    const qreal value = currentResolutionPPI();
    if (value == 0.0) return;
 
    m_page->printWidth->setMaximum(maxImagePixelSize / value);
    m_page->printHeight->setMaximum(maxImagePixelSize / value);
}

References currentResolutionPPI(), m_page, maxImagePixelSize, and value().

Member Data Documentation

m_heightUnitManager

KisDocumentAwareSpinBoxUnitManager* WdgImageSize::m_heightUnitManager

private

Definition at line 70 of file wdg_imagesize.h.

m_originalSize

QSize WdgImageSize::m_originalSize

private

Definition at line 64 of file wdg_imagesize.h.

m_page

PageImageSize* WdgImageSize::m_page

private

Definition at line 62 of file wdg_imagesize.h.

m_pixelSizeLocker

KisAspectRatioLocker* WdgImageSize::m_pixelSizeLocker

private

Definition at line 66 of file wdg_imagesize.h.

m_printSizeLocker

KisAspectRatioLocker* WdgImageSize::m_printSizeLocker

private

Definition at line 67 of file wdg_imagesize.h.

m_printSizeUnitManager

KisSpinBoxUnitManager* WdgImageSize::m_printSizeUnitManager

private

Definition at line 71 of file wdg_imagesize.h.

m_widthUnitManager

KisDocumentAwareSpinBoxUnitManager* WdgImageSize::m_widthUnitManager

private

Definition at line 69 of file wdg_imagesize.h.

PARAM_IMSIZE_UNIT

const QString WdgImageSize::PARAM_IMSIZE_UNIT = WdgImageSize::PARAM_PREFIX + "_imsizeunit"

static

Definition at line 27 of file wdg_imagesize.h.

PARAM_PREFIX

const QString WdgImageSize::PARAM_PREFIX = "imagesizedlg"

static

Definition at line 26 of file wdg_imagesize.h.

PARAM_PRINT_SIZE_SEPARATE

const QString WdgImageSize::PARAM_PRINT_SIZE_SEPARATE = WdgImageSize::PARAM_PREFIX + "_printSizeSeparatly"

static

Definition at line 31 of file wdg_imagesize.h.

PARAM_RATIO_LOCK

const QString WdgImageSize::PARAM_RATIO_LOCK = WdgImageSize::PARAM_PREFIX + "_ratioLock"

static

Definition at line 30 of file wdg_imagesize.h.

PARAM_RES_UNIT

const QString WdgImageSize::PARAM_RES_UNIT = WdgImageSize::PARAM_PREFIX + "_resunit"

static

Definition at line 29 of file wdg_imagesize.h.

PARAM_SIZE_UNIT

const QString WdgImageSize::PARAM_SIZE_UNIT = WdgImageSize::PARAM_PREFIX + "_sizeunit"

static

Definition at line 28 of file wdg_imagesize.h.

---

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

• libs/ui/imagesize/wdg_imagesize.h
• libs/ui/imagesize/wdg_imagesize.cc