Command to break a subpath at points. More...

#include <KoPathBreakAtPointCommand.h>

Inheritance diagram for KoPathBreakAtPointCommand:

Public Member Functions
	KoPathBreakAtPointCommand (const QList< KoPathPointData > &pointDataList, KUndo2Command *parent=0)

void	redo () override
	redo the command

void	undo () override
	revert the actions done in redo

	~KoPathBreakAtPointCommand () 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
QList< KoPathPointIndex >	m_closedIndex

bool	m_deletePoints

QList< KoPathPointData >	m_pointDataList

QList< KoPathPoint * >	m_points

Detailed Description

Command to break a subpath at points.

Definition at line 18 of file KoPathBreakAtPointCommand.h.

Constructor & Destructor Documentation

◆ KoPathBreakAtPointCommand()

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

explicit

Command to break a subpath at points.

The paths are broken at the given points. New points will be inserted after the given points and then the paths will be split after the given points.

Parameters

pointDataList	List of point data where the path should be split.
parent	the parent command used for macro commands

Definition at line 21 of file KoPathBreakAtPointCommand.cpp.

        : KUndo2Command(parent)
        , m_deletePoints(true)
{
    QList<KoPathPointData> sortedPointDataList(pointDataList);
    std::sort(sortedPointDataList.begin(), sortedPointDataList.end());
    setText(kundo2_i18n("Break subpath at points"));
 
    QList<KoPathPointData>::const_iterator it(sortedPointDataList.constBegin());
    for (; it != sortedPointDataList.constEnd(); ++it) {
        KoPathShape * pathShape = it->pathShape;
        KoPathPoint * point = pathShape->pointByIndex(it->pointIndex);
        if(! point)
            continue;
 
        // check if subpath is closed and the point is start or end point of the subpath
        if(! pathShape->isClosedSubpath(it->pointIndex.first)) {
            if(it->pointIndex.second == 0
                || it->pointIndex.second == pathShape->subpathPointCount(it->pointIndex.first)) {
                continue;
            }
        }
 
        m_pointDataList.append(*it);
        m_points.push_back(new KoPathPoint(*point));
        m_closedIndex.push_back(KoPathPointIndex(-1, 0));
    }
 
    KoPathPointData last(0, KoPathPointIndex(-1, -1));
    for (int i = m_pointDataList.size() - 1; i >= 0; --i) {
        const KoPathPointData &current = m_pointDataList.at(i);
 
        if (last.pathShape != current.pathShape || last.pointIndex.first != current.pointIndex.first) {
            last = current;
            if (current.pathShape->isClosedSubpath(current.pointIndex.first)) {
                // the break will happen before the inserted point so we have to increment by 1
                m_closedIndex[i] = current.pointIndex;
                ++m_closedIndex[i].second;
            }
        }
    }
}

References KoPathShape::isClosedSubpath(), kundo2_i18n(), m_closedIndex, m_pointDataList, m_points, KoPathPointData::pathShape, KoPathShape::pointByIndex(), KoPathPointData::pointIndex, KUndo2Command::setText(), and KoPathShape::subpathPointCount().

◆ ~KoPathBreakAtPointCommand()

KoPathBreakAtPointCommand::~KoPathBreakAtPointCommand ( )

override

Definition at line 64 of file KoPathBreakAtPointCommand.cpp.

{
    if (m_deletePoints) {
        qDeleteAll(m_points);
    }
}

References m_deletePoints, and m_points.

Member Function Documentation

◆ redo()

void KoPathBreakAtPointCommand::redo ( )

overridevirtual

redo the command

Reimplemented from KUndo2Command.

Definition at line 71 of file KoPathBreakAtPointCommand.cpp.

{
    KUndo2Command::redo();
    KoPathPointData last(0, KoPathPointIndex(-1, -1));
 
    // offset, needed when path was opened
    int offset = 0;
    for (int i = m_pointDataList.size() - 1; i >= 0; --i) {
        const KoPathPointData & pd = m_pointDataList.at(i);
        KoPathShape * pathShape = pd.pathShape;
 
        KoPathPointIndex pointIndex = pd.pointIndex;
        if (last.pathShape != pathShape || last.pointIndex.first != pointIndex.first) {
            offset = 0;
        }
 
        pointIndex.second = pointIndex.second + offset + 1;
        pathShape->insertPoint(m_points[i], pointIndex);
 
        if (m_closedIndex.at(i).first != -1) {
            m_closedIndex[i] = pathShape->openSubpath(m_closedIndex.at(i));
            offset = m_closedIndex.at(i).second;
        } else {
            KoPathPointIndex breakIndex = pd.pointIndex;
            breakIndex.second += offset;
            pathShape->breakAfter(breakIndex);
            m_closedIndex[i].second = offset;
        }
 
        if (last.pathShape != pathShape) {
            if (last.pathShape) {
                last.pathShape->update();
            }
            last = pd;
        }
    }
    if (last.pathShape) {
        last.pathShape->update();
    }
 
    m_deletePoints = false;
}

References KoPathShape::breakAfter(), KoPathShape::insertPoint(), m_closedIndex, m_deletePoints, m_pointDataList, m_points, KoPathShape::openSubpath(), KoPathPointData::pathShape, KoPathPointData::pointIndex, KUndo2Command::redo(), and KoShapeContainer::update().

◆ undo()

void KoPathBreakAtPointCommand::undo ( )

overridevirtual

revert the actions done in redo

Reimplemented from KUndo2Command.

Definition at line 114 of file KoPathBreakAtPointCommand.cpp.

{
    KUndo2Command::undo();
    KoPathShape * lastPathShape = 0;
 
    QMap<KoPathShape *, QList<KoPathPointIndex>> pointsMap;
 
    for (int i = 0; i < m_pointDataList.size(); ++i) {
        const KoPathPointData & pd = m_pointDataList.at(i);
        KoPathShape * pathShape = pd.pathShape;
        KoPathPointIndex pointIndex = pd.pointIndex;
        ++pointIndex.second;
        if (m_closedIndex.at(i).first != -1) {
            m_closedIndex[i] = pathShape->closeSubpath(m_closedIndex.at(i));
        } else {
            pointIndex.second = pointIndex.second + m_closedIndex.at(i).second;
            pathShape->join(pd.pointIndex.first);
        }
 
        m_points[i] = pathShape->removePoint(pointIndex);
 
        pointsMap[pathShape].append(pd.pointIndex);
 
        if (lastPathShape != pathShape) {
            if (lastPathShape) {
                lastPathShape->update();
            }
            lastPathShape = pathShape;
        }
    }
    if (lastPathShape) {
        lastPathShape->update();
    }
 
    for (auto it = pointsMap.constBegin(); it != pointsMap.constEnd(); ++it) {
        it.key()->recommendPointSelectionChange(it.value());
    }
 
    m_deletePoints = true;
}