#include <KoPathTool.h>

Inheritance diagram for KoPathTool:

Classes
struct	PathSegment

Public Slots
void	canvasResourceChanged (int key, const QVariant &res) override

Public Slots inherited from KoToolBase
virtual void	canvasResourceChanged (int key, const QVariant &res)

virtual void	documentResourceChanged (int key, const QVariant &res)

virtual void	requestRedoDuringStroke ()

void	setStatusText (const QString &statusText)

void	updateOptionsWidgetIcons ()

Signals
void	singleShapeChanged (KoPathShape *path)

void	typeChanged (int types)

Signals inherited from KoToolBase
void	activateTool (const QString &id)

void	cursorChanged (const QCursor &cursor)

void	selectionChanged (bool hasSelection)

void	statusTextChanged (const QString &statusText)

void	textModeChanged (bool inTextMode)

Public Member Functions
void	activate (const QSet< KoShape * > &shapes) override

void	deactivate () override

QRectF	decorationsRect () const override

void	deleteSelection () override

void	deselect () override
	deselect the tool should clear the selection if it has one.

void	explicitUserStrokeEndRequest () override
	explicitUserStrokeEndRequest is called by the input manager when the user presses Enter key or any equivalent. This callback comes before requestStrokeEnd(), which comes from a different source.

void	keyPressEvent (QKeyEvent *event) override

void	keyReleaseEvent (QKeyEvent *event) override

	KoPathTool (KoCanvasBase *canvas)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mouseMoveEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

void	notifyPathPointsChanged (KoPathShape *shape)

void	paint (QPainter &painter, const KoViewConverter &converter) override

QMenu *	popupActionsMenu () override

void	repaintDecorations () override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

void	requestUndoDuringStroke () override

bool	selectAll () override
	selectAll select all data the tool can select.

KoToolSelection *	selection () override

	~KoPathTool () override

Public Member Functions inherited from KoToolBase
QAction *	action (const QString &name) const

KoCanvasBase *	canvas () const
	Returns the canvas the tool is working on.

virtual void	copy () const

QCursor	cursor () const
	return the last emitted cursor

virtual void	customMoveEvent (KoPointerEvent *event)

virtual void	customPressEvent (KoPointerEvent *event)

virtual void	customReleaseEvent (KoPointerEvent *event)

virtual void	cut ()

int	decorationThickness () const
	decorationThickness The minimum thickness for tool decoration lines, this is derived from the screen magnification, thus the HiDPI settings. Note: to use this effectively, also set the pen to isCosmetic(true);

virtual void	dragLeaveEvent (QDragLeaveEvent *event)

virtual void	dragMoveEvent (QDragMoveEvent *event, const QPointF &point)

virtual void	dropEvent (QDropEvent *event, const QPointF &point)

KoToolFactoryBase *	factory () const

virtual void	focusInEvent (QFocusEvent *event)

virtual void	focusOutEvent (QFocusEvent *event)

virtual bool	hasSelection ()

virtual void	inputMethodEvent (QInputMethodEvent *event)

virtual QVariant	inputMethodQuery (Qt::InputMethodQuery query) const

bool	isInTextMode () const

bool	isOpacityPresetMode () const

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

virtual void	mouseTripleClickEvent (KoPointerEvent *event)

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

virtual KisPopupWidgetInterface *	popupWidget ()

Q_INVOKABLE QString	toolId () const

virtual bool	wantsAutoScroll () const

	~KoToolBase () override

Protected Member Functions
QList< QPointer< QWidget > >	createOptionWidgets () override
	reimplemented

Protected Member Functions inherited from KoToolBase
virtual QWidget *	createOptionWidget ()

int	grabSensitivity () const
	Convenience function to get the current grab sensitivity.

qreal	handleDocRadius () const

QRectF	handleGrabRect (const QPointF &position) const

QRectF	handlePaintRect (const QPointF &position) const

int	handleRadius () const
	Convenience function to get the current handle radius.

bool	isActivated () const

	KoToolBase (KoToolBasePrivate &dd)

KoPointerEvent *	lastDeliveredPointerEvent () const

void	setAbstractResource (KoAbstractCanvasResourceInterfaceSP abstractResource)

void	setConverter (KoDerivedResourceConverterSP converter)

void	setIsOpacityPresetMode (bool value)

void	setMaskSyntheticEvents (bool value)

void	setTextMode (bool value)

QHash< int, KoAbstractCanvasResourceInterfaceSP >	toolAbstractResources ()

QHash< int, KoDerivedResourceConverterSP >	toolConverters ()

void	useCursor (const QCursor &cursor)

Protected Attributes
KoPathToolSelection	m_pointSelection
	the point selection

QCursor	m_selectCursor

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Private Slots
void	breakAtPoint ()

void	breakAtSegment ()

void	breakAtSelection ()

void	convertToPath ()

void	insertPoints ()

void	joinPoints ()

void	mergePoints ()

void	pointSelectionChanged ()

void	pointToCurve ()

void	pointToLine ()

void	pointTypeChanged (KoPathPointTypeCommand::PointType type)

void	pointTypeChangedCorner ()

void	pointTypeChangedSmooth ()

void	pointTypeChangedSymmetric ()

void	removePoints ()

void	segmentToCurve ()

void	segmentToLine ()

void	slotSelectionChanged ()

void	updateActions ()

Private Member Functions
void	clearActivePointSelectionReferences ()

KUndo2Command *	createPointToCurveCommand (const QList< KoPathPointData > &points)

void	initializeWithShapes (const QList< KoShape * > shapes)

void	mergePointsImpl (bool doJoin)

PathSegment *	segmentAtPoint (const QPointF &point)

void	updateOptionsWidget ()

Private Attributes
QAction *	m_actionAddPoint

QAction *	m_actionBreakPoint

QAction *	m_actionBreakSegment

QAction *	m_actionBreakSelection

QAction *	m_actionConvertToPath

QAction *	m_actionCurvePoint

QAction *	m_actionCurveSegment

QAction *	m_actionJoinSegment

QAction *	m_actionLinePoint

QAction *	m_actionLineSegment

QAction *	m_actionMergePoints

QAction *	m_actionPathPointCorner

QAction *	m_actionPathPointSmooth

QAction *	m_actionPathPointSymmetric

QAction *	m_actionRemovePoint

QScopedPointer< KoPathToolHandle >	m_activeHandle
	the currently active handle

QScopedPointer< PathSegment >	m_activeSegment

KisSignalAutoConnectionsStore	m_canvasConnections

QScopedPointer< QMenu >	m_contextMenu

QScopedPointer< KoInteractionStrategy >	m_currentStrategy
	the rubber selection strategy

QPointF	m_lastPoint
	needed for interaction strategy

QCursor	m_moveCursor

KoShapeFillResourceConnector	m_shapeFillResourceConnector

Friends
class	TestPathTool

Detailed Description

The tool for editing a KoPathShape or a KoParameterShape. See KoCreatePathTool for code handling the initial path creation.

Definition at line 35 of file KoPathTool.h.

Constructor & Destructor Documentation

◆ KoPathTool()

KoPathTool::KoPathTool ( KoCanvasBase * canvas )

explicit

Definition at line 86 of file KoPathTool.cpp.

    : KoToolBase(canvas)
    , m_pointSelection(this)
{
    m_actionPathPointCorner = action("pathpoint-corner");
    m_actionPathPointSmooth = action("pathpoint-smooth");
    m_actionPathPointSymmetric = action("pathpoint-symmetric");
    m_actionCurvePoint = action("pathpoint-curve");
    m_actionLinePoint = action("pathpoint-line");
    m_actionLineSegment = action("pathsegment-line");
    m_actionCurveSegment = action("pathsegment-curve");
    m_actionAddPoint = action("pathpoint-insert");
    m_actionRemovePoint = action("pathpoint-remove");
    m_actionBreakPoint = action("path-break-point");
    m_actionBreakSegment = action("path-break-segment");
    m_actionBreakSelection = action("path-break-selection");
    m_actionJoinSegment = action("pathpoint-join");
    m_actionMergePoints = action("pathpoint-merge");
    m_actionConvertToPath = action("convert-to-path");
 
    m_contextMenu.reset(new QMenu());
 
    m_selectCursor = QCursor(QIcon(":/cursor-needle.svg").pixmap(32), 0, 0);
    m_moveCursor = QCursor(QIcon(":/cursor-needle-move.svg").pixmap(32), 0, 0);
 
    connect(&m_pointSelection, SIGNAL(selectionChanged()), SLOT(repaintDecorations()));
}

References KoToolBase::action(), connect(), m_actionAddPoint, m_actionBreakPoint, m_actionBreakSegment, m_actionBreakSelection, m_actionConvertToPath, m_actionCurvePoint, m_actionCurveSegment, m_actionJoinSegment, m_actionLinePoint, m_actionLineSegment, m_actionMergePoints, m_actionPathPointCorner, m_actionPathPointSmooth, m_actionPathPointSymmetric, m_actionRemovePoint, m_contextMenu, m_moveCursor, m_pointSelection, m_selectCursor, repaintDecorations(), and KoToolBase::selectionChanged().

◆ ~KoPathTool()

KoPathTool::~KoPathTool ( )

override

Definition at line 114 of file KoPathTool.cpp.

115{

116}

Member Function Documentation

◆ activate()

void KoPathTool::activate ( const QSet< KoShape * > & shapes )

overridevirtual

This method is called when this tool instance is activated. For any main window there is only one tool active at a time, which then gets all user input. Switching between tools will call deactivate on one and activate on the new tool allowing the tool to flush items (like a selection) when it is not in use.

Parameters

shapes the set of shapes that are selected or suggested for editing by a selected shape for the tool to work on. Not all shapes will be meant for this tool.

See also: deactivate()

Reimplemented from KoToolBase.

Definition at line 861 of file KoPathTool.cpp.

{
    KoToolBase::activate(shapes);
 
    Q_D(KoToolBase);
 
    d->canvas->snapGuide()->reset();
 
    useCursor(m_selectCursor);
    m_canvasConnections.addConnection(d->canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
    m_canvasConnections.addConnection(d->canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()), this, SLOT(updateActions()));
 
    m_canvasConnections.addConnection(d->canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(repaintDecorations()));
    m_canvasConnections.addConnection(d->canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()), this, SLOT(repaintDecorations()));
    m_shapeFillResourceConnector.connectToCanvas(d->canvas);
    initializeWithShapes(QList<KoShape*>(shapes.begin(), shapes.end()));
    connect(m_actionCurvePoint, SIGNAL(triggered()), this, SLOT(pointToCurve()), Qt::UniqueConnection);
    connect(m_actionLinePoint, SIGNAL(triggered()), this, SLOT(pointToLine()), Qt::UniqueConnection);
    connect(m_actionLineSegment, SIGNAL(triggered()), this, SLOT(segmentToLine()), Qt::UniqueConnection);
    connect(m_actionCurveSegment, SIGNAL(triggered()), this, SLOT(segmentToCurve()), Qt::UniqueConnection);
    connect(m_actionAddPoint, SIGNAL(triggered()), this, SLOT(insertPoints()), Qt::UniqueConnection);
    connect(m_actionRemovePoint, SIGNAL(triggered()), this, SLOT(removePoints()), Qt::UniqueConnection);
    connect(m_actionBreakPoint, SIGNAL(triggered()), this, SLOT(breakAtPoint()), Qt::UniqueConnection);
    connect(m_actionBreakSegment, SIGNAL(triggered()), this, SLOT(breakAtSegment()), Qt::UniqueConnection);
    connect(m_actionBreakSelection, SIGNAL(triggered()), this, SLOT(breakAtSelection()), Qt::UniqueConnection);
    connect(m_actionJoinSegment, SIGNAL(triggered()), this, SLOT(joinPoints()), Qt::UniqueConnection);
    connect(m_actionMergePoints, SIGNAL(triggered()), this, SLOT(mergePoints()), Qt::UniqueConnection);
    connect(m_actionConvertToPath, SIGNAL(triggered()), this, SLOT(convertToPath()), Qt::UniqueConnection);
    connect(m_actionPathPointCorner, SIGNAL(triggered()), this, SLOT(pointTypeChangedCorner()), Qt::UniqueConnection);
    connect(m_actionPathPointSmooth, SIGNAL(triggered()), this, SLOT(pointTypeChangedSmooth()), Qt::UniqueConnection);
    connect(m_actionPathPointSymmetric, SIGNAL(triggered()), this, SLOT(pointTypeChangedSymmetric()), Qt::UniqueConnection);
    connect(&m_pointSelection, SIGNAL(selectionChanged()), this, SLOT(pointSelectionChanged()), Qt::UniqueConnection);
 
}

References KoToolBase::activate(), KisSignalAutoConnectionsStore::addConnection(), breakAtPoint(), breakAtSegment(), breakAtSelection(), connect(), KoShapeFillResourceConnector::connectToCanvas(), convertToPath(), initializeWithShapes(), insertPoints(), joinPoints(), m_actionAddPoint, m_actionBreakPoint, m_actionBreakSegment, m_actionBreakSelection, m_actionConvertToPath, m_actionCurvePoint, m_actionCurveSegment, m_actionJoinSegment, m_actionLinePoint, m_actionLineSegment, m_actionMergePoints, m_actionPathPointCorner, m_actionPathPointSmooth, m_actionPathPointSymmetric, m_actionRemovePoint, m_canvasConnections, m_pointSelection, m_selectCursor, m_shapeFillResourceConnector, mergePoints(), pointSelectionChanged(), pointToCurve(), pointToLine(), pointTypeChangedCorner(), pointTypeChangedSmooth(), pointTypeChangedSymmetric(), removePoints(), repaintDecorations(), segmentToCurve(), segmentToLine(), KoToolBase::selectionChanged(), slotSelectionChanged(), updateActions(), and KoToolBase::useCursor().

◆ breakAtPoint

void KoPathTool::breakAtPoint ( )

privateslot

Definition at line 403 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_pointSelection.hasSelection()) {
        d->canvas->addCommand(new KoPathBreakAtPointCommand(m_pointSelection.selectedPointsData()));
    }
}

References KoPathToolSelection::hasSelection(), m_pointSelection, and KoPathToolSelection::selectedPointsData().

◆ breakAtSegment

void KoPathTool::breakAtSegment ( )

privateslot

Definition at line 425 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    // only try to break a segment when 2 points of the same object are selected
    if (m_pointSelection.objectCount() == 1 && m_pointSelection.size() == 2) {
        QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
        if (segments.size() == 1) {
            d->canvas->addCommand(new KoPathSegmentBreakCommand(segments.at(0)));
        }
    }
}

References m_pointSelection, KoPathToolSelection::objectCount(), KoPathToolSelection::selectedSegmentsData(), and KoPathToolSelection::size().

◆ breakAtSelection

void KoPathTool::breakAtSelection ( )

privateslot

Definition at line 411 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
 
    if (m_pointSelection.objectCount() == 1 && m_pointSelection.size() == 2) {
        QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
        if (segments.size() == 1) {
            d->canvas->addCommand(new KoPathSegmentBreakCommand(segments.at(0)));
        }
    } else if (m_pointSelection.hasSelection()) {
        d->canvas->addCommand(new KoPathBreakAtPointCommand(m_pointSelection.selectedPointsData()));
    }
}

References KoPathToolSelection::hasSelection(), m_pointSelection, KoPathToolSelection::objectCount(), KoPathToolSelection::selectedPointsData(), KoPathToolSelection::selectedSegmentsData(), and KoPathToolSelection::size().

◆ canvasResourceChanged

void KoPathTool::canvasResourceChanged	(	int	key,
		const QVariant &	res )

overrideslot

Definition at line 1095 of file KoPathTool.cpp.

{
    if (key == KoCanvasResource::HandleRadius || key == KoCanvasResource::DecorationThickness) {
        repaintDecorations();
    }
}

References KoCanvasResource::DecorationThickness, KoCanvasResource::HandleRadius, and repaintDecorations().

◆ clearActivePointSelectionReferences()

void KoPathTool::clearActivePointSelectionReferences ( )

private

Definition at line 916 of file KoPathTool.cpp.

{
    m_activeHandle.reset();
    m_activeSegment.reset();
    m_pointSelection.clear();
}

References KoPathToolSelection::clear(), m_activeHandle, m_activeSegment, and m_pointSelection.

◆ convertToPath

void KoPathTool::convertToPath ( )

privateslot

Definition at line 284 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
 
    KoSelection *selection = canvas()->selectedShapesProxy()->selection();
 
    QList<KoParameterShape*> parameterShapes;
 
    Q_FOREACH (KoShape *shape, m_pointSelection.selectedShapes()) {
        KoParameterShape * parametric = dynamic_cast<KoParameterShape*>(shape);
        if (parametric && parametric->isParametricShape()) {
            parameterShapes.append(parametric);
        }
    }
 
    if (!parameterShapes.isEmpty()) {
        d->canvas->addCommand(new KoParameterToPathCommand(parameterShapes));
    }
 
    QList<KoSvgTextShape*> textShapes;
    Q_FOREACH (KoShape *shape, selection->selectedEditableShapes()) {
        if (KoSvgTextShape *text = dynamic_cast<KoSvgTextShape*>(shape)) {
            textShapes.append(text);
        }
    }
 
    if (!textShapes.isEmpty()) {
        KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Convert to Path")); // TODO: reuse the text from KoParameterToPathCommand
        const QList<KoShape*> oldSelectedShapes = implicitCastList<KoShape*>(textShapes);
 
 
        new KoKeepShapesSelectedCommand(oldSelectedShapes, {}, canvas()->selectedShapesProxy(),
                                        KisCommandUtils::FlipFlopCommand::State::INITIALIZING, cmd);
 
        QList<KoShape*> newSelectedShapes;
        Q_FOREACH (KoSvgTextShape *shape, textShapes) {
            KoShape *outlineShape = shape->textOutline();
 
            KoShapeContainer *parent = shape->parent();
            canvas()->shapeController()->addShapeDirect(outlineShape, parent, cmd);
 
            newSelectedShapes << outlineShape;
        }
 
        canvas()->shapeController()->removeShapes(oldSelectedShapes, cmd);
 
        new KoKeepShapesSelectedCommand({}, newSelectedShapes, canvas()->selectedShapesProxy(),
                                        KisCommandUtils::FlipFlopCommand::State::FINALIZING, cmd);
 
        canvas()->addCommand(cmd);
    }
 
    updateOptionsWidget();
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisCommandUtils::FlipFlopCommand::INITIALIZING, KoParameterShape::isParametricShape(), kundo2_i18n(), m_pointSelection, KoShape::parent(), KoPathToolSelection::selectedShapes(), KoCanvasBase::selectedShapesProxy(), selection(), KoSelectedShapesProxy::selection(), KoCanvasBase::shapeController, KoSvgTextShape::textOutline(), and updateOptionsWidget().

◆ createOptionWidgets()

QList< QPointer< QWidget > > KoPathTool::createOptionWidgets ( )

overrideprotectedvirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 118 of file KoPathTool.cpp.

{
    QList<QPointer<QWidget> > list;
 
    PathToolOptionWidget * toolOptions = new PathToolOptionWidget(this);
    connect(this, SIGNAL(typeChanged(int)), toolOptions, SLOT(setSelectionType(int)));
    connect(this, SIGNAL(singleShapeChanged(KoPathShape*)), toolOptions, SLOT(setCurrentShape(KoPathShape*)));
    connect(toolOptions, SIGNAL(sigRequestUpdateActions()), this, SLOT(updateActions()));
    updateOptionsWidget();
    toolOptions->setWindowTitle(i18n("Edit Shape"));
    list.append(toolOptions);
 
    return list;
}

References connect(), singleShapeChanged(), typeChanged(), updateActions(), and updateOptionsWidget().

◆ createPointToCurveCommand()

KUndo2Command * KoPathTool::createPointToCurveCommand ( const QList< KoPathPointData > & points )

private

Definition at line 243 of file KoPathTool.cpp.

{
    KUndo2Command *command = 0;
    QList<KoPathPointData> pointToChange;
 
    QList<KoPathPointData>::const_iterator it(points.constBegin());
    for (; it != points.constEnd(); ++it) {
        KoPathPoint *point = it->pathShape->pointByIndex(it->pointIndex);
        if (point && (! point->activeControlPoint1() || ! point->activeControlPoint2()))
            pointToChange.append(*it);
    }
 
    if (!pointToChange.isEmpty()) {
        command = new KoPathPointTypeCommand(pointToChange, KoPathPointTypeCommand::Curve);
    }
 
    return command;
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, and KoPathPointTypeCommand::Curve.

◆ deactivate()

void KoPathTool::deactivate ( )

overridevirtual

This method is called whenever this tool is no longer the active tool

See also: activate()

Reimplemented from KoToolBase.

Definition at line 1062 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
 
    m_shapeFillResourceConnector.disconnect();
    m_canvasConnections.clear();
    m_pointSelection.clear();
    m_pointSelection.setSelectedShapes(QList<KoPathShape*>());
    m_activeHandle.reset();
    m_activeSegment.reset();
    m_currentStrategy.reset();
    d->canvas->snapGuide()->reset();
 
    disconnect(m_actionCurvePoint, 0, this, 0);
    disconnect(m_actionLinePoint, 0, this, 0);
    disconnect(m_actionLineSegment, 0, this, 0);
    disconnect(m_actionCurveSegment, 0, this, 0);
    disconnect(m_actionAddPoint, 0, this, 0);
    disconnect(m_actionRemovePoint, 0, this, 0);
    disconnect(m_actionBreakPoint, 0, this, 0);
    disconnect(m_actionBreakSegment, 0, this, 0);
    disconnect(m_actionBreakSelection, 0, this, 0);
    disconnect(m_actionJoinSegment, 0, this, 0);
    disconnect(m_actionMergePoints, 0, this, 0);
    disconnect(m_actionConvertToPath, 0, this, 0);
    disconnect(m_actionPathPointCorner, 0, this, 0);
    disconnect(m_actionPathPointSmooth, 0, this, 0);
    disconnect(m_actionPathPointSymmetric, 0, this, 0);
    disconnect(&m_pointSelection, 0, this, 0);
 
    KoToolBase::deactivate();
}

References KoPathToolSelection::clear(), KisSignalAutoConnectionsStore::clear(), KoToolBase::deactivate(), KoShapeFillResourceConnector::disconnect(), m_actionAddPoint, m_actionBreakPoint, m_actionBreakSegment, m_actionBreakSelection, m_actionConvertToPath, m_actionCurvePoint, m_actionCurveSegment, m_actionJoinSegment, m_actionLinePoint, m_actionLineSegment, m_actionMergePoints, m_actionPathPointCorner, m_actionPathPointSmooth, m_actionPathPointSymmetric, m_actionRemovePoint, m_activeHandle, m_activeSegment, m_canvasConnections, m_currentStrategy, m_pointSelection, m_shapeFillResourceConnector, and KoPathToolSelection::setSelectedShapes().

◆ decorationsRect()

QRectF KoPathTool::decorationsRect ( ) const

overridevirtual

Reimplemented from KoToolBase.

Definition at line 508 of file KoPathTool.cpp.

{
    const_cast<KoPathToolSelection&>(m_pointSelection).update();
 
    QRectF newDecorationsRect;
 
    Q_FOREACH (KoShape *shape, m_pointSelection.selectedShapes()) {
        newDecorationsRect |= kisGrowRect(shape->boundingRect(), handleDocRadius());
    }
 
    Q_FOREACH(const KoPathPoint *point, m_pointSelection.selectedPoints()) {
        newDecorationsRect |= kisGrowRect(point->boundingRect(false), handleDocRadius());
    }
 
    if (m_activeHandle) {
        newDecorationsRect |= kisGrowRect(m_activeHandle->boundingRect(), handleDocRadius());
    }
 
    if (m_activeSegment) {
        KoPathPointIndex index = m_activeSegment->path->pathPointIndex(m_activeSegment->segmentStart);
        KoPathSegment segment = m_activeSegment->path->segmentByIndex(index);
 
        QRectF rect = segment.boundingRect();
        rect = m_activeSegment->path->shapeToDocument(rect);
 
        newDecorationsRect |= kisGrowRect(rect, handleDocRadius());
    }
 
    return newDecorationsRect;
}

References KoPathSegment::boundingRect(), KoShape::boundingRect(), KoPathPoint::boundingRect(), KoToolBase::handleDocRadius(), kisGrowRect(), m_activeHandle, m_activeSegment, m_pointSelection, KoPathToolSelection::selectedPoints(), and KoPathToolSelection::selectedShapes().

◆ deleteSelection()

void KoPathTool::deleteSelection ( )

overridevirtual

Delete the tools selection. The default implementation is empty to aid tools that don't have any selection.

See also: selection()

Reimplemented from KoToolBase.

Definition at line 1181 of file KoPathTool.cpp.

{
    removePoints();
}

References removePoints().

◆ deselect()

void KoPathTool::deselect ( )

overridevirtual

deselect the tool should clear the selection if it has one.

Reimplemented from KoToolBase.

Definition at line 1218 of file KoPathTool.cpp.

{
    clearActivePointSelectionReferences();
    repaintDecorations();
}

References clearActivePointSelectionReferences(), and repaintDecorations().

◆ explicitUserStrokeEndRequest()

void KoPathTool::explicitUserStrokeEndRequest ( )

overridevirtual

explicitUserStrokeEndRequest is called by the input manager when the user presses Enter key or any equivalent. This callback comes before requestStrokeEnd(), which comes from a different source.

Reimplemented from KoToolBase.

Definition at line 1206 of file KoPathTool.cpp.

{
    KoToolManager::instance()->switchToolRequested("InteractionTool");
}

References KoToolManager::instance(), and KoToolManager::switchToolRequested().

◆ initializeWithShapes()

void KoPathTool::initializeWithShapes ( const QList< KoShape * > shapes )

private

Definition at line 923 of file KoPathTool.cpp.

{
    QList<KoPathShape*> selectedShapes;
    Q_FOREACH (KoShape *shape, shapes) {
        KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
 
        if (pathShape && pathShape->isShapeEditable()) {
            selectedShapes.append(pathShape);
        }
    }
 
    if (selectedShapes != m_pointSelection.selectedShapes()) {
        clearActivePointSelectionReferences();
        m_pointSelection.setSelectedShapes(selectedShapes);
        repaintDecorations();
    }
 
    updateOptionsWidget();
    updateActions();
}

References clearActivePointSelectionReferences(), KoShape::isShapeEditable(), m_pointSelection, repaintDecorations(), KoPathToolSelection::selectedShapes(), KoPathToolSelection::setSelectedShapes(), updateActions(), and updateOptionsWidget().

◆ insertPoints

void KoPathTool::insertPoints ( )

privateslot

Definition at line 173 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
    if (segments.size() == 1) {
        qreal positionInSegment = 0.5;
        if (m_activeSegment && m_activeSegment->isValid()) {
            positionInSegment = m_activeSegment->positionOnSegment;
        }
 
        KoPathPointInsertCommand *cmd = new KoPathPointInsertCommand(segments, positionInSegment);
        d->canvas->addCommand(cmd);
 
        // TODO: this construction is dangerous. The canvas can remove the command right after
        //       it has been added to it!
        m_pointSelection.clear();
        foreach (KoPathPoint * p, cmd->insertedPoints()) {
            m_pointSelection.add(p, false);
        }
    }
}

References KoPathToolSelection::add(), KoPathToolSelection::clear(), KoPathPointInsertCommand::insertedPoints(), m_activeSegment, m_pointSelection, p, and KoPathToolSelection::selectedSegmentsData().

◆ joinPoints

void KoPathTool::joinPoints ( )

privateslot

Definition at line 393 of file KoPathTool.cpp.

{
    mergePointsImpl(true);
}

References mergePointsImpl().

◆ keyPressEvent()

void KoPathTool::keyPressEvent ( QKeyEvent * event )

overridevirtual

Called when a key is pressed. Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event state and reason of this key press

Reimplemented from KoToolBase.

Definition at line 731 of file KoPathTool.cpp.

{
    if (m_currentStrategy) {
        switch (event->key()) {
        case Qt::Key_Control:
        case Qt::Key_Alt:
        case Qt::Key_Shift:
        case Qt::Key_Meta:
            if (! event->isAutoRepeat()) {
                m_currentStrategy->handleMouseMove(m_lastPoint, event->modifiers());
            }
            break;
        case Qt::Key_Escape:
            m_currentStrategy->cancelInteraction();
            m_currentStrategy.reset();
            break;
        default:
            event->ignore();
            return;
        }
    } else {
        switch (event->key()) {
#ifndef NDEBUG
//        case Qt::Key_D:
//            if (m_pointSelection.objectCount() == 1) {
//                QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
//                KoPathShapePrivate *p = static_cast<KoPathShapePrivate*>(selectedPoints[0].pathShape->priv());
//                p->debugPath();
//            }
//            break;
#endif
        default:
            event->ignore();
            return;
        }
    }
    event->accept();
}

References m_currentStrategy, and m_lastPoint.

◆ keyReleaseEvent()

void KoPathTool::keyReleaseEvent ( QKeyEvent * event )

overridevirtual

Called when a key is released Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event state and reason of this key release

Reimplemented from KoToolBase.

Definition at line 770 of file KoPathTool.cpp.

{
    if (m_currentStrategy) {
        switch (event->key()) {
        case Qt::Key_Control:
        case Qt::Key_Alt:
        case Qt::Key_Shift:
        case Qt::Key_Meta:
            if (! event->isAutoRepeat()) {
                m_currentStrategy->handleMouseMove(m_lastPoint, Qt::NoModifier);
            }
            break;
        default:
            break;
        }
    }
    event->accept();
}

References m_currentStrategy, and m_lastPoint.

◆ mergePoints

void KoPathTool::mergePoints ( )

privateslot

Definition at line 398 of file KoPathTool.cpp.

{
    mergePointsImpl(false);
}

References mergePointsImpl().

◆ mergePointsImpl()

void KoPathTool::mergePointsImpl ( bool doJoin )

private

Definition at line 364 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
 
    if (m_pointSelection.size() != 2)
        return;
 
    QList<KoPathPointData> pointData = m_pointSelection.selectedPointsData();
    if (pointData.size() != 2) return;
 
    const KoPathPointData & pd1 = pointData.at(0);
    const KoPathPointData & pd2 = pointData.at(1);
 
    if (!checkCanJoinToPoints(pd1, pd2)) {
        return;
    }
 
    clearActivePointSelectionReferences();
 
    KUndo2Command *cmd = 0;
 
    if (doJoin) {
        cmd = new KoMultiPathPointJoinCommand(pd1, pd2, d->canvas->shapeController()->documentBase(), d->canvas->shapeManager()->selection());
    } else {
        cmd = new KoMultiPathPointMergeCommand(pd1, pd2, d->canvas->shapeController()->documentBase(), d->canvas->shapeManager()->selection());
    }
    d->canvas->addCommand(cmd);
}

References clearActivePointSelectionReferences(), m_pointSelection, KoPathToolSelection::selectedPointsData(), and KoPathToolSelection::size().

◆ mouseDoubleClickEvent()

void KoPathTool::mouseDoubleClickEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is double clicked. Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event state and reason of this mouse or stylus press

Reimplemented from KoToolBase.

Definition at line 789 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    // check if we are doing something else at the moment
    if (m_currentStrategy) return;
 
    if (!m_activeHandle && m_activeSegment && m_activeSegment->isValid()) {
        QList<KoPathPointData> segments;
        segments.append(
                    KoPathPointData(m_activeSegment->path,
                                    m_activeSegment->path->pathPointIndex(m_activeSegment->segmentStart)));
 
        KoPathPointInsertCommand *cmd = new KoPathPointInsertCommand(segments, m_activeSegment->positionOnSegment);
        d->canvas->addCommand(cmd);
 
        m_pointSelection.clear();
        foreach (KoPathPoint * p, cmd->insertedPoints()) {
            m_pointSelection.add(p, false);
        }
        updateActions();
    } else if (!m_activeHandle && !m_activeSegment) {
        explicitUserStrokeEndRequest();
    }
}

References KoPathToolSelection::add(), KoPathToolSelection::clear(), explicitUserStrokeEndRequest(), KoPathPointInsertCommand::insertedPoints(), m_activeHandle, m_activeSegment, m_currentStrategy, m_pointSelection, p, and updateActions().

◆ mouseMoveEvent()

void KoPathTool::mouseMoveEvent ( KoPointerEvent * event )

overridevirtual

Called when the mouse or stylus moved over the canvas. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus move

Implements KoToolBase.

Definition at line 587 of file KoPathTool.cpp.

{
    if (event->button() & Qt::RightButton)
        return;
 
    if (m_currentStrategy) {
        m_lastPoint = event->point;
        m_currentStrategy->handleMouseMove(event->point, event->modifiers());
 
        repaintDecorations();
 
        return;
    }
 
    if (m_activeSegment) {
        m_activeSegment.reset();
        repaintDecorations();
    }
 
    Q_FOREACH (KoPathShape *shape, m_pointSelection.selectedShapes()) {
        QRectF roi = shape->documentToShape(handleGrabRect(event->point));
        KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
        if (parameterShape && parameterShape->isParametricShape()) {
            int handleId = parameterShape->handleIdAt(roi);
            if (handleId != -1) {
                useCursor(m_moveCursor);
                Q_EMIT statusTextChanged(i18n("Drag to move handle."));
 
                m_activeHandle.reset(new ParameterHandle(this, parameterShape, handleId));
                repaintDecorations();
                return;
            }
        } else {
            QList<KoPathPoint*> points = shape->pointsAt(roi, true);
            if (! points.empty()) {
                // find the nearest control point from all points within the roi
                KoPathPoint * bestPoint = 0;
                KoPathPoint::PointType bestPointType = KoPathPoint::Node;
                qreal minDistance = HUGE_VAL;
                Q_FOREACH (KoPathPoint *p, points) {
                    // the node point must be hit if the point is not selected yet
                    if (! m_pointSelection.contains(p) && ! roi.contains(p->point()))
                        continue;
 
                    // check for the control points first as otherwise it is no longer
                    // possible to change the control points when they are the same as the point
                    if (p->activeControlPoint1() && roi.contains(p->controlPoint1())) {
                        qreal dist = squaredDistance(roi.center(), p->controlPoint1());
                        if (dist < minDistance) {
                            bestPoint = p;
                            bestPointType = KoPathPoint::ControlPoint1;
                            minDistance = dist;
                        }
                    }
 
                    if (p->activeControlPoint2() && roi.contains(p->controlPoint2())) {
                        qreal dist = squaredDistance(roi.center(), p->controlPoint2());
                        if (dist < minDistance) {
                            bestPoint = p;
                            bestPointType = KoPathPoint::ControlPoint2;
                            minDistance = dist;
                        }
                    }
 
                    // check the node point at last
                    qreal dist = squaredDistance(roi.center(), p->point());
                    if (dist < minDistance) {
                        bestPoint = p;
                        bestPointType = KoPathPoint::Node;
                        minDistance = dist;
                    }
                }
 
                if (! bestPoint) {
                    repaintDecorations();
                    return;
                }
 
                useCursor(m_moveCursor);
                if (bestPointType == KoPathPoint::Node)
                    Q_EMIT statusTextChanged(i18n("Drag to move point. Shift click to change point type."));
                else
                    Q_EMIT statusTextChanged(i18n("Drag to move control point."));
 
                PointHandle *prev = dynamic_cast<PointHandle*>(m_activeHandle.data());
                if (prev && prev->activePoint() == bestPoint && prev->activePointType() == bestPointType)
                    return; // no change;
 
                m_activeHandle.reset(new PointHandle(this, bestPoint, bestPointType));
                repaintDecorations();
                return;
            }
        }
    }
 
    useCursor(m_selectCursor);
 
    if (m_activeHandle) {
        m_activeHandle.reset();
        repaintDecorations();
    }
 
    PathSegment *hoveredSegment = segmentAtPoint(event->point);
    if(hoveredSegment) {
        useCursor(Qt::PointingHandCursor);
        Q_EMIT statusTextChanged(i18n("Drag to change curve directly. Double click to insert new path point."));
        m_activeSegment.reset(hoveredSegment);
        repaintDecorations();
    } else {
        uint selectedPointCount = m_pointSelection.size();
        if (selectedPointCount == 0)
            Q_EMIT statusTextChanged(QString());
        else {
            if (!m_actionBreakSelection->shortcut().isEmpty()) {
                if (selectedPointCount == 1)
                    Q_EMIT statusTextChanged(i18nc("%1 is a shortcut to be pressed", "Press %1 to break path at selected point.", m_actionBreakSelection->shortcut().toString()));
                else
                    Q_EMIT statusTextChanged(i18nc("%1 is a shortcut to be pressed", "Press %1 to break path at selected segments.", m_actionBreakSelection->shortcut().toString()));
            } else {
                Q_EMIT statusTextChanged(QString());
            }
        }
    }
}

References PointHandle::activePoint(), PointHandle::activePointType(), KoPointerEvent::button(), KoPathToolSelection::contains(), KoPathPoint::ControlPoint1, KoPathPoint::ControlPoint2, KoShape::documentToShape(), KoToolBase::handleGrabRect(), KoParameterShape::handleIdAt(), KoParameterShape::isParametricShape(), m_actionBreakSelection, m_activeHandle, m_activeSegment, m_currentStrategy, m_lastPoint, m_moveCursor, m_pointSelection, m_selectCursor, KoPointerEvent::modifiers(), KoPathPoint::Node, p, KoPointerEvent::point, KoPathShape::pointsAt(), repaintDecorations(), segmentAtPoint(), KoPathToolSelection::selectedShapes(), KoPathToolSelection::size(), squaredDistance(), KoToolBase::statusTextChanged(), and KoToolBase::useCursor().

◆ mousePressEvent()

void KoPathTool::mousePressEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is pressed. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus press

Implements KoToolBase.

Definition at line 545 of file KoPathTool.cpp.

{
    // we are moving if we hit a point and use the left mouse button
    if (m_activeHandle) {
        m_currentStrategy.reset(m_activeHandle->handleMousePress(event));
    } else {
        if (event->button() & Qt::LeftButton) {
 
            // check if we hit a path segment
            if (m_activeSegment && m_activeSegment->isValid()) {
 
                KoPathShape *shape = m_activeSegment->path;
                KoPathPointIndex index = shape->pathPointIndex(m_activeSegment->segmentStart);
                KoPathSegment segment = shape->segmentByIndex(index);
 
                m_pointSelection.add(segment.first(), !(event->modifiers() & Qt::ShiftModifier));
                m_pointSelection.add(segment.second(), false);
 
                KoPathPointData data(shape, index);
                m_currentStrategy.reset(new KoPathSegmentChangeStrategy(this, event->point, data, m_activeSegment->positionOnSegment));
            } else {
 
                KoShapeManager *shapeManager = canvas()->shapeManager();
                KoSelection *selection = shapeManager->selection();
                KoShape *shape = shapeManager->shapeAt(event->point, KoFlake::ShapeOnTop);
 
                if (shape && !selection->isSelected(shape)) {
 
                    if (!(event->modifiers() & Qt::ShiftModifier)) {
                        selection->deselectAll();
                    }
 
                    selection->select(shape);
                } else {
                    KIS_ASSERT_RECOVER_RETURN(m_currentStrategy == 0);
                    m_currentStrategy.reset(new KoPathPointRubberSelectStrategy(this, event->point));
                }
            }
        }
    }
}

References KoPathToolSelection::add(), KoPointerEvent::button(), KoToolBase::canvas(), KoPathSegment::first, KIS_ASSERT_RECOVER_RETURN, m_activeHandle, m_activeSegment, m_currentStrategy, m_pointSelection, KoPointerEvent::modifiers(), KoPathShape::pathPointIndex(), KoPointerEvent::point, KoPathSegment::second, KoPathShape::segmentByIndex(), KoShapeManager::selection, selection(), KoShapeManager::shapeAt(), KoCanvasBase::shapeManager(), and KoFlake::ShapeOnTop.

◆ mouseReleaseEvent()

void KoPathTool::mouseReleaseEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is released. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus release

Implements KoToolBase.

Definition at line 712 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_currentStrategy) {
        const bool hadNoSelection = !m_pointSelection.hasSelection();
        m_currentStrategy->finishInteraction(event->modifiers());
        KUndo2Command *command = m_currentStrategy->createCommand();
        if (command)
            d->canvas->addCommand(command);
        if (hadNoSelection && dynamic_cast<KoPathPointRubberSelectStrategy*>(m_currentStrategy.data())
                && !m_pointSelection.hasSelection()) {
            // the click didn't do anything at all. Allow it to be used by others.
            event->ignore();
        }
        m_currentStrategy.reset();
        repaintDecorations();
    }
}

References KoPathToolSelection::hasSelection(), m_currentStrategy, m_pointSelection, KoPointerEvent::modifiers(), and repaintDecorations().

◆ notifyPathPointsChanged()

void KoPathTool::notifyPathPointsChanged ( KoPathShape * shape )

Definition at line 905 of file KoPathTool.cpp.

{
    Q_UNUSED(shape);
 
    // active handle and selection might have already become invalid, so just
    // delete them without dereferencing anything...
 
    m_activeHandle.reset();
    m_activeSegment.reset();
}

References m_activeHandle, and m_activeSegment.

◆ paint()

void KoPathTool::paint	(	QPainter &	painter,
		const KoViewConverter &	converter )

overridevirtual

Called by the canvas to paint any decorations that the tool deems needed. The painter has the top left of the canvas as its origin.

Parameters

painter	used for painting the shape
converter	to convert between internal and view coordinates.

Implements KoToolBase.

Definition at line 437 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
 
    Q_FOREACH (KoPathShape *shape, m_pointSelection.selectedShapes()) {
        KisHandlePainterHelper helper =
                KoShape::createHandlePainterHelperView(&painter, shape, converter, handleRadius(), decorationThickness());
        helper.setHandleStyle(KisHandleStyle::primarySelection());
 
        KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
        if (parameterShape && parameterShape->isParametricShape()) {
            parameterShape->paintHandles(helper);
        } else {
            shape->paintPoints(helper);
        }
 
        if (!shape->stroke() || !shape->stroke()->isVisible()) {
            helper.setHandleStyle(KisHandleStyle::secondarySelection());
            helper.drawPath(shape->outline());
        }
    }
 
    if (m_currentStrategy) {
        painter.save();
        m_currentStrategy->paint(painter, converter);
        painter.restore();
    }
 
    m_pointSelection.paint(painter, converter, handleRadius());
 
    if (m_activeHandle) {
        if (m_activeHandle->check(m_pointSelection.selectedShapes())) {
            m_activeHandle->paint(painter, converter, handleRadius(), decorationThickness());
        } else {
            m_activeHandle.reset();
        }
    } else if (m_activeSegment && m_activeSegment->isValid()) {
 
        KoPathShape *shape = m_activeSegment->path;
 
        // if the stroke is invisible, then we already painted the outline of the shape!
        if (shape->stroke() && shape->stroke()->isVisible()) {
            KoPathPointIndex index = shape->pathPointIndex(m_activeSegment->segmentStart);
            KoPathSegment segment = shape->segmentByIndex(index).toCubic();
 
            KIS_SAFE_ASSERT_RECOVER_RETURN(segment.isValid());
 
            KisHandlePainterHelper helper =
                    KoShape::createHandlePainterHelperView(&painter, shape, converter, handleRadius(), decorationThickness());
            helper.setHandleStyle(KisHandleStyle::secondarySelection());
 
            QPainterPath path;
            path.moveTo(segment.first()->point());
            path.cubicTo(segment.first()->controlPoint2(),
                         segment.second()->controlPoint1(),
                         segment.second()->point());
 
            helper.drawPath(path);
        }
    }
 
 
 
    if (m_currentStrategy) {
        painter.save();
        painter.setTransform(converter.documentToView(), true);
        d->canvas->snapGuide()->paint(painter, converter);
        painter.restore();
    }
}

References KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, KoShape::createHandlePainterHelperView(), KoToolBase::decorationThickness(), KoViewConverter::documentToView(), KisHandlePainterHelper::drawPath(), KoPathSegment::first, KoToolBase::handleRadius(), KoParameterShape::isParametricShape(), KoPathSegment::isValid(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_activeHandle, m_activeSegment, m_currentStrategy, m_pointSelection, KoPathShape::outline(), KoPathToolSelection::paint(), KoParameterShape::paintHandles(), KoPathShape::paintPoints(), KoPathShape::pathPointIndex(), KoPathPoint::point, KisHandleStyle::primarySelection(), KoPathSegment::second, KisHandleStyle::secondarySelection(), KoPathShape::segmentByIndex(), KoPathToolSelection::selectedShapes(), KisHandlePainterHelper::setHandleStyle(), KoShape::stroke(), and KoPathSegment::toCubic().

◆ pointSelectionChanged

void KoPathTool::pointSelectionChanged ( )

privateslot

Definition at line 1102 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    updateActions();
    d->canvas->snapGuide()->setIgnoredPathPoints(QList<KoPathPoint*>(m_pointSelection.selectedPoints().begin(), m_pointSelection.selectedPoints().end()));
    Q_EMIT selectionChanged(m_pointSelection.hasSelection());
}

References KoPathToolSelection::hasSelection(), m_pointSelection, KoPathToolSelection::selectedPoints(), KoToolBase::selectionChanged(), and updateActions().

◆ pointToCurve

void KoPathTool::pointToCurve ( )

privateslot

Definition at line 229 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_pointSelection.hasSelection()) {
        QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
 
        KUndo2Command *command = createPointToCurveCommand(selectedPoints);
 
        if (command) {
            d->canvas->addCommand(command);
        }
    }
}

References createPointToCurveCommand(), KoPathToolSelection::hasSelection(), m_pointSelection, and KoPathToolSelection::selectedPointsData().

◆ pointToLine

void KoPathTool::pointToLine ( )

privateslot

Definition at line 209 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_pointSelection.hasSelection()) {
        QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
        QList<KoPathPointData> pointToChange;
 
        QList<KoPathPointData>::const_iterator it(selectedPoints.constBegin());
        for (; it != selectedPoints.constEnd(); ++it) {
            KoPathPoint *point = it->pathShape->pointByIndex(it->pointIndex);
            if (point && (point->activeControlPoint1() || point->activeControlPoint2()))
                pointToChange.append(*it);
        }
 
        if (! pointToChange.isEmpty()) {
            d->canvas->addCommand(new KoPathPointTypeCommand(pointToChange, KoPathPointTypeCommand::Line));
        }
    }
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathToolSelection::hasSelection(), KoPathPointTypeCommand::Line, m_pointSelection, and KoPathToolSelection::selectedPointsData().

◆ pointTypeChanged

void KoPathTool::pointTypeChanged ( KoPathPointTypeCommand::PointType type )

privateslot

Definition at line 143 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_pointSelection.hasSelection()) {
        QList<KoPathPointData> selectedPoints = m_pointSelection.selectedPointsData();
 
        KUndo2Command *initialConversionCommand = createPointToCurveCommand(selectedPoints);
 
        // conversion should happen before the c-tor
        // of KoPathPointTypeCommand is executed!
        if (initialConversionCommand) {
            initialConversionCommand->redo();
        }
 
        KUndo2Command *command =
                new KoPathPointTypeCommand(selectedPoints, type);
 
        if (initialConversionCommand) {
            using namespace KisCommandUtils;
            CompositeCommand *parent = new CompositeCommand();
            parent->setText(command->text());
            parent->addCommand(new SkipFirstRedoWrapper(initialConversionCommand));
            parent->addCommand(command);
            command = parent;
        }
 
        d->canvas->addCommand(command);
    }
}

References createPointToCurveCommand(), KoPathToolSelection::hasSelection(), m_pointSelection, KUndo2Command::redo(), KoPathToolSelection::selectedPointsData(), and KUndo2Command::text().

◆ pointTypeChangedCorner

void KoPathTool::pointTypeChangedCorner ( )

privateslot

Definition at line 133 of file KoPathTool.cpp.

                                        {
    pointTypeChanged(KoPathPointTypeCommand::Corner);
}

References KoPathPointTypeCommand::Corner, and pointTypeChanged().

◆ pointTypeChangedSmooth

void KoPathTool::pointTypeChangedSmooth ( )

privateslot

Definition at line 136 of file KoPathTool.cpp.

                                        {
    pointTypeChanged(KoPathPointTypeCommand::Smooth);
}

References pointTypeChanged(), and KoPathPointTypeCommand::Smooth.

◆ pointTypeChangedSymmetric

void KoPathTool::pointTypeChangedSymmetric ( )

privateslot

Definition at line 139 of file KoPathTool.cpp.

                                           {
    pointTypeChanged(KoPathPointTypeCommand::Symmetric);
}

References pointTypeChanged(), and KoPathPointTypeCommand::Symmetric.

◆ popupActionsMenu()

QMenu * KoPathTool::popupActionsMenu ( )

overridevirtual

Returns: a menu with context-aware actions for the current selection. If the returned value is null, no context menu is shown.

Reimplemented from KoToolBase.

Definition at line 1131 of file KoPathTool.cpp.

{
    if (m_activeHandle) {
        m_activeHandle->trySelectHandle();
    }
 
    if (m_activeSegment && m_activeSegment->isValid()) {
        KoPathShape *shape = m_activeSegment->path;
        KoPathSegment segment = shape->segmentByIndex(shape->pathPointIndex(m_activeSegment->segmentStart));
 
        m_pointSelection.add(segment.first(), true);
        m_pointSelection.add(segment.second(), false);
    }
 
    if (m_contextMenu) {
        m_contextMenu->clear();
 
        addActionsGroupIfEnabled(m_contextMenu.data(),
                                 m_actionPathPointCorner,
                                 m_actionPathPointSmooth,
                                 m_actionPathPointSymmetric);
 
        addActionsGroupIfEnabled(m_contextMenu.data(),
                                 m_actionCurvePoint,
                                 m_actionLinePoint);
 
        addActionsGroupIfEnabled(m_contextMenu.data(),
                                 m_actionAddPoint,
                                 m_actionRemovePoint);
 
        addActionsGroupIfEnabled(m_contextMenu.data(),
                                 m_actionLineSegment,
                                 m_actionCurveSegment);
 
        addActionsGroupIfEnabled(m_contextMenu.data(),
                                 m_actionBreakPoint,
                                 m_actionBreakSegment);
 
        addActionsGroupIfEnabled(m_contextMenu.data(),
                                 m_actionJoinSegment,
                                 m_actionMergePoints);
 
        m_contextMenu->addAction(m_actionConvertToPath);
 
        m_contextMenu->addSeparator();
    }
 
    return m_contextMenu.data();
}

References KoPathToolSelection::add(), KoPathSegment::first, m_actionAddPoint, m_actionBreakPoint, m_actionBreakSegment, m_actionConvertToPath, m_actionCurvePoint, m_actionCurveSegment, m_actionJoinSegment, m_actionLinePoint, m_actionLineSegment, m_actionMergePoints, m_actionPathPointCorner, m_actionPathPointSmooth, m_actionPathPointSymmetric, m_actionRemovePoint, m_activeHandle, m_activeSegment, m_contextMenu, m_pointSelection, KoPathShape::pathPointIndex(), KoPathSegment::second, and KoPathShape::segmentByIndex().

◆ removePoints

void KoPathTool::removePoints ( )

privateslot

Definition at line 195 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_pointSelection.size() > 0) {
        KUndo2Command *cmd = KoPathPointRemoveCommand::createCommand(m_pointSelection.selectedPointsData(), d->canvas->shapeController());
        PointHandle *pointHandle = dynamic_cast<PointHandle*>(m_activeHandle.data());
        if (pointHandle && m_pointSelection.contains(pointHandle->activePoint())) {
            m_activeHandle.reset();
        }
        clearActivePointSelectionReferences();
        d->canvas->addCommand(cmd);
    }
}

References PointHandle::activePoint(), clearActivePointSelectionReferences(), KoPathToolSelection::contains(), KoPathPointRemoveCommand::createCommand(), m_activeHandle, m_pointSelection, KoPathToolSelection::selectedPointsData(), and KoPathToolSelection::size().

◆ repaintDecorations()

void KoPathTool::repaintDecorations ( )

overridevirtual

request a repaint of the decorations to be made. This triggers an update call on the canvas, but does not paint directly.

Reimplemented from KoToolBase.

Definition at line 539 of file KoPathTool.cpp.

{
    KoToolBase::repaintDecorations();
    updateOptionsWidget();
}

References KoToolBase::repaintDecorations(), and updateOptionsWidget().

◆ requestStrokeCancellation()

void KoPathTool::requestStrokeCancellation ( )

overridevirtual

Called when the user requested the cancellation of the current stroke. If you tool supports cancelling, override this method and do the needed work there

Reimplemented from KoToolBase.

Definition at line 1196 of file KoPathTool.cpp.

{
    explicitUserStrokeEndRequest();
}

References explicitUserStrokeEndRequest().

◆ requestStrokeEnd()

void KoPathTool::requestStrokeEnd ( )

overridevirtual

Called when the image decided that the stroke should better be ended. If you tool supports long strokes, override this method and do the needed work there

Reimplemented from KoToolBase.

Definition at line 1201 of file KoPathTool.cpp.

{
    // noop!
}

◆ requestUndoDuringStroke()

void KoPathTool::requestUndoDuringStroke ( )

overridevirtual

Called when the user requested undo while the stroke is active. If you tool supports undo of the part of its actions, override this method and do the needed work there.

NOTE: Default implementation forwards this request to requestStrokeCancellation() method, so that the stroke would be cancelled.

Default implementation just cancels the stroke

Reimplemented from KoToolBase.

Definition at line 1191 of file KoPathTool.cpp.

{
    // noop!
}

◆ segmentAtPoint()

KoPathTool::PathSegment * KoPathTool::segmentAtPoint ( const QPointF & point )

private

Definition at line 814 of file KoPathTool.cpp.

{
    // the max allowed distance from a segment
    const QRectF grabRoi = handleGrabRect(point);
    const qreal distanceThreshold = 0.5 * KisAlgebra2D::maxDimension(grabRoi);
 
    QScopedPointer<PathSegment> segment(new PathSegment);
 
    Q_FOREACH (KoPathShape *shape, m_pointSelection.selectedShapes()) {
        KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
        if (parameterShape && parameterShape->isParametricShape())
            continue;
 
        // convert document point to shape coordinates
        const QPointF p = shape->documentToShape(point);
        // our region of interest, i.e. a region around our mouse position
        const QRectF roi = shape->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 = shape->segmentsAt(roi);
 
        foreach (const 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->path = shape;
                segment->segmentStart = s.first();
                segment->positionOnSegment = nearestPointParam;
            }
        }
    }
 
    if (!segment->isValid()) {
        segment.reset();
    }
 
    return segment.take();
}

References distance(), KoShape::documentToShape(), KoPathSegment::first, KoToolBase::handleGrabRect(), KoParameterShape::isParametricShape(), kisDistance(), m_pointSelection, KisAlgebra2D::maxDimension(), KoPathSegment::nearestPoint(), p, KoPathSegment::pointAt(), KoPathShape::segmentsAt(), and KoPathToolSelection::selectedShapes().

◆ segmentToCurve

void KoPathTool::segmentToCurve ( )

privateslot

Definition at line 273 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_pointSelection.size() > 1) {
        QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
        if (segments.size() > 0) {
            d->canvas->addCommand(new KoPathSegmentTypeCommand(segments, KoPathSegmentTypeCommand::Curve));
        }
    }
}

References KoPathSegmentTypeCommand::Curve, m_pointSelection, KoPathToolSelection::selectedSegmentsData(), and KoPathToolSelection::size().

◆ segmentToLine

void KoPathTool::segmentToLine ( )

privateslot

Definition at line 262 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    if (m_pointSelection.size() > 1) {
        QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
        if (segments.size() > 0) {
            d->canvas->addCommand(new KoPathSegmentTypeCommand(segments, KoPathSegmentTypeCommand::Line));
        }
    }
}

References KoPathSegmentTypeCommand::Line, m_pointSelection, KoPathToolSelection::selectedSegmentsData(), and KoPathToolSelection::size().

◆ selectAll()

bool KoPathTool::selectAll ( )

overridevirtual

selectAll select all data the tool can select.

Returns: true if something happened, false if nothing happened.

Reimplemented from KoToolBase.

Definition at line 1211 of file KoPathTool.cpp.

{
    m_pointSelection.selectAll();
    repaintDecorations();
    return true;
}

References m_pointSelection, repaintDecorations(), and KoPathToolSelection::selectAll().

◆ selection()

KoToolSelection * KoPathTool::selection ( )

overridevirtual

Returns the internal selection object of this tool. Each tool can have a selection which is private to that tool and the specified shape that it comes with. The default returns 0.

Reimplemented from KoToolBase.

Definition at line 1186 of file KoPathTool.cpp.

{
    return &m_pointSelection;
}

References m_pointSelection.

◆ singleShapeChanged

void KoPathTool::singleShapeChanged ( KoPathShape * path )

signal

◆ slotSelectionChanged

void KoPathTool::slotSelectionChanged ( )

privateslot

Definition at line 896 of file KoPathTool.cpp.

{
    Q_D(KoToolBase);
    QList<KoShape*> shapes =
            d->canvas->selectedShapesProxy()->selection()->selectedEditableShapesAndDelegates();
 
    initializeWithShapes(shapes);
}

References initializeWithShapes().

◆ typeChanged

void KoPathTool::typeChanged ( int types )

signal

◆ updateActions

void KoPathTool::updateActions ( )

privateslot

Definition at line 958 of file KoPathTool.cpp.

{
    QList<KoPathPointData> pointData = m_pointSelection.selectedPointsData();
 
    bool canBreakAtPoint = false;
 
    bool hasNonSmoothPoints = false;
    bool hasNonSymmetricPoints = false;
    bool hasNonSplitPoints = false;
 
    bool hasNonLinePoints = false;
    bool hasNonCurvePoints = false;
 
    bool canJoinSubpaths = false;
 
    if (!pointData.isEmpty()) {
        Q_FOREACH (const KoPathPointData &pd, pointData) {
            const int subpathIndex = pd.pointIndex.first;
            const int pointIndex = pd.pointIndex.second;
 
            canBreakAtPoint |= pd.pathShape->isClosedSubpath(subpathIndex) ||
                    (pointIndex > 0 && pointIndex < pd.pathShape->subpathPointCount(subpathIndex) - 1);
 
            KoPathPoint *point = pd.pathShape->pointByIndex(pd.pointIndex);
 
            hasNonSmoothPoints |= !(point->properties() & KoPathPoint::IsSmooth);
            hasNonSymmetricPoints |= !(point->properties() & KoPathPoint::IsSymmetric);
            hasNonSplitPoints |=
                    point->properties() & KoPathPoint::IsSymmetric ||
                    point->properties() & KoPathPoint::IsSmooth;
 
            hasNonLinePoints |= point->activeControlPoint1() || point->activeControlPoint2();
            hasNonCurvePoints |= !point->activeControlPoint1() && !point->activeControlPoint2();
        }
 
        if (pointData.size() == 2) {
            const KoPathPointData & pd1 = pointData.at(0);
            const KoPathPointData & pd2 = pointData.at(1);
 
            canJoinSubpaths = checkCanJoinToPoints(pd1, pd2);
        }
    }
 
    m_actionPathPointCorner->setEnabled(hasNonSplitPoints);
    m_actionPathPointSmooth->setEnabled(hasNonSmoothPoints);
    m_actionPathPointSymmetric->setEnabled(hasNonSymmetricPoints);
 
    m_actionRemovePoint->setEnabled(!pointData.isEmpty());
 
    m_actionBreakPoint->setEnabled(canBreakAtPoint);
 
    m_actionCurvePoint->setEnabled(hasNonCurvePoints);
    m_actionLinePoint->setEnabled(hasNonLinePoints);
 
    m_actionJoinSegment->setEnabled(canJoinSubpaths);
    m_actionMergePoints->setEnabled(canJoinSubpaths);
 
    QList<KoPathPointData> segments(m_pointSelection.selectedSegmentsData());
 
 
    bool canSplitAtSegment = false;
    bool canConvertSegmentToLine = false;
    bool canConvertSegmentToCurve= false;
 
    if (!segments.isEmpty()) {
 
        canSplitAtSegment = segments.size() == 1;
 
        bool hasLines = false;
        bool hasCurves = false;
 
        Q_FOREACH (const KoPathPointData &pd, segments) {
            KoPathSegment segment = pd.pathShape->segmentByIndex(pd.pointIndex);
            hasLines |= segment.degree() == 1;
            hasCurves |= segment.degree() > 1;
        }
 
        canConvertSegmentToLine = !segments.isEmpty() && hasCurves;
        canConvertSegmentToCurve= !segments.isEmpty() && hasLines;
    }
 
    m_actionAddPoint->setEnabled(canSplitAtSegment);
 
    m_actionLineSegment->setEnabled(canConvertSegmentToLine);
    m_actionCurveSegment->setEnabled(canConvertSegmentToCurve);
 
    m_actionBreakSegment->setEnabled(canSplitAtSegment);
    m_actionBreakSelection->setEnabled(canSplitAtSegment | canBreakAtPoint);
 
    KoSelection *selection = canvas()->selectedShapesProxy()->selection();
    bool haveConvertibleShapes = false;
    Q_FOREACH (KoShape *shape, selection->selectedEditableShapes()) {
        KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
        KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
        if (textShape ||
                (parameterShape && parameterShape->isParametricShape())) {
 
            haveConvertibleShapes = true;
            break;
        }
    }
    m_actionConvertToPath->setEnabled(haveConvertibleShapes);
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoToolBase::canvas(), KoPathSegment::degree(), KoPathShape::isClosedSubpath(), KoParameterShape::isParametricShape(), KoPathPoint::IsSmooth, KoPathPoint::IsSymmetric, m_actionAddPoint, m_actionBreakPoint, m_actionBreakSegment, m_actionBreakSelection, m_actionConvertToPath, m_actionCurvePoint, m_actionCurveSegment, m_actionJoinSegment, m_actionLinePoint, m_actionLineSegment, m_actionMergePoints, m_actionPathPointCorner, m_actionPathPointSmooth, m_actionPathPointSymmetric, m_actionRemovePoint, m_pointSelection, KoPathPointData::pathShape, KoPathShape::pointByIndex(), KoPathPointData::pointIndex, KoPathPoint::properties, KoPathShape::segmentByIndex(), KoPathToolSelection::selectedPointsData(), KoPathToolSelection::selectedSegmentsData(), KoCanvasBase::selectedShapesProxy(), selection(), KoSelectedShapesProxy::selection(), and KoPathShape::subpathPointCount().

◆ updateOptionsWidget()

void KoPathTool::updateOptionsWidget ( )

private

Definition at line 944 of file KoPathTool.cpp.

{
    PathToolOptionWidget::Types type;
    QList<KoPathShape*> selectedShapes = m_pointSelection.selectedShapes();
    Q_FOREACH (KoPathShape *shape, selectedShapes) {
        KoParameterShape * parameterShape = dynamic_cast<KoParameterShape*>(shape);
        type |= parameterShape && parameterShape->isParametricShape() ?
                    PathToolOptionWidget::ParametricShape : PathToolOptionWidget::PlainPath;
    }
 
    Q_EMIT singleShapeChanged(selectedShapes.size() == 1 ? selectedShapes.first() : 0);
    Q_EMIT typeChanged(type);
}

References KoParameterShape::isParametricShape(), m_pointSelection, PathToolOptionWidget::ParametricShape, PathToolOptionWidget::PlainPath, KoPathToolSelection::selectedShapes(), singleShapeChanged(), and typeChanged().

Friends And Related Symbol Documentation

◆ TestPathTool

friend class TestPathTool

friend

Definition at line 122 of file KoPathTool.h.

Member Data Documentation

◆ m_actionAddPoint

QAction* KoPathTool::m_actionAddPoint

private

Definition at line 133 of file KoPathTool.h.

◆ m_actionBreakPoint

QAction* KoPathTool::m_actionBreakPoint

private

Definition at line 135 of file KoPathTool.h.

◆ m_actionBreakSegment

QAction* KoPathTool::m_actionBreakSegment

private

Definition at line 136 of file KoPathTool.h.

◆ m_actionBreakSelection

QAction* KoPathTool::m_actionBreakSelection

private

Definition at line 137 of file KoPathTool.h.

◆ m_actionConvertToPath

QAction* KoPathTool::m_actionConvertToPath

private

Definition at line 140 of file KoPathTool.h.

◆ m_actionCurvePoint

QAction* KoPathTool::m_actionCurvePoint

private

Definition at line 129 of file KoPathTool.h.

◆ m_actionCurveSegment

QAction* KoPathTool::m_actionCurveSegment

private

Definition at line 132 of file KoPathTool.h.

◆ m_actionJoinSegment

QAction* KoPathTool::m_actionJoinSegment

private

Definition at line 138 of file KoPathTool.h.

◆ m_actionLinePoint

QAction* KoPathTool::m_actionLinePoint

private

Definition at line 130 of file KoPathTool.h.

◆ m_actionLineSegment

QAction* KoPathTool::m_actionLineSegment

private

Definition at line 131 of file KoPathTool.h.

◆ m_actionMergePoints

QAction* KoPathTool::m_actionMergePoints

private

Definition at line 139 of file KoPathTool.h.

◆ m_actionPathPointCorner

QAction* KoPathTool::m_actionPathPointCorner

private

Definition at line 126 of file KoPathTool.h.

◆ m_actionPathPointSmooth

QAction* KoPathTool::m_actionPathPointSmooth

private

Definition at line 127 of file KoPathTool.h.

◆ m_actionPathPointSymmetric

QAction* KoPathTool::m_actionPathPointSymmetric

private

Definition at line 128 of file KoPathTool.h.

◆ m_actionRemovePoint

QAction* KoPathTool::m_actionRemovePoint

private

Definition at line 134 of file KoPathTool.h.

◆ m_activeHandle

QScopedPointer<KoPathToolHandle> KoPathTool::m_activeHandle

private

the currently active handle

Definition at line 117 of file KoPathTool.h.

◆ m_activeSegment

QScopedPointer<PathSegment> KoPathTool::m_activeSegment

private

Definition at line 119 of file KoPathTool.h.

◆ m_canvasConnections

KisSignalAutoConnectionsStore KoPathTool::m_canvasConnections

private

Definition at line 143 of file KoPathTool.h.

◆ m_contextMenu

QScopedPointer<QMenu> KoPathTool::m_contextMenu

private

Definition at line 142 of file KoPathTool.h.

◆ m_currentStrategy

QScopedPointer<KoInteractionStrategy> KoPathTool::m_currentStrategy

private

the rubber selection strategy

Definition at line 124 of file KoPathTool.h.

◆ m_lastPoint

QPointF KoPathTool::m_lastPoint

private

needed for interaction strategy

Definition at line 118 of file KoPathTool.h.

◆ m_moveCursor

QCursor KoPathTool::m_moveCursor

private

Definition at line 141 of file KoPathTool.h.

◆ m_pointSelection

KoPathToolSelection KoPathTool::m_pointSelection

protected

the point selection

Definition at line 113 of file KoPathTool.h.

◆ m_selectCursor

QCursor KoPathTool::m_selectCursor

protected

Definition at line 114 of file KoPathTool.h.

◆ m_shapeFillResourceConnector

KoShapeFillResourceConnector KoPathTool::m_shapeFillResourceConnector

private

Definition at line 144 of file KoPathTool.h.

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

libs/flake/tools/KoPathTool.h
libs/flake/tools/KoPathTool.cpp

Classes

Public Slots

Signals

Public Member Functions

Protected Member Functions

Protected Attributes

Private Slots

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ KoPathTool()

◆ ~KoPathTool()

Member Function Documentation

◆ activate()

◆ breakAtPoint

◆ breakAtSegment

◆ breakAtSelection

◆ canvasResourceChanged

◆ clearActivePointSelectionReferences()

◆ convertToPath

◆ createOptionWidgets()

◆ createPointToCurveCommand()

◆ deactivate()

◆ decorationsRect()

◆ deleteSelection()

◆ deselect()

◆ explicitUserStrokeEndRequest()

◆ initializeWithShapes()

◆ insertPoints

◆ joinPoints

◆ keyPressEvent()

◆ keyReleaseEvent()

◆ mergePoints

◆ mergePointsImpl()

◆ mouseDoubleClickEvent()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ notifyPathPointsChanged()

◆ paint()

◆ pointSelectionChanged

◆ pointToCurve

◆ pointToLine

◆ pointTypeChanged

◆ pointTypeChangedCorner

◆ pointTypeChangedSmooth

◆ pointTypeChangedSymmetric

◆ popupActionsMenu()

◆ removePoints

◆ repaintDecorations()

◆ requestStrokeCancellation()

◆ requestStrokeEnd()

◆ requestUndoDuringStroke()

◆ segmentAtPoint()

◆ segmentToCurve

◆ segmentToLine

◆ selectAll()

◆ selection()

◆ singleShapeChanged

◆ slotSelectionChanged

◆ typeChanged

◆ updateActions

◆ updateOptionsWidget()

Friends And Related Symbol Documentation

◆ TestPathTool

Member Data Documentation

◆ m_actionAddPoint

◆ m_actionBreakPoint

◆ m_actionBreakSegment

◆ m_actionBreakSelection

◆ m_actionConvertToPath

◆ m_actionCurvePoint

◆ m_actionCurveSegment

◆ m_actionJoinSegment

◆ m_actionLinePoint

◆ m_actionLineSegment

◆ m_actionMergePoints

◆ m_actionPathPointCorner