KoCreatePathTool Class Reference

#include <KoCreatePathTool.h>

Inheritance diagram for KoCreatePathTool:

Public Slots
void	activate (const QSet< KoShape * > &shapes) override
	reimplemented
void	canvasResourceChanged (int key, const QVariant &res) override
	reimplemented
void	deactivate () override
	reimplemented
Public Slots inherited from KoToolBase
virtual void	activate (const QSet< KoShape * > &shapes)
virtual void	canvasResourceChanged (int key, const QVariant &res)
virtual void	deactivate ()
virtual void	documentResourceChanged (int key, const QVariant &res)
virtual void	repaintDecorations ()
virtual void	requestRedoDuringStroke ()
virtual void	requestStrokeCancellation ()
virtual void	requestStrokeEnd ()
virtual void	requestUndoDuringStroke ()
void	setStatusText (const QString &statusText)
void	updateOptionsWidgetIcons ()

Signals
void	sigUpdateAutoSmoothCurvesGUI (bool value)
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
QRectF	decorationsRect () const override
	KoCreatePathTool (KoCanvasBase *canvas)
void	mouseDoubleClickEvent (KoPointerEvent *event) override
	reimplemented
void	mouseMoveEvent (KoPointerEvent *event) override
	reimplemented
void	mousePressEvent (KoPointerEvent *event) override
	reimplemented
void	mouseReleaseEvent (KoPointerEvent *event) override
	reimplemented
void	paint (QPainter &painter, const KoViewConverter &converter) override
	reimplemented
bool	pathStarted () const
void	setEnableClosePathShortcut (bool value)
bool	tryMergeInPathShape (KoPathShape *pathShape)
	~KoCreatePathTool () 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	deleteSelection ()
virtual void	deselect ()
	deselect the tool should clear the selection if it has one.
virtual void	dragLeaveEvent (QDragLeaveEvent *event)
virtual void	dragMoveEvent (QDragMoveEvent *event, const QPointF &point)
virtual void	dropEvent (QDropEvent *event, const QPointF &point)
virtual void	explicitUserStrokeEndRequest ()
	explicitUserStrokeEndRequest is called by the input manager when the user presses the Enter key or any equivalent key. This callback comes before requestStrokeEnd(), which comes from a different source.
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
virtual void	keyPressEvent (QKeyEvent *event)
virtual void	keyReleaseEvent (QKeyEvent *event)
	KoToolBase (KoCanvasBase *canvas)
bool	maskSyntheticEvents () const
virtual void	mouseTripleClickEvent (KoPointerEvent *event)
QList< QPointer< QWidget > >	optionWidgets ()
virtual bool	paste ()
virtual QMenu *	popupActionsMenu ()
virtual KisPopupWidgetInterface *	popupWidget ()
virtual bool	selectAll ()
	selectAll select all data the tool can select.
virtual KoToolSelection *	selection ()
Q_INVOKABLE QString	toolId () const
virtual bool	wantsAutoScroll () const
	~KoToolBase () override

Protected Member Functions
virtual void	addPathShape (KoPathShape *pathShape)
bool	addPathShapeImpl (KoPathShape *pathShape, bool tryMergeOnly)
virtual void	beginShape ()
void	cancelPath ()
QList< QPointer< QWidget > >	createOptionWidgets () override
	reimplemented
void	endPath ()
void	endPathWithoutLastPoint ()
virtual void	endShape ()
void	handleMouseMove (const KoPointerEvent *event, bool considerDrag)
virtual void	paintPath (KoPathShape &pathShape, QPainter &painter, const KoViewConverter &converter)
void	removeLastPoint ()
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)

Private Member Functions
void	angleSnapChanged (int)) Q_PRIVATE_SLOT(d_func()
	Q_PRIVATE_SLOT (d_func(), void angleDeltaChanged(qreal)) Q_PRIVATE_SLOT(d_func()

Additional Inherited Members
Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Detailed Description

Tool for creating path shapes.

Definition at line 28 of file KoCreatePathTool.h.

Constructor & Destructor Documentation

KoCreatePathTool()

KoCreatePathTool::KoCreatePathTool ( KoCanvasBase * canvas )

explicit

Constructor for the tool that allows you to create new paths by hand.

Parameters

canvas

the canvas this tool will be working for.

Definition at line 35 of file KoCreatePathTool.cpp.

    : KoToolBase(*(new KoCreatePathToolPrivate(this, canvas)))
{
}

~KoCreatePathTool()

KoCreatePathTool::~KoCreatePathTool ( )

override

Definition at line 40 of file KoCreatePathTool.cpp.

{
}

Member Function Documentation

activate

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

overrideslot

reimplemented

Definition at line 455 of file KoCreatePathTool.cpp.

{
    KoToolBase::activate(shapes);
 
    Q_D(KoCreatePathTool);
    useCursor(Qt::ArrowCursor);
 
    // retrieve the actual global handle radius
    d->handleRadius = handleRadius();
    d->decorationThickness = decorationThickness();
    d->loadAutoSmoothValueFromConfig();
 
    // reset snap guide
    canvas()->snapGuide()->reset();
    repaintDecorations();
}

References KoToolBase::activate(), KoToolBase::canvas(), KoToolBase::decorationThickness(), KoToolBase::handleRadius(), KoToolBase::repaintDecorations(), KoSnapGuide::reset(), KoCanvasBase::snapGuide, and KoToolBase::useCursor().

addPathShape()

void KoCreatePathTool::addPathShape ( KoPathShape * pathShape )

protectedvirtual

Add path shape to document. This method can be overridden and change the behaviour of the tool. In that case the subclass takes ownership of pathShape. It gets only called if there are two or more points in the path.

Reimplemented in __KisToolPathLocalTool, __KisToolSelectPathLocalTool, and KisToolPathLocalTool.

Definition at line 553 of file KoCreatePathTool.cpp.

{
    addPathShapeImpl(pathShape, false);
}

References addPathShapeImpl().

addPathShapeImpl()

bool KoCreatePathTool::addPathShapeImpl ( KoPathShape * pathShape, bool tryMergeOnly )

protected

Definition at line 496 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    KoPathShape *startShape = 0;
    KoPathShape *endShape = 0;
    pathShape->normalize();
 
    // check if existing start/end points are still valid
    d->existingStartPoint.validate(canvas());
    d->existingEndPoint.validate(canvas());
 
    if (d->connectPaths(pathShape, d->existingStartPoint, d->existingEndPoint)) {
        if (d->existingStartPoint.isValid()) {
            startShape = d->existingStartPoint.path;
        }
        if (d->existingEndPoint.isValid() && d->existingEndPoint != d->existingStartPoint) {
            endShape = d->existingEndPoint.path;
        }
    }
 
    if (tryMergeOnly && !startShape && !endShape) {
        return false;
    }
 
    KUndo2Command *cmd = canvas()->shapeController()->addShape(pathShape, 0);
    KIS_SAFE_ASSERT_RECOVER(cmd) {
        canvas()->updateCanvas(pathShape->boundingRect());
        delete pathShape;
        return true;
    }
 
    KoSelection *selection = canvas()->shapeManager()->selection();
    selection->deselectAll();
    selection->select(pathShape);
 
    if (startShape) {
        pathShape->setBackground(startShape->background());
        pathShape->setStroke(startShape->stroke());
    } else if (endShape) {
        pathShape->setBackground(endShape->background());
        pathShape->setStroke(endShape->stroke());
    }
 
 
    if (startShape) {
        canvas()->shapeController()->removeShape(startShape, cmd);
    }
    if (endShape && startShape != endShape) {
        canvas()->shapeController()->removeShape(endShape, cmd);
    }
    canvas()->addCommand(cmd);
 
    return true;
}

References KoCanvasBase::addCommand(), KoShape::background(), KoPathShape::boundingRect(), KoToolBase::canvas(), endShape(), KIS_SAFE_ASSERT_RECOVER, KoPathShape::normalize(), KoShapeManager::selection, KoToolBase::selection(), KoShape::setBackground(), KoShape::setStroke(), KoCanvasBase::shapeController, KoCanvasBase::shapeManager(), KoShape::stroke(), and KoCanvasBase::updateCanvas().

angleSnapChanged()

void KoCreatePathTool::angleSnapChanged ( int )

private

beginShape()

virtual void KoCreatePathTool::beginShape ( )

inlineprotectedvirtual

Use these methods in subclassed to notify when the user starts and finishes making a shape, and override to be notified

Reimplemented in __KisToolSelectPathLocalTool, and KisToolPathLocalTool.

Definition at line 85 of file KoCreatePathTool.h.

{}

cancelPath()

void KoCreatePathTool::cancelPath ( )

protected

Definition at line 423 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    if (!d->shape) {
        return;
    }
    d->firstPoint = 0;
    d->activePoint = 0;
    d->cleanUp();
    repaintDecorations();
    endShape();
}

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

canvasResourceChanged

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

overrideslot

reimplemented

Definition at line 478 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    switch (key) {
    case KoCanvasResource::HandleRadius: {
        d->handleRadius = res.toUInt();
    }
    break;
    case KoCanvasResource::DecorationThickness: {
        d->decorationThickness = res.toUInt();
    }
    break;
    default:
        return;
    }
}

References KoCanvasResource::DecorationThickness, and KoCanvasResource::HandleRadius.

createOptionWidgets()

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

overrideprotectedvirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 558 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    QList<QPointer<QWidget> > list;
 
    QWidget *widget = new QWidget();
    widget->setObjectName("bezier-curve-tool-widget");
    widget->setWindowTitle(i18n("Path options"));
 
    QCheckBox *smoothCurves = new QCheckBox(i18n("Autosmooth curve"), widget);
    smoothCurves->setObjectName("smooth-curves-widget");
    smoothCurves->setChecked(d->autoSmoothCurves);
 
    QCheckBox *angleSnap = new QCheckBox(i18n("Activate angle snap"), widget);
    angleSnap->setObjectName("angle-snap-widget");
    angleSnap->setChecked(false);
    angleSnap->setCheckable(true);
 
    KisAngleSelector *angleEdit = new KisAngleSelector(widget);
    angleEdit->setObjectName("angle-edit-widget");
    angleEdit->setAngle(d->angleSnappingDelta);
    angleEdit->setRange(1, 360);
    angleEdit->setDecimals(0);
    angleEdit->setFlipOptionsMode(KisAngleSelector::FlipOptionsMode_MenuButton);
    angleEdit->setEnabled(angleSnap->isChecked());
 
    QHBoxLayout *angleEditLayout = new QHBoxLayout;
    angleEditLayout->setContentsMargins(10, 0, 0, 0);
    angleEditLayout->setSpacing(0);
    angleEditLayout->addWidget(angleEdit);
 
    QVBoxLayout *mainLayout = new QVBoxLayout;
    mainLayout->setContentsMargins(0, 0, 0, 0);
    mainLayout->setSpacing(5);
 
    mainLayout->addWidget(smoothCurves);
    mainLayout->addWidget(angleSnap);
    mainLayout->addLayout(angleEditLayout);
 
    widget->setLayout(mainLayout);
 
    list.append(widget);
 
    connect(smoothCurves,
            SIGNAL(toggled(bool)),
            this,
            SLOT(autoSmoothCurvesChanged(bool)));
    connect(this,
            SIGNAL(sigUpdateAutoSmoothCurvesGUI(bool)),
            smoothCurves,
            SLOT(setChecked(bool)));
    connect(angleEdit, SIGNAL(angleChanged(qreal)), this, SLOT(angleDeltaChanged(qreal)));
    connect(angleSnap, SIGNAL(stateChanged(int)), this, SLOT(angleSnapChanged(int)));
    connect(angleSnap,
            SIGNAL(toggled(bool)),
            angleEdit,
            SLOT(setEnabled(bool)));
 
    return list;
}

References angleSnapChanged(), KisAngleSelector::FlipOptionsMode_MenuButton, KisAngleSelector::setAngle(), KisAngleSelector::setDecimals(), KisAngleSelector::setFlipOptionsMode(), KisAngleSelector::setRange(), and sigUpdateAutoSmoothCurvesGUI().

deactivate

void KoCreatePathTool::deactivate ( )

overrideslot

reimplemented

Definition at line 472 of file KoCreatePathTool.cpp.

{
    cancelPath();
    KoToolBase::deactivate();
}

References cancelPath(), and KoToolBase::deactivate().

decorationsRect()

QRectF KoCreatePathTool::decorationsRect ( ) const

overridevirtual

Reimplemented from KoToolBase.

Definition at line 44 of file KoCreatePathTool.cpp.

{
    Q_D(const KoCreatePathTool);
 
    QRectF dirtyRect;
 
    if (pathStarted()) {
        dirtyRect |= kisGrowRect(d->shape->boundingRect(), handleDocRadius());
    }
 
    if (d->hoveredPoint) {
        dirtyRect |= kisGrowRect(d->hoveredPoint->boundingRect(false), handleDocRadius());
    }
 
    if (d->activePoint) {
        dirtyRect |= kisGrowRect(d->activePoint->boundingRect(false), handleDocRadius());
 
        if (d->pointIsDragged) {
            // the path is not closed, therefore the point is not marked as
            // active inside the path itself
            dirtyRect |= handlePaintRect(
                        d->activePoint->parent()->shapeToDocument(
                            d->activePoint->controlPoint2()));
        }
 
    }
 
    if (canvas()->snapGuide()->isSnapping()) {
        dirtyRect |= canvas()->snapGuide()->boundingRect();
    }
 
    return dirtyRect;
}

References KoSnapGuide::boundingRect(), KoToolBase::canvas(), KoToolBase::handleDocRadius(), KoToolBase::handlePaintRect(), kisGrowRect(), pathStarted(), and KoCanvasBase::snapGuide.

endPath()

void KoCreatePathTool::endPath ( )

protected

Definition at line 397 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    if (!d->shape) {
        return;
    }
    d->addPathShape();
    repaintDecorations();
    endShape();
}

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

endPathWithoutLastPoint()

void KoCreatePathTool::endPathWithoutLastPoint ( )

protected

Definition at line 409 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    if (!d->shape) {
        return;
    }
    delete d->shape->removePoint(d->shape->pathPointIndex(d->activePoint));
    d->addPathShape();
 
    repaintDecorations();
    endShape();
}

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

endShape()

virtual void KoCreatePathTool::endShape ( )

inlineprotectedvirtual

Reimplemented in __KisToolSelectPathLocalTool, and KisToolPathLocalTool.

Definition at line 86 of file KoCreatePathTool.h.

{}

handleMouseMove()

void KoCreatePathTool::handleMouseMove ( const KoPointerEvent * event, bool considerDrag )

protected

Definition at line 280 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    d->hoveredPoint = d->endPointAtPosition(event->point);
 
    if (!pathStarted()) {
        canvas()->snapGuide()->snap(event->point, event->modifiers());
        repaintDecorations();
 
        d->mouseOverFirstPoint = false;
        return;
    }
 
    d->mouseOverFirstPoint = handleGrabRect(d->firstPoint->point()).contains(event->point);
 
    QPointF snappedPosition = canvas()->snapGuide()->snap(event->point, event->modifiers());
 
    if (considerDrag && (event->buttons() & Qt::LeftButton)) {
        if (d->pointIsDragged ||
            !handleGrabRect(d->dragStartPoint).contains(event->point)) {
 
            d->pointIsDragged = true;
            QPointF offset = snappedPosition - d->activePoint->point();
            d->activePoint->setControlPoint2(d->activePoint->point() + offset);
            // pressing <alt> stops controls points moving symmetrically
            if ((event->modifiers() & Qt::AltModifier) == 0) {
                d->activePoint->setControlPoint1(d->activePoint->point() - offset);
            }
        }
    } else {
        d->activePoint->setPoint(snappedPosition);
 
        if (!d->prevPointWasDragged && d->autoSmoothCurves) {
            KoPathPointIndex index = d->shape->pathPointIndex(d->activePoint);
            if (index.second > 0) {
 
                KoPathPointIndex prevIndex(index.first, index.second - 1);
                KoPathPoint *prevPoint = d->shape->pointByIndex(prevIndex);
 
                if (prevPoint) {
                    KoPathPoint *prevPrevPoint = 0;
 
                    if (index.second > 1) {
                        KoPathPointIndex prevPrevIndex(index.first, index.second - 2);
                        prevPrevPoint = d->shape->pointByIndex(prevPrevIndex);
                    }
 
                    if (prevPrevPoint) {
                        const QPointF control1 = prevPoint->point() + 0.3 * (prevPrevPoint->point() - prevPoint->point());
                        prevPoint->setControlPoint1(control1);
                    }
 
                    const QPointF control2 = prevPoint->point() + 0.3 * (d->activePoint->point() - prevPoint->point());
                    prevPoint->setControlPoint2(control2);
 
                    const QPointF activeControl = d->activePoint->point() + 0.3 * (prevPoint->point() - d->activePoint->point());
                    d->activePoint->setControlPoint1(activeControl);
 
                    KoPathPointTypeCommand::makeCubicPointSmooth(prevPoint);
                }
            }
        }
 
    }
 
    repaintDecorations();
}

References KoPointerEvent::buttons(), KoToolBase::canvas(), KoToolBase::handleGrabRect(), KoPathPointTypeCommand::makeCubicPointSmooth(), KoPointerEvent::modifiers(), pathStarted(), KoPathPoint::point, KoPointerEvent::point, KoToolBase::repaintDecorations(), KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), KoSnapGuide::snap(), and KoCanvasBase::snapGuide.

mouseDoubleClickEvent()

void KoCreatePathTool::mouseDoubleClickEvent ( KoPointerEvent * event )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 267 of file KoCreatePathTool.cpp.

{
    //remove handle
    canvas()->updateCanvas(handlePaintRect(event->point));
 
    endPathWithoutLastPoint();
}

References KoToolBase::canvas(), endPathWithoutLastPoint(), KoToolBase::handlePaintRect(), KoPointerEvent::point, and KoCanvasBase::updateCanvas().

mouseMoveEvent()

void KoCreatePathTool::mouseMoveEvent ( KoPointerEvent * event )

overridevirtual

reimplemented

Implements KoToolBase.

Definition at line 275 of file KoCreatePathTool.cpp.

{
    handleMouseMove(event, true);
}

References handleMouseMove().

mousePressEvent()

void KoCreatePathTool::mousePressEvent ( KoPointerEvent * event )

overridevirtual

reimplemented

Implements KoToolBase.

Definition at line 145 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    // When using touch drawing, we only ever receive move events after the
    // finger has pressed down. We have to issue an artificial move here so that
    // the tool's state is updated properly to handle the press.
    if (event->isTouchEvent()) {
        handleMouseMove(event, false);
    }
 
    //Right click removes last point
    if (event->button() == Qt::RightButton) {
        removeLastPoint();
        return;
    }
 
    const bool isOverFirstPoint = d->shape &&
            handleGrabRect(d->firstPoint->point()).contains(event->point);
 
    const bool haveCloseModifier = d->enableClosePathShortcut
            && d->shape
            && d->shape->pointCount() > 2
            && (event->modifiers() & Qt::ShiftModifier);
 
    if ((event->button() == Qt::LeftButton) && haveCloseModifier && !isOverFirstPoint) {
        endPathWithoutLastPoint();
        return;
    }
 
    d->finishAfterThisPoint = false;
 
    if (d->shape && pathStarted()) {
        if (isOverFirstPoint) {
            d->activePoint->setPoint(d->firstPoint->point());
            canvas()->updateCanvas(d->shape->boundingRect());
            canvas()->updateCanvas(canvas()->snapGuide()->boundingRect());
 
            if (haveCloseModifier) {
                d->shape->closeMerge();
                // we are closing the path, so reset the existing start path point
                d->existingStartPoint = 0;
                // finish path
                endPath();
            } else {
                // the path shape will get closed when the user releases
                // the mouse button
                d->finishAfterThisPoint = true;
                repaintDecorations();
            }
        } else {
            QPointF point = canvas()->snapGuide()->snap(event->point, event->modifiers());
 
            // check whether we hit an start/end node of an existing path
            d->existingEndPoint = d->endPointAtPosition(point);
            if (d->existingEndPoint.isValid() && d->existingEndPoint != d->existingStartPoint) {
                point = d->existingEndPoint.path->shapeToDocument(d->existingEndPoint.point->point());
                d->activePoint->setPoint(point);
                // finish path
                endPath();
            } else {
                d->activePoint->setPoint(point);
                repaintDecorations();
            }
        }
    } else {
        beginShape();
 
        KoPathShape *pathShape = new KoPathShape();
        d->shape = pathShape;
        pathShape->setShapeId(KoPathShapeId);
 
        KoShapeStrokeSP stroke(new KoShapeStroke());
        const qreal size = canvas()->resourceManager()->resource(KoCanvasResource::Size).toReal();
 
        stroke->setLineWidth(canvas()->unit().fromUserValue(size));
        stroke->setColor(canvas()->resourceManager()->foregroundColor().toQColor());
 
        pathShape->setStroke(stroke);
        QPointF point = canvas()->snapGuide()->snap(event->point, event->modifiers());
 
        // check whether we hit an start/end node of an existing path
        d->existingStartPoint = d->endPointAtPosition(point);
 
        if (d->existingStartPoint.isValid()) {
            point = d->existingStartPoint.path->shapeToDocument(d->existingStartPoint.point->point());
        }
 
        d->activePoint = pathShape->moveTo(point);
        d->firstPoint = d->activePoint;
 
        canvas()->snapGuide()->setAdditionalEditedShape(pathShape);
 
        d->angleSnapStrategy = new AngleSnapStrategy(d->angleSnappingDelta, d->angleSnapStatus);
        canvas()->snapGuide()->addCustomSnapStrategy(d->angleSnapStrategy);
 
        repaintDecorations();
    }
 
    d->dragStartPoint = event->point;
 
    if (d->angleSnapStrategy)
        d->angleSnapStrategy->setStartPoint(d->activePoint->point());
}

References KoSnapGuide::addCustomSnapStrategy(), beginShape(), KoPointerEvent::button(), KoToolBase::canvas(), endPath(), endPathWithoutLastPoint(), KoToolBase::handleGrabRect(), handleMouseMove(), KoPointerEvent::isTouchEvent(), KoPathShapeId, KoPointerEvent::modifiers(), KoPathShape::moveTo(), pathStarted(), KoPointerEvent::point, removeLastPoint(), KoToolBase::repaintDecorations(), KoCanvasBase::resourceManager, KoSnapGuide::setAdditionalEditedShape(), KoShape::setShapeId(), KoShape::setStroke(), KoCanvasResource::Size, KoSnapGuide::snap(), KoCanvasBase::snapGuide, and KoCanvasBase::updateCanvas().

mouseReleaseEvent()

void KoCreatePathTool::mouseReleaseEvent ( KoPointerEvent * event )

overridevirtual

reimplemented

Implements KoToolBase.

Definition at line 349 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    if (! d->shape || (event->buttons() & Qt::RightButton)) return;
 
    d->prevPointWasDragged  = d->pointIsDragged;
    d->pointIsDragged = false;
    KoPathPoint *lastActivePoint = d->activePoint;
 
    if (!d->finishAfterThisPoint) {
        d->activePoint = d->shape->lineTo(event->point);
        canvas()->snapGuide()->setIgnoredPathPoints((QList<KoPathPoint*>() << d->activePoint));
    }
 
    // apply symmetric point property if applicable
    if (lastActivePoint->activeControlPoint1() && lastActivePoint->activeControlPoint2()) {
        QPointF diff1 = lastActivePoint->point() - lastActivePoint->controlPoint1();
        QPointF diff2 = lastActivePoint->controlPoint2() - lastActivePoint->point();
        if (qFuzzyCompare(diff1.x(), diff2.x()) && qFuzzyCompare(diff1.y(), diff2.y()))
            lastActivePoint->setProperty(KoPathPoint::IsSymmetric);
    }
 
    if (d->finishAfterThisPoint) {
 
        d->firstPoint->setControlPoint1(d->activePoint->controlPoint1());
        delete d->shape->removePoint(d->shape->pathPointIndex(d->activePoint));
        d->activePoint = d->firstPoint;
 
        if (!d->prevPointWasDragged && d->autoSmoothCurves) {
            KoPathPointTypeCommand::makeCubicPointSmooth(d->activePoint);
        }
 
        d->shape->closeMerge();
 
        // we are closing the path, so reset the existing start path point
        d->existingStartPoint = 0;
        // finish path
        endPath();
    }
 
    if (d->angleSnapStrategy && lastActivePoint->activeControlPoint2()) {
        d->angleSnapStrategy->deactivate();
    }
 
    repaintDecorations();
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPointerEvent::buttons(), KoToolBase::canvas(), KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, endPath(), KoPathPoint::IsSymmetric, KoPathPointTypeCommand::makeCubicPointSmooth(), KoPathPoint::point, KoPointerEvent::point, qFuzzyCompare(), KoToolBase::repaintDecorations(), KoSnapGuide::setIgnoredPathPoints(), KoPathPoint::setProperty(), and KoCanvasBase::snapGuide.

paint()

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

overridevirtual

reimplemented

Implements KoToolBase.

Definition at line 78 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    KisHandlePalette palette = canvas()->displayRendererInterface()->handlePaletteForDisplayColorSpace();
 
    if (pathStarted()) {
 
        painter.save();
        paintPath(*(d->shape), painter, converter);
        painter.restore();
 
        KisHandlePainterHelper helper =
            KoShape::createHandlePainterHelperView(&painter, d->shape, converter, d->handleRadius, d->decorationThickness);
 
        const bool firstPointActive = d->firstPoint == d->activePoint;
 
        if (d->pointIsDragged || firstPointActive) {
            const bool onlyPaintActivePoints = false;
            KoPathPoint::PointTypes paintFlags = KoPathPoint::ControlPoint2;
 
            if (d->activePoint->activeControlPoint1()) {
                paintFlags |= KoPathPoint::ControlPoint1;
            }
 
            helper.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles(palette));
            d->activePoint->paint(helper, paintFlags, onlyPaintActivePoints);
        }
 
        if (!firstPointActive) {
            helper.setHandleStyle(d->mouseOverFirstPoint ?
                                      KisHandleStyle::highlightedPrimaryHandles(palette) :
                                      KisHandleStyle::primarySelection());
            d->firstPoint->paint(helper, KoPathPoint::Node);
        }
    }
 
    if (d->hoveredPoint) {
        KisHandlePainterHelper helper = KoShape::createHandlePainterHelperView(&painter, d->hoveredPoint->parent(), converter, d->handleRadius, d->decorationThickness);
        helper.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles(palette));
        d->hoveredPoint->paint(helper, KoPathPoint::Node);
    }
 
    painter.save();
    painter.setTransform(converter.documentToView(), true);
    canvas()->snapGuide()->paint(painter, converter, canvas()->displayRendererInterface());
    painter.restore();
}

References KoToolBase::canvas(), KoShape::createHandlePainterHelperView(), KoCanvasBase::displayRendererInterface(), KoColorDisplayRendererInterface::handlePaletteForDisplayColorSpace(), paintPath(), palette, and pathStarted().

paintPath()

void KoCreatePathTool::paintPath ( KoPathShape & pathShape, QPainter & painter, const KoViewConverter & converter )

protectedvirtual

This method is called to paint the path. Decorations are drawn by KoCreatePathTool afterwards.

Reimplemented in __KisToolPathLocalTool, __KisToolSelectPathLocalTool, and KisToolPathLocalTool.

Definition at line 127 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
    painter.setTransform(pathShape.absoluteTransformation() *
                         converter.documentToView() *
                         painter.transform());
    painter.save();
 
    pathShape.paint(painter);
    painter.restore();
 
    if (pathShape.stroke()) {
        painter.save();
        pathShape.stroke()->paint(d->shape, painter);
        painter.restore();
    }
}

References KoShape::absoluteTransformation(), KoViewConverter::documentToView(), KoPathShape::paint(), and KoShape::stroke().

pathStarted()

bool KoCreatePathTool::pathStarted

(

)

const

Returns true if path has been started

Definition at line 250 of file KoCreatePathTool.cpp.

{
    Q_D(const KoCreatePathTool);
    return ((bool) d->shape);
}

Q_PRIVATE_SLOT()

KoCreatePathTool::Q_PRIVATE_SLOT ( d_func() , void angleDeltaChangedqreal )

private

removeLastPoint()

void KoCreatePathTool::removeLastPoint ( )

protected

Definition at line 437 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
 
    if ((d->shape)) {
        KoPathPointIndex lastPointIndex = d->shape->pathPointIndex(d->activePoint);
 
        if (lastPointIndex.second > 1) {
            lastPointIndex.second--;
            delete d->shape->removePoint(lastPointIndex);
 
            d->hoveredPoint = 0;
 
            repaintDecorations();
        }
    }
}

References KoToolBase::repaintDecorations().

setEnableClosePathShortcut()

void KoCreatePathTool::setEnableClosePathShortcut

(

bool

value

)

Definition at line 261 of file KoCreatePathTool.cpp.

{
    Q_D(KoCreatePathTool);
    d->enableClosePathShortcut = value;
}

References value().

sigUpdateAutoSmoothCurvesGUI

void KoCreatePathTool::sigUpdateAutoSmoothCurvesGUI ( bool value )

signal

tryMergeInPathShape()

bool KoCreatePathTool::tryMergeInPathShape

(

KoPathShape *

pathShape

)

Definition at line 256 of file KoCreatePathTool.cpp.

{
    return addPathShapeImpl(pathShape, true);
}

References addPathShapeImpl().

---

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

• libs/basicflakes/tools/KoCreatePathTool.h
• libs/basicflakes/tools/KoCreatePathTool.cpp