#include <SvgInlineSizeChangeStrategy.h>

Inheritance diagram for SvgInlineSizeChangeStrategy:

Public Member Functions
void	cancelInteraction () override

KUndo2Command *	createCommand () override

void	finishInteraction (Qt::KeyboardModifiers modifiers) override

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

	SvgInlineSizeChangeStrategy (KoToolBase tool, KoSvgTextShape shape, const QPointF &clicked, bool start)

	~SvgInlineSizeChangeStrategy () override=default

Public Member Functions inherited from KoInteractionStrategy
	KoInteractionStrategy (KoToolBase *parent)
	constructor

virtual void	paint (QPainter &painter, const KoViewConverter &converter)

KoToolBase *	tool () const

virtual	~KoInteractionStrategy ()
	Destructor.

Private Attributes
SvgInlineSizeHelper::VisualAnchor	m_anchor

QPointF	m_anchorOffset

QPointF	m_dragStart

int	m_finalAnchor

double	m_finalInlineSize

QPointF	m_finalPos

SvgInlineSizeHelper::Side	m_handleSide

double	m_initialInlineSize

QPointF	m_initialPosition

int	m_originalAnchor

KoSvgTextShape *	m_shape

QPointF	m_snapDelta

bool	m_startHandle

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

Definition at line 23 of file SvgInlineSizeChangeStrategy.h.

Constructor & Destructor Documentation

◆ SvgInlineSizeChangeStrategy()

SvgInlineSizeChangeStrategy::SvgInlineSizeChangeStrategy	(	KoToolBase *	tool,
		KoSvgTextShape *	shape,
		const QPointF &	clicked,
		bool	start )

Definition at line 26 of file SvgInlineSizeChangeStrategy.cpp.

    : KoInteractionStrategy(tool)
    , m_shape(shape)
    , m_dragStart(clicked)
    , m_initialPosition(shape->absolutePosition(KoFlake::TopLeft))
    , m_finalPos(m_initialPosition)
    , m_anchorOffset(m_shape->absoluteTransformation().map(QPointF()))
    , m_startHandle(start)
{
    this->tool()->canvas()->snapGuide()->setIgnoredShapes(KoShape::linearizeSubtree({shape}));
    m_originalAnchor = m_finalAnchor =
        KoSvgText::TextAnchor(shape->textProperties().propertyOrDefault(KoSvgTextProperties::TextAnchorId).toInt());
    if (std::optional<InlineSizeInfo> info = InlineSizeInfo::fromShape(shape)) {
        m_initialInlineSize = m_finalInlineSize = info->inlineSize;
        m_anchor = info->anchor;
        m_handleSide = m_startHandle? info->startLineSide(): info->endLineSide();
        QPointF handleLocation = m_startHandle? info->startLine().p1(): info->endLine().p1();
        QTransform invTransform = (info->editorTransform * info->shapeTransform).inverted();
        QPointF initPos = info->editorTransform.inverted().map(m_shape->initialTextPosition());
        m_snapDelta = invTransform.inverted().map(QPointF(invTransform.map(handleLocation).x(), initPos.y())) - m_dragStart;
    } else {
        // We cannot bail out, so just pretend to be doing something :(
        m_initialInlineSize = m_finalInlineSize = SvgInlineSizeHelper::getInlineSizePt(shape);
        m_anchor = VisualAnchor::LeftOrTop;
        m_handleSide = m_startHandle? Side::LeftOrTop: Side::RightOrBottom;
    }
}

References KoToolBase::canvas(), SvgInlineSizeHelper::getInlineSizePt(), KoSvgTextShape::initialTextPosition, KoShape::linearizeSubtree(), m_anchor, m_dragStart, m_finalAnchor, m_finalInlineSize, m_handleSide, m_initialInlineSize, m_originalAnchor, m_shape, m_snapDelta, m_startHandle, KoSvgTextProperties::propertyOrDefault(), KoSnapGuide::setIgnoredShapes(), KoCanvasBase::snapGuide, KoSvgTextProperties::TextAnchorId, KoSvgTextShape::textProperties(), and KoInteractionStrategy::tool().

◆ ~SvgInlineSizeChangeStrategy()

SvgInlineSizeChangeStrategy::~SvgInlineSizeChangeStrategy ( )

overridedefault

Member Function Documentation

◆ cancelInteraction()

void SvgInlineSizeChangeStrategy::cancelInteraction ( )

overridevirtual

This method will undo frames based interactions by calling createCommand() and unexecuting that.

Reimplemented from KoInteractionStrategy.

Definition at line 161 of file SvgInlineSizeChangeStrategy.cpp.

{
    if (qFuzzyCompare(m_initialInlineSize, m_finalInlineSize)
            && m_initialPosition == m_finalPos
            && m_originalAnchor == m_finalAnchor) {
        return;
    }
    SvgInlineSizeChangeCommand(m_shape, m_finalInlineSize, m_initialInlineSize, m_finalAnchor,
                               m_originalAnchor, m_finalPos, m_initialPosition).undo();
    tool()->repaintDecorations();
}

References m_finalAnchor, m_finalInlineSize, m_finalPos, m_initialInlineSize, m_initialPosition, m_originalAnchor, m_shape, qFuzzyCompare(), KoToolBase::repaintDecorations(), KoInteractionStrategy::tool(), and SvgInlineSizeChangeCommand::undo().

◆ createCommand()

KUndo2Command * SvgInlineSizeChangeStrategy::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 149 of file SvgInlineSizeChangeStrategy.cpp.

{
    tool()->canvas()->snapGuide()->reset();
    if (qFuzzyCompare(m_initialInlineSize, m_finalInlineSize)
            && m_initialPosition == m_finalPos
            && m_originalAnchor == m_finalAnchor) {
        return nullptr;
    }
    return new SvgInlineSizeChangeCommand(m_shape, m_finalInlineSize, m_initialInlineSize, m_finalAnchor,
                                          m_originalAnchor, m_finalPos, m_initialPosition);
}

References KoToolBase::canvas(), m_finalAnchor, m_finalInlineSize, m_finalPos, m_initialInlineSize, m_initialPosition, m_originalAnchor, m_shape, qFuzzyCompare(), KoSnapGuide::reset(), KoCanvasBase::snapGuide, and KoInteractionStrategy::tool().

◆ finishInteraction()

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

overridevirtual

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

Implements KoInteractionStrategy.

Definition at line 173 of file SvgInlineSizeChangeStrategy.cpp.

174{

175}

◆ handleMouseMove()

void SvgInlineSizeChangeStrategy::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.

Implements KoInteractionStrategy.

Definition at line 56 of file SvgInlineSizeChangeStrategy.cpp.

{
    QTransform invTransform{};
    QPointF initPos;
    if (std::optional<InlineSizeInfo> info = InlineSizeInfo::fromShape(m_shape)) {
        invTransform = (info->editorTransform * info->shapeTransform).inverted();
        initPos = info->editorTransform.inverted().map(m_shape->initialTextPosition());
    }
 
    double newInlineSize = 0.0;
 
    QPointF snapDelta = invTransform.inverted().map(QPointF(invTransform.map(mouseLocation + m_snapDelta).x(), initPos.y())) - mouseLocation;
    QPointF snappedLocation = tool()->canvas()->snapGuide()->snap(mouseLocation + snapDelta, modifiers) - snapDelta;
    const double mouseDelta = invTransform.map(QLineF(m_dragStart, snappedLocation)).dx();
    QPointF newPosition = m_shape->absolutePosition(KoFlake::TopLeft);
 
    // The anchor pos is mostly to determine the transformed origin so that moving the position stays consistent.
    QPointF anchorPos = m_shape->absoluteTransformation().map(QPointF());
    QPointF anchorDiff = anchorPos - m_anchorOffset;
    QPointF diff = (invTransform.inverted().map(QPointF(mouseDelta, 0)) - anchorPos) - anchorDiff;
 
 
    switch (m_anchor) {
    case VisualAnchor::LeftOrTop:
        if (m_handleSide == Side::RightOrBottom) {
            newInlineSize = m_initialInlineSize + mouseDelta;
        } else {
            newInlineSize = m_initialInlineSize - mouseDelta;
        }
        break;
    case VisualAnchor::Mid:
        if (modifiers.testFlag(Qt::ControlModifier)) {
            if (m_handleSide == Side::RightOrBottom) {
                newInlineSize = m_initialInlineSize + 2.0 * mouseDelta;
            } else {
                newInlineSize = m_initialInlineSize - 2.0 * mouseDelta;
            }
            diff = QPointF();
            newPosition -= anchorDiff;
        } else {
            if (m_handleSide == Side::RightOrBottom) {
                newInlineSize = m_initialInlineSize + mouseDelta;
                newPosition += ((invTransform.inverted().map(QPointF(0.5 * mouseDelta, 0)) - anchorPos)) - anchorDiff;
            } else {
                newInlineSize = m_initialInlineSize - mouseDelta;
                diff = ((invTransform.inverted().map(QPointF(0.5 * mouseDelta, 0)) - anchorPos)) - anchorDiff;
            }
        }
        break;
    case VisualAnchor::RightOrBottom:
        if (m_handleSide == Side::LeftOrTop) {
            newInlineSize = m_initialInlineSize - mouseDelta;
        } else {
            newInlineSize = m_initialInlineSize + mouseDelta;
        }
        break;
    }
 
    if (m_startHandle) {
        newPosition += diff;
    }
 
    const bool flip = newInlineSize < -1.0;
    if (newInlineSize >= -1.0 && newInlineSize < 1.0) {
        newInlineSize = 1.0;
    } else {
        newInlineSize = qRound(newInlineSize * 100.0) / 100.0;
 
    }
 
    KoSvgText::TextAnchor newAnchor = KoSvgText::TextAnchor(m_originalAnchor);
    if (flip) {
        newInlineSize = fabs(newInlineSize);
        if (newAnchor == KoSvgText::AnchorStart) {
            newAnchor = KoSvgText::AnchorEnd;
        } else if (newAnchor == KoSvgText::AnchorEnd) {
            newAnchor = KoSvgText::AnchorStart;
        }
    }
    if (qFuzzyCompare(m_finalInlineSize, newInlineSize)
            && m_initialPosition == newPosition
            && m_originalAnchor == newAnchor) {
        return;
    }
    SvgInlineSizeChangeCommand(m_shape, newInlineSize, m_initialInlineSize, newAnchor, m_originalAnchor,
                               newPosition, m_initialPosition).redo();
 
    m_finalInlineSize = newInlineSize;
    m_finalAnchor = newAnchor;
    m_finalPos = newPosition;
    tool()->repaintDecorations();
}