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

#include <KoPathPointRemoveCommand.h>

Inheritance diagram for KoPathPointRemoveCommand:

Public Member Functions
	KoPathPointRemoveCommand (const QList< KoPathPointData > &pointDataList, KUndo2Command *parent=0)
	Command to remove a points from path shapes.

void	redo () override
	redo the command

void	undo () override
	revert the actions done in redo

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

Static Public Member Functions
static KUndo2Command *	createCommand (const QList< KoPathPointData > &pointDataList, KoShapeController shapeController, KUndo2Command parent=0)
	Create command for removing points from path shapes.

Private Attributes
KoPathPointRemoveCommandPrivate *	d

Detailed Description

The undo / redo command for removing path points.

Definition at line 20 of file KoPathPointRemoveCommand.h.

Constructor & Destructor Documentation

◆ KoPathPointRemoveCommand()

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

explicit

Command to remove a points from path shapes.

Don't use this directly use createCommand instead.

Parameters

pointDataList	List of point data to remove.
parent	the parent command used for macro commands

Definition at line 110 of file KoPathPointRemoveCommand.cpp.

    : KUndo2Command(parent),
    d(new KoPathPointRemoveCommandPrivate())
{
    QList<KoPathPointData>::const_iterator it(pointDataList.begin());
    for (; it != pointDataList.end(); ++it) {
        KoPathPoint *point = it->pathShape->pointByIndex(it->pointIndex);
        if (point) {
            d->pointDataList.append(*it);
            d->points.append(0);
        }
    }
    std::sort(d->pointDataList.begin(), d->pointDataList.end());
    setText(kundo2_i18n("Remove points"));
}

References d, kundo2_i18n(), KoPathPointRemoveCommandPrivate::pointDataList, KoPathPointRemoveCommandPrivate::points, and KUndo2Command::setText().

◆ ~KoPathPointRemoveCommand()

KoPathPointRemoveCommand::~KoPathPointRemoveCommand ( )

override

Definition at line 127 of file KoPathPointRemoveCommand.cpp.

{
    delete d;
}

References d.

Member Function Documentation

◆ createCommand()

KUndo2Command * KoPathPointRemoveCommand::createCommand	(	const QList< KoPathPointData > &	pointDataList,
		KoShapeController *	shapeController,
		KUndo2Command *	parent = 0 )

static

Create command for removing points from path shapes.

This will create the command for removing points from path shapes. If all points from a path shape are deleted it will delete the path shape. If all points from a subpath are deleted it will delete the subpath.

Parameters

pointDataList	List of point data to remove
shapeController	shape controller in charge
parent	the parent command used for macro commands

Definition at line 27 of file KoPathPointRemoveCommand.cpp.

{
    /*
     * We want to decide if we have to:
     * 1. delete only some points of a path or
     * 2. delete one or more complete subpath or
     * 3. delete a complete path
     */
 
    QList<KoPathPointData> sortedPointData(pointDataList);
    std::sort(sortedPointData.begin(), sortedPointData.end());
 
    KoPathPointData last(0, KoPathPointIndex(-1, -1));
    // add last at the end so that the point date before last will also be put in
    // the right places.
    sortedPointData.append(last);
 
    QList<KoPathPointData> pointsOfSubpath; // points of current subpath
    QList<KoPathPointData> subpathsOfPath;  // subpaths of current path
    QList<KoPathPointData> pointsToDelete;  // single points to delete
    QList<KoPathPointData> subpathToDelete; // single subpaths to delete
    QList<KoShape*> shapesToDelete;         // single paths to delete
 
    last = sortedPointData.first();
 
    QList<KoPathPointData>::const_iterator it(sortedPointData.constBegin());
    for (; it != sortedPointData.constEnd(); ++it) {
        // check if we have come to the next subpath of the same or another path
        if (last.pathShape != it->pathShape || last.pointIndex.first != it->pointIndex.first) {
            // check if all points of the last subpath should be deleted
            if (last.pathShape->subpathPointCount(last.pointIndex.first) == pointsOfSubpath.size()) {
                // all points of subpath to be deleted -> mark subpath as to be deleted
                subpathsOfPath.append(pointsOfSubpath.first());
            } else {
                // not all points of subpath to be deleted -> add them to the delete point list
                pointsToDelete += pointsOfSubpath;
            }
            // clear the suboath point list
            pointsOfSubpath.clear();
        }
 
        // check if we have come to the next shape
        if (last.pathShape != it->pathShape) {
            // check if all subpath of the shape should be deleted
            if (last.pathShape->subpathCount() == subpathsOfPath.size()) {
                // all subpaths of path to be deleted -> add shape to delete shape list
                shapesToDelete.append(last.pathShape);
            } else {
                // not all subpaths of path to be deleted -> add them to delete subpath list
                subpathToDelete += subpathsOfPath;
            }
            subpathsOfPath.clear();
        }
        if (! it->pathShape)
            continue;
        // keep reference to last point
        last = *it;
        // add this point to the current subpath point list
        pointsOfSubpath.append(*it);
    }
 
    KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Remove points"), parent);
 
    if (pointsToDelete.size() > 0) {
        new KoPathPointRemoveCommand(pointsToDelete, cmd);
    }
 
    //Reverse sort the subpath list to account for shifting indices of the subpaths
    std::sort(subpathToDelete.begin(), subpathToDelete.end(), std::greater<>{});
 
    Q_FOREACH (const KoPathPointData & pd, subpathToDelete) {
        new KoSubpathRemoveCommand(pd.pathShape, pd.pointIndex.first, cmd);
    }
    if (shapesToDelete.size() > 0) {
        shapeController->removeShapes(shapesToDelete, cmd);
    }
 
    return cmd;
}

References KoPathPointRemoveCommand(), kundo2_i18n(), KUndo2Command::KUndo2Command(), KoPathPointData::pathShape, KoPathPointData::pointIndex, KoShapeController::removeShapes(), KoPathShape::subpathCount(), and KoPathShape::subpathPointCount().

◆ redo()

void KoPathPointRemoveCommand::redo ( )

overridevirtual

redo the command

Reimplemented from KUndo2Command.

Definition at line 132 of file KoPathPointRemoveCommand.cpp.

{
    KUndo2Command::redo();
    KoPathShape * lastPathShape = 0;
    int updateBefore = d->pointDataList.size();
    for (int i = d->pointDataList.size() - 1; i >= 0; --i) {
        const KoPathPointData &pd = d->pointDataList.at(i);
        pd.pathShape->update();
        d->points[i] = pd.pathShape->removePoint(pd.pointIndex);
 
        if (lastPathShape != pd.pathShape) {
            if (lastPathShape) {
                QPointF offset = lastPathShape->normalize();
 
                QTransform matrix;
                matrix.translate(-offset.x(), -offset.y());
                for (int j = i + 1; j < updateBefore; ++j) {
                    d->points.at(j)->map(matrix);
                }
                lastPathShape->update();
                updateBefore = i + 1;
            }
            lastPathShape = pd.pathShape;
        }
    }
 
    if (lastPathShape) {
        QPointF offset = lastPathShape->normalize();
 
        QTransform matrix;
        matrix.translate(-offset.x(), -offset.y());
        for (int j = 0; j < updateBefore; ++j) {
            d->points.at(j)->map(matrix);
        }
        lastPathShape->update();
    }
 
    d->deletePoints = true;
}

References d, KoPathPointRemoveCommandPrivate::deletePoints, KoPathShape::normalize(), KoPathPointData::pathShape, KoPathPointRemoveCommandPrivate::pointDataList, KoPathPointData::pointIndex, KoPathPointRemoveCommandPrivate::points, KUndo2Command::redo(), KoPathShape::removePoint(), and KoShape::update().

◆ undo()

void KoPathPointRemoveCommand::undo ( )

overridevirtual

revert the actions done in redo

Reimplemented from KUndo2Command.

Definition at line 172 of file KoPathPointRemoveCommand.cpp.

{
    KUndo2Command::undo();
    KoPathShape * lastPathShape = 0;
 
    QMap<KoPathShape *, QList<KoPathPointIndex>> pointsMap;
 
    for (int i = 0; i < d->pointDataList.size(); ++i) {
        const KoPathPointData &pd = d->pointDataList.at(i);
        if (lastPathShape && lastPathShape != pd.pathShape) {
            lastPathShape->normalize();
            lastPathShape->update();
        }
        pd.pathShape->insertPoint(d->points[i], pd.pointIndex);
        lastPathShape = pd.pathShape;
 
        pointsMap[pd.pathShape].append(pd.pointIndex);
    }
 
    if (lastPathShape) {
        lastPathShape->normalize();
        lastPathShape->update();
    }
 
    for (auto it = pointsMap.constBegin(); it != pointsMap.constEnd(); ++it) {
        it.key()->recommendPointSelectionChange(it.value());
    }
 
    d->deletePoints = false;
}