KoPathPointTypeCommand Class Reference

The undo / redo command for changing the path point type. More...

#include <KoPathPointTypeCommand.h>

Inheritance diagram for KoPathPointTypeCommand:

Classes
struct	PointData

Public Types
enum	PointType {   Corner , Smooth , Symmetric , Line ,   Curve }
	The type of the point. More...

Public Member Functions
	KoPathPointTypeCommand (const QList< KoPathPointData > &pointDataList, PointType pointType, KUndo2Command *parent=0)
void	redo () override
	redo the command
void	undo () override
	revert the actions done in redo
	~KoPathPointTypeCommand () override
Public Member Functions inherited from KoPathBaseCommand
	KoPathBaseCommand (KoPathShape *shape, KUndo2Command *parent=0)
	KoPathBaseCommand (KUndo2Command *parent=0)
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 void	makeCubicPointSmooth (KoPathPoint *point)

Private Member Functions
bool	appendPointData (KoPathPointData data)
void	undoChanges (const QList< PointData > &data)

Private Attributes
QList< PointData >	m_additionalPointData
QList< PointData >	m_oldPointData
PointType	m_pointType

Additional Inherited Members
Protected Member Functions inherited from KoPathBaseCommand
void	repaint (bool normalizeShapes)
Protected Attributes inherited from KoPathBaseCommand
QSet< KoPathShape * >	m_shapes
	the shapes the command operates on

Detailed Description

The undo / redo command for changing the path point type.

Definition at line 19 of file KoPathPointTypeCommand.h.

Member Enumeration Documentation

PointType

enum KoPathPointTypeCommand::PointType

The type of the point.

Enumerator
Corner
Smooth
Symmetric
Line
Curve

Definition at line 23 of file KoPathPointTypeCommand.h.

                   {
        Corner,
        Smooth,
        Symmetric,
        Line,
        Curve
    };

Constructor & Destructor Documentation

KoPathPointTypeCommand()

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

Command to change the type of the given points

Parameters

pointDataList	List of point for changing the points
pointType	the new point type to set
parent	the parent command used for macro commands

Definition at line 15 of file KoPathPointTypeCommand.cpp.

        : KoPathBaseCommand(parent)
        , m_pointType(pointType)
{
    QList<KoPathPointData>::const_iterator it(pointDataList.begin());
    for (; it != pointDataList.end(); ++it) {
        KoPathPoint *point = it->pathShape->pointByIndex(it->pointIndex);
        if (point) {
            PointData pointData(*it);
            pointData.m_oldControlPoint1 = it->pathShape->shapeToDocument(point->controlPoint1());
            pointData.m_oldControlPoint2 = it->pathShape->shapeToDocument(point->controlPoint2());
            pointData.m_oldProperties = point->properties();
            pointData.m_hadControlPoint1 = point->activeControlPoint1();
            pointData.m_hadControlPoint2 = point->activeControlPoint2();
            m_oldPointData.append(pointData);
            m_shapes.insert(it->pathShape);
        }
    }
    setText(kundo2_i18n("Set point type"));
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, kundo2_i18n(), KoPathPointTypeCommand::PointData::m_hadControlPoint1, KoPathPointTypeCommand::PointData::m_hadControlPoint2, KoPathPointTypeCommand::PointData::m_oldControlPoint1, KoPathPointTypeCommand::PointData::m_oldControlPoint2, m_oldPointData, KoPathPointTypeCommand::PointData::m_oldProperties, KoPathBaseCommand::m_shapes, KoPathPoint::properties, and KUndo2Command::setText().

~KoPathPointTypeCommand()

KoPathPointTypeCommand::~KoPathPointTypeCommand ( )

override

Definition at line 39 of file KoPathPointTypeCommand.cpp.

{
}

Member Function Documentation

appendPointData()

bool KoPathPointTypeCommand::appendPointData ( KoPathPointData data )

private

Definition at line 206 of file KoPathPointTypeCommand.cpp.

{
    KoPathPoint *point = data.pathShape->pointByIndex(data.pointIndex);
    if (! point)
        return false;
 
    PointData pointData(data);
    pointData.m_oldControlPoint1 = data.pathShape->shapeToDocument(point->controlPoint1());
    pointData.m_oldControlPoint2 = data.pathShape->shapeToDocument(point->controlPoint2());
    pointData.m_oldProperties = point->properties();
    pointData.m_hadControlPoint1 = point->activeControlPoint1();
    pointData.m_hadControlPoint2 = point->activeControlPoint2();
 
    m_additionalPointData.append(pointData);
 
    return true;
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, m_additionalPointData, KoPathPointTypeCommand::PointData::m_hadControlPoint1, KoPathPointTypeCommand::PointData::m_hadControlPoint2, KoPathPointTypeCommand::PointData::m_oldControlPoint1, KoPathPointTypeCommand::PointData::m_oldControlPoint2, KoPathPointTypeCommand::PointData::m_oldProperties, KoPathPointData::pathShape, KoPathShape::pointByIndex(), KoPathPointData::pointIndex, KoPathPoint::properties, and KoShape::shapeToDocument().

makeCubicPointSmooth()

void KoPathPointTypeCommand::makeCubicPointSmooth ( KoPathPoint * point )

static

Definition at line 164 of file KoPathPointTypeCommand.cpp.

{
    KoPathPoint::PointProperties properties = point->properties();
 
    properties &= ~KoPathPoint::IsSymmetric;
    properties |= KoPathPoint::IsSmooth;
 
    // calculate vector from node point to first control point and normalize it
    QPointF directionC1 = point->controlPoint1() - point->point();
    qreal dirLengthC1 = sqrt(directionC1.x() * directionC1.x() + directionC1.y() * directionC1.y());
    directionC1 /= dirLengthC1;
    // calculate vector from node point to second control point and normalize it
    QPointF directionC2 = point->controlPoint2() - point->point();
    qreal dirLengthC2 = sqrt(directionC2.x() * directionC2.x() + directionC2.y() * directionC2.y());
    directionC2 /= dirLengthC2;
    // compute position of the control points so that they lie on a line going through the node point
    // the new distance of the control points is the average distance to the node point
    point->setControlPoint1(point->point() + 0.5 * dirLengthC1 * (directionC1 - directionC2));
    point->setControlPoint2(point->point() + 0.5 * dirLengthC2 * (directionC2 - directionC1));
 
    point->setProperties(properties);
}

References KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, KoPathPoint::IsSmooth, KoPathPoint::point, KoPathPoint::properties, KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), and KoPathPoint::setProperties().

redo()

void KoPathPointTypeCommand::redo ( )

overridevirtual

redo the command

Reimplemented from KUndo2Command.

Definition at line 43 of file KoPathPointTypeCommand.cpp.

{
    KUndo2Command::redo();
    repaint(false);
    m_additionalPointData.clear();
 
    QList<PointData>::iterator it(m_oldPointData.begin());
    for (; it != m_oldPointData.end(); ++it) {
        KoPathPoint *point = it->m_pointData.pathShape->pointByIndex(it->m_pointData.pointIndex);
        KoPathPoint::PointProperties properties = point->properties();
 
        switch (m_pointType) {
        case Line: {
            point->removeControlPoint1();
            point->removeControlPoint2();
            break;
        }
        case Curve: {
            KoPathPointIndex pointIndex = it->m_pointData.pointIndex;
            KoPathPointIndex prevIndex;
            KoPathPointIndex nextIndex;
            KoPathShape * path = it->m_pointData.pathShape;
            // get previous path node
            if (pointIndex.second > 0)
                prevIndex = KoPathPointIndex(pointIndex.first, pointIndex.second - 1);
            else if (pointIndex.second == 0 && path->isClosedSubpath(pointIndex.first))
                prevIndex = KoPathPointIndex(pointIndex.first, path->subpathPointCount(pointIndex.first) - 1);
            // get next node
            if (pointIndex.second < path->subpathPointCount(pointIndex.first) - 1)
                nextIndex = KoPathPointIndex(pointIndex.first, pointIndex.second + 1);
            else if (pointIndex.second < path->subpathPointCount(pointIndex.first) - 1
                     && path->isClosedSubpath(pointIndex.first))
                nextIndex = KoPathPointIndex(pointIndex.first, 0);
 
            KoPathPoint * prevPoint = path->pointByIndex(prevIndex);
            KoPathPoint * nextPoint = path->pointByIndex(nextIndex);
 
            if (prevPoint && ! point->activeControlPoint1() && appendPointData(KoPathPointData(path, prevIndex))) {
                KoPathSegment cubic = KoPathSegment(prevPoint, point).toCubic();
                if (prevPoint->activeControlPoint2()) {
                    prevPoint->setControlPoint2(cubic.first()->controlPoint2());
                    point->setControlPoint1(cubic.second()->controlPoint1());
                } else
                    point->setControlPoint1(cubic.second()->controlPoint1());
            }
            if (nextPoint && ! point->activeControlPoint2() && appendPointData(KoPathPointData(path, nextIndex))) {
                KoPathSegment cubic = KoPathSegment(point, nextPoint).toCubic();
                if (nextPoint->activeControlPoint1()) {
                    point->setControlPoint2(cubic.first()->controlPoint2());
                    nextPoint->setControlPoint1(cubic.second()->controlPoint1());
                } else
                    point->setControlPoint2(cubic.first()->controlPoint2());
            }
            point->setProperties(properties);
            break;
        }
        case Symmetric: {
            properties &= ~KoPathPoint::IsSmooth;
            properties |= KoPathPoint::IsSymmetric;
 
            // calculate vector from node point to first control point and normalize it
            QPointF directionC1 = point->controlPoint1() - point->point();
            qreal dirLengthC1 = sqrt(directionC1.x() * directionC1.x() + directionC1.y() * directionC1.y());
            directionC1 /= dirLengthC1;
            // calculate vector from node point to second control point and normalize it
            QPointF directionC2 = point->controlPoint2() - point->point();
            qreal dirLengthC2 = sqrt(directionC2.x() * directionC2.x() + directionC2.y() * directionC2.y());
            directionC2 /= dirLengthC2;
            // calculate the average distance of the control points to the node point
            qreal averageLength = 0.5 * (dirLengthC1 + dirLengthC2);
            // compute position of the control points so that they lie on a line going through the node point
            // the new distance of the control points is the average distance to the node point
            point->setControlPoint1(point->point() + 0.5 * averageLength * (directionC1 - directionC2));
            point->setControlPoint2(point->point() + 0.5 * averageLength * (directionC2 - directionC1));
            point->setProperties(properties);
        }
        break;
        case Smooth: {
            makeCubicPointSmooth(point);
        }
        break;
        case Corner:
        default:
            properties &= ~KoPathPoint::IsSymmetric;
            properties &= ~KoPathPoint::IsSmooth;
            point->setProperties(properties);
            break;
        }
    }
    repaint(true);
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, appendPointData(), KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, Corner, Curve, KoPathSegment::first, KoPathPoint::IsSymmetric, Line, m_additionalPointData, m_oldPointData, m_pointType, makeCubicPointSmooth(), KoPathPoint::point, KoPathPoint::properties, KUndo2Command::redo(), KoPathPoint::removeControlPoint1(), KoPathPoint::removeControlPoint2(), KoPathBaseCommand::repaint(), KoPathSegment::second, KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), KoPathPoint::setProperties(), Smooth, Symmetric, and KoPathSegment::toCubic().

undo()

void KoPathPointTypeCommand::undo ( )

overridevirtual

revert the actions done in redo

Reimplemented from KUndo2Command.

Definition at line 135 of file KoPathPointTypeCommand.cpp.

{
    KUndo2Command::undo();
    repaint(false);
 
    /*
    QList<PointData>::iterator it(m_oldPointData.begin());
    for (; it != m_oldPointData.end(); ++it)
    {
        KoPathShape *pathShape = it->m_pointData.pathShape;
        KoPathPoint *point = pathShape->pointByIndex(it->m_pointData.pointIndex);
 
        point->setProperties(it->m_oldProperties);
        if (it->m_hadControlPoint1)
            point->setControlPoint1(pathShape->documentToShape(it->m_oldControlPoint1));
        else
            point->removeControlPoint1();
        if (it->m_hadControlPoint2)
            point->setControlPoint2(pathShape->documentToShape(it->m_oldControlPoint2));
        else
            point->removeControlPoint2();
    }
    */
    undoChanges(m_oldPointData);
    undoChanges(m_additionalPointData);
 
    repaint(true);
}

References m_additionalPointData, m_oldPointData, KoPathBaseCommand::repaint(), KUndo2Command::undo(), and undoChanges().

undoChanges()

void KoPathPointTypeCommand::undoChanges ( const QList< PointData > & data )

private

Definition at line 187 of file KoPathPointTypeCommand.cpp.

{
    QList<PointData>::const_iterator it(data.begin());
    for (; it != data.end(); ++it) {
        KoPathShape *pathShape = it->m_pointData.pathShape;
        KoPathPoint *point = pathShape->pointByIndex(it->m_pointData.pointIndex);
 
        point->setProperties(it->m_oldProperties);
        if (it->m_hadControlPoint1)
            point->setControlPoint1(pathShape->documentToShape(it->m_oldControlPoint1));
        else
            point->removeControlPoint1();
        if (it->m_hadControlPoint2)
            point->setControlPoint2(pathShape->documentToShape(it->m_oldControlPoint2));
        else
            point->removeControlPoint2();
    }
}

References KoShape::documentToShape(), KoPathShape::pointByIndex(), KoPathPoint::removeControlPoint1(), KoPathPoint::removeControlPoint2(), KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), and KoPathPoint::setProperties().

Member Data Documentation

m_additionalPointData

QList<PointData> KoPathPointTypeCommand::m_additionalPointData

private

Definition at line 65 of file KoPathPointTypeCommand.h.

m_oldPointData

QList<PointData> KoPathPointTypeCommand::m_oldPointData

private

Definition at line 64 of file KoPathPointTypeCommand.h.

m_pointType

PointType KoPathPointTypeCommand::m_pointType

private

Definition at line 63 of file KoPathPointTypeCommand.h.

---

The documentation for this class was generated from the following files:

• libs/flake/commands/KoPathPointTypeCommand.h
• libs/flake/commands/KoPathPointTypeCommand.cpp