ShapeResizeStrategy Class Reference

#include <ShapeResizeStrategy.h>

Inheritance diagram for ShapeResizeStrategy:

Public Member Functions
KUndo2Command *	createCommand () override
void	finishInteraction (Qt::KeyboardModifiers modifiers) override
void	handleMouseMove (const QPointF &mouseLocation, Qt::KeyboardModifiers modifiers) override
void	paint (QPainter &painter, const KoViewConverter &converter) override
	ShapeResizeStrategy (KoToolBase *tool, KoSelection *selection, const QPointF &clicked, KoFlake::SelectionHandle direction, bool forceUniformScalingMode)
	~ShapeResizeStrategy () override
Public Member Functions inherited from KoInteractionStrategy
virtual void	cancelInteraction ()
	KoInteractionStrategy (KoToolBase *parent)
	constructor
KoToolBase *	tool () const
virtual	~KoInteractionStrategy ()
	Destructor.

Private Member Functions
void	resizeBy (const QPointF &stillPoint, qreal zoomX, qreal zoomY)

Private Attributes
bool	m_bottom {false}
QScopedPointer< KoShapeResizeCommand >	m_executedCommand
bool	m_forceUniformScalingMode {false}
QPointF	m_globalCenterPoint
QPointF	m_globalStillPoint
QSizeF	m_initialSelectionSize
bool	m_left {false}
QTransform	m_postScalingCoveringTransform
bool	m_right {false}
QList< KoShape * >	m_selectedShapes
QPointF	m_start
bool	m_top {false}
QTransform	m_unwindMatrix

Additional Inherited Members
Protected Member Functions inherited from KoInteractionStrategy
uint	decorationThickness () const
uint	grabSensitivity () const
	Convenience function to get the global grab sensitivity.
uint	handleRadius () const
	Convenience function to get the global handle radius.
	KoInteractionStrategy (KoInteractionStrategyPrivate &)
	constructor
Protected Attributes inherited from KoInteractionStrategy
KoInteractionStrategyPrivate *	d_ptr

Detailed Description

A strategy for the KoInteractionTool. This strategy is invoked when the user starts a resize of a selection of objects, the strategy will then resize the objects interactively and provide a command afterwards.

Definition at line 28 of file ShapeResizeStrategy.h.

Constructor & Destructor Documentation

ShapeResizeStrategy()

ShapeResizeStrategy::ShapeResizeStrategy	(	KoToolBase *	tool,
		KoSelection *	selection,
		const QPointF &	clicked,
		KoFlake::SelectionHandle	direction,
		bool	forceUniformScalingMode )

Constructor

Definition at line 28 of file ShapeResizeStrategy.cpp.

    : KoInteractionStrategy(tool),
      m_forceUniformScalingMode(forceUniformScalingMode)
{
    KIS_SAFE_ASSERT_RECOVER_RETURN(selection && selection->count() > 0);
 
    m_selectedShapes = selection->selectedEditableShapes();
    m_start = clicked;
 
    KoShape *shape = selection;
 
    const qreal w = shape->size().width();
    const qreal h = shape->size().height();
 
    switch (direction) {
    case KoFlake::TopMiddleHandle:
        m_start = 0.5 * (shape->absolutePosition(KoFlake::TopLeft) + shape->absolutePosition(KoFlake::TopRight));
        m_top = true; m_bottom = false; m_left = false; m_right = false;
        m_globalStillPoint = QPointF(0.5 * w, h);
        break;
    case KoFlake::TopRightHandle:
        m_start = shape->absolutePosition(KoFlake::TopRight);
        m_top = true; m_bottom = false; m_left = false; m_right = true;
        m_globalStillPoint = QPointF(0, h);
        break;
    case KoFlake::RightMiddleHandle:
        m_start = 0.5 * (shape->absolutePosition(KoFlake::TopRight) + shape->absolutePosition(KoFlake::BottomRight));
        m_top = false; m_bottom = false; m_left = false; m_right = true;
        m_globalStillPoint = QPointF(0, 0.5 * h);
        break;
    case KoFlake::BottomRightHandle:
        m_start = shape->absolutePosition(KoFlake::BottomRight);
        m_top = false; m_bottom = true; m_left = false; m_right = true;
        m_globalStillPoint = QPointF(0, 0);
        break;
    case KoFlake::BottomMiddleHandle:
        m_start = 0.5 * (shape->absolutePosition(KoFlake::BottomRight) + shape->absolutePosition(KoFlake::BottomLeft));
        m_top = false; m_bottom = true; m_left = false; m_right = false;
        m_globalStillPoint = QPointF(0.5 * w, 0);
        break;
    case KoFlake::BottomLeftHandle:
        m_start = shape->absolutePosition(KoFlake::BottomLeft);
        m_top = false; m_bottom = true; m_left = true; m_right = false;
        m_globalStillPoint = QPointF(w, 0);
        break;
    case KoFlake::LeftMiddleHandle:
        m_start = 0.5 * (shape->absolutePosition(KoFlake::BottomLeft) + shape->absolutePosition(KoFlake::TopLeft));
        m_top = false; m_bottom = false; m_left = true; m_right = false;
        m_globalStillPoint = QPointF(w, 0.5 * h);
        break;
    case KoFlake::TopLeftHandle:
        m_start = shape->absolutePosition(KoFlake::TopLeft);
        m_top = true; m_bottom = false; m_left = true; m_right = false;
        m_globalStillPoint = QPointF(w, h);
        break;
    default:
        Q_ASSERT(0); // illegal 'corner'
    }
 
    const QPointF p0 = shape->outlineRect().topLeft();
    m_globalStillPoint = shape->absoluteTransformation().map(p0 + m_globalStillPoint);
    m_globalCenterPoint = shape->absolutePosition(KoFlake::Center);
 
    m_unwindMatrix = shape->absoluteTransformation().inverted();
    m_initialSelectionSize = shape->size();
    m_postScalingCoveringTransform = shape->transformation();
 
 
    tool->setStatusText(i18n("Press CTRL to resize from center."));
    tool->canvas()->snapGuide()->setIgnoredShapes(KoShape::linearizeSubtree(m_selectedShapes));
}

References KoShape::absolutePosition(), KoShape::absoluteTransformation(), KoFlake::BottomLeft, KoFlake::BottomLeftHandle, KoFlake::BottomMiddleHandle, KoFlake::BottomRight, KoFlake::BottomRightHandle, KoToolBase::canvas(), KoFlake::Center, KoSelection::count(), KIS_SAFE_ASSERT_RECOVER_RETURN, KoFlake::LeftMiddleHandle, KoShape::linearizeSubtree(), m_bottom, m_globalCenterPoint, m_globalStillPoint, m_initialSelectionSize, m_left, m_postScalingCoveringTransform, m_right, m_selectedShapes, m_start, m_top, m_unwindMatrix, KoShape::outlineRect(), p0, KoFlake::RightMiddleHandle, KoSelection::selectedEditableShapes(), KoSnapGuide::setIgnoredShapes(), KoToolBase::setStatusText(), KoShape::size(), KoCanvasBase::snapGuide, KoInteractionStrategy::tool(), KoFlake::TopLeft, KoFlake::TopLeftHandle, KoFlake::TopMiddleHandle, KoFlake::TopRight, KoFlake::TopRightHandle, and KoShape::transformation().

~ShapeResizeStrategy()

ShapeResizeStrategy::~ShapeResizeStrategy ( )

override

Definition at line 100 of file ShapeResizeStrategy.cpp.

{
 
}

Member Function Documentation

createCommand()

KUndo2Command * ShapeResizeStrategy::createCommand ( )

overridevirtual

For interactions that are undo-able this method should be implemented to return such a command. Implementations should return 0 otherwise.

Returns

a command, or 0.

Implements KoInteractionStrategy.

Definition at line 210 of file ShapeResizeStrategy.cpp.

{
    tool()->canvas()->snapGuide()->reset();
 
    if (m_executedCommand) {
        m_executedCommand->setSkipOneRedo(true);
    }
 
    return m_executedCommand.take();
}

References KoToolBase::canvas(), m_executedCommand, KoSnapGuide::reset(), KoCanvasBase::snapGuide, and KoInteractionStrategy::tool().

finishInteraction()

void ShapeResizeStrategy::finishInteraction ( Qt::KeyboardModifiers modifiers )

overridevirtual

Override to make final changes to the data on the end of an interaction.

Implements KoInteractionStrategy.

Definition at line 221 of file ShapeResizeStrategy.cpp.

{
    Q_UNUSED(modifiers);
}

handleMouseMove()

void ShapeResizeStrategy::handleMouseMove ( const QPointF & mouseLocation, Qt::KeyboardModifiers modifiers )

overridevirtual

Extending classes should implement this method to update the selectedShapes based on the new mouse position.

Parameters

mouseLocation	the new location in pt
modifiers	OR-ed set of keys pressed.

Do not let a shape be less than 1px in size in current view coordinates. If the user wants it to be smaller, he can just zoom-in a bit.

Implements KoInteractionStrategy.

Definition at line 105 of file ShapeResizeStrategy.cpp.

{
    QPointF newPos = tool()->canvas()->snapGuide()->snap(point, modifiers);
 
    bool keepAspect = modifiers & Qt::ShiftModifier;
    Q_FOREACH (KoShape *shape, m_selectedShapes) {
        keepAspect = keepAspect || shape->keepAspectRatio();
    }
 
    qreal startWidth = m_initialSelectionSize.width();
    if (startWidth < std::numeric_limits<qreal>::epsilon()) {
        startWidth = std::numeric_limits<qreal>::epsilon();
    }
    qreal startHeight = m_initialSelectionSize.height();
    if (startHeight < std::numeric_limits<qreal>::epsilon()) {
        startHeight = std::numeric_limits<qreal>::epsilon();
    }
 
    QPointF distance = m_unwindMatrix.map(newPos) - m_unwindMatrix.map(m_start);
 
    // guard against resizing zero width shapes, which would result in huge zoom factors
    if (m_initialSelectionSize.width() < std::numeric_limits<qreal>::epsilon()) {
        distance.rx() = 0.0;
    }
    // guard against resizing zero height shapes, which would result in huge zoom factors
    if (m_initialSelectionSize.height() < std::numeric_limits<qreal>::epsilon()) {
        distance.ry() = 0.0;
    }
 
    const bool scaleFromCenter = modifiers & Qt::ControlModifier;
    if (scaleFromCenter) {
        distance *= 2.0;
    }
 
    qreal newWidth = startWidth;
    qreal newHeight = startHeight;
 
    if (m_left) {
        newWidth = startWidth - distance.x();
    } else if (m_right) {
        newWidth = startWidth + distance.x();
    }
 
    if (m_top) {
        newHeight = startHeight - distance.y();
    } else if (m_bottom) {
        newHeight = startHeight + distance.y();
    }
 
    QSizeF minViewSize(1.0, 1.0);
    QSizeF minDocSize = tool()->canvas()->viewConverter()->viewToDocument(minViewSize);
 
    if (qAbs(newWidth) < minDocSize.width()) {
        newWidth = KisAlgebra2D::signPZ(newWidth) * minDocSize.width();
    }
 
    if (qAbs(newHeight) < minDocSize.height()) {
        newHeight = KisAlgebra2D::signPZ(newHeight) * minDocSize.height();
    }
 
    qreal zoomX = qAbs(startWidth) >= minDocSize.width() ? newWidth / startWidth : 1.0;
    qreal zoomY = qAbs(startHeight) >= minDocSize.height() ? newHeight / startHeight : 1.0;
 
    if (keepAspect) {
        const bool cornerUsed = m_bottom + m_top + m_left + m_right == 2;
        if (cornerUsed) {
            if (startWidth < startHeight) {
                zoomY = zoomX;
            } else {
                zoomX = zoomY;
            }
        } else {
            if (m_left || m_right) {
               zoomY = qAbs(zoomX);
            } else {
               zoomX = qAbs(zoomY);
            }
        }
    }
 
    resizeBy(scaleFromCenter ? m_globalCenterPoint : m_globalStillPoint, zoomX, zoomY);
}

References KoToolBase::canvas(), distance(), KoShape::keepAspectRatio(), m_bottom, m_globalCenterPoint, m_globalStillPoint, m_initialSelectionSize, m_left, m_right, m_selectedShapes, m_start, m_top, m_unwindMatrix, resizeBy(), KisAlgebra2D::signPZ(), KoSnapGuide::snap(), KoCanvasBase::snapGuide, KoInteractionStrategy::tool(), KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocument().

paint()

void ShapeResizeStrategy::paint ( QPainter & painter, const KoViewConverter & converter )

overridevirtual

Reimplement this if the action needs to draw a "blob" on the canvas; that is, a transient decoration like a rubber band.

Reimplemented from KoInteractionStrategy.

Definition at line 226 of file ShapeResizeStrategy.cpp.

{
    Q_UNUSED(painter);
    Q_UNUSED(converter);
}

resizeBy()

void ShapeResizeStrategy::resizeBy ( const QPointF & stillPoint, qreal zoomX, qreal zoomY )

private

Definition at line 193 of file ShapeResizeStrategy.cpp.

{
    if (!m_executedCommand) {
        const bool usePostScaling = m_selectedShapes.size() > 1 || m_forceUniformScalingMode;
 
        m_executedCommand.reset(
                    new KoShapeResizeCommand(
                        m_selectedShapes,
                        zoomX, zoomY,
                        stillPoint,
                        false, usePostScaling, m_postScalingCoveringTransform));
        m_executedCommand->redo();
    } else {
        m_executedCommand->replaceResizeAction(zoomX, zoomY, stillPoint);
    }
}

References m_executedCommand, m_forceUniformScalingMode, m_postScalingCoveringTransform, and m_selectedShapes.

Member Data Documentation

m_bottom

bool ShapeResizeStrategy::m_bottom {false}

private

Definition at line 52 of file ShapeResizeStrategy.h.

{false};

m_executedCommand

QScopedPointer<KoShapeResizeCommand> ShapeResizeStrategy::m_executedCommand

private

Definition at line 57 of file ShapeResizeStrategy.h.

m_forceUniformScalingMode

bool ShapeResizeStrategy::m_forceUniformScalingMode {false}

private

Definition at line 59 of file ShapeResizeStrategy.h.

{false};

m_globalCenterPoint

QPointF ShapeResizeStrategy::m_globalCenterPoint

private

Definition at line 56 of file ShapeResizeStrategy.h.

m_globalStillPoint

QPointF ShapeResizeStrategy::m_globalStillPoint

private

Definition at line 55 of file ShapeResizeStrategy.h.

m_initialSelectionSize

QSizeF ShapeResizeStrategy::m_initialSelectionSize

private

Definition at line 48 of file ShapeResizeStrategy.h.

m_left

bool ShapeResizeStrategy::m_left {false}

private

Definition at line 51 of file ShapeResizeStrategy.h.

{false};

m_postScalingCoveringTransform

QTransform ShapeResizeStrategy::m_postScalingCoveringTransform

private

Definition at line 47 of file ShapeResizeStrategy.h.

m_right

bool ShapeResizeStrategy::m_right {false}

private

Definition at line 53 of file ShapeResizeStrategy.h.

{false};

m_selectedShapes

QList<KoShape *> ShapeResizeStrategy::m_selectedShapes

private

Definition at line 45 of file ShapeResizeStrategy.h.

m_start

QPointF ShapeResizeStrategy::m_start

private

Definition at line 44 of file ShapeResizeStrategy.h.

m_top

bool ShapeResizeStrategy::m_top {false}

private

Definition at line 50 of file ShapeResizeStrategy.h.

{false};

m_unwindMatrix

QTransform ShapeResizeStrategy::m_unwindMatrix

private

Definition at line 49 of file ShapeResizeStrategy.h.

---

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

• plugins/tools/defaulttool/defaulttool/ShapeResizeStrategy.h
• plugins/tools/defaulttool/defaulttool/ShapeResizeStrategy.cpp