The undo / redo command for merging two subpath end points. More...

#include <KoPathPointMergeCommand.h>

Inheritance diagram for KoPathPointMergeCommand:

Public Types
enum	Reverse { ReverseNone = 0 , ReverseFirst = 1 , ReverseSecond = 2 }

Public Member Functions
bool	closeSubpathMode () const

	KoPathPointMergeCommand (const KoPathPointData &pointData1, const KoPathPointData &pointData2, KUndo2Command *parent=0)

KoPathPointData	mergedPointData () const

void	mergePoints (KoPathPoint p1, KoPathPoint p2, KoPathPoint *dstPoint)

	Private (const KoPathPointData &pointData1, const KoPathPointData &pointData2)

void	redo () override
	redo the command

void	restorePointState (KoPathPoint *point)

void	savePointState (KoPathPoint *point)

void	undo () override
	revert the actions done in redo

	~KoPathPointMergeCommand () override

	~Private ()

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 ()

Public Attributes
KoPathPointIndex	mergedPointIndex

KoPathShape *	pathShape

KoPathPointIndex	pointIndex1

KoPathPointIndex	pointIndex2

KoPathPoint *	removedPoint

int	reverse

boost::optional< QPointF >	savedControlPoint11

boost::optional< QPointF >	savedControlPoint12

QPointF	savedNodePoint1

Private Attributes
Private *const	d

Private Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Additional Inherited Members
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Detailed Description

The undo / redo command for merging two subpath end points.

Definition at line 18 of file KoPathPointMergeCommand.cpp.

Member Enumeration Documentation

◆ Reverse

enum KoPathPointMergeCommand::Reverse

Enumerator
ReverseNone
ReverseFirst
ReverseSecond

Definition at line 79 of file KoPathPointMergeCommand.cpp.

                 {
        ReverseNone = 0,
        ReverseFirst = 1,
        ReverseSecond = 2
    };

Constructor & Destructor Documentation

◆ ~Private()

KoPathPointMergeCommand::~Private ( )

inline

Definition at line 31 of file KoPathPointMergeCommand.cpp.

    {
        delete removedPoint;
    }

◆ KoPathPointMergeCommand()

KoPathPointMergeCommand::KoPathPointMergeCommand	(	const KoPathPointData &	pointData1,
		const KoPathPointData &	pointData2,
		KUndo2Command *	parent = 0 )

Command to merge two subpath end points.

The points have to be from the same path shape.

Parameters

pointData1	the data of the first point to merge
pointData2	the data of the second point to merge
parent	the parent command used for macro commands

How does is work:

The goal is to merge the point that is ending an open subpath with the one starting the same or another open subpath.

Definition at line 99 of file KoPathPointMergeCommand.cpp.

    : KUndo2Command(parent), d(new Private(pointData1, pointData2))
{
    KIS_ASSERT(pointData1.pathShape == pointData2.pathShape);
    KIS_ASSERT(d->pathShape);
 
    KIS_ASSERT(!d->pathShape->isClosedSubpath(d->pointIndex1.first));
    KIS_ASSERT(!d->pathShape->isClosedSubpath(d->pointIndex2.first));
 
    KIS_ASSERT(d->pointIndex1.second == 0 ||
             d->pointIndex1.second == d->pathShape->subpathPointCount(d->pointIndex1.first) - 1);
 
    KIS_ASSERT(d->pointIndex2.second == 0 ||
             d->pointIndex2.second == d->pathShape->subpathPointCount(d->pointIndex2.first) - 1);
 
    KIS_ASSERT(d->pointIndex2 != d->pointIndex1);
 
    if (d->pointIndex2 < d->pointIndex1) {
        std::swap(d->pointIndex2, d->pointIndex1);
    }
 
    // if we have two different subpaths we might need to reverse them
    if (!d->closeSubpathMode()) {
        if (d->pointIndex1.second == 0 &&
            d->pathShape->subpathPointCount(d->pointIndex1.first) > 1) {
 
            d->reverse |= Private::ReverseFirst;
        }
 
        if (d->pointIndex2.second != 0 &&
            d->pathShape->subpathPointCount(d->pointIndex2.first) > 1) {
 
            d->reverse |= Private::ReverseSecond;
        }
    }
 
    setText(kundo2_i18n("Merge points"));
}

References d, KIS_ASSERT, kundo2_i18n(), KoPathPointData::pathShape, and KUndo2Command::setText().

◆ ~KoPathPointMergeCommand()

KoPathPointMergeCommand::~KoPathPointMergeCommand ( )

override

Definition at line 138 of file KoPathPointMergeCommand.cpp.

{
    delete d;
}

References d.

Member Function Documentation

◆ closeSubpathMode()

bool KoPathPointMergeCommand::closeSubpathMode ( ) const

inline

Definition at line 68 of file KoPathPointMergeCommand.cpp.

                                  {
        return pointIndex2.first == pointIndex1.first;
    }

◆ mergedPointData()

KoPathPointData KoPathPointMergeCommand::mergedPointData ( ) const

Definition at line 224 of file KoPathPointMergeCommand.cpp.

{
    return KoPathPointData(d->pathShape, d->mergedPointIndex);
}

References d.

◆ mergePoints()

void KoPathPointMergeCommand::mergePoints	(	KoPathPoint *	p1,
		KoPathPoint *	p2,
		KoPathPoint *	dstPoint )

inline

Definition at line 48 of file KoPathPointMergeCommand.cpp.

    {
        QPointF mergePosition = 0.5 * (p1->point() + p2->point());
 
        boost::optional<QPointF> mergedControlPoint1;
        boost::optional<QPointF> mergedControlPoint2;
 
        if (p1->activeControlPoint1()) {
            mergedControlPoint1 = mergePosition + (p1->controlPoint1() - p1->point());
        }
 
        if (p2->activeControlPoint2()) {
            mergedControlPoint2 = mergePosition + (p2->controlPoint2() - p2->point());
        }
 
        dstPoint->setPoint(mergePosition);
        KritaUtils::restoreControlPoint(dstPoint, true, mergedControlPoint1);
        KritaUtils::restoreControlPoint(dstPoint, false, mergedControlPoint2);
    }

References dstPoint, p1, p2, and KritaUtils::restoreControlPoint().

◆ Private()

KoPathPointMergeCommand::Private	(	const KoPathPointData &	pointData1,
		const KoPathPointData &	pointData2 )

inline

Definition at line 21 of file KoPathPointMergeCommand.cpp.

    : pathShape(pointData1.pathShape)
    , pointIndex1(pointData1.pointIndex)
    , pointIndex2(pointData2.pointIndex)
    , removedPoint(0)
    , mergedPointIndex(-1, -1)
    , reverse(ReverseNone)
    {
    }

◆ redo()

void KoPathPointMergeCommand::redo ( )

overridevirtual

redo the command

Reimplemented from KUndo2Command.

Definition at line 143 of file KoPathPointMergeCommand.cpp.

{
    KUndo2Command::redo();
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(!d->removedPoint);
 
    KoPathPoint * point1 = d->pathShape->pointByIndex(d->pointIndex1);
    KoPathPoint * point2 = d->pathShape->pointByIndex(d->pointIndex2);
 
    d->pathShape->update();
 
    if (d->closeSubpathMode()) {
        d->savePointState(point1);
        d->mergePoints(point2, point1, point1);
        d->removedPoint = d->pathShape->removePoint(d->pointIndex2);
 
        KoPathPointIndex newStartIndex(d->pointIndex1.first, 0);
 
        d->pathShape->closeSubpath(newStartIndex);
        d->mergedPointIndex = newStartIndex;
 
    } else {
        if (d->reverse & Private::ReverseFirst) {
            d->pathShape->reverseSubpath(d->pointIndex1.first);
        }
 
        if (d->reverse & Private::ReverseSecond) {
            d->pathShape->reverseSubpath(d->pointIndex2.first);
        }
 
        d->pathShape->moveSubpath(d->pointIndex2.first, d->pointIndex1.first + 1);
        d->mergedPointIndex = d->pathShape->pathPointIndex(point1);
        d->pathShape->join(d->pointIndex1.first);
 
        d->savePointState(point1);
        d->mergePoints(point1, point2, point1);
 
        KoPathPointIndex removeIndex = d->pathShape->pathPointIndex(point2);
        d->removedPoint = d->pathShape->removePoint(removeIndex);
    }
 
    d->pathShape->recommendPointSelectionChange({d->mergedPointIndex});
    d->pathShape->update();
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN, and KUndo2Command::redo().

◆ restorePointState()

void KoPathPointMergeCommand::restorePointState ( KoPathPoint * point )

inline

Definition at line 42 of file KoPathPointMergeCommand.cpp.

                                               {
        point->setPoint(savedNodePoint1);
        KritaUtils::restoreControlPoint(point, true, savedControlPoint11);
        KritaUtils::restoreControlPoint(point, false, savedControlPoint12);
    }

References KritaUtils::restoreControlPoint(), and KoPathPoint::setPoint().

◆ savePointState()

void KoPathPointMergeCommand::savePointState ( KoPathPoint * point )

inline

Definition at line 36 of file KoPathPointMergeCommand.cpp.

                                            {
        savedNodePoint1 = point->point();
        savedControlPoint11 = KritaUtils::fetchControlPoint(point, true);
        savedControlPoint12 = KritaUtils::fetchControlPoint(point, false);
    }

References KritaUtils::fetchControlPoint(), and KoPathPoint::point.

◆ undo()

void KoPathPointMergeCommand::undo ( )

overridevirtual

revert the actions done in redo

Reimplemented from KUndo2Command.

Definition at line 188 of file KoPathPointMergeCommand.cpp.

{
    KUndo2Command::undo();
 
    d->pathShape->update();
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(d->removedPoint);
 
    if (d->closeSubpathMode()) {
        d->pathShape->openSubpath(d->mergedPointIndex);
        d->pathShape->insertPoint(d->removedPoint, d->pointIndex2);
        d->restorePointState(d->pathShape->pointByIndex(d->pointIndex1));
    } else {
        d->pathShape->breakAfter(d->mergedPointIndex);
        d->pathShape->insertPoint(d->removedPoint, KoPathPointIndex(d->mergedPointIndex.first+1,0));
        d->restorePointState(d->pathShape->pointByIndex(d->mergedPointIndex));
        d->pathShape->moveSubpath(d->mergedPointIndex.first+1, d->pointIndex2.first);
 
        // undo the reversion of the subpaths
        if (d->reverse & Private::ReverseFirst) {
            d->pathShape->reverseSubpath(d->pointIndex1.first);
        }
 
        if (d->reverse & Private::ReverseSecond) {
            d->pathShape->reverseSubpath(d->pointIndex2.first);
        }
    }
 
    // reset the removed point
    d->removedPoint = 0;
    d->mergedPointIndex = KoPathPointIndex(-1,-1);
 
    d->pathShape->recommendPointSelectionChange({d->pointIndex1, d->pointIndex2});
    d->pathShape->update();
}