The position of a path point within a path shape. More...

#include <KoPathShape.h>

Inheritance diagram for KoPathShape:

Classes
struct	PointSelectionChangeListener

class	Private

Public Member Functions
bool	addSubpath (KoSubpath *subpath, int subpathIndex)
	Adds a subpath at the given index to the path.

KoPathPoint *	arcTo (qreal rx, qreal ry, qreal startAngle, qreal sweepAngle)
	Add an arc.

bool	autoFillMarkers () const

QRectF	boundingRect () const override
	reimplemented

bool	breakAfter (const KoPathPointIndex &pointIndex)
	Breaks the path after the point index.

void	clear ()
	Removes all subpaths and their points from the path.

KoShape *	cloneShape () const override
	creates a deep copy of the shape or shape's subtree

void	close ()
	Closes the current subpath.

void	closeMerge ()
	Closes the current subpath.

KoPathPointIndex	closeSubpath (const KoPathPointIndex &pointIndex)
	Close a open subpath.

int	combine (KoPathShape *path)
	Combines two path shapes by appending the data of the specified path.

KoPathPoint *	curveTo (const QPointF &c, const QPointF &p)
	Adds a new quadratic Bezier curve segment.

KoPathPoint *	curveTo (const QPointF &c1, const QPointF &c2, const QPointF &p)
	Adds a new cubic Bezier curve segment.

Qt::FillRule	fillRule () const
	Returns the fill rule for the path object.

bool	hasMarkers () const

bool	hitTest (const QPointF &position) const override
	reimplemented

bool	insertPoint (KoPathPoint *point, const KoPathPointIndex &pointIndex)
	Inserts a new point into the given subpath at the specified position.

bool	isClosedSubpath (int subpathIndex) const
	Checks if a subpath is closed.

bool	join (int subpathIndex)
	Joins the given subpath with the following one.

	KoPathShape ()
	constructor

KoPathPoint *	lineTo (const QPointF &p)
	Adds a new line segment.

void	loadNodeTypes (const QString &nodeTypes)
	Loads node types.

KoMarker *	marker (KoFlake::MarkerPosition pos) const

bool	moveSubpath (int oldSubpathIndex, int newSubpathIndex)
	Moves the position of a subpath within a path.

KoPathPoint *	moveTo (const QPointF &p)
	Starts a new Subpath.

QString	nodeTypes () const
	Saves the node types.

virtual QPointF	normalize ()
	Normalizes the path data.

KoPathPointIndex	openSubpath (const KoPathPointIndex &pointIndex)
	Opens a closed subpath.

QPainterPath	outline () const override
	reimplemented

QRectF	outlineRect () const override
	reimplemented

void	paint (QPainter &painter) const override
	reimplemented

virtual void	paintPoints (KisHandlePainterHelper &handlesHelper)

KoPathPointIndex	pathPointIndex (const KoPathPoint *point) const
	Returns the path point index of a given path point.

virtual QString	pathShapeId () const

QPainterPath	pathStroke (const QPen &pen) const

KoPathPoint *	pointByIndex (const KoPathPointIndex &pointIndex) const
	Returns the path point specified by a path point index.

int	pointCount () const
	Returns the number of points in the path.

QList< KoPathPoint * >	pointsAt (const QRectF &rect, const bool useControlPoints=false) const
	Returns the path points within the given rectangle.

void	recommendPointSelectionChange (const QList< KoPathPointIndex > &newSelection)

KoPathPoint *	removePoint (const KoPathPointIndex &pointIndex)
	Removes a point from the path.

KoSubpath *	removeSubpath (int subpathIndex)
	Removes subpath from the path.

bool	reverseSubpath (int subpathIndex)
	Reverse subpath.

KoPathSegment	segmentAtPoint (const QPointF &point, const QRectF &grabRoi) const

KoPathSegment	segmentByIndex (const KoPathPointIndex &pointIndex) const
	Returns the segment specified by a path point index.

QList< KoPathSegment >	segmentsAt (const QRectF &rect) const
	Returns the list of path segments within the given rectangle.

bool	separate (QList< KoPathShape * > &separatedPaths)
	Creates separate path shapes, one for each existing subpath.

void	setAutoFillMarkers (bool value)

void	setFillRule (Qt::FillRule fillRule)
	Sets the fill rule to be used for painting the background.

void	setMarker (KoMarker *marker, KoFlake::MarkerPosition pos)

void	setSize (const QSizeF &size) override

QSizeF	size () const override
	reimplemented

int	subpathCount () const
	Returns the number of subpaths in the path.

int	subpathPointCount (int subpathIndex) const
	Returns the number of points in a subpath.

QString	toString (const QTransform &matrix=QTransform()) const
	Returns a odf/svg string representation of the path data with the given matrix applied.

	~KoPathShape () override

Public Member Functions inherited from KoShape
QRectF	absoluteOutlineRect () const

QPointF	absolutePosition (KoFlake::AnchorPosition anchor=KoFlake::Center) const

QTransform	absoluteTransformation () const

bool	addDependee (KoShape *shape)

QString	additionalAttribute (const QString &name) const

void	addShapeChangeListener (ShapeChangeListener *listener)

KoShapeAnchor *	anchor () const

void	applyAbsoluteTransformation (const QTransform &matrix)

void	applyTransformation (const QTransform &matrix)

virtual QSharedPointer< KoShapeBackground >	background () const

virtual ChildZOrderPolicy	childZOrderPolicy ()

KoClipMask *	clipMask () const
	Returns the currently set clip mask or 0 if there is no clip mask set.

KoClipPath *	clipPath () const
	Returns the currently set clip path or 0 if there is no clip path set.

KoShape *	cloneShapeAndBakeAbsoluteTransform () const
	creates a deep copy of the shape/shapes tree and bakes the absolute transform of `this` into the resulting shape.

void	copySettings (const KoShape *shape)

QList< KoShape * >	dependees () const
	Returns list of shapes depending on this shape.

QPointF	documentToShape (const QPointF &point) const
	Transforms point from document coordinates to shape coordinates.

QRectF	documentToShape (const QRectF &rect) const
	Transform rect from document coordinates to shape coordinates.

bool	hasAdditionalAttribute (const QString &name) const

bool	hasCommonParent (const KoShape *shape) const

bool	hasDependee (KoShape *shape) const
	Returns if the given shape is dependent on this shape.

virtual bool	hasTransparency () const

QString	hyperLink () const

bool	inheritBackground () const
	inheritBackground shows if the shape inherits background from its parent

bool	inheritPaintOrder () const
	inheritPaintOrder

bool	inheritsTransformFromAny (const QList< KoShape * > ancestorsInQuestion) const
	inheritsTransformFromAny checks if the shape inherits transformation from any of the shapes listed in `ancestorsInQuestion`. The inheritance is checked in recursive way.

bool	inheritStroke () const
	inheritStroke shows if the shape inherits the stroke from its parent

bool	isContentProtected () const

bool	isGeometryProtected () const

bool	isPrintable () const

bool	isSelectable () const

virtual bool	isShapeEditable (bool recursive=true) const
	checks recursively if the shape or one of its parents is not visible or locked

bool	isVisible (bool recursive=true) const

bool	keepAspectRatio () const

	KoShape ()
	Constructor.

qreal	minimumHeight () const

QString	name () const

void	notifyChanged ()

virtual void	paintMarkers (QPainter &painter) const
	paintStroke paints the shape's markers

virtual QVector< PaintOrder >	paintOrder () const
	paintOrder

virtual void	paintStroke (QPainter &painter) const
	paintStroke paints the shape's stroked outline

KoShapeContainer *	parent () const

QPointF	position () const
	Get the position of the shape in pt.

void	removeAdditionalAttribute (const QString &name)

void	removeAdditionalStyleAttribute (const char *name)

void	removeDependee (KoShape *shape)

void	removeShapeChangeListener (ShapeChangeListener *listener)

void	rotate (qreal angle)
	Rotate the shape (relative)

qreal	rotation () const

void	scale (qreal sx, qreal sy)
	Scale the shape using the zero-point which is the top-left corner.

void	setAbsolutePosition (const QPointF &newPosition, KoFlake::AnchorPosition anchor=KoFlake::Center)

void	setAdditionalAttribute (const QString &name, const QString &value)

void	setAdditionalStyleAttribute (const char *name, const QString &value)

void	setAnchor (KoShapeAnchor *anchor)

virtual void	setBackground (QSharedPointer< KoShapeBackground > background)

void	setClipMask (KoClipMask *clipMask)
	Sets a new clip mask, removing the old one. The mask is owned by the shape.

void	setClipPath (KoClipPath *clipPath)
	Sets a new clip path, removing the old one.

void	setContentProtected (bool protect)

void	setGeometryProtected (bool on)

void	setHyperLink (const QString &hyperLink)

void	setInheritBackground (bool value)
	setInheritBackground marks a shape as inheriting the background from the parent shape. NOTE: The currently selected background is destroyed.

void	setInheritPaintOrder (bool value)
	setInheritPaintOrder set inherit paint order.

void	setInheritStroke (bool value)
	setInheritStroke marks a shape as inheriting the stroke from the parent shape. NOTE: The currently selected stroke is destroyed.

void	setKeepAspectRatio (bool keepAspect)

void	setMinimumHeight (qreal height)

void	setName (const QString &name)

virtual void	setPaintOrder (PaintOrder first, PaintOrder second)
	setPaintOrder set the paint order. As there's only three entries in any given paintorder, you only need to have the first and second entry to set it.

void	setParent (KoShapeContainer *parent)

virtual void	setPosition (const QPointF &position)
	Set the position of the shape in pt.

void	setPrintable (bool on)

virtual void	setResolution (qreal xRes, qreal yRes)

void	setSelectable (bool selectable)

void	setShapeId (const QString &id)

virtual void	setStroke (KoShapeStrokeModelSP stroke)

void	setToolDelegates (const QSet< KoShape * > &delegates)

void	setTransformation (const QTransform &matrix)

void	setTransparency (qreal transparency)

void	setUserData (KoShapeUserData *userData)

void	setVisible (bool on)

void	setZIndex (qint16 zIndex)

QString	shapeId () const

QPointF	shapeToDocument (const QPointF &point) const
	Transforms point from shape coordinates to document coordinates.

QRectF	shapeToDocument (const QRectF &rect) const
	Transforms rect from shape coordinates to document coordinates.

void	shear (qreal sx, qreal sy)
	Shear the shape The shape will be sheared using the zero-point which is the top-left corner.

virtual KoSnapData	snapData () const
	Returns additional snap data the shape wants to have snapping to.

virtual KoShapeStrokeModelSP	stroke () const

KoInsets	strokeInsets () const

QSet< KoShape * >	toolDelegates () const

QTransform	transformation () const
	Returns the shapes local transformation matrix.

qreal	transparency (bool recursive=false) const

virtual void	update () const

virtual void	updateAbsolute (const QRectF &rect) const

KoShapeUserData *	userData () const

virtual void	waitUntilReady (bool asynchronous=true) const

qint16	zIndex () const

virtual	~KoShape ()
	Destructor.

Static Public Member Functions
static KoPathShape *	createShapeFromPainterPath (const QPainterPath &path)
	Creates path shape from given QPainterPath.

Static Public Member Functions inherited from KoShape
static QRectF	absoluteOutlineRect (const QList< KoShape * > &shapes)

static QRectF	boundingRect (const QList< KoShape * > &shapes)

static bool	compareShapeZIndex (KoShape s1, KoShape s2)

static KisHandlePainterHelper	createHandlePainterHelperDocument (QPainter painter, KoShape shape, qreal handleRadius, int decorationThickness)

static KisHandlePainterHelper	createHandlePainterHelperView (QPainter painter, KoShape shape, const KoViewConverter &converter, qreal handleRadius=0.0, int decorationThickness=1)

static QVector< PaintOrder >	defaultPaintOrder ()
	default paint order as per SVG specification

static QList< KoShape * >	linearizeSubtree (const QList< KoShape * > &shapes)

static QList< KoShape * >	linearizeSubtreeSorted (const QList< KoShape * > &shapes)

Protected Member Functions
int	arcToCurve (qreal rx, qreal ry, qreal startAngle, qreal sweepAngle, const QPointF &offset, QPointF *curvePoints) const
	Add an arc.

	KoPathShape (const KoPathShape &rhs)

void	map (const QTransform &matrix)

void	notifyPointsChanged ()

QTransform	resizeMatrix (const QSizeF &newSize) const

KoSubpathList &	subpaths ()
	XXX: refactor this using setter?

const KoSubpathList &	subpaths () const

Protected Member Functions inherited from KoShape
	KoShape (const KoShape &rhs)

QList< ShapeChangeListener * >	listeners () const

void	setSizeImpl (const QSizeF &size) const

virtual void	shapeChanged (ChangeType type, KoShape *shape=0)

void	shapeChangedPriv (KoShape::ChangeType type)

QTransform	transform () const
	return the current matrix that contains the rotation/scale/position of this shape

Private Member Functions
void	closeMergeSubpathPriv (KoSubpath *subpath)
	close-merges specified subpath

void	closeSubpathPriv (KoSubpath *subpath)
	closes specified subpath

void	updateLastPriv (KoPathPoint **lastPoint)

Private Attributes
QScopedPointer< Private >	d

Additional Inherited Members
Public Types inherited from KoShape
enum	ChangeType { PositionChanged , RotationChanged , ScaleChanged , ShearChanged , SizeChanged , GenericMatrixChange , KeepAspectRatioChange , ParentChanged , Deleted , StrokeChanged , BackgroundChanged , BorderChanged , ParameterChanged , ContentChanged , TextContourMarginChanged , ChildChanged , ConnectionPointChanged , ClipPathChanged , ClipMaskChanged , TransparencyChanged }
	Used by shapeChanged() to select which change was made. More...

enum	ChildZOrderPolicy { ChildZDefault , ChildZParentChild = ChildZDefault , ChildZPassThrough }
	Used by compareShapeZIndex() to order shapes. More...

enum	PaintOrder { Fill , Stroke , Markers }

Static Public Attributes inherited from KoShape
static const qint16	maxZIndex = std::numeric_limits<qint16>::max()

static const qint16	minZIndex = std::numeric_limits<qint16>::min()

Detailed Description

The position of a path point within a path shape.

This is the base for all graphical objects.

All graphical objects are based on this object e.g. lines, rectangles, pies and so on.

The KoPathShape uses KoPathPoint's to describe the path of the shape.

Here a short example: 3 points connected by a curveTo's described by the following svg: M 100,200 C 100,100 250,100 250,200 C 250,200 400,300 400,200.

This will be stored in 3 KoPathPoint's as The first point contains in point 100,200 controlPoint2 100,100 The second point contains in point 250,200 controlPoint1 250,100 controlPoint2 250,300 The third point contains in point 400,300 controlPoint1 400,200

Not the segments are stored but the points. Out of the points the segments are generated. See the outline method. The reason for storing it like that is that it is the points that are modified by the user and not the segments.

Definition at line 62 of file KoPathShape.h.

Constructor & Destructor Documentation

◆ KoPathShape() [1/2]

KoPathShape::KoPathShape ( )

constructor

Definition at line 59 of file KoPathShape.cpp.

    : KoShape()
    , d(new Private)
{
}

◆ ~KoPathShape()

KoPathShape::~KoPathShape ( )

override

Definition at line 84 of file KoPathShape.cpp.

{
    clear();
}

References clear().

◆ KoPathShape() [2/2]

KoPathShape::KoPathShape ( const KoPathShape & rhs )

protected

constructor: to be used in cloneShape(), not in descendants!

Definition at line 65 of file KoPathShape.cpp.

    : KoShape(rhs)
    , d(new Private(*rhs.d))
{
    // local data cannot be shared via QSharedData because
    // every path point holds a pointer to the parent shape
    KoSubpathList subpaths;
    Q_FOREACH (KoSubpath *subPath, rhs.d->subpaths) {
        KoSubpath *clonedSubPath = new KoSubpath();
 
        Q_FOREACH (KoPathPoint *point, *subPath) {
            *clonedSubPath << new KoPathPoint(*point, this);
        }
 
        subpaths << clonedSubPath;
    }
    d->subpaths = subpaths;
}

References d, and subpaths().

Member Function Documentation

◆ addSubpath()

bool KoPathShape::addSubpath	(	KoSubpath *	subpath,
		int	subpathIndex )

Adds a subpath at the given index to the path.

Parameters

subpath	the subpath to add
subpathIndex	the index at which the new subpath should be inserted

Returns: true on success, false otherwise e.g. subpathIndex out of bounds

Definition at line 925 of file KoPathShape.cpp.

{
    if (subpathIndex < 0 || subpathIndex > d->subpaths.size())
        return false;
 
    Q_FOREACH (KoPathPoint* point, *subpath) {
        point->setParent(this);
    }
 
    d->subpaths.insert(subpathIndex, subpath);
    notifyPointsChanged();
 
 
    return true;
}

References d, notifyPointsChanged(), and KoPathPoint::setParent().

◆ arcTo()

KoPathPoint * KoPathShape::arcTo	(	qreal	rx,
		qreal	ry,
		qreal	startAngle,
		qreal	sweepAngle )

Add an arc.

Adds an arc starting at the current point. The arc will be converted to bezier curves.

Parameters

rx	x radius of the ellipse
ry	y radius of the ellipse
startAngle	the angle where the arc will be started
sweepAngle	the length of the angle TODO add param to have angle of the ellipse

Returns: The newly created point

Definition at line 384 of file KoPathShape.cpp.

{
    if (d->subpaths.empty()) {
        moveTo(QPointF(0, 0));
    }
 
    KoPathPoint * lastPoint = d->subpaths.last()->last();
    if (lastPoint->properties() & KoPathPoint::CloseSubpath) {
        lastPoint = d->subpaths.last()->first();
    }
    QPointF startpoint(lastPoint->point());
 
    KoPathPoint * newEndPoint = lastPoint;
 
    QPointF curvePoints[12];
    int pointCnt = arcToCurve(rx, ry, startAngle, sweepAngle, startpoint, curvePoints);
    for (int i = 0; i < pointCnt; i += 3) {
        newEndPoint = curveTo(curvePoints[i], curvePoints[i+1], curvePoints[i+2]);
    }
    return newEndPoint;
}

References arcToCurve(), KoPathPoint::CloseSubpath, curveTo(), d, moveTo(), KoPathPoint::point, and KoPathPoint::properties.

◆ arcToCurve()

int KoPathShape::arcToCurve	(	qreal	rx,
		qreal	ry,
		qreal	startAngle,
		qreal	sweepAngle,
		const QPointF &	offset,
		QPointF *	curvePoints ) const

protected

Add an arc.

Adds an arc starting at the current point. The arc will be converted to bezier curves.

Parameters

rx	x radius of the ellipse
ry	y radius of the ellipse
startAngle	the angle where the arc will be started
sweepAngle	the length of the angle TODO add param to have angle of the ellipse
offset	to the first point in the arc
curvePoints	an array which take the curve points, pass a 'QPointF curvePoints[12]';

Returns: number of points created by the curve

Definition at line 406 of file KoPathShape.cpp.

{
    int pointCnt = 0;
 
    // check Parameters
    if (sweepAngle == 0.0)
        return pointCnt;
 
    sweepAngle = qBound(-360.0, sweepAngle, 360.0);
 
    if (rx == 0 || ry == 0) {
        //TODO
    }
 
    // split angles bigger than 90° so that it gives a good approximation to the circle
    qreal parts = ceil(qAbs(sweepAngle / 90.0));
 
    qreal sa_rad = startAngle * M_PI / 180.0;
    qreal partangle = sweepAngle / parts;
    qreal endangle = startAngle + partangle;
    qreal se_rad = endangle * M_PI / 180.0;
    qreal sinsa = sin(sa_rad);
    qreal cossa = cos(sa_rad);
    qreal kappa = 4.0 / 3.0 * tan((se_rad - sa_rad) / 4);
 
    // startpoint is at the last point is the path but when it is closed
    // it is at the first point
    QPointF startpoint(offset);
 
    //center berechnen
    QPointF center(startpoint - QPointF(cossa * rx, -sinsa * ry));
 
    //debugFlake <<"kappa" << kappa <<"parts" << parts;
 
    for (int part = 0; part < parts; ++part) {
        // start tangent
        curvePoints[pointCnt++] = QPointF(startpoint - QPointF(sinsa * rx * kappa, cossa * ry * kappa));
 
        qreal sinse = sin(se_rad);
        qreal cosse = cos(se_rad);
 
        // end point
        QPointF endpoint(center + QPointF(cosse * rx, -sinse * ry));
        // end tangent
        curvePoints[pointCnt++] = QPointF(endpoint - QPointF(-sinse * rx * kappa, -cosse * ry * kappa));
        curvePoints[pointCnt++] = endpoint;
 
        // set the endpoint as next start point
        startpoint = endpoint;
        sinsa = sinse;
        cossa = cosse;
        endangle += partangle;
        se_rad = endangle * M_PI / 180.0;
    }
 
    return pointCnt;
}

References M_PI, and part().

◆ autoFillMarkers()

bool KoPathShape::autoFillMarkers ( ) const

Definition at line 1310 of file KoPathShape.cpp.

{
    return d->autoFillMarkers;
}

References d.

◆ boundingRect()

QRectF KoPathShape::boundingRect ( ) const

overridevirtual

reimplemented

First we approximate the insets of the stroke by rendering a fat bezier curve with width set to the maximum inset of miters and markers. The are swept by this curve will be a good approximation of the real curve bounding rect.

NOTE: stroking the entire shape might be too expensive, so try to estimate the bounds using insets only...

Reimplemented from KoShape.

Definition at line 249 of file KoPathShape.cpp.

{
    const QTransform transform = absoluteTransformation();
 
    qreal outlineSweepWidth = 0;
 
    const QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke());
    if (lineBorder) {
        outlineSweepWidth = lineBorder->lineWidth();
    }
 
    if (stroke()) {
        KoInsets inset;
        stroke()->strokeInsets(this, inset);
        const qreal maxInset = std::max({inset.left, inset.top, inset.right, inset.bottom});
 
        // insets extend outside the shape, but width extends both inside and outside,
        // so we should multiply insets by 2.0
        outlineSweepWidth = std::max({outlineSweepWidth,
                                      2.0 * maxInset,
                                      2.0 * stroke()->strokeMaxMarkersInset(this)});
    }
 
 
 
 
#if 0
    QPen pen(Qt::black, outlineSweepWidth);
 
    // select round joins and caps to ensure it sweeps exactly
    // 'outlineSweepWidth' pixels in every possible
    pen.setJoinStyle(Qt::RoundJoin);
    pen.setCapStyle(Qt::RoundCap);
    QRectF bb = transform.map(pathStroke(pen)).boundingRect();
#endif
 
    // add 10% extra update area around the doubled insets
    return transform.mapRect(kisGrowRect(outline().boundingRect(), 1.1 * 0.5 * outlineSweepWidth));
}

References KoShape::absoluteTransformation(), KoInsets::bottom, boundingRect(), kisGrowRect(), KoInsets::left, outline(), pathStroke(), KoInsets::right, KoShape::stroke(), KoInsets::top, and KoShape::transform().

◆ breakAfter()

bool KoPathShape::breakAfter ( const KoPathPointIndex & pointIndex )

Breaks the path after the point index.

The new subpath will be behind the one that was broken. The segment between the given point and the one behind will be removed. If you want to split at one point insert first a copy of the point behind it. This does not work when the subpath is closed. Use openSubpath for this. It does not break at the last position of a subpath or if there is only one point in the subpath.

Parameters

pointIndex index of the point after which the path should be broken

Returns: true if the subpath was broken, otherwise false

Definition at line 743 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(pointIndex.first);
 
    if (!subpath || pointIndex.second < 0 || pointIndex.second > subpath->size() - 2
            || isClosedSubpath(pointIndex.first))
        return false;
 
    KoSubpath * newSubpath = new KoSubpath;
 
    int size = subpath->size();
    for (int i = pointIndex.second + 1; i < size; ++i) {
        newSubpath->append(subpath->takeAt(pointIndex.second + 1));
    }
    // now make the first point of the new subpath a starting node
    newSubpath->first()->setProperty(KoPathPoint::StartSubpath);
    // the last point of the old subpath is now an ending node
    subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
    // insert the new subpath after the broken one
    d->subpaths.insert(pointIndex.first + 1, newSubpath);
    notifyPointsChanged();
 
    return true;
}

References d, isClosedSubpath(), notifyPointsChanged(), size(), KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ clear()

void KoPathShape::clear ( )

Removes all subpaths and their points from the path.

Definition at line 94 of file KoPathShape.cpp.

{
    Q_FOREACH (KoSubpath *subpath, d->subpaths) {
        Q_FOREACH (KoPathPoint *point, *subpath)
            delete point;
        delete subpath;
    }
    d->subpaths.clear();
 
    notifyPointsChanged();
}

References d, and notifyPointsChanged().

◆ cloneShape()

KoShape * KoPathShape::cloneShape ( ) const

overridevirtual

creates a deep copy of the shape or shape's subtree

Returns: a cloned shape

Reimplemented from KoShape.

Reimplemented in RectangleShape, SpiralShape, and StarShape.

Definition at line 89 of file KoPathShape.cpp.

{
    return new KoPathShape(*this);
}

References KoPathShape().

◆ close()

void KoPathShape::close ( )

Closes the current subpath.

Definition at line 464 of file KoPathShape.cpp.

{
    if (d->subpaths.empty()) {
        return;
    }
    closeSubpathPriv(d->subpaths.last());
}

References closeSubpathPriv(), and d.

◆ closeMerge()

void KoPathShape::closeMerge ( )

Closes the current subpath.

It tries to merge the last and first point of the subpath to one point and then closes the subpath. If merging is not possible as the two point are to far from each other a close will be done. TODO define a maximum distance between the two points until this is working

Definition at line 472 of file KoPathShape.cpp.

{
    if (d->subpaths.empty()) {
        return;
    }
    closeMergeSubpathPriv(d->subpaths.last());
}

References closeMergeSubpathPriv(), and d.

◆ closeMergeSubpathPriv()

void KoPathShape::closeMergeSubpathPriv ( KoSubpath * subpath )

private

close-merges specified subpath

Definition at line 1013 of file KoPathShape.cpp.

{
    if (! subpath || subpath->size() < 2)
        return;
 
    KoPathPoint * lastPoint = subpath->last();
    KoPathPoint * firstPoint = subpath->first();
 
    // check if first and last points are coincident
    if (lastPoint->point() == firstPoint->point()) {
        // we are removing the current last point and
        // reuse its first control point if active
        firstPoint->setProperty(KoPathPoint::StartSubpath);
        firstPoint->setProperty(KoPathPoint::CloseSubpath);
        if (lastPoint->activeControlPoint1())
            firstPoint->setControlPoint1(lastPoint->controlPoint1());
        // remove last point
        delete subpath->takeLast();
        // the new last point closes the subpath now
        lastPoint = subpath->last();
        lastPoint->setProperty(KoPathPoint::StopSubpath);
        lastPoint->setProperty(KoPathPoint::CloseSubpath);
 
        notifyPointsChanged();
    } else {
        closeSubpathPriv(subpath);
    }
}

References KoPathPoint::activeControlPoint1, KoPathPoint::CloseSubpath, closeSubpathPriv(), KoPathPoint::controlPoint1, notifyPointsChanged(), KoPathPoint::point, KoPathPoint::setControlPoint1(), KoPathPoint::setProperty(), KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ closeSubpath()

KoPathPointIndex KoPathShape::closeSubpath ( const KoPathPointIndex & pointIndex )

Close a open subpath.

The subpath is closed be inserting a segment between the start and end point, making the given point the new start point of the subpath.

Returns: the new position of the old first point in the subpath otherwise KoPathPointIndex( -1, -1 )

Definition at line 844 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(pointIndex.first);
 
    if (!subpath || pointIndex.second < 0 || pointIndex.second >= subpath->size()
            || isClosedSubpath(pointIndex.first))
        return KoPathPointIndex(-1, -1);
 
    KoPathPoint * oldStartPoint = subpath->first();
    // the old starting node no longer starts the subpath
    oldStartPoint->unsetProperty(KoPathPoint::StartSubpath);
    // the old end node no longer ends the subpath
    subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
 
    // reorder the subpath
    for (int i = 0; i < pointIndex.second; ++i) {
        subpath->append(subpath->takeFirst());
    }
    subpath->first()->setProperty(KoPathPoint::StartSubpath);
    subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
    closeSubpathPriv(subpath);
 
    notifyPointsChanged();
 
    return pathPointIndex(oldStartPoint);
}

References closeSubpathPriv(), d, isClosedSubpath(), notifyPointsChanged(), pathPointIndex(), KoPathPoint::StartSubpath, KoPathPoint::StopSubpath, and KoPathPoint::unsetProperty().

◆ closeSubpathPriv()

void KoPathShape::closeSubpathPriv ( KoSubpath * subpath )

private

closes specified subpath

Definition at line 1002 of file KoPathShape.cpp.

{
    if (! subpath)
        return;
 
    subpath->last()->setProperty(KoPathPoint::CloseSubpath);
    subpath->first()->setProperty(KoPathPoint::CloseSubpath);
 
    notifyPointsChanged();
}

References KoPathPoint::CloseSubpath, and notifyPointsChanged().

◆ combine()

int KoPathShape::combine ( KoPathShape * path )

Combines two path shapes by appending the data of the specified path.

Parameters

path	the path to combine with

Returns: index of the first segment inserted or -1 on failure

Definition at line 940 of file KoPathShape.cpp.

{
    int insertSegmentPosition = -1;
    if (!path) return insertSegmentPosition;
 
    QTransform pathMatrix = path->absoluteTransformation();
    QTransform myMatrix = absoluteTransformation().inverted();
 
    Q_FOREACH (KoSubpath* subpath, path->d->subpaths) {
        KoSubpath *newSubpath = new KoSubpath();
 
        Q_FOREACH (KoPathPoint* point, *subpath) {
            KoPathPoint *newPoint = new KoPathPoint(*point, this);
            newPoint->map(pathMatrix);
            newPoint->map(myMatrix);
            newSubpath->append(newPoint);
        }
        d->subpaths.append(newSubpath);
 
        if (insertSegmentPosition < 0) {
            insertSegmentPosition = d->subpaths.size() - 1;
        }
    }
    normalize();
 
    notifyPointsChanged();
    return insertSegmentPosition;
}

References KoShape::absoluteTransformation(), d, KoPathPoint::map(), normalize(), and notifyPointsChanged().

◆ createShapeFromPainterPath()

KoPathShape * KoPathShape::createShapeFromPainterPath ( const QPainterPath & path )

static

Creates path shape from given QPainterPath.

Definition at line 1235 of file KoPathShape.cpp.

{
    KoPathShape * shape = new KoPathShape();
 
    int elementCount = path.elementCount();
    for (int i = 0; i < elementCount; i++) {
        QPainterPath::Element element = path.elementAt(i);
        switch (element.type) {
        case QPainterPath::MoveToElement:
            shape->moveTo(QPointF(element.x, element.y));
            break;
        case QPainterPath::LineToElement:
            shape->lineTo(QPointF(element.x, element.y));
            break;
        case QPainterPath::CurveToElement:
            shape->curveTo(QPointF(element.x, element.y),
                           QPointF(path.elementAt(i + 1).x, path.elementAt(i + 1).y),
                           QPointF(path.elementAt(i + 2).x, path.elementAt(i + 2).y));
            break;
        default:
            continue;
        }
    }
 
    shape->setShapeId(KoPathShapeId);
 
    //shape->normalize();
    return shape;
}

References curveTo(), KoPathShape(), KoPathShapeId, lineTo(), moveTo(), and KoShape::setShapeId().

◆ curveTo() [1/2]

KoPathPoint * KoPathShape::curveTo	(	const QPointF &	c,
		const QPointF &	p )

Adds a new quadratic Bezier curve segment.

Adds a quadratic Bezier curve between the last point and the given point p, using the control point specified by c.

Parameters

c	control point
p	the endpoint of this curve segment

Returns: The newly created point

Definition at line 370 of file KoPathShape.cpp.

{
    if (d->subpaths.empty())
        moveTo(QPointF(0, 0));
 
    KoPathPoint * lastPoint = d->subpaths.last()->last();
    updateLastPriv(&lastPoint);
    lastPoint->setControlPoint2(c);
    KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
    d->subpaths.last()->push_back(point);
    notifyPointsChanged();
    return point;
}

References d, moveTo(), notifyPointsChanged(), p, KoPathPoint::setControlPoint2(), KoPathPoint::StopSubpath, and updateLastPriv().

◆ curveTo() [2/2]

KoPathPoint * KoPathShape::curveTo	(	const QPointF &	c1,
		const QPointF &	c2,
		const QPointF &	p )

Adds a new cubic Bezier curve segment.

Adds a cubic Bezier curve between the last point and the given point p, using the control points specified by c1 and c2.

Parameters

c1	control point1
c2	control point2
p	the endpoint of this curve segment

Returns: The newly created point

Definition at line 355 of file KoPathShape.cpp.

{
    if (d->subpaths.empty()) {
        moveTo(QPointF(0, 0));
    }
    KoPathPoint * lastPoint = d->subpaths.last()->last();
    updateLastPriv(&lastPoint);
    lastPoint->setControlPoint2(c1);
    KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
    point->setControlPoint1(c2);
    d->subpaths.last()->push_back(point);
    notifyPointsChanged();
    return point;
}

References d, moveTo(), notifyPointsChanged(), p, KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), KoPathPoint::StopSubpath, and updateLastPriv().

◆ fillRule()

Qt::FillRule KoPathShape::fillRule ( ) const

Returns the fill rule for the path object.

Definition at line 1225 of file KoPathShape.cpp.

{
    return d->fillRule;
}

References d.

◆ hasMarkers()

bool KoPathShape::hasMarkers ( ) const

Definition at line 1305 of file KoPathShape.cpp.

{
    return !d->markersNew.isEmpty();
}

References d.

◆ hitTest()

bool KoPathShape::hitTest ( const QPointF & position ) const

overridevirtual

reimplemented

Reimplemented from KoShape.

Definition at line 1265 of file KoPathShape.cpp.

{
    if (parent() && parent()->isClipped(this) && ! parent()->hitTest(position))
        return false;
 
    QPointF point = absoluteTransformation().inverted().map(position);
    const QPainterPath outlinePath = outline();
    if (stroke()) {
        KoInsets insets;
        stroke()->strokeInsets(this, insets);
        QRectF roi(QPointF(-insets.left, -insets.top), QPointF(insets.right, insets.bottom));
 
        roi.moveCenter(point);
        if (outlinePath.intersects(roi) || outlinePath.contains(roi))
            return true;
    } else {
        if (outlinePath.contains(point))
            return true;
    }
 
    return false;
}

References KoShape::absoluteTransformation(), KoInsets::bottom, hitTest(), KoInsets::left, map(), outline(), KoShape::parent(), KoShape::position(), KoInsets::right, KoShape::stroke(), and KoInsets::top.

◆ insertPoint()

bool KoPathShape::insertPoint	(	KoPathPoint *	point,
		const KoPathPointIndex &	pointIndex )

Inserts a new point into the given subpath at the specified position.

This method keeps the subpath closed if it is closed, and open when it was open. So it can change the properties of the point inserted. You might need to update the point before/after to get the desired result e.g. when you insert the point into a curve.

Parameters

point	to insert
pointIndex	index at which the point should be inserted

Returns: true on success, false when pointIndex is out of bounds

Definition at line 661 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(pointIndex.first);
 
    if (subpath == 0 || pointIndex.second < 0 || pointIndex.second > subpath->size())
        return false;
 
    KoPathPoint::PointProperties properties = point->properties();
    properties &= ~KoPathPoint::StartSubpath;
    properties &= ~KoPathPoint::StopSubpath;
    properties &= ~KoPathPoint::CloseSubpath;
    // check if new point starts subpath
    if (pointIndex.second == 0) {
        properties |= KoPathPoint::StartSubpath;
        // subpath was closed
        if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
            // keep the path closed
            properties |= KoPathPoint::CloseSubpath;
        }
        // old first point does not start the subpath anymore
        subpath->first()->unsetProperty(KoPathPoint::StartSubpath);
    }
    // check if new point stops subpath
    else if (pointIndex.second == subpath->size()) {
        properties |= KoPathPoint::StopSubpath;
        // subpath was closed
        if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
            // keep the path closed
            properties = properties | KoPathPoint::CloseSubpath;
        }
        // old last point does not end subpath anymore
        subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
    }
 
    point->setProperties(properties);
    point->setParent(this);
    subpath->insert(pointIndex.second , point);
    notifyPointsChanged();
 
    return true;
}

References KoPathPoint::CloseSubpath, d, notifyPointsChanged(), KoPathPoint::properties, KoPathPoint::setParent(), KoPathPoint::setProperties(), KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ isClosedSubpath()

bool KoPathShape::isClosedSubpath ( int subpathIndex ) const

Checks if a subpath is closed.

Parameters

subpathIndex index of the subpath to check

Returns: true when the subpath is closed, false otherwise

Definition at line 648 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(subpathIndex);
 
    if (subpath == 0)
        return false;
 
    const bool firstClosed = subpath->first()->properties() & KoPathPoint::CloseSubpath;
    const bool lastClosed = subpath->last()->properties() & KoPathPoint::CloseSubpath;
 
    return firstClosed && lastClosed;
}

References KoPathPoint::CloseSubpath, and d.

◆ join()

bool KoPathShape::join ( int subpathIndex )

Joins the given subpath with the following one.

Joins the given subpath with the following one by inserting a segment between the two subpaths. This does nothing if the specified subpath is the last subpath or one of both subpaths is closed.

Parameters

subpathIndex index of the subpath being joined with the following subpath

Returns: true if the subpath was joined, otherwise false

Definition at line 769 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(subpathIndex);
    KoSubpath *nextSubpath = d->subPath(subpathIndex + 1);
 
    if (!subpath || !nextSubpath || isClosedSubpath(subpathIndex)
            || isClosedSubpath(subpathIndex+1))
        return false;
 
    // the last point of the subpath does not end the subpath anymore
    subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
    // the first point of the next subpath does not start a subpath anymore
    nextSubpath->first()->unsetProperty(KoPathPoint::StartSubpath);
 
    // append the second subpath to the first
    Q_FOREACH (KoPathPoint * p, *nextSubpath)
        subpath->append(p);
 
    // remove the nextSubpath from path
    d->subpaths.removeAt(subpathIndex + 1);
 
    // delete it as it is no longer possible to use it
    delete nextSubpath;
 
    notifyPointsChanged();
 
    return true;
}

References d, isClosedSubpath(), notifyPointsChanged(), p, KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ lineTo()

KoPathPoint * KoPathShape::lineTo ( const QPointF & p )

Adds a new line segment.

Adds a straight line between the last point and the given point p.

Returns: the newly created point

Definition at line 342 of file KoPathShape.cpp.

{
    if (d->subpaths.empty()) {
        moveTo(QPointF(0, 0));
    }
    KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StopSubpath);
    KoPathPoint * lastPoint = d->subpaths.last()->last();
    updateLastPriv(&lastPoint);
    d->subpaths.last()->push_back(point);
    notifyPointsChanged();
    return point;
}

References d, moveTo(), notifyPointsChanged(), p, KoPathPoint::StopSubpath, and updateLastPriv().

◆ loadNodeTypes()

void KoPathShape::loadNodeTypes ( const QString & nodeTypes )

Loads node types.

Definition at line 1199 of file KoPathShape.cpp.

{
    QString::const_iterator nIt(nodeTypes.constBegin());
    KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
    for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
        KoSubpath::const_iterator it((*pathIt)->constBegin());
        for (; it != (*pathIt)->constEnd(); ++it, nIt++) {
            // be sure not to crash if there are not enough nodes in nodeTypes
            if (nIt == nodeTypes.constEnd()) {
                warnFlake << "not enough nodes in sodipodi:nodetypes";
                return;
            }
            // the first node is always of type 'c'
            if (it != (*pathIt)->constBegin()) {
                updateNodeType(*it, *nIt);
            }
 
            if ((*it)->properties() & KoPathPoint::StopSubpath
                    && (*it)->properties() & KoPathPoint::CloseSubpath) {
                ++nIt;
                updateNodeType((*pathIt)->first(), *nIt);
            }
        }
    }
}

References KoPathPoint::CloseSubpath, d, nodeTypes(), KoPathPoint::StopSubpath, updateNodeType(), and warnFlake.

◆ map()

void KoPathShape::map ( const QTransform & matrix )

protected

Definition at line 1052 of file KoPathShape.cpp.

{
    return d->map(matrix);
}

References d.

◆ marker()

KoMarker * KoPathShape::marker ( KoFlake::MarkerPosition pos ) const

Definition at line 1300 of file KoPathShape.cpp.

{
    return d->markersNew[pos].data();
}

References d.

◆ moveSubpath()

bool KoPathShape::moveSubpath	(	int	oldSubpathIndex,
		int	newSubpathIndex )

Moves the position of a subpath within a path.

Parameters

oldSubpathIndex	old index of the subpath
newSubpathIndex	new index of the subpath

Returns: true if the subpath was moved, otherwise false e.g. if an index is out of bounds

Definition at line 798 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(oldSubpathIndex);
 
    if (subpath == 0 || newSubpathIndex >= d->subpaths.size())
        return false;
 
    if (oldSubpathIndex == newSubpathIndex)
        return true;
 
    d->subpaths.removeAt(oldSubpathIndex);
    d->subpaths.insert(newSubpathIndex, subpath);
 
    notifyPointsChanged();
 
    return true;
}

References d, and notifyPointsChanged().

◆ moveTo()

KoPathPoint * KoPathShape::moveTo ( const QPointF & p )

Starts a new Subpath.

Moves the pen to p and starts a new subpath.

Returns: the newly created point

Definition at line 332 of file KoPathShape.cpp.

{
    KoPathPoint * point = new KoPathPoint(this, p, KoPathPoint::StartSubpath | KoPathPoint::StopSubpath);
    KoSubpath * path = new KoSubpath;
    path->push_back(point);
    d->subpaths.push_back(path);
    notifyPointsChanged();
    return point;
}

References d, notifyPointsChanged(), p, KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ nodeTypes()

QString KoPathShape::nodeTypes ( ) const

Saves the node types.

This is inspired by inkscape and uses the same mechanism as they do. This attribute contains of a string which has the node type of each point in it. The following node types exist:

c corner s smooth z symmetric

The first point of a path is always of the type c. If the path is closed the type of the first point is saved in the last element E.g. you have a closed path with 2 points in it. The first one (start/end of path) is symmetric and the second one is smooth that will result in the nodeType="czs" So if there is a closed sub path the nodeTypes contain one more entry then there are points. That is due to the first and the last point of a closed sub path get merged into one when they are on the same position.

Returns: The node types as string

Definition at line 1165 of file KoPathShape.cpp.

{
    QString types;
    KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
    for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
        KoSubpath::const_iterator it((*pathIt)->constBegin());
        for (; it != (*pathIt)->constEnd(); ++it) {
            if (it == (*pathIt)->constBegin()) {
                types.append('c');
            }
            else {
                types.append(nodeType(*it));
            }
 
            if ((*it)->properties() & KoPathPoint::StopSubpath
                    && (*it)->properties() & KoPathPoint::CloseSubpath) {
                KoPathPoint * firstPoint = (*pathIt)->first();
                types.append(nodeType(firstPoint));
            }
        }
    }
    return types;
}

References KoPathPoint::CloseSubpath, d, nodeType(), and KoPathPoint::StopSubpath.

◆ normalize()

QPointF KoPathShape::normalize ( )

virtual

Normalizes the path data.

The path points are transformed so that the top-left corner of the bounding rect is at (0,0). This should be called after adding points to the path or changing positions of path points.

Returns: the offset by which the points are moved in shape coordinates.

Reimplemented in KoParameterShape, EllipseShape, SpiralShape, and KarbonCalligraphicShape.

Definition at line 480 of file KoPathShape.cpp.

{
    QPointF tl(outline().boundingRect().topLeft());
    QTransform matrix;
    matrix.translate(-tl.x(), -tl.y());
    d->map(matrix);
 
    // keep the top left point of the object
    applyTransformation(matrix.inverted());
    shapeChangedPriv(ContentChanged);
    return tl;
}

References KoShape::applyTransformation(), boundingRect(), KoShape::ContentChanged, d, outline(), and KoShape::shapeChangedPriv().

◆ notifyPointsChanged()

void KoPathShape::notifyPointsChanged ( )

protected

Definition at line 1362 of file KoPathShape.cpp.

{
    Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
        PointSelectionChangeListener *pointListener = dynamic_cast<PointSelectionChangeListener*>(listener);
        if (pointListener) {
            pointListener->notifyPathPointsChanged(this);
        }
    }
}

References KoShape::listeners(), and KoPathShape::PointSelectionChangeListener::notifyPathPointsChanged().

◆ openSubpath()

KoPathPointIndex KoPathShape::openSubpath ( const KoPathPointIndex & pointIndex )

Opens a closed subpath.

The subpath is opened by removing the segment before the given point, making the given point the new start point of the subpath.

Parameters

pointIndex the index of the point at which to open the closed subpath

Returns: the new position of the old first point in the subpath otherwise KoPathPointIndex( -1, -1 )

Definition at line 816 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(pointIndex.first);
 
    if (!subpath || pointIndex.second < 0 || pointIndex.second >= subpath->size()
            || !isClosedSubpath(pointIndex.first))
        return KoPathPointIndex(-1, -1);
 
    KoPathPoint * oldStartPoint = subpath->first();
    // the old starting node no longer starts the subpath
    oldStartPoint->unsetProperty(KoPathPoint::StartSubpath);
    // the old end node no longer closes the subpath
    subpath->last()->unsetProperty(KoPathPoint::StopSubpath);
 
    // reorder the subpath
    for (int i = 0; i < pointIndex.second; ++i) {
        subpath->append(subpath->takeFirst());
    }
    // make the first point a start node
    subpath->first()->setProperty(KoPathPoint::StartSubpath);
    // make the last point an end node
    subpath->last()->setProperty(KoPathPoint::StopSubpath);
 
    notifyPointsChanged();
 
    return pathPointIndex(oldStartPoint);
}

References d, isClosedSubpath(), notifyPointsChanged(), pathPointIndex(), KoPathPoint::StartSubpath, KoPathPoint::StopSubpath, and KoPathPoint::unsetProperty().

◆ outline()

QPainterPath KoPathShape::outline ( ) const

overridevirtual

reimplemented

Reimplemented from KoShape.

Definition at line 184 of file KoPathShape.cpp.

{
    QPainterPath path;
    for (auto subpathIt = d->subpaths.constBegin(); subpathIt != d->subpaths.constEnd(); ++subpathIt) {
        const KoSubpath * subpath = *subpathIt;
        const KoPathPoint * lastPoint = subpath->constFirst();
        bool activeCP = false;
        for (auto pointIt = subpath->constBegin(); pointIt != subpath->constEnd(); ++pointIt) {
            const KoPathPoint * currPoint = *pointIt;
            KoPathPoint::PointProperties currProperties = currPoint->properties();
            if (currPoint == subpath->constFirst()) {
                if (currProperties & KoPathPoint::StartSubpath) {
                    Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                    path.moveTo(currPoint->point());
                }
            } else if (activeCP && currPoint->activeControlPoint1()) {
                Q_ASSERT(!qIsNaNPoint(lastPoint->controlPoint2()));
                Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                path.cubicTo(
                            lastPoint->controlPoint2(),
                            currPoint->controlPoint1(),
                            currPoint->point());
            } else if (activeCP || currPoint->activeControlPoint1()) {
                Q_ASSERT(!qIsNaNPoint(lastPoint->controlPoint2()));
                Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                path.quadTo(
                            activeCP ? lastPoint->controlPoint2() : currPoint->controlPoint1(),
                            currPoint->point());
            } else {
                Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                path.lineTo(currPoint->point());
            }
            if (currProperties & KoPathPoint::CloseSubpath && currProperties & KoPathPoint::StopSubpath) {
                // add curve when there is a curve on the way to the first point
                KoPathPoint * firstPoint = subpath->first();
                Q_ASSERT(!qIsNaNPoint(firstPoint->point()));
                if (currPoint->activeControlPoint2() && firstPoint->activeControlPoint1()) {
                    path.cubicTo(
                                currPoint->controlPoint2(),
                                firstPoint->controlPoint1(),
                                firstPoint->point());
                }
                else if (currPoint->activeControlPoint2() || firstPoint->activeControlPoint1()) {
                    Q_ASSERT(!qIsNaNPoint(currPoint->point()));
                    Q_ASSERT(!qIsNaNPoint(currPoint->controlPoint1()));
                    path.quadTo(
                                currPoint->activeControlPoint2() ? currPoint->controlPoint2() : firstPoint->controlPoint1(),
                                firstPoint->point());
                }
                path.closeSubpath();
            }
 
            if (currPoint->activeControlPoint2()) {
                activeCP = true;
            } else {
                activeCP = false;
            }
            lastPoint = currPoint;
        }
    }
 
    return path;
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::CloseSubpath, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, d, KoPathPoint::point, KoPathPoint::properties, qIsNaNPoint(), KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ outlineRect()

QRectF KoPathShape::outlineRect ( ) const

overridevirtual

reimplemented

Reimplemented from KoShape.

Definition at line 179 of file KoPathShape.cpp.

{
    return outline().boundingRect();
}

References outline().

◆ paint()

void KoPathShape::paint ( QPainter & painter ) const

overridevirtual

reimplemented

Implements KoShape.

Definition at line 106 of file KoPathShape.cpp.

{
    KisQPainterStateSaver saver(&painter);
    Q_UNUSED(saver);
 
    QPainterPath path(outline());
    path.setFillRule(d->fillRule);
 
    if (background()) {
        background()->paint(painter, path);
    }
    //d->paintDebug(painter);
}

References KoShape::background(), d, and outline().

◆ paintPoints()

void KoPathShape::paintPoints ( KisHandlePainterHelper & handlesHelper )

virtual

Definition at line 168 of file KoPathShape.cpp.

{
    KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
 
    for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
        KoSubpath::const_iterator it((*pathIt)->constBegin());
        for (; it != (*pathIt)->constEnd(); ++it)
            (*it)->paint(handlesHelper, KoPathPoint::Node);
    }
}

References d, and KoPathPoint::Node.

◆ pathPointIndex()

KoPathPointIndex KoPathShape::pathPointIndex ( const KoPathPoint * point ) const

Returns the path point index of a given path point.

Parameters

point the point for which you want to get the index

Returns: path point index of the point if it exists otherwise KoPathPointIndex( -1, -1 )

Definition at line 577 of file KoPathShape.cpp.

{
    for (int subpathIndex = 0; subpathIndex < d->subpaths.size(); ++subpathIndex) {
        KoSubpath * subpath = d->subpaths.at(subpathIndex);
        for (int pointPos = 0; pointPos < subpath->size(); ++pointPos) {
            if (subpath->at(pointPos) == point) {
                return KoPathPointIndex(subpathIndex, pointPos);
            }
        }
    }
    return KoPathPointIndex(-1, -1);
}

References d.

◆ pathShapeId()

QString KoPathShape::pathShapeId ( ) const

virtual

Returns the specific path shape id.

Path shape derived shapes have a different shape id which link them to their respective shape factories. In most cases they do not have a special tool for editing them. This function returns the specific shape id for finding the shape factory from KoShapeRegistry. The default KoPathShapeId is returned from KoShape::shapeId() so that the generic path editing tool gets activated when the shape is selected.

Returns: the specific shape id

Reimplemented in EllipseShape, RectangleShape, SpiralShape, StarShape, and KarbonCalligraphicShape.

Definition at line 1065 of file KoPathShape.cpp.

{
    return KoPathShapeId;
}

References KoPathShapeId.

◆ pathStroke()

QPainterPath KoPathShape::pathStroke ( const QPen & pen ) const

Definition at line 1372 of file KoPathShape.cpp.

{
    if (d->subpaths.isEmpty()) {
        return QPainterPath();
    }
    QPainterPath pathOutline;
 
    QPainterPathStroker stroker;
    stroker.setWidth(0);
    stroker.setJoinStyle(Qt::MiterJoin);
    stroker.setWidth(pen.widthF());
    stroker.setJoinStyle(pen.joinStyle());
    stroker.setMiterLimit(pen.miterLimit());
    stroker.setCapStyle(pen.capStyle());
    stroker.setDashOffset(pen.dashOffset());
    stroker.setDashPattern(pen.dashPattern());
 
    QPainterPath path = stroker.createStroke(outline());
 
    pathOutline.addPath(path);
    pathOutline.setFillRule(Qt::WindingFill);
 
    return pathOutline;
}

References d, and outline().

◆ pointByIndex()

KoPathPoint * KoPathShape::pointByIndex ( const KoPathPointIndex & pointIndex ) const

Returns the path point specified by a path point index.

Parameters

pointIndex index of the point to get

Returns: KoPathPoint on success, 0 otherwise e.g. out of bounds

Definition at line 590 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(pointIndex.first);
 
    if (subpath == 0 || pointIndex.second < 0 || pointIndex.second >= subpath->size())
        return 0;
 
    return subpath->at(pointIndex.second);
}

References d.

◆ pointCount()

int KoPathShape::pointCount ( ) const

Returns the number of points in the path.

Returns: The number of points in the path

Definition at line 622 of file KoPathShape.cpp.

{
    int i = 0;
    KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
    for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
        i += (*pathIt)->size();
    }
 
    return i;
}

References d.

◆ pointsAt()

QList< KoPathPoint * > KoPathShape::pointsAt	(	const QRectF &	rect,
		const bool	useControlPoints = false ) const

Returns the path points within the given rectangle.

Parameters

rect	the rectangle the requested points are in
useControlPoints	whether to add control points to result or not

Returns: list of points within the rectangle

Definition at line 531 of file KoPathShape.cpp.

{
    QList<KoPathPoint*> result;
 
    KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
    for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
        KoSubpath::const_iterator it((*pathIt)->constBegin());
        for (; it != (*pathIt)->constEnd(); ++it) {
            if (r.contains((*it)->point()))
                result.append(*it);
            else if (useControlPoints) {
                if ((*it)->activeControlPoint1() && r.contains((*it)->controlPoint1()))
                    result.append(*it);
                else if ((*it)->activeControlPoint2() && r.contains((*it)->controlPoint2()))
                    result.append(*it);
            }
        }
    }
    return result;
}

References d.

◆ recommendPointSelectionChange()

void KoPathShape::recommendPointSelectionChange ( const QList< KoPathPointIndex > & newSelection )

Definition at line 1352 of file KoPathShape.cpp.

{
    Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
        PointSelectionChangeListener *pointListener = dynamic_cast<PointSelectionChangeListener*>(listener);
        if (pointListener) {
            pointListener->recommendPointSelectionChange(this, newSelection);
        }
    }
}

References KoShape::listeners(), and KoPathShape::PointSelectionChangeListener::recommendPointSelectionChange().

◆ removePoint()

KoPathPoint * KoPathShape::removePoint ( const KoPathPointIndex & pointIndex )

Removes a point from the path.

Note that the ownership of the point will pass to the caller.

Parameters

pointIndex index of the point which should be removed

Returns: The removed point on success, otherwise 0

Definition at line 703 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(pointIndex.first);
 
    if (subpath == 0 || pointIndex.second < 0 || pointIndex.second >= subpath->size())
        return 0;
 
    KoPathPoint * point = subpath->takeAt(pointIndex.second);
    point->setParent(0);
 
    //don't do anything (not even crash), if there was only one point
    if (pointCount()==0) {
        return point;
    }
    // check if we removed the first point
    else if (pointIndex.second == 0) {
        // first point removed, set new StartSubpath
        subpath->first()->setProperty(KoPathPoint::StartSubpath);
        // check if path was closed
        if (subpath->last()->properties() & KoPathPoint::CloseSubpath) {
            // keep path closed
            subpath->first()->setProperty(KoPathPoint::CloseSubpath);
        }
    }
    // check if we removed the last point
    else if (pointIndex.second == subpath->size()) { // use size as point is already removed
        // last point removed, set new StopSubpath
        subpath->last()->setProperty(KoPathPoint::StopSubpath);
        // check if path was closed
        if (point->properties() & KoPathPoint::CloseSubpath) {
            // keep path closed
            subpath->last()->setProperty(KoPathPoint::CloseSubpath);
        }
    }
 
    notifyPointsChanged();
 
    return point;
}

References KoPathPoint::CloseSubpath, d, notifyPointsChanged(), pointCount(), KoPathPoint::properties, KoPathPoint::setParent(), KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ removeSubpath()

KoSubpath * KoPathShape::removeSubpath ( int subpathIndex )

Removes subpath from the path.

Parameters

subpathIndex the index of the subpath to remove

Returns: the removed subpath on success, 0 otherwise.

Definition at line 909 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(subpathIndex);
 
    if (subpath != 0) {
        Q_FOREACH (KoPathPoint* point, *subpath) {
            point->setParent(this);
        }
        d->subpaths.removeAt(subpathIndex);
    }
 
    notifyPointsChanged();
 
    return subpath;
}

References d, notifyPointsChanged(), and KoPathPoint::setParent().

◆ resizeMatrix()

QTransform KoPathShape::resizeMatrix ( const QSizeF & newSize ) const

protected

Get the resize matrix

This makes sure that also if the newSize isNull that there will be a very small size of 0.000001 pixels

Definition at line 311 of file KoPathShape.cpp.

{
    QSizeF oldSize = size();
    if (oldSize.width() == 0.0) {
        oldSize.setWidth(0.000001);
    }
    if (oldSize.height() == 0.0) {
        oldSize.setHeight(0.000001);
    }
 
    QSizeF sizeNew(newSize);
    if (sizeNew.width() == 0.0) {
        sizeNew.setWidth(0.000001);
    }
    if (sizeNew.height() == 0.0) {
        sizeNew.setHeight(0.000001);
    }
 
    return QTransform(sizeNew.width() / oldSize.width(), 0, 0, sizeNew.height() / oldSize.height(), 0, 0);
}

References size().

◆ reverseSubpath()

bool KoPathShape::reverseSubpath ( int subpathIndex )

Reverse subpath.

The last point becomes the first point and the first one becomes the last one.

Parameters

subpathIndex the index of the subpath to reverse

Definition at line 872 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(subpathIndex);
 
    if (subpath == 0)
        return false;
 
    int size = subpath->size();
    for (int i = 0; i < size; ++i) {
        KoPathPoint *p = subpath->takeAt(i);
        p->reverse();
        subpath->prepend(p);
    }
 
    // adjust the position dependent properties
    KoPathPoint *first = subpath->first();
    KoPathPoint *last = subpath->last();
 
    KoPathPoint::PointProperties firstProps = first->properties();
    KoPathPoint::PointProperties lastProps = last->properties();
 
    firstProps |= KoPathPoint::StartSubpath;
    firstProps &= ~KoPathPoint::StopSubpath;
    lastProps |= KoPathPoint::StopSubpath;
    lastProps &= ~KoPathPoint::StartSubpath;
    if (firstProps & KoPathPoint::CloseSubpath) {
        firstProps |= KoPathPoint::CloseSubpath;
        lastProps |= KoPathPoint::CloseSubpath;
    }
    first->setProperties(firstProps);
    last->setProperties(lastProps);
 
    notifyPointsChanged();
 
    return true;
}

References KoPathPoint::CloseSubpath, d, notifyPointsChanged(), p, KoPathPoint::properties, KoPathPoint::setProperties(), size(), KoPathPoint::StartSubpath, and KoPathPoint::StopSubpath.

◆ segmentAtPoint()

KoPathSegment KoPathShape::segmentAtPoint	(	const QPointF &	point,
		const QRectF &	grabRoi ) const

Definition at line 1320 of file KoPathShape.cpp.

{
    const qreal distanceThreshold = 0.5 * KisAlgebra2D::maxDimension(grabRoi);
    KoPathSegment segment;
 
    // convert document point to shape coordinates
    const QPointF p = documentToShape(point);
    // our region of interest, i.e. a region around our mouse position
    const QRectF roi = documentToShape(grabRoi);
 
    qreal minDistance = std::numeric_limits<qreal>::max();
 
    // check all segments of this shape which intersect the region of interest
    const QList<KoPathSegment> segments = segmentsAt(roi);
 
    foreach (KoPathSegment s, segments) {
        const qreal nearestPointParam = s.nearestPoint(p);
        const QPointF nearestPoint = s.pointAt(nearestPointParam);
        const qreal distance = kisDistance(p, nearestPoint);
 
        // are we within the allowed distance ?
        if (distance > distanceThreshold)
            continue;
        // are we closer to the last closest point ?
        if (distance < minDistance) {
            segment = s;
        }
    }
 
    return segment;
}

References distance(), KoShape::documentToShape(), kisDistance(), KisAlgebra2D::maxDimension(), p, KoShape::s, and segmentsAt().

◆ segmentByIndex()

KoPathSegment KoPathShape::segmentByIndex ( const KoPathPointIndex & pointIndex ) const

Returns the segment specified by a path point index.

A segment is defined by the point index of the first point in the segment. A segment contains the defined point and its following point. If the subpath is closed and the and the pointIndex point to the last point in the subpath, the following point is the first point in the subpath.

Parameters

pointIndex index of the first point of the segment

Returns: Segment containing both points of the segment or KoPathSegment( 0, 0 ) on error e.g. out of bounds

Definition at line 600 of file KoPathShape.cpp.

{
    KoPathSegment segment(0, 0);
 
    KoSubpath *subpath = d->subPath(pointIndex.first);
 
    if (subpath != 0 && pointIndex.second >= 0 && pointIndex.second < subpath->size()) {
        KoPathPoint * point = subpath->at(pointIndex.second);
        int index = pointIndex.second;
        // check if we have a (closing) segment starting from the last point
        if ((index == subpath->size() - 1) && point->properties() & KoPathPoint::CloseSubpath)
            index = 0;
        else
            ++index;
 
        if (index < subpath->size()) {
            segment = KoPathSegment(point, subpath->at(index));
        }
    }
    return segment;
}

References KoPathPoint::CloseSubpath, d, KoPathPoint::properties, and size().

◆ segmentsAt()

QList< KoPathSegment > KoPathShape::segmentsAt ( const QRectF & rect ) const

Returns the list of path segments within the given rectangle.

Parameters

rect	the rectangle the requested segments are in

Returns: list of segments within the rectangle

Definition at line 552 of file KoPathShape.cpp.

{
    QList<KoPathSegment> segments;
    int subpathCount = d->subpaths.count();
    for (int subpathIndex = 0; subpathIndex < subpathCount; ++subpathIndex) {
        KoSubpath * subpath = d->subpaths[subpathIndex];
        int pointCount = subpath->count();
        bool subpathClosed = isClosedSubpath(subpathIndex);
        for (int pointIndex = 0; pointIndex < pointCount; ++pointIndex) {
            if (pointIndex == (pointCount - 1) && ! subpathClosed)
                break;
            KoPathSegment s(subpath->at(pointIndex), subpath->at((pointIndex + 1) % pointCount));
            QRectF controlRect = s.controlPointRect();
            if (! r.intersects(controlRect) && ! controlRect.contains(r))
                continue;
            QRectF bound = s.boundingRect();
            if (! r.intersects(bound) && ! bound.contains(r))
                continue;
 
            segments.append(s);
        }
    }
    return segments;
}

References d, isClosedSubpath(), pointCount(), KoShape::s, and subpathCount().

◆ separate()

bool KoPathShape::separate ( QList< KoPathShape * > & separatedPaths )

Creates separate path shapes, one for each existing subpath.

Parameters

separatedPaths the list which contains the separated path shapes

Returns: true if separating the path was successful, false otherwise

Definition at line 969 of file KoPathShape.cpp.

{
    if (! d->subpaths.size())
        return false;
 
    QTransform myMatrix = absoluteTransformation();
 
    Q_FOREACH (KoSubpath* subpath, d->subpaths) {
        KoPathShape *shape = new KoPathShape();
 
        shape->setStroke(stroke());
        shape->setBackground(background());
        shape->setShapeId(shapeId());
        shape->setZIndex(zIndex());
 
        KoSubpath *newSubpath = new KoSubpath();
 
        Q_FOREACH (KoPathPoint* point, *subpath) {
            KoPathPoint *newPoint = new KoPathPoint(*point, shape);
            newPoint->map(myMatrix);
            newSubpath->append(newPoint);
        }
        shape->d->subpaths.append(newSubpath);
        shape->normalize();
 
        // NOTE: shape cannot have any listeners yet, so no notification about
        //       points modification is needed
 
        separatedPaths.append(shape);
    }
    return true;
}

References KoShape::absoluteTransformation(), KoShape::background(), d, KoPathShape(), KoPathPoint::map(), normalize(), KoShape::setBackground(), KoShape::setShapeId(), KoShape::setStroke(), KoShape::setZIndex(), KoShape::shapeId(), KoShape::stroke(), and KoShape::zIndex().

◆ setAutoFillMarkers()

void KoPathShape::setAutoFillMarkers ( bool value )

Definition at line 1315 of file KoPathShape.cpp.

{
    d->autoFillMarkers = value;
}

References d, and value().

◆ setFillRule()

void KoPathShape::setFillRule ( Qt::FillRule fillRule )

Sets the fill rule to be used for painting the background.

Definition at line 1230 of file KoPathShape.cpp.

{
    d->fillRule = fillRule;
}

References d, and fillRule().

◆ setMarker()

void KoPathShape::setMarker	(	KoMarker *	marker,
		KoFlake::MarkerPosition	pos )

Definition at line 1288 of file KoPathShape.cpp.

{
    if (!marker && d->markersNew.contains(pos)) {
        d->markersNew.remove(pos);
    } else {
        d->markersNew[pos] = marker;
    }
 
    notifyChanged();
    shapeChangedPriv(StrokeChanged);
}

References d, marker(), KoShape::notifyChanged(), KoShape::shapeChangedPriv(), and KoShape::StrokeChanged.

◆ setSize()

void KoPathShape::setSize ( const QSizeF & size )

overridevirtual

Resize the shape

This makes sure that the pathshape will not be resized to 0 if the new size is null as that makes it impossible to undo the change.

All functions that overwrite this function should also use the resizeMatrix function to get and use the same data in resizing.

See also: resizeMatrix()

Reimplemented from KoShape.

Reimplemented in SpiralShape, and StarShape.

Definition at line 303 of file KoPathShape.cpp.

{
    QTransform matrix(resizeMatrix(newSize));
 
    KoShape::setSize(newSize);
    d->map(matrix);
}

References d, resizeMatrix(), and KoShape::setSize().

◆ size()

QSizeF KoPathShape::size ( ) const

overridevirtual

reimplemented

Reimplemented from KoShape.

Definition at line 296 of file KoPathShape.cpp.

{
    // don't call boundingRect here as it uses absoluteTransformation
    // which itself uses size() -> leads to infinite recursion
    return outlineRect().size();
}

References outlineRect().

◆ subpathCount()

int KoPathShape::subpathCount ( ) const

Returns the number of subpaths in the path.

Returns: The number of subpaths in the path

Definition at line 633 of file KoPathShape.cpp.

{
    return d->subpaths.count();
}

References d.

◆ subpathPointCount()

int KoPathShape::subpathPointCount ( int subpathIndex ) const

Returns the number of points in a subpath.

Returns: The number of points in the subpath or -1 if subpath out of bounds

Definition at line 638 of file KoPathShape.cpp.

{
    KoSubpath *subpath = d->subPath(subpathIndex);
 
    if (subpath == 0)
        return -1;
 
    return subpath->size();
}

References d.

◆ subpaths() [1/2]

KoSubpathList & KoPathShape::subpaths ( )

protected

XXX: refactor this using setter?

Definition at line 1047 of file KoPathShape.cpp.

{
    return d->subpaths;
}

References d.

◆ subpaths() [2/2]

const KoSubpathList & KoPathShape::subpaths ( ) const

protected

Definition at line 1042 of file KoPathShape.cpp.

{
    return d->subpaths;
}

References d.

◆ toString()

QString KoPathShape::toString ( const QTransform & matrix = QTransform() ) const

Returns a odf/svg string representation of the path data with the given matrix applied.

Definition at line 1070 of file KoPathShape.cpp.

{
    QString pathString;
 
    // iterate over all subpaths
    KoSubpathList::const_iterator pathIt(d->subpaths.constBegin());
    for (; pathIt != d->subpaths.constEnd(); ++pathIt) {
        KoSubpath::const_iterator pointIt((*pathIt)->constBegin());
        // keep a pointer to the first point of the subpath
        KoPathPoint *firstPoint(*pointIt);
        // keep a pointer to the previous point of the subpath
        KoPathPoint *lastPoint = firstPoint;
        // keep track if the previous point has an active control point 2
        bool activeControlPoint2 = false;
 
        // iterate over all points of the current subpath
        for (; pointIt != (*pathIt)->constEnd(); ++pointIt) {
            KoPathPoint *currPoint(*pointIt);
            if (!currPoint) {
                qWarning() << "Found a zero point in the shape's path!";
                continue;
            }
            // first point of subpath ?
            if (currPoint == firstPoint) {
                // are we starting a subpath ?
                if (currPoint->properties() & KoPathPoint::StartSubpath) {
                    const QPointF p = matrix.map(currPoint->point());
                    pathString += QString("M%1 %2").arg(p.x()).arg(p.y());
                }
            }
            // end point of curve segment ?
            else if (activeControlPoint2 || currPoint->activeControlPoint1()) {
                // check if we have a cubic or quadratic curve
                const bool isCubic = activeControlPoint2 && currPoint->activeControlPoint1();
                KoPathSegment cubicSeg = isCubic ? KoPathSegment(lastPoint, currPoint)
                                                 : KoPathSegment(lastPoint, currPoint).toCubic();
                if (cubicSeg.first()  && cubicSeg.second()) {
                    const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
                    const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
                    const QPointF p = matrix.map(cubicSeg.second()->point());
                    pathString += QString("C%1 %2 %3 %4 %5 %6")
                            .arg(cp1.x()).arg(cp1.y())
                            .arg(cp2.x()).arg(cp2.y())
                            .arg(p.x()).arg(p.y());
                }
            }
            // end point of line segment!
            else {
                const QPointF p = matrix.map(currPoint->point());
                pathString += QString("L%1 %2").arg(p.x()).arg(p.y());
            }
            // last point closes subpath ?
            if (currPoint->properties() & KoPathPoint::StopSubpath
                    && currPoint->properties() & KoPathPoint::CloseSubpath) {
                // add curve when there is a curve on the way to the first point
                if (currPoint->activeControlPoint2() || firstPoint->activeControlPoint1()) {
                    // check if we have a cubic or quadratic curve
                    const bool isCubic = currPoint->activeControlPoint2() && firstPoint->activeControlPoint1();
                    KoPathSegment cubicSeg = isCubic ? KoPathSegment(currPoint, firstPoint)
                                                     : KoPathSegment(currPoint, firstPoint).toCubic();
                    if (cubicSeg.first()  && cubicSeg.second()) {
                        const QPointF cp1 = matrix.map(cubicSeg.first()->controlPoint2());
                        const QPointF cp2 = matrix.map(cubicSeg.second()->controlPoint1());
 
                        const QPointF p = matrix.map(cubicSeg.second()->point());
                        pathString += QString("C%1 %2 %3 %4 %5 %6")
                                .arg(cp1.x()).arg(cp1.y())
                                .arg(cp2.x()).arg(cp2.y())
                                .arg(p.x()).arg(p.y());
                    }
                }
                pathString += QString("Z");
            }
 
            activeControlPoint2 = currPoint->activeControlPoint2();
            lastPoint = currPoint;
        }
    }
 
    return pathString;
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::CloseSubpath, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, d, KoPathSegment::first, p, KoPathPoint::point, KoPathPoint::properties, KoPathSegment::second, KoPathPoint::StartSubpath, KoPathPoint::StopSubpath, and KoPathSegment::toCubic().

◆ updateLastPriv()

void KoPathShape::updateLastPriv ( KoPathPoint ** lastPoint )

private

Definition at line 507 of file KoPathShape.cpp.

{
    // check if we are about to add a new point to a closed subpath
    if ((*lastPoint)->properties() & KoPathPoint::StopSubpath
            && (*lastPoint)->properties() & KoPathPoint::CloseSubpath) {
        // get the first point of the subpath
        KoPathPoint *subpathStart = d->subpaths.last()->first();
        // clone the first point of the subpath...
        KoPathPoint * newLastPoint = new KoPathPoint(*subpathStart, this);
        // ... and make it a normal point
        newLastPoint->setProperties(KoPathPoint::Normal);
        // now start a new subpath with the cloned start point
        KoSubpath *path = new KoSubpath;
        path->push_back(newLastPoint);
        d->subpaths.push_back(path);
        *lastPoint = newLastPoint;
    } else {
        // the subpath was not closed so the formerly last point
        // of the subpath is no end point anymore
        (*lastPoint)->unsetProperty(KoPathPoint::StopSubpath);
    }
    (*lastPoint)->unsetProperty(KoPathPoint::CloseSubpath);
}

References KoPathPoint::CloseSubpath, d, KoPathPoint::Normal, KoPathPoint::setProperties(), KoPathPoint::StopSubpath, and KoPathPoint::unsetProperty().

Member Data Documentation

◆ d

QScopedPointer<Private> KoPathShape::d

private

Definition at line 526 of file KoPathShape.h.

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

libs/flake/KoPathShape.h
libs/flake/KoPathShape.cpp

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KoPathShape() [1/2]

◆ ~KoPathShape()

◆ KoPathShape() [2/2]

Member Function Documentation

◆ addSubpath()

◆ arcTo()

◆ arcToCurve()

◆ autoFillMarkers()

◆ boundingRect()

◆ breakAfter()

◆ clear()

◆ cloneShape()

◆ close()

◆ closeMerge()

◆ closeMergeSubpathPriv()

◆ closeSubpath()

◆ closeSubpathPriv()

◆ combine()

◆ createShapeFromPainterPath()

◆ curveTo() [1/2]

◆ curveTo() [2/2]

◆ fillRule()

◆ hasMarkers()

◆ hitTest()

◆ insertPoint()

◆ isClosedSubpath()

◆ join()

◆ lineTo()

◆ loadNodeTypes()

◆ map()

◆ marker()

◆ moveSubpath()

◆ moveTo()

◆ nodeTypes()

◆ normalize()

◆ notifyPointsChanged()

◆ openSubpath()

◆ outline()

◆ outlineRect()

◆ paint()

◆ paintPoints()

◆ pathPointIndex()

◆ pathShapeId()

◆ pathStroke()

◆ pointByIndex()

◆ pointCount()

◆ pointsAt()

◆ recommendPointSelectionChange()

◆ removePoint()

◆ removeSubpath()

◆ resizeMatrix()

◆ reverseSubpath()

◆ segmentAtPoint()

◆ segmentByIndex()

◆ segmentsAt()

◆ separate()

◆ setAutoFillMarkers()

◆ setFillRule()

◆ setMarker()

◆ setSize()

◆ size()

◆ subpathCount()

◆ subpathPointCount()

◆ subpaths() [1/2]

◆ subpaths() [2/2]

◆ toString()

◆ updateLastPriv()

Member Data Documentation

◆ d