The undo / redo command for inserting path points. More...

#include <KoPathPointInsertCommand.h>

Inheritance diagram for KoPathPointInsertCommand:

Public Member Functions
QList< KoPathPoint * >	insertedPoints () const
	Returns list of inserted points.

	KoPathPointInsertCommand (const QList< KoPathPointData > &pointDataList, qreal insertPosition, KUndo2Command *parent=0)

void	redo () override
	redo the command

void	undo () override
	revert the actions done in redo

	~KoPathPointInsertCommand () override

Public Member Functions inherited from KUndo2Command
QString	actionText () const

virtual bool	canAnnihilateWith (const KUndo2Command *other) const

const KUndo2Command *	child (int index) const

int	childCount () const

virtual QTime	endTime () const

KUndo2CommandExtraData *	extraData () const

bool	hasParent () const

virtual int	id () const

virtual bool	isMerged () const

	KUndo2Command (const KUndo2MagicString &text, KUndo2Command *parent=0)

	KUndo2Command (KUndo2Command *parent=0)

virtual QVector< KUndo2Command * >	mergeCommandsVector () const

virtual bool	mergeWith (const KUndo2Command *other)

virtual void	redoMergedCommands ()

void	setEndTime ()

virtual void	setEndTime (const QTime &time)

void	setExtraData (KUndo2CommandExtraData *data)

void	setText (const KUndo2MagicString &text)

void	setTime ()

virtual void	setTime (const QTime &time)

virtual void	setTimedID (int timedID)

KUndo2MagicString	text () const

virtual QTime	time () const

virtual int	timedId () const

virtual bool	timedMergeWith (KUndo2Command *other)

virtual void	undoMergedCommands ()

virtual	~KUndo2Command ()

Private Attributes
KoPathPointInsertCommandPrivate *const	d

Detailed Description

The undo / redo command for inserting path points.

Definition at line 20 of file KoPathPointInsertCommand.h.

Constructor & Destructor Documentation

◆ KoPathPointInsertCommand()

KoPathPointInsertCommand::KoPathPointInsertCommand	(	const QList< KoPathPointData > &	pointDataList,
		qreal	insertPosition,
		KUndo2Command *	parent = 0 )

Command to insert path points.

This splits the segments at the given position by inserting new points. The De Casteljau algorithm is used for calculating the position of the new points.

Parameters

pointDataList	describing the segments to split
insertPosition	the position to insert at [0..1]
parent	the parent command used for macro commands

Definition at line 29 of file KoPathPointInsertCommand.cpp.

        : KUndo2Command(parent),
        d(new KoPathPointInsertCommandPrivate())
{
    if (insertPosition < 0)
        insertPosition = 0;
    if (insertPosition > 1)
        insertPosition = 1;
 
    //TODO the list needs to be sorted
 
    QList<KoPathPointData>::const_iterator it(pointDataList.begin());
    for (; it != pointDataList.end(); ++it) {
        KoPathShape * pathShape = it->pathShape;
 
        KoPathSegment segment = pathShape->segmentByIndex(it->pointIndex);
 
        // should not happen but to be sure
        if (! segment.isValid())
            continue;
 
        d->pointDataList.append(*it);
 
        QPair<KoPathSegment, KoPathSegment> splitSegments = segment.splitAt(insertPosition);
 
        KoPathPoint * split1 = splitSegments.first.second();
        KoPathPoint * split2 = splitSegments.second.first();
        KoPathPoint * splitPoint = new KoPathPoint(pathShape, split1->point());
        if(split1->activeControlPoint1())
            splitPoint->setControlPoint1(split1->controlPoint1());
        if(split2->activeControlPoint2())
            splitPoint->setControlPoint2(split2->controlPoint2());
 
        d->points.append(splitPoint);
        QPointF cp1 = splitSegments.first.first()->controlPoint2();
        QPointF cp2 = splitSegments.second.second()->controlPoint1();
        d->controlPoints.append(QPair<QPointF, QPointF>(cp1, cp2));
    }
    setText(kundo2_i18n("Insert points"));
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, KoPathPointInsertCommandPrivate::controlPoints, d, KoPathSegment::isValid(), kundo2_i18n(), KoPathPoint::point, KoPathPointInsertCommandPrivate::pointDataList, KoPathPointInsertCommandPrivate::points, KoPathShape::segmentByIndex(), KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), KUndo2Command::setText(), and KoPathSegment::splitAt().

◆ ~KoPathPointInsertCommand()

KoPathPointInsertCommand::~KoPathPointInsertCommand ( )

override

Definition at line 70 of file KoPathPointInsertCommand.cpp.

{
    delete d;
}

References d.

Member Function Documentation

◆ insertedPoints()

QList< KoPathPoint * > KoPathPointInsertCommand::insertedPoints ( ) const

Returns list of inserted points.

Definition at line 150 of file KoPathPointInsertCommand.cpp.

{
    return d->points;
}

References d, and KoPathPointInsertCommandPrivate::points.

◆ redo()

void KoPathPointInsertCommand::redo ( )

overridevirtual

redo the command

Reimplemented from KUndo2Command.

Definition at line 75 of file KoPathPointInsertCommand.cpp.

{
    KUndo2Command::redo();
    for (int i = d->pointDataList.size() - 1; i >= 0; --i) {
        KoPathPointData pointData = d->pointDataList.at(i);
        KoPathShape * pathShape = pointData.pathShape;
 
        KoPathSegment segment = pathShape->segmentByIndex(pointData.pointIndex);
 
        ++pointData.pointIndex.second;
 
        if (segment.first()->activeControlPoint2()) {
            QPointF controlPoint2 = segment.first()->controlPoint2();
            std::swap(controlPoint2, d->controlPoints[i].first);
            segment.first()->setControlPoint2(controlPoint2);
        }
 
        if (segment.second()->activeControlPoint1()) {
            QPointF controlPoint1 = segment.second()->controlPoint1();
            std::swap(controlPoint1, d->controlPoints[i].second);
            segment.second()->setControlPoint1(controlPoint1);
        }
 
        pathShape->insertPoint(d->points.at(i), pointData.pointIndex);
        pathShape->recommendPointSelectionChange({pointData.pointIndex});
        pathShape->update();
    }
    d->deletePoints = false;
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, KoPathPointInsertCommandPrivate::controlPoints, d, KoPathPointInsertCommandPrivate::deletePoints, KoPathSegment::first, KoPathShape::insertPoint(), KoPathPointData::pathShape, KoPathPointInsertCommandPrivate::pointDataList, KoPathPointData::pointIndex, KoPathPointInsertCommandPrivate::points, KoPathShape::recommendPointSelectionChange(), KUndo2Command::redo(), KoPathSegment::second, KoPathShape::segmentByIndex(), KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), and KoShapeContainer::update().

◆ undo()

void KoPathPointInsertCommand::undo ( )

overridevirtual

revert the actions done in redo

Reimplemented from KUndo2Command.

Definition at line 105 of file KoPathPointInsertCommand.cpp.

{
    KUndo2Command::undo();
    for (int i = 0; i < d->pointDataList.size(); ++i) {
        const KoPathPointData &pdBefore = d->pointDataList.at(i);
        KoPathShape * pathShape = pdBefore.pathShape;
        KoPathPointIndex piAfter = pdBefore.pointIndex;
        ++piAfter.second;
 
        KoPathPoint * before = pathShape->pointByIndex(pdBefore.pointIndex);
 
        d->points[i] = pathShape->removePoint(piAfter);
 
        if (d->points[i]->properties() & KoPathPoint::CloseSubpath) {
            piAfter.second = 0;
        }
 
        KoPathPoint * after = pathShape->pointByIndex(piAfter);
 
        if (before->activeControlPoint2()) {
            QPointF controlPoint2 = before->controlPoint2();
            std::swap(controlPoint2, d->controlPoints[i].first);
            before->setControlPoint2(controlPoint2);
        }
 
        if (after->activeControlPoint1()) {
            QPointF controlPoint1 = after->controlPoint1();
            std::swap(controlPoint1, d->controlPoints[i].second);
            after->setControlPoint1(controlPoint1);
        }
 
        QList<KoPathPointIndex> segmentPoints;
        segmentPoints << pdBefore.pointIndex;
 
        KoPathPointIndex nextPoint(pdBefore.pointIndex.first, pdBefore.pointIndex.second + 1);
        if (pathShape->pointByIndex(nextPoint)) {
            segmentPoints << nextPoint;
        }
 
        pathShape->recommendPointSelectionChange(segmentPoints);
        pathShape->update();
    }
    d->deletePoints = true;
}