DlgCanvasSize Class Reference

#include <dlg_canvassize.h>

Inheritance diagram for DlgCanvasSize:

Public Types
enum	anchor {   NORTH_WEST = 0 , NORTH , NORTH_EAST , WEST ,   CENTER , EAST , SOUTH_WEST , SOUTH ,   SOUTH_EAST , NONE }
Public Types inherited from KoDialog
enum	ButtonCode {   None = 0x00000000 , Help = 0x00000001 , Default = 0x00000002 , Ok = 0x00000004 ,   Apply = 0x00000008 , Try = 0x00000010 , Cancel = 0x00000020 , Close = 0x00000040 ,   No = 0x00000080 , Yes = 0x00000100 , Reset = 0x00000200 , Details = 0x00000400 ,   User1 = 0x00001000 , User2 = 0x00002000 , User3 = 0x00004000 , NoDefault = 0x00008000 }
enum	ButtonPopupMode { InstantPopup = 0 , DelayedPopup = 1 }
enum	CaptionFlag { NoCaptionFlags = 0 , AppNameCaption = 1 , ModifiedCaption = 2 , HIGCompliantCaption = AppNameCaption }

Public Member Functions
	DlgCanvasSize (QWidget *parent, int width, int height, double resolution)
qint32	height ()
qint32	width ()
qint32	xOffset ()
qint32	yOffset ()
	~DlgCanvasSize () override
Public Member Functions inherited from KoDialog
QPushButton *	button (ButtonCode id) const
QIcon	buttonIcon (ButtonCode id) const
QString	buttonText (ButtonCode id) const
QString	buttonToolTip (ButtonCode id) const
QString	buttonWhatsThis (ButtonCode id) const
ButtonCode	defaultButton () const
QString	helpLinkText () const
void	incrementInitialSize (const QSize &size)
bool	isButtonEnabled (ButtonCode id) const
	KoDialog (QWidget *parent=0, Qt::WindowFlags f=Qt::WindowFlags())
QWidget *	mainWidget ()
QSize	minimumSizeHint () const override
void	setButtonFocus (ButtonCode id)
void	setButtonGuiItem (ButtonCode id, const KGuiItem &item)
void	setButtonIcon (ButtonCode id, const QIcon &icon)
void	setButtons (ButtonCodes buttonMask)
void	setButtonsOrientation (Qt::Orientation orientation)
void	setButtonText (ButtonCode id, const QString &text)
void	setButtonToolTip (ButtonCode id, const QString &text)
void	setButtonWhatsThis (ButtonCode id, const QString &text)
void	setDefaultButton (ButtonCode id)
void	setEscapeButton (ButtonCode id)
void	setInitialSize (const QSize &size)
void	setMainWidget (QWidget *widget)
void	showButton (ButtonCode id, bool state)
void	showButtonSeparator (bool state)
QSize	sizeHint () const override
	~KoDialog () override

Public Attributes
WdgCanvasSize *	m_page

Static Public Attributes
static const QString	PARAM_HEIGHT_UNIT = DlgCanvasSize::PARAM_PREFIX + "_heightunit"
static const QString	PARAM_PREFIX = "canvasizedlg"
static const QString	PARAM_WIDTH_UNIT = DlgCanvasSize::PARAM_PREFIX + "_widthunit"
static const QString	PARAM_XOFFSET_UNIT = DlgCanvasSize::PARAM_PREFIX + "_xoffsetunit"
static const QString	PARAM_YOFFSET_UNIT = DlgCanvasSize::PARAM_PREFIX + "_yoffsetunit"

Private Slots
void	slotAnchorButtonClicked (int)
void	slotAspectChanged (bool keep)
void	slotCanvasPreviewXOffsetChanged (int v)
void	slotCanvasPreviewYOffsetChanged (int v)
void	slotHeightChanged (double v)
void	slotWidthChanged (double v)
void	slotXOffsetChanged (double v)
void	slotYOffsetChanged (double v)
void	updatexOffsetIcon (bool v)
void	updateyOffsetIcon (bool v)

Private Member Functions
void	expectedOffset (int id, double &xOffset, double &yOffset)
void	loadAnchorIcons ()
void	updateAnchorIcons (int id)
void	updateButtons (int forceId)
void	updateOffset (int id)

Private Attributes
KisDocumentAwareSpinBoxUnitManager *	_heightUnitManager
KisDocumentAwareSpinBoxUnitManager *	_widthUnitManager
KisDocumentAwareSpinBoxUnitManager *	_xOffsetUnitManager
KisDocumentAwareSpinBoxUnitManager *	_yOffsetUnitManager
QIcon	m_anchorIcons [9]
const double	m_aspectRatio
QButtonGroup *	m_group
bool	m_keepAspect
int	m_newHeight
int	m_newWidth
const int	m_originalHeight
const int	m_originalWidth
const double	m_resolution
int	m_xOffset
int	m_yOffset

Additional Inherited Members
Public Slots inherited from KoDialog
void	delayedDestruct ()
void	enableButton (ButtonCode id, bool state)
void	enableButtonApply (bool state)
void	enableButtonCancel (bool state)
void	enableButtonOk (bool state)
void	enableLinkedHelp (bool state)
bool	isDetailsWidgetVisible () const
virtual void	setCaption (const QString &caption)
virtual void	setCaption (const QString &caption, bool modified)
void	setDetailsWidget (QWidget *detailsWidget)
void	setDetailsWidgetVisible (bool visible)
void	setHelp (const QString &anchor, const QString &appname=QString())
void	setHelpLinkText (const QString &text)
virtual void	setPlainCaption (const QString &caption)
Signals inherited from KoDialog
void	aboutToShowDetails ()
void	applyClicked ()
void	buttonClicked (KoDialog::ButtonCode button)
void	cancelClicked ()
void	closeClicked ()
void	defaultClicked ()
void	finished ()
void	helpClicked ()
void	hidden ()
void	layoutHintChanged ()
void	noClicked ()
void	okClicked ()
void	resetClicked ()
void	tryClicked ()
void	user1Clicked ()
void	user2Clicked ()
void	user3Clicked ()
void	yesClicked ()
Static Public Member Functions inherited from KoDialog
static int	groupSpacingHint ()
static QString	makeStandardCaption (const QString &userCaption, QWidget *window=0, CaptionFlags flags=HIGCompliantCaption)
static int	marginHint ()
static void	resizeLayout (QLayout *lay, int margin, int spacing)
static void	resizeLayout (QWidget *widget, int margin, int spacing)
static int	spacingHint ()
Protected Slots inherited from KoDialog
virtual void	slotButtonClicked (int button)
Protected Member Functions inherited from KoDialog
void	closeEvent (QCloseEvent *e) override
void	hideEvent (QHideEvent *) override
void	keyPressEvent (QKeyEvent *) override
void	showEvent (QShowEvent *e) override

Detailed Description

Definition at line 31 of file dlg_canvassize.h.

Member Enumeration Documentation

anchor

enum DlgCanvasSize::anchor

Enumerator
NORTH_WEST
NORTH
NORTH_EAST
WEST
CENTER
EAST
SOUTH_WEST
SOUTH
SOUTH_EAST
NONE

Definition at line 37 of file dlg_canvassize.h.

{ NORTH_WEST = 0, NORTH, NORTH_EAST, WEST, CENTER, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST, NONE};

Constructor & Destructor Documentation

DlgCanvasSize()

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

Definition at line 28 of file dlg_canvassize.cc.

    : KoDialog(parent)
    , m_keepAspect(true)
    , m_aspectRatio((double)width / height)
    , m_resolution(resolution)
    , m_originalWidth(width)
    , m_originalHeight(height)
    , m_newWidth(width)
    , m_newHeight(height)
    , m_xOffset(0)
    , m_yOffset(0)
{
    setCaption(i18n("Resize Canvas"));
    setButtons(Ok | Cancel);
    setDefaultButton(Ok);
 
    m_page = new WdgCanvasSize(this);
    Q_CHECK_PTR(m_page);
    m_page->layout()->setContentsMargins(0, 0, 0, 0);
    m_page->setObjectName("canvas_size");
 
    _widthUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
    _heightUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
    KisConfig cfg(true);
 
    _widthUnitManager->setApparentUnitFromSymbol("px");
    _heightUnitManager->setApparentUnitFromSymbol("px");
 
    m_page->newWidthDouble->setUnitManager(_widthUnitManager);
    m_page->newHeightDouble->setUnitManager(_heightUnitManager);
    m_page->newWidthDouble->setDisplayUnit(false);
    m_page->newHeightDouble->setDisplayUnit(false);
 
    m_page->newWidthDouble->setValue(width);
    m_page->newWidthDouble->setFocus();
    m_page->newHeightDouble->setValue(height);
 
    m_page->widthUnit->setModel(_widthUnitManager);
    m_page->heightUnit->setModel(_heightUnitManager);
 
    QString unitw = cfg.readEntry<QString>(PARAM_WIDTH_UNIT, "px");
    QString unith = cfg.readEntry<QString>(PARAM_HEIGHT_UNIT, "px");
 
    _widthUnitManager->setApparentUnitFromSymbol(unitw);
    _heightUnitManager->setApparentUnitFromSymbol(unith);
 
    const int wUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf(unitw);
    const int hUnitIndex = _widthUnitManager->getsUnitSymbolList().indexOf(unith);
 
    m_page->widthUnit->setCurrentIndex(wUnitIndex);
    m_page->heightUnit->setCurrentIndex(hUnitIndex);
 
    _xOffsetUnitManager = new KisDocumentAwareSpinBoxUnitManager(this);
    _yOffsetUnitManager = new KisDocumentAwareSpinBoxUnitManager(this, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y);
 
    _xOffsetUnitManager->setApparentUnitFromSymbol("px");
    _yOffsetUnitManager->setApparentUnitFromSymbol("px");
 
    m_page->xOffsetDouble->setUnitManager(_xOffsetUnitManager);
    m_page->yOffsetDouble->setUnitManager(_yOffsetUnitManager);
    m_page->xOffsetDouble->setDisplayUnit(false);
    m_page->yOffsetDouble->setDisplayUnit(false);
 
    m_page->xOffUnit->setModel(_xOffsetUnitManager);
    m_page->yOffUnit->setModel(_yOffsetUnitManager);
 
    m_page->xOffsetDouble->changeValue(m_xOffset);
    m_page->yOffsetDouble->changeValue(m_yOffset);
 
    QString unitx = cfg.readEntry<QString>(PARAM_XOFFSET_UNIT, "px");
    QString unity = cfg.readEntry<QString>(PARAM_YOFFSET_UNIT, "px");
 
    _xOffsetUnitManager->setApparentUnitFromSymbol(unitx);
    _yOffsetUnitManager->setApparentUnitFromSymbol(unity);
 
    const int xUnitIndex = _xOffsetUnitManager->getsUnitSymbolList().indexOf(unitx);
    const int yUnitIndex = _yOffsetUnitManager->getsUnitSymbolList().indexOf(unity);
 
    m_page->xOffUnit->setCurrentIndex(xUnitIndex);
    m_page->yOffUnit->setCurrentIndex(yUnitIndex);
 
    QIcon lockedIcon = KisIconUtils::loadIcon("locked");
    QIcon unlockedIcon = KisIconUtils::loadIcon("unlocked");
    m_page->lockxOffset->setCheckable(true);
    m_page->lockyOffset->setCheckable(true);
    m_page->lockxOffset->setChecked(false);
    m_page->lockyOffset->setChecked(false);
    m_page->lockxOffset-> setIcon(m_page->lockxOffset->isChecked() ? lockedIcon : unlockedIcon);
    m_page->lockyOffset-> setIcon(m_page->lockyOffset->isChecked() ? lockedIcon : unlockedIcon);
 
    m_page->canvasPreview->setImageSize(m_originalWidth, m_originalHeight);
    m_page->canvasPreview->setCanvasSize(m_originalWidth, m_originalHeight);
    m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
 
    m_page->aspectRatioBtn->setKeepAspectRatio(cfg.readEntry("CanvasSize/KeepAspectRatio", false));
    m_page->constrainProportionsCkb->setChecked(cfg.readEntry("CanvasSize/ConstrainProportions", false));
    m_keepAspect = cfg.readEntry("CanvasSize/KeepAspectRatio", false);
 
 
    m_group = new QButtonGroup(m_page);
    m_group->addButton(m_page->topLeft, NORTH_WEST);
    m_group->addButton(m_page->topCenter, NORTH);
    m_group->addButton(m_page->topRight, NORTH_EAST);
 
    m_group->addButton(m_page->middleLeft, WEST);
    m_group->addButton(m_page->middleCenter, CENTER);
    m_group->addButton(m_page->middleRight, EAST);
 
    m_group->addButton(m_page->bottomLeft, SOUTH_WEST);
    m_group->addButton(m_page->bottomCenter, SOUTH);
    m_group->addButton(m_page->bottomRight, SOUTH_EAST);
 
    loadAnchorIcons();
    m_group->button(CENTER)->setChecked(true);
    updateAnchorIcons(CENTER);
 
    KisSizeGroup *labelsGroup = new KisSizeGroup(this);
    labelsGroup->addWidget(m_page->lblNewWidth);
    labelsGroup->addWidget(m_page->lblNewHeight);
    labelsGroup->addWidget(m_page->lblXOff);
    labelsGroup->addWidget(m_page->lblYOff);
    labelsGroup->addWidget(m_page->lblAnchor);
 
    KisSizeGroup *spinboxesGroup = new KisSizeGroup(this);
    spinboxesGroup->addWidget(m_page->newWidthDouble);
    spinboxesGroup->addWidget(m_page->newHeightDouble);
    spinboxesGroup->addWidget(m_page->xOffsetDouble);
    spinboxesGroup->addWidget(m_page->yOffsetDouble);
 
    KisSizeGroup *comboboxesGroup = new KisSizeGroup(this);
    comboboxesGroup->addWidget(m_page->widthUnit);
    comboboxesGroup->addWidget(m_page->heightUnit);
    comboboxesGroup->addWidget(m_page->xOffUnit);
    comboboxesGroup->addWidget(m_page->yOffUnit);
 
    setMainWidget(m_page);
    connect(this, SIGNAL(okClicked()), this, SLOT(accept()));
 
    connect(m_page->newWidthDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotWidthChanged(double)));
    connect(m_page->newHeightDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotHeightChanged(double)));
    connect(m_page->widthUnit, SIGNAL(currentIndexChanged(int)), _widthUnitManager, SLOT(selectApparentUnitFromIndex(int)));
    connect(m_page->heightUnit, SIGNAL(currentIndexChanged(int)), _heightUnitManager, SLOT(selectApparentUnitFromIndex(int)));
    connect(_widthUnitManager, SIGNAL(unitChanged(int)), m_page->widthUnit, SLOT(setCurrentIndex(int)));
    connect(_heightUnitManager, SIGNAL(unitChanged(int)), m_page->heightUnit, SLOT(setCurrentIndex(int)));
 
    connect(m_page->xOffsetDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotXOffsetChanged(double)));
    connect(m_page->yOffsetDouble, SIGNAL(valueChangedPt(double)), this, SLOT(slotYOffsetChanged(double)));
    connect(m_page->xOffUnit, SIGNAL(currentIndexChanged(int)), _xOffsetUnitManager, SLOT(selectApparentUnitFromIndex(int)));
    connect(m_page->yOffUnit, SIGNAL(currentIndexChanged(int)), _yOffsetUnitManager, SLOT(selectApparentUnitFromIndex(int)));
    connect(_xOffsetUnitManager, SIGNAL(unitChanged(int)), m_page->xOffUnit, SLOT(setCurrentIndex(int)));
    connect(_yOffsetUnitManager, SIGNAL(unitChanged(int)), m_page->yOffUnit, SLOT(setCurrentIndex(int)));
 
    connect(m_page->lockxOffset, SIGNAL(toggled(bool)), this, SLOT(updatexOffsetIcon(bool)));
    connect(m_page->lockyOffset, SIGNAL(toggled(bool)), this, SLOT(updateyOffsetIcon(bool)));
    connect(m_page->lockxOffset, SIGNAL(toggled(bool)), m_page->canvasPreview , SLOT(setxOffsetLock(bool)));
    connect(m_page->lockyOffset, SIGNAL(toggled(bool)), m_page->canvasPreview , SLOT(setyOffsetLock(bool)));
 
    connect(m_page->constrainProportionsCkb, SIGNAL(toggled(bool)), this, SLOT(slotAspectChanged(bool)));
    connect(m_page->aspectRatioBtn, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotAspectChanged(bool)));
 
    connect(m_group, SIGNAL(idClicked(int)), SLOT(slotAnchorButtonClicked(int)));
    connect(m_page->canvasPreview, SIGNAL(sigModifiedXOffset(int)), this, SLOT(slotCanvasPreviewXOffsetChanged(int)));
    connect(m_page->canvasPreview, SIGNAL(sigModifiedYOffset(int)), this, SLOT(slotCanvasPreviewYOffsetChanged(int)));
}

References _heightUnitManager, _widthUnitManager, _xOffsetUnitManager, _yOffsetUnitManager, KisSizeGroup::addWidget(), KoDialog::Cancel, CENTER, EAST, KisSpinBoxUnitManager::getsUnitSymbolList(), height(), loadAnchorIcons(), KisIconUtils::loadIcon(), m_group, m_keepAspect, m_originalHeight, m_originalWidth, m_page, m_xOffset, m_yOffset, NORTH, NORTH_EAST, NORTH_WEST, KoDialog::Ok, KoDialog::okClicked(), PARAM_HEIGHT_UNIT, PARAM_WIDTH_UNIT, PARAM_XOFFSET_UNIT, PARAM_YOFFSET_UNIT, KisDocumentAwareSpinBoxUnitManager::PIX_DIR_Y, KisConfig::readEntry(), KisSpinBoxUnitManager::setApparentUnitFromSymbol(), KoDialog::setButtons(), KoDialog::setCaption(), KoDialog::setDefaultButton(), KoDialog::setMainWidget(), slotAnchorButtonClicked(), slotAspectChanged(), slotCanvasPreviewXOffsetChanged(), slotCanvasPreviewYOffsetChanged(), slotHeightChanged(), slotWidthChanged(), slotXOffsetChanged(), slotYOffsetChanged(), SOUTH, SOUTH_EAST, SOUTH_WEST, updateAnchorIcons(), updatexOffsetIcon(), updateyOffsetIcon(), WEST, and width().

~DlgCanvasSize()

DlgCanvasSize::~DlgCanvasSize ( )

override

Definition at line 194 of file dlg_canvassize.cc.

{
    KisConfig cfg(false);
    cfg.writeEntry<bool>("CanvasSize/KeepAspectRatio", m_page->aspectRatioBtn->keepAspectRatio());
    cfg.writeEntry<bool>("CanvasSize/ConstrainProportions", m_page->constrainProportionsCkb->isChecked());
 
    cfg.writeEntry<QString>(PARAM_WIDTH_UNIT, _widthUnitManager->getApparentUnitSymbol());
    cfg.writeEntry<QString>(PARAM_HEIGHT_UNIT, _heightUnitManager->getApparentUnitSymbol());
 
    cfg.writeEntry<QString>(PARAM_XOFFSET_UNIT, _xOffsetUnitManager->getApparentUnitSymbol());
    cfg.writeEntry<QString>(PARAM_YOFFSET_UNIT, _yOffsetUnitManager->getApparentUnitSymbol());
 
    delete m_page;
}

References _heightUnitManager, _widthUnitManager, _xOffsetUnitManager, _yOffsetUnitManager, KisSpinBoxUnitManager::getApparentUnitSymbol(), m_page, PARAM_HEIGHT_UNIT, PARAM_WIDTH_UNIT, PARAM_XOFFSET_UNIT, PARAM_YOFFSET_UNIT, and KisConfig::writeEntry().

Member Function Documentation

expectedOffset()

void DlgCanvasSize::expectedOffset ( int id, double & xOffset, double & yOffset )

private

Definition at line 499 of file dlg_canvassize.cc.

{
    const double xCoeff = (id % 3) * 0.5;
    const double yCoeff = (int)(id / 3.0) * 0.5;
 
    const int xDiff = m_newWidth - m_originalWidth;
    const int yDiff = m_newHeight - m_originalHeight;
 
    //convert to unitmanager default unit.
    xOffset = xDiff * xCoeff / _xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
    yOffset = yDiff * yCoeff / _yOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
}

References _xOffsetUnitManager, _yOffsetUnitManager, KisDocumentAwareSpinBoxUnitManager::getConversionFactor(), KisSpinBoxUnitManager::LENGTH, m_newHeight, m_newWidth, m_originalHeight, m_originalWidth, xOffset(), and yOffset().

height()

qint32 DlgCanvasSize::height

(

)

Definition at line 214 of file dlg_canvassize.cc.

{
    return (qint32) m_newHeight;
}

References m_newHeight.

loadAnchorIcons()

void DlgCanvasSize::loadAnchorIcons ( )

private

Definition at line 351 of file dlg_canvassize.cc.

{
 
    m_anchorIcons[NORTH_WEST] =  KisIconUtils::loadIcon("arrow-topleft");
    m_anchorIcons[NORTH] = KisIconUtils::loadIcon("arrow-up");
    m_anchorIcons[NORTH_EAST] = KisIconUtils::loadIcon("arrow-topright");
    m_anchorIcons[EAST] = KisIconUtils::loadIcon("arrow-right");
    m_anchorIcons[CENTER] = KisIconUtils::loadIcon("arrow_center");
    m_anchorIcons[WEST] = KisIconUtils::loadIcon("arrow-left");
    m_anchorIcons[SOUTH_WEST] = KisIconUtils::loadIcon("arrow-downleft");
    m_anchorIcons[SOUTH] = KisIconUtils::loadIcon("arrow-down");
    m_anchorIcons[SOUTH_EAST] = KisIconUtils::loadIcon("arrow-downright");
 
}

References CENTER, EAST, KisIconUtils::loadIcon(), m_anchorIcons, NORTH, NORTH_EAST, NORTH_WEST, SOUTH, SOUTH_EAST, SOUTH_WEST, and WEST.

slotAnchorButtonClicked

void DlgCanvasSize::slotAnchorButtonClicked ( int id )

privateslot

Definition at line 263 of file dlg_canvassize.cc.

{
    updateOffset(id);
    updateButtons(id);
}

References updateButtons(), and updateOffset().

slotAspectChanged

void DlgCanvasSize::slotAspectChanged ( bool keep )

privateslot

Definition at line 229 of file dlg_canvassize.cc.

{
    m_page->aspectRatioBtn->blockSignals(true);
    m_page->constrainProportionsCkb->blockSignals(true);
 
    m_page->aspectRatioBtn->setKeepAspectRatio(keep);
    m_page->constrainProportionsCkb->setChecked(keep);
 
    m_page->aspectRatioBtn->blockSignals(false);
    m_page->constrainProportionsCkb->blockSignals(false);
 
    m_keepAspect = keep;
 
 
    if (keep) {
        // Do a dummy update of all the data to force it to recalculate the offset and size
        m_xOffset = 0;
        m_yOffset = 0;
 
        double h = m_page->newHeightDouble->valuePt();
        double w = m_page->newWidthDouble->valuePt();
 
        m_page->canvasPreview->blockSignals(true);
        m_page->canvasPreview->setCanvasSize(w, h);
        m_page->newWidthDouble->setValuePt(w);
        m_page->newHeightDouble->setValuePt(h);
        m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
        m_page->canvasPreview->blockSignals(false);
        updateOffset(CENTER);
        updateButtons(CENTER);
 
    }
}

References CENTER, m_keepAspect, m_page, m_xOffset, m_yOffset, updateButtons(), and updateOffset().

slotCanvasPreviewXOffsetChanged

void DlgCanvasSize::slotCanvasPreviewXOffsetChanged ( int v )

privateslot

Definition at line 338 of file dlg_canvassize.cc.

{
    double newVal = v / _xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
    m_page->xOffsetDouble->changeValue(newVal);
}

References _xOffsetUnitManager, KisDocumentAwareSpinBoxUnitManager::getConversionFactor(), KisSpinBoxUnitManager::LENGTH, m_page, and v.

slotCanvasPreviewYOffsetChanged

void DlgCanvasSize::slotCanvasPreviewYOffsetChanged ( int v )

privateslot

Definition at line 344 of file dlg_canvassize.cc.

{
 
    double newVal = v / _yOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
    m_page->yOffsetDouble->changeValue(newVal);
}

References _yOffsetUnitManager, KisDocumentAwareSpinBoxUnitManager::getConversionFactor(), KisSpinBoxUnitManager::LENGTH, m_page, and v.

slotHeightChanged

void DlgCanvasSize::slotHeightChanged ( double v )

privateslot

Definition at line 290 of file dlg_canvassize.cc.

{
    //this slot receives values in pt from the unitspinbox, so just use the resolution.
    const double resValue = v*_heightUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
    m_newHeight = qRound(resValue);
 
    if (m_keepAspect) {
        m_newWidth = qRound(m_newHeight * m_aspectRatio);
        m_page->newWidthDouble->blockSignals(true);
        m_page->newWidthDouble->changeValue(v * m_aspectRatio);
        m_page->newWidthDouble->blockSignals(false);
    }
 
    int savedId = m_group->checkedId();
    m_page->canvasPreview->blockSignals(true);
    m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
    m_page->canvasPreview->blockSignals(false);
    updateOffset(savedId);
    updateButtons(savedId);
}

References _heightUnitManager, KisDocumentAwareSpinBoxUnitManager::getConversionFactor(), KisSpinBoxUnitManager::LENGTH, m_aspectRatio, m_group, m_keepAspect, m_newHeight, m_newWidth, m_page, updateButtons(), updateOffset(), and v.

slotWidthChanged

void DlgCanvasSize::slotWidthChanged ( double v )

privateslot

Definition at line 269 of file dlg_canvassize.cc.

{
    //this slot receives values in pt from the unitspinbox, so just use the resolution.
    const double resValue = v*_widthUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
    m_newWidth = qRound(resValue);
 
    if (m_keepAspect) {
        m_newHeight = qRound(m_newWidth / m_aspectRatio);
        m_page->newHeightDouble->blockSignals(true);
        m_page->newHeightDouble->changeValue(v / m_aspectRatio);
        m_page->newHeightDouble->blockSignals(false);
    }
 
    int savedId = m_group->checkedId();
    m_page->canvasPreview->blockSignals(true);
    m_page->canvasPreview->setCanvasSize(m_newWidth, m_newHeight);
    m_page->canvasPreview->blockSignals(false);
    updateOffset(savedId);
    updateButtons(savedId);
}

References _widthUnitManager, KisDocumentAwareSpinBoxUnitManager::getConversionFactor(), KisSpinBoxUnitManager::LENGTH, m_aspectRatio, m_group, m_keepAspect, m_newHeight, m_newWidth, m_page, updateButtons(), updateOffset(), and v.

slotXOffsetChanged

void DlgCanvasSize::slotXOffsetChanged ( double v )

privateslot

Definition at line 311 of file dlg_canvassize.cc.

{
    //this slot receives values in pt from the unitspinbox, so just use the resolution.
    const double resValue = v*_xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
    m_xOffset = qRound(resValue);
 
    m_page->canvasPreview->blockSignals(true);
    m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
    m_page->canvasPreview->blockSignals(false);
 
    updateButtons(-1);
}

References _xOffsetUnitManager, KisDocumentAwareSpinBoxUnitManager::getConversionFactor(), KisSpinBoxUnitManager::LENGTH, m_page, m_xOffset, m_yOffset, updateButtons(), and v.

slotYOffsetChanged

void DlgCanvasSize::slotYOffsetChanged ( double v )

privateslot

Definition at line 324 of file dlg_canvassize.cc.

{
    //this slot receives values in pt from the unitspinbox, so just use the resolution.
    const double resValue = v*_xOffsetUnitManager->getConversionFactor(KisSpinBoxUnitManager::LENGTH, "px");
    m_yOffset = qRound(resValue);
 
 
    m_page->canvasPreview->blockSignals(true);
    m_page->canvasPreview->setImageOffset(m_xOffset, m_yOffset);
    m_page->canvasPreview->blockSignals(false);
 
    updateButtons(-1);
}

References _xOffsetUnitManager, KisDocumentAwareSpinBoxUnitManager::getConversionFactor(), KisSpinBoxUnitManager::LENGTH, m_page, m_xOffset, m_yOffset, updateButtons(), and v.

updateAnchorIcons()

void DlgCanvasSize::updateAnchorIcons ( int id )

private

Definition at line 366 of file dlg_canvassize.cc.

{
    anchor iconLayout[10][9] = {
        {NONE, EAST,  NONE, SOUTH, SOUTH_EAST, NONE, NONE, NONE, NONE},
        {WEST, NONE, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST, NONE, NONE, NONE},
        {NONE, WEST, NONE, NONE, SOUTH_WEST, SOUTH, NONE, NONE, NONE},
        {NORTH, NORTH_EAST, NONE, NONE, EAST, NONE, SOUTH, SOUTH_EAST, NONE},
        {NORTH_WEST, NORTH, NORTH_EAST, WEST, NONE, EAST, SOUTH_WEST, SOUTH, SOUTH_EAST},
        {NONE, NORTH_WEST, NORTH, NONE, WEST, NONE, NONE, SOUTH_WEST, SOUTH},
        {NONE, NONE, NONE, NORTH, NORTH_EAST, NONE, NONE, EAST, NONE},
        {NONE, NONE, NONE, NORTH_WEST, NORTH, NORTH_EAST, WEST, NONE, EAST},
        {NONE, NONE, NONE, NONE, NORTH_WEST, NORTH, NONE, WEST, NONE},
        {NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE}
    };
 
    if (id == -1) {
        id = SOUTH_EAST + 1;
    }
 
    // we are going to swap arrows direction based on width and height shrinking
    bool shrinkWidth = (m_newWidth < m_originalWidth) ? true : false;
    bool shrinkHeight = (m_newHeight < m_originalHeight) ? true : false;
 
    for (int i = NORTH_WEST; i <= SOUTH_EAST; i++) {
        anchor iconId = iconLayout[id][i];
 
        // all corner arrows represents shrinking in some direction
        if (shrinkWidth || shrinkHeight) {
            switch (iconId) {
            case NORTH_WEST: iconId = SOUTH_EAST; break;
            case NORTH_EAST: iconId = SOUTH_WEST; break;
            case SOUTH_WEST: iconId = NORTH_EAST; break;
            case SOUTH_EAST: iconId = NORTH_WEST; break;
            default: break;
            }
        }
 
        if (shrinkWidth) {
            switch (iconId) {
            case WEST: iconId = EAST; break;
            case EAST: iconId = WEST; break;
            default: break;
            }
        }
 
        if (shrinkHeight) {
            switch (iconId) {
            case NORTH: iconId = SOUTH; break;
            case SOUTH: iconId = NORTH; break;
            default: break;
            }
        }
 
        QAbstractButton *button = m_group->button(i);
 
        if (iconId == NONE) {
            button->setIcon(QIcon());
        } else {
            button->setIcon(m_anchorIcons[iconId]);
        }
    }
 
}

References KoDialog::button(), EAST, m_anchorIcons, m_group, m_newHeight, m_newWidth, m_originalHeight, m_originalWidth, NONE, NORTH, NORTH_EAST, NORTH_WEST, SOUTH, SOUTH_EAST, SOUTH_WEST, and WEST.

updateButtons()

void DlgCanvasSize::updateButtons ( int forceId )

private

Definition at line 430 of file dlg_canvassize.cc.

{
    int id = m_group->checkedId();
 
    if (forceId != -1) {
        m_group->setExclusive(true);
        m_group->button(forceId)->setChecked(true);
        updateAnchorIcons(forceId);
    } else if (id != -1) {
        double xOffset, yOffset;
        expectedOffset(id, xOffset, yOffset);
 
        // convert values to internal unit
        int internalXOffset = 0;
        int internalYOffset = 0;
        const KoUnit xOffsetUnit = KoUnit::fromListForUi(m_page->xOffUnit->currentIndex());
        internalXOffset = qRound(xOffsetUnit.fromUserValue(xOffset));
        const KoUnit yOffsetUnit = KoUnit::fromListForUi(m_page->yOffUnit->currentIndex());
        internalYOffset = qRound(yOffsetUnit.fromUserValue(yOffset));
 
        bool offsetAsExpected =
                internalXOffset == m_xOffset &&
                internalYOffset == m_yOffset;
 
        if (offsetAsExpected) {
            m_group->setExclusive(true);
        } else {
            m_group->setExclusive(false);
            m_group->button(id)->setChecked(false);
            id = -1;
        }
 
        updateAnchorIcons(id);
    } else {
        updateAnchorIcons(id);
    }
}

References expectedOffset(), KoUnit::fromListForUi(), KoUnit::fromUserValue(), m_group, m_page, m_xOffset, m_yOffset, updateAnchorIcons(), xOffset(), and yOffset().

updateOffset()

void DlgCanvasSize::updateOffset ( int id )

private

Definition at line 468 of file dlg_canvassize.cc.

{
    if (id == -1) return;
 
    double xOffset;
    double yOffset;
    expectedOffset(id, xOffset, yOffset);
 
    m_page->xOffsetDouble->changeValue(xOffset);
    m_page->yOffsetDouble->changeValue(yOffset);
}

References expectedOffset(), m_page, xOffset(), and yOffset().

updatexOffsetIcon

void DlgCanvasSize::updatexOffsetIcon ( bool v )

privateslot

Definition at line 479 of file dlg_canvassize.cc.

{
    if (v) {
      m_page->xOffsetDouble->setReadOnly(true);
      m_page->lockxOffset->setIcon(KisIconUtils::loadIcon("locked"));
    } else {
      m_page->xOffsetDouble->setReadOnly(false);
      m_page->lockxOffset->setIcon(KisIconUtils::loadIcon("unlocked"));
    }
}

References KisIconUtils::loadIcon(), m_page, and v.

updateyOffsetIcon

void DlgCanvasSize::updateyOffsetIcon ( bool v )

privateslot

Definition at line 489 of file dlg_canvassize.cc.

{
    if (v) {
      m_page->yOffsetDouble->setReadOnly(true);
      m_page->lockyOffset->setIcon(KisIconUtils::loadIcon("locked"));
    } else {
      m_page->yOffsetDouble->setReadOnly(false);
      m_page->lockyOffset->setIcon(KisIconUtils::loadIcon("unlocked"));
    }
}

References KisIconUtils::loadIcon(), m_page, and v.

width()

qint32 DlgCanvasSize::width

(

)

Definition at line 209 of file dlg_canvassize.cc.

{
    return (qint32) m_newWidth;
}

References m_newWidth.

xOffset()

qint32 DlgCanvasSize::xOffset

(

)

Definition at line 219 of file dlg_canvassize.cc.

{
    return (qint32) m_xOffset;
}

References m_xOffset.

yOffset()

qint32 DlgCanvasSize::yOffset

(

)

Definition at line 224 of file dlg_canvassize.cc.

{
    return (qint32) m_yOffset;
}

References m_yOffset.

Member Data Documentation

_heightUnitManager

KisDocumentAwareSpinBoxUnitManager* DlgCanvasSize::_heightUnitManager

private

Definition at line 89 of file dlg_canvassize.h.

_widthUnitManager

KisDocumentAwareSpinBoxUnitManager* DlgCanvasSize::_widthUnitManager

private

Definition at line 88 of file dlg_canvassize.h.

_xOffsetUnitManager

KisDocumentAwareSpinBoxUnitManager* DlgCanvasSize::_xOffsetUnitManager

private

Definition at line 91 of file dlg_canvassize.h.

_yOffsetUnitManager

KisDocumentAwareSpinBoxUnitManager* DlgCanvasSize::_yOffsetUnitManager

private

Definition at line 92 of file dlg_canvassize.h.

m_anchorIcons

QIcon DlgCanvasSize::m_anchorIcons[9]

private

Definition at line 85 of file dlg_canvassize.h.

m_aspectRatio

const double DlgCanvasSize::m_aspectRatio

private

Definition at line 79 of file dlg_canvassize.h.

m_group

QButtonGroup* DlgCanvasSize::m_group

private

Definition at line 86 of file dlg_canvassize.h.

m_keepAspect

bool DlgCanvasSize::m_keepAspect

private

Definition at line 78 of file dlg_canvassize.h.

m_newHeight

int DlgCanvasSize::m_newHeight

private

Definition at line 82 of file dlg_canvassize.h.

m_newWidth

int DlgCanvasSize::m_newWidth

private

Definition at line 82 of file dlg_canvassize.h.

m_originalHeight

const int DlgCanvasSize::m_originalHeight

private

Definition at line 81 of file dlg_canvassize.h.

m_originalWidth

const int DlgCanvasSize::m_originalWidth

private

Definition at line 81 of file dlg_canvassize.h.

m_page

WdgCanvasSize* DlgCanvasSize::m_page

Definition at line 52 of file dlg_canvassize.h.

m_resolution

const double DlgCanvasSize::m_resolution

private

Definition at line 80 of file dlg_canvassize.h.

m_xOffset

int DlgCanvasSize::m_xOffset

private

Definition at line 83 of file dlg_canvassize.h.

m_yOffset

int DlgCanvasSize::m_yOffset

private

Definition at line 83 of file dlg_canvassize.h.

PARAM_HEIGHT_UNIT

const QString DlgCanvasSize::PARAM_HEIGHT_UNIT = DlgCanvasSize::PARAM_PREFIX + "_heightunit"

static

Definition at line 41 of file dlg_canvassize.h.

PARAM_PREFIX

const QString DlgCanvasSize::PARAM_PREFIX = "canvasizedlg"

static

Definition at line 39 of file dlg_canvassize.h.

PARAM_WIDTH_UNIT

const QString DlgCanvasSize::PARAM_WIDTH_UNIT = DlgCanvasSize::PARAM_PREFIX + "_widthunit"

static

Definition at line 40 of file dlg_canvassize.h.

PARAM_XOFFSET_UNIT

const QString DlgCanvasSize::PARAM_XOFFSET_UNIT = DlgCanvasSize::PARAM_PREFIX + "_xoffsetunit"

static

Definition at line 42 of file dlg_canvassize.h.

PARAM_YOFFSET_UNIT

const QString DlgCanvasSize::PARAM_YOFFSET_UNIT = DlgCanvasSize::PARAM_PREFIX + "_yoffsetunit"

static

Definition at line 43 of file dlg_canvassize.h.

---

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

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