#include <KoCreatePathTool_p.h>

Inheritance diagram for KoCreatePathToolPrivate:

Public Member Functions
void	addPathShape ()

void	angleDeltaChanged (qreal value)

void	angleSnapChanged (int angleSnap)

void	autoSmoothCurvesChanged (bool value)

void	cleanUp ()

bool	connectPaths (KoPathShape *pathShape, const PathConnectionPoint &pointAtStart, const PathConnectionPoint &pointAtEnd) const
	Connects given path with the ones we hit when starting/finishing.

KoPathPoint *	endPointAtPosition (const QPointF &position) const
	returns the nearest existing path point

	KoCreatePathToolPrivate (KoCreatePathTool const qq, KoCanvasBase canvas)

void	loadAutoSmoothValueFromConfig ()

void	repaintActivePoint () const

Public Member Functions inherited from KoToolBasePrivate
void	connectSignals ()

	KoToolBasePrivate (KoToolBase qq, KoCanvasBase canvas_)

virtual	~KoToolBasePrivate ()

Public Attributes
KoPathPoint *	activePoint

int	angleSnappingDelta

bool	angleSnapStatus

AngleSnapStrategy *	angleSnapStrategy

bool	autoSmoothCurves = false

int	decorationThickness

QPointF	dragStartPoint

bool	enableClosePathShortcut

PathConnectionPoint	existingEndPoint
	an existing path point we finished a new path at

PathConnectionPoint	existingStartPoint
	an existing path point we started a new path at

bool	finishAfterThisPoint

KoPathPoint *	firstPoint

int	handleRadius

KoPathPoint *	hoveredPoint
	an existing path end point the mouse is hovering on

bool	mouseOverFirstPoint

bool	pointIsDragged

bool	prevPointWasDragged = false

KoPathShape *	shape

Public Attributes inherited from KoToolBasePrivate
KoCanvasBase *	canvas
	the canvas interface this tool will work for.

QCursor	currentCursor

KoToolFactoryBase *	factory {0}

bool	isActivated

bool	isInTextMode

bool	isOpacityPresetMode {false}
	Whether the opacity is preset or tool.

QRectF	lastDecorationsRect

bool	maskSyntheticEvents {false}
	Whether this tool masks synthetic events.

QList< QPointer< QWidget > >	optionWidgets
	the optionwidgets associated with this tool

bool	optionWidgetsCreated {false}

KoToolBase *	q

ToolCanvasResources	toolCanvasResources

Private Attributes
KoCreatePathTool *const	q

Detailed Description

Definition at line 165 of file KoCreatePathTool_p.h.

Constructor & Destructor Documentation

◆ KoCreatePathToolPrivate()

KoCreatePathToolPrivate::KoCreatePathToolPrivate	(	KoCreatePathTool *const	qq,
		KoCanvasBase *	canvas )

inline

Definition at line 169 of file KoCreatePathTool_p.h.

        : KoToolBasePrivate(qq, canvas),
          q(qq),
          shape(0),
          activePoint(0),
          firstPoint(0),
          handleRadius(3),
          decorationThickness(1),
          mouseOverFirstPoint(false),
          pointIsDragged(false),
          finishAfterThisPoint(false),
          hoveredPoint(0),
          angleSnapStrategy(0),
          angleSnappingDelta(15),
          angleSnapStatus(false),
          enableClosePathShortcut(true)
    {
    }

Member Function Documentation

◆ addPathShape()

void KoCreatePathToolPrivate::addPathShape ( )

inline

Definition at line 373 of file KoCreatePathTool_p.h.

                        {
        if (!shape) return;
 
        if (shape->pointCount() < 2) {
            cleanUp();
            return;
        }
 
        // this is done so that nothing happens when the mouseReleaseEvent for the this event is received
        KoPathShape *pathShape = shape;
        shape = 0;
 
        q->addPathShape(pathShape);
 
        cleanUp();
 
        return;
    }

References KoCreatePathTool::addPathShape(), cleanUp(), KoPathShape::pointCount(), q, and shape.

◆ angleDeltaChanged()

void KoCreatePathToolPrivate::angleDeltaChanged ( qreal value )

inline

Definition at line 406 of file KoCreatePathTool_p.h.

                                        {
        angleSnappingDelta = static_cast<int>(value);
        if (angleSnapStrategy)
            angleSnapStrategy->setAngleStep(angleSnappingDelta);
    }

References angleSnappingDelta, angleSnapStrategy, AngleSnapStrategy::setAngleStep(), and value().

◆ angleSnapChanged()

void KoCreatePathToolPrivate::angleSnapChanged ( int angleSnap )

inline

Definition at line 426 of file KoCreatePathTool_p.h.

                                         {
        angleSnapStatus = ! angleSnapStatus;
        if (angleSnapStrategy) {
            if (angleSnap == Qt::Checked)
                angleSnapStrategy->activate();
            else
                angleSnapStrategy->deactivate();
        }
    }

References AngleSnapStrategy::activate(), angleSnapStatus, angleSnapStrategy, and AngleSnapStrategy::deactivate().

◆ autoSmoothCurvesChanged()

void KoCreatePathToolPrivate::autoSmoothCurvesChanged ( bool value )

inline

Definition at line 412 of file KoCreatePathTool_p.h.

                                             {
        autoSmoothCurves = value;
 
        KisConfig cfg(false);
        cfg.setAutoSmoothBezierCurves(value);
    }

References autoSmoothCurves, KisConfig::setAutoSmoothBezierCurves(), and value().

◆ cleanUp()

void KoCreatePathToolPrivate::cleanUp ( )

inline

Definition at line 392 of file KoCreatePathTool_p.h.

                   {
        // reset snap guide
        q->canvas()->updateCanvas(q->canvas()->snapGuide()->boundingRect());
        q->canvas()->snapGuide()->reset();
        angleSnapStrategy = 0;
 
        delete shape;
        shape = 0;
        existingStartPoint = 0;
        existingEndPoint = 0;
        hoveredPoint = 0;
        activePoint = 0;
    }

References activePoint, angleSnapStrategy, KoSnapGuide::boundingRect(), KoToolBase::canvas(), existingEndPoint, existingStartPoint, hoveredPoint, q, KoSnapGuide::reset(), shape, KoCanvasBase::snapGuide, and KoCanvasBase::updateCanvas().

◆ connectPaths()

bool KoCreatePathToolPrivate::connectPaths	(	KoPathShape *	pathShape,
		const PathConnectionPoint &	pointAtStart,
		const PathConnectionPoint &	pointAtEnd ) const

inline

Connects given path with the ones we hit when starting/finishing.

Definition at line 283 of file KoCreatePathTool_p.h.

                                                                                                                                    {
        KoPathShape * startShape = 0;
        KoPathShape * endShape = 0;
        KoPathPoint * startPoint = 0;
        KoPathPoint * endPoint = 0;
 
        if (pointAtStart.isValid()) {
            startShape = pointAtStart.path;
            startPoint = pointAtStart.point;
        }
        if (pointAtEnd.isValid()) {
            endShape = pointAtEnd.path;
            endPoint = pointAtEnd.point;
        }
 
        // at least one point must be valid
        if (!startPoint && !endPoint)
            return false;
        // do not allow connecting to the same point twice
        if (startPoint == endPoint)
            endPoint = 0;
 
        // we have hit an existing path point on start/finish
        // what we now do is:
        // 1. combine the new created path with the ones we hit on start/finish
        // 2. merge the endpoints of the corresponding subpaths
 
        uint newPointCount = pathShape->subpathPointCount(0);
        KoPathPointIndex newStartPointIndex(0, 0);
        KoPathPointIndex newEndPointIndex(0, newPointCount - 1);
        KoPathPoint * newStartPoint = pathShape->pointByIndex(newStartPointIndex);
        KoPathPoint * newEndPoint = pathShape->pointByIndex(newEndPointIndex);
 
        // combine with the path we hit on start
        KoPathPointIndex startIndex(-1, -1);
        if (startShape && startPoint) {
            startIndex = startShape->pathPointIndex(startPoint);
            pathShape->combine(startShape);
            pathShape->moveSubpath(0, pathShape->subpathCount() - 1);
        }
        // combine with the path we hit on finish
        KoPathPointIndex endIndex(-1, -1);
        if (endShape && endPoint) {
            endIndex = endShape->pathPointIndex(endPoint);
            if (endShape != startShape) {
                endIndex.first += pathShape->subpathCount();
                pathShape->combine(endShape);
            }
        }
        // do we connect twice to a single subpath ?
        bool connectToSingleSubpath = (startShape == endShape && startIndex.first == endIndex.first);
 
        if (startIndex.second == 0 && !connectToSingleSubpath) {
            pathShape->reverseSubpath(startIndex.first);
            startIndex.second = pathShape->subpathPointCount(startIndex.first) - 1;
        }
        if (endIndex.second > 0 && !connectToSingleSubpath) {
            pathShape->reverseSubpath(endIndex.first);
            endIndex.second = 0;
        }
 
        // after combining we have a path where with the subpaths in the following
        // order:
        // 1. the subpaths of the pathshape we started the new path at
        // 2. the subpath we just created
        // 3. the subpaths of the pathshape we finished the new path at
 
        // get the path points we want to merge, as these are not going to
        // change while merging
        KoPathPoint * existingStartPoint = pathShape->pointByIndex(startIndex);
        KoPathPoint * existingEndPoint = pathShape->pointByIndex(endIndex);
 
        // merge first two points
        if (existingStartPoint) {
            KoPathPointData pd1(pathShape, pathShape->pathPointIndex(existingStartPoint));
            KoPathPointData pd2(pathShape, pathShape->pathPointIndex(newStartPoint));
            KoPathPointMergeCommand cmd1(pd1, pd2);
            cmd1.redo();
        }
        // merge last two points
        if (existingEndPoint) {
            KoPathPointData pd3(pathShape, pathShape->pathPointIndex(newEndPoint));
            KoPathPointData pd4(pathShape, pathShape->pathPointIndex(existingEndPoint));
            KoPathPointMergeCommand cmd2(pd3, pd4);
            cmd2.redo();
        }
 
        return true;
    }

References KoPathShape::combine(), existingEndPoint, existingStartPoint, PathConnectionPoint::isValid(), KoPathShape::moveSubpath(), PathConnectionPoint::path, KoPathShape::pathPointIndex(), PathConnectionPoint::point, KoPathShape::pointByIndex(), KoPathPointMergeCommand::redo(), KoPathShape::reverseSubpath(), KoPathShape::subpathCount(), and KoPathShape::subpathPointCount().

◆ endPointAtPosition()

KoPathPoint * KoCreatePathToolPrivate::endPointAtPosition ( const QPointF & position ) const

inline

returns the nearest existing path point

Definition at line 240 of file KoCreatePathTool_p.h.

                                                                   {
        QRectF roi = q->handleGrabRect(position);
        QList<KoShape *> shapes = q->canvas()->shapeManager()->shapesAt(roi);
 
        KoPathPoint * nearestPoint = 0;
        qreal minDistance = HUGE_VAL;
        uint grabSensitivity = q->grabSensitivity();
        qreal maxDistance = q->canvas()->viewConverter()->viewToDocumentX(grabSensitivity);
 
        Q_FOREACH(KoShape * s, shapes) {
            KoPathShape * path = dynamic_cast<KoPathShape*>(s);
            if (!path)
                continue;
            KoParameterShape *paramShape = dynamic_cast<KoParameterShape*>(s);
            if (paramShape && paramShape->isParametricShape())
                continue;
 
            KoPathPoint * p = 0;
            uint subpathCount = path->subpathCount();
            for (uint i = 0; i < subpathCount; ++i) {
                if (path->isClosedSubpath(i))
                    continue;
                p = path->pointByIndex(KoPathPointIndex(i, 0));
                // check start of subpath
                qreal d = squareDistance(position, path->shapeToDocument(p->point()));
                if (d < minDistance && d < maxDistance) {
                    nearestPoint = p;
                    minDistance = d;
                }
                // check end of subpath
                p = path->pointByIndex(KoPathPointIndex(i, path->subpathPointCount(i) - 1));
                d = squareDistance(position, path->shapeToDocument(p->point()));
                if (d < minDistance && d < maxDistance) {
                    nearestPoint = p;
                    minDistance = d;
                }
            }
        }
 
        return nearestPoint;
    }

References KoToolBase::canvas(), KoToolBase::grabSensitivity(), KoToolBase::handleGrabRect(), KoParameterShape::isParametricShape(), p, q, KoCanvasBase::shapeManager(), KoShapeManager::shapesAt(), squareDistance(), KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocumentX().

◆ loadAutoSmoothValueFromConfig()

void KoCreatePathToolPrivate::loadAutoSmoothValueFromConfig ( )

inline

Definition at line 419 of file KoCreatePathTool_p.h.

                                         {
        KisConfig cfg(true);
        autoSmoothCurves = cfg.autoSmoothBezierCurves();
 
        Q_EMIT q->sigUpdateAutoSmoothCurvesGUI(autoSmoothCurves);
    }

References KisConfig::autoSmoothBezierCurves(), autoSmoothCurves, q, and KoCreatePathTool::sigUpdateAutoSmoothCurvesGUI().

◆ repaintActivePoint()

void KoCreatePathToolPrivate::repaintActivePoint ( ) const

inline

Definition at line 209 of file KoCreatePathTool_p.h.

                                    {
        const bool isFirstPoint = (activePoint == firstPoint);
 
        if (!isFirstPoint && !pointIsDragged)
            return;
 
        QRectF rect = activePoint->boundingRect(false);
 
        // make sure that we have the second control point inside our
        // update rect, as KoPathPoint::boundingRect will not include
        // the second control point of the last path point if the path
        // is not closed
        const QPointF &point = activePoint->point();
        const QPointF &controlPoint = activePoint->controlPoint2();
        rect = rect.united(QRectF(point, controlPoint).normalized());
 
        // when painting the first point we want the
        // first control point to be painted as well
        if (isFirstPoint) {
            const QPointF &controlPoint = activePoint->controlPoint1();
            rect = rect.united(QRectF(point, controlPoint).normalized());
        }
 
        QPointF border = q->canvas()->viewConverter()
                         ->viewToDocument(QPointF(handleRadius, handleRadius));
 
        rect.adjust(-border.x(), -border.y(), border.x(), border.y());
        q->canvas()->updateCanvas(rect);
    }

References activePoint, KoPathPoint::boundingRect(), KoToolBase::canvas(), KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, firstPoint, handleRadius, KoPathPoint::point, pointIsDragged, q, KoCanvasBase::updateCanvas(), KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocument().

Member Data Documentation

◆ activePoint

KoPathPoint* KoCreatePathToolPrivate::activePoint

Definition at line 189 of file KoCreatePathTool_p.h.

◆ angleSnappingDelta

int KoCreatePathToolPrivate::angleSnappingDelta

Definition at line 205 of file KoCreatePathTool_p.h.

◆ angleSnapStatus

bool KoCreatePathToolPrivate::angleSnapStatus

Definition at line 206 of file KoCreatePathTool_p.h.

◆ angleSnapStrategy

AngleSnapStrategy* KoCreatePathToolPrivate::angleSnapStrategy

Definition at line 204 of file KoCreatePathTool_p.h.

◆ autoSmoothCurves

bool KoCreatePathToolPrivate::autoSmoothCurves = false

Definition at line 200 of file KoCreatePathTool_p.h.

◆ decorationThickness

int KoCreatePathToolPrivate::decorationThickness

Definition at line 192 of file KoCreatePathTool_p.h.

◆ dragStartPoint

QPointF KoCreatePathToolPrivate::dragStartPoint

Definition at line 202 of file KoCreatePathTool_p.h.

◆ enableClosePathShortcut

bool KoCreatePathToolPrivate::enableClosePathShortcut

Definition at line 207 of file KoCreatePathTool_p.h.

◆ existingEndPoint

PathConnectionPoint KoCreatePathToolPrivate::existingEndPoint

an existing path point we finished a new path at

Definition at line 197 of file KoCreatePathTool_p.h.

◆ existingStartPoint

PathConnectionPoint KoCreatePathToolPrivate::existingStartPoint

an existing path point we started a new path at

Definition at line 196 of file KoCreatePathTool_p.h.

◆ finishAfterThisPoint

bool KoCreatePathToolPrivate::finishAfterThisPoint

Definition at line 195 of file KoCreatePathTool_p.h.

◆ firstPoint

KoPathPoint* KoCreatePathToolPrivate::firstPoint

Definition at line 190 of file KoCreatePathTool_p.h.

◆ handleRadius

int KoCreatePathToolPrivate::handleRadius

Definition at line 191 of file KoCreatePathTool_p.h.

◆ hoveredPoint

KoPathPoint* KoCreatePathToolPrivate::hoveredPoint

an existing path end point the mouse is hovering on

Definition at line 198 of file KoCreatePathTool_p.h.

◆ mouseOverFirstPoint

bool KoCreatePathToolPrivate::mouseOverFirstPoint

Definition at line 193 of file KoCreatePathTool_p.h.

◆ pointIsDragged

bool KoCreatePathToolPrivate::pointIsDragged

Definition at line 194 of file KoCreatePathTool_p.h.

◆ prevPointWasDragged

bool KoCreatePathToolPrivate::prevPointWasDragged = false

Definition at line 199 of file KoCreatePathTool_p.h.

◆ q

KoCreatePathTool* const KoCreatePathToolPrivate::q

private

Definition at line 167 of file KoCreatePathTool_p.h.

◆ shape

KoPathShape* KoCreatePathToolPrivate::shape

Definition at line 188 of file KoCreatePathTool_p.h.

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

libs/basicflakes/tools/KoCreatePathTool_p.h

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KoCreatePathToolPrivate()

Member Function Documentation

◆ addPathShape()

◆ angleDeltaChanged()

◆ angleSnapChanged()

◆ autoSmoothCurvesChanged()

◆ cleanUp()

◆ connectPaths()

◆ endPointAtPosition()

◆ loadAutoSmoothValueFromConfig()

◆ repaintActivePoint()

Member Data Documentation

◆ activePoint

◆ angleSnappingDelta

◆ angleSnapStatus

◆ angleSnapStrategy

◆ autoSmoothCurves

◆ decorationThickness

◆ dragStartPoint

◆ enableClosePathShortcut

◆ existingEndPoint

◆ existingStartPoint

◆ finishAfterThisPoint

◆ firstPoint

◆ handleRadius

◆ hoveredPoint

◆ mouseOverFirstPoint

◆ pointIsDragged

◆ prevPointWasDragged

◆ q

◆ shape