Strategy for deforming a segment of a path shape. More...

#include <KoPathSegmentChangeStrategy.h>

Inheritance diagram for KoPathSegmentChangeStrategy:

Public Member Functions
KUndo2Command *	createCommand () override

void	finishInteraction (Qt::KeyboardModifiers modifiers) override

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

	KoPathSegmentChangeStrategy (KoPathTool *tool, const QPointF &pos, const KoPathPointData &segment, qreal segmentParam)

	~KoPathSegmentChangeStrategy () override

Public Member Functions inherited from KoInteractionStrategy
virtual void	cancelInteraction ()

	KoInteractionStrategy (KoToolBase *parent)
	constructor

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

KoToolBase *	tool () const

virtual	~KoInteractionStrategy ()
	Destructor.

Private Attributes
QPointF	m_ctrlPoint1Move

QPointF	m_ctrlPoint2Move

QPointF	m_lastPosition

QPointF	m_move
	the accumulated point move amount

QPointF	m_originalPosition

int	m_originalSegmentDegree

KoPathShape *	m_path

KoPathPointData	m_pointData1

KoPathPointData	m_pointData2

KoPathSegment	m_segment

qreal	m_segmentParam

KoPathTool *	m_tool
	pointer to the path tool

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

Strategy for deforming a segment of a path shape.

Definition at line 21 of file KoPathSegmentChangeStrategy.h.

Constructor & Destructor Documentation

◆ KoPathSegmentChangeStrategy()

KoPathSegmentChangeStrategy::KoPathSegmentChangeStrategy	(	KoPathTool *	tool,
		const QPointF &	pos,
		const KoPathPointData &	segment,
		qreal	segmentParam )

Definition at line 21 of file KoPathSegmentChangeStrategy.cpp.

: KoInteractionStrategy(tool)
, m_originalPosition(pos)
, m_lastPosition(pos)
, m_tool(tool)
, m_segmentParam(segmentParam)
, m_pointData1(segment)
, m_pointData2(segment)
{
    // The following value is a bit arbitrary, it would be more mathematically correct to use
    // "std::numeric_limits<qreal>::epsilon()", but if the value is too small, when the user
    // click near a control point it is relatively easy to create a path shape of almost
    // infinite size, which blocks the application for a long period of time. A bigger value
    // is mathematically incorrect, but it avoids to block application, it also avoid to create
    // an huge path shape by accident, and anyway, but it does not prevent the user to create one
    // if they choose so.
    const qreal eps = 1e-2;
    // force segment parameter range to avoid division by zero
    m_segmentParam = qBound(eps, m_segmentParam, qreal(1.0)-eps);
 
    m_path = segment.pathShape;
    m_segment = m_path->segmentByIndex(segment.pointIndex);
    m_pointData2.pointIndex = m_path->pathPointIndex(m_segment.second());
    m_originalSegmentDegree = m_segment.degree();
}

References KoPathSegment::degree(), eps, m_originalSegmentDegree, m_path, m_pointData2, m_segment, m_segmentParam, KoPathShape::pathPointIndex(), KoPathPointData::pathShape, KoPathPointData::pointIndex, KoPathSegment::second, and KoPathShape::segmentByIndex().

◆ ~KoPathSegmentChangeStrategy()

KoPathSegmentChangeStrategy::~KoPathSegmentChangeStrategy ( )

override

Definition at line 47 of file KoPathSegmentChangeStrategy.cpp.

48{

49}

Member Function Documentation

◆ createCommand()

KUndo2Command * KoPathSegmentChangeStrategy::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 104 of file KoPathSegmentChangeStrategy.cpp.

{
    bool hasControlPoint1 = m_segment.second()->activeControlPoint1();
    bool hasControlPoint2 = m_segment.first()->activeControlPoint2();
 
    KUndo2Command * cmd = new KUndo2Command(kundo2_i18n("Change Segment"));
    if (m_originalSegmentDegree == 1) {
        new KoPathSegmentTypeCommand(m_pointData1, KoPathSegmentTypeCommand::Curve, cmd);
    }
 
    if (hasControlPoint2) {
        new KoPathControlPointMoveCommand(m_pointData1, m_ctrlPoint2Move, KoPathPoint::ControlPoint2, cmd);
    }
    if (hasControlPoint1) {
        new KoPathControlPointMoveCommand(m_pointData2, m_ctrlPoint1Move, KoPathPoint::ControlPoint1, cmd);
    }
 
    if (cmd) {
        return new KisCommandUtils::SkipFirstRedoWrapper(cmd);
    }
    return nullptr;
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::ControlPoint1, KoPathPoint::ControlPoint2, KoPathSegmentTypeCommand::Curve, KoPathSegment::first, kundo2_i18n(), m_ctrlPoint1Move, m_ctrlPoint2Move, m_originalSegmentDegree, m_pointData1, m_pointData2, m_segment, and KoPathSegment::second.

◆ finishInteraction()

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

overridevirtual

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

Implements KoInteractionStrategy.

Definition at line 99 of file KoPathSegmentChangeStrategy.cpp.

{
    Q_UNUSED(modifiers);
}

◆ handleMouseMove()

void KoPathSegmentChangeStrategy::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 51 of file KoPathSegmentChangeStrategy.cpp.

{
    QPointF snappedPosition = m_tool->canvas()->snapGuide()->snap(mouseLocation, modifiers);
    QPointF localPos = m_path->documentToShape(snappedPosition);
 
    if (m_segment.degree() == 1) {
        // line segment is converted to a curve
        KoPathSegmentTypeCommand cmd(m_pointData1, KoPathSegmentTypeCommand::Curve);
        cmd.redo();
    }
 
    QPointF move1, move2;
 
    if (m_segment.degree() == 2) {
        // interpolate quadratic segment between segment start, mouse position and segment end
        KoPathSegment ipol = KoPathSegment::interpolate(m_segment.first()->point(),
                                                         localPos,
                                                         m_segment.second()->point(),
                                                         m_segmentParam);
        if (ipol.isValid()) {
            move1 = move2 = ipol.controlPoints()[1] - m_segment.controlPoints()[1];
        }
    }
    else if (m_segment.degree() == 3) {
        QPointF lastLocalPos = m_path->documentToShape(m_lastPosition);
        QPointF delta = localPos - lastLocalPos;
 
        std::tie(move2, move1) =
            KisBezierUtils::offsetSegment(m_segmentParam, delta);
    }
 
    if(m_segment.first()->activeControlPoint2()) {
        KoPathControlPointMoveCommand cmd(m_pointData1, move2, KoPathPoint::ControlPoint2);
        cmd.redo();
    }
    if(m_segment.second()->activeControlPoint1()) {
        KoPathControlPointMoveCommand cmd(m_pointData2, move1, KoPathPoint::ControlPoint1);
        cmd.redo();
    }
    m_path->normalize();
 
    m_ctrlPoint1Move += move1;
    m_ctrlPoint2Move += move2;
 
    // save last mouse position
    m_lastPosition = snappedPosition;
}