#include <KoPencilTool.h>

Inheritance diagram for KoPencilTool:

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

void	deactivate () override

void	keyPressEvent (QKeyEvent *event) override

	KoPencilTool (KoCanvasBase *canvas)

void	mouseMoveEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

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

	~KoPencilTool () 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 ()

virtual QRectF	decorationsRect () const

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 Enter key or any equivalent. 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	keyReleaseEvent (QKeyEvent *event)

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

virtual void	mouseDoubleClickEvent (KoPointerEvent *event)

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 Slots
virtual void	slotUpdatePencilCursor ()

Protected Member Functions
virtual void	addPathShape (KoPathShape *path, bool closePath)

QList< QPointer< QWidget > >	createOptionWidgets () override

KoShapeStrokeSP	createStroke ()

qreal	getFittingError ()

KoPathShape *	path ()

void	setFittingError (qreal fittingError)

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 Types
enum	PencilMode { ModeRaw , ModeCurve , ModeStraight }

Private Slots
void	selectMode (int mode)

void	setDelta (double delta)

void	setOptimize (int state)

Private Member Functions
void	addPoint (const QPointF &point)

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

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

void	finish (bool closePath)

qreal	lineAngle (const QPointF &p1, const QPointF &p2)

Private Attributes
bool	m_close {false}

qreal	m_combineAngle {15.0}

KConfigGroup	m_configGroup

KoPathPoint *	m_existingEndPoint {0}
	an existing path point we finished a new path at

KoPathPoint *	m_existingStartPoint {0}
	an existing path point we started a new path at

qreal	m_fittingError {5.0}

KoPathPoint *	m_hoveredPoint {0}
	an existing path end point the mouse is hovering on

PencilMode	m_mode {ModeCurve}

bool	m_optimizeCurve {false}

bool	m_optimizeRaw {false}

QList< QPointF >	m_points

KoPathShape *	m_shape {0}

KoStrokeConfigWidget *	m_strokeWidget {0}

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

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 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)

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Detailed Description

Definition at line 21 of file KoPencilTool.h.

Member Enumeration Documentation

◆ PencilMode

enum KoPencilTool::PencilMode

private

Enumerator
ModeRaw
ModeCurve
ModeStraight

Definition at line 73 of file KoPencilTool.h.

73{ ModeRaw, ModeCurve, ModeStraight };

KoPencilTool::ModeRaw

@ ModeRaw

Definition KoPencilTool.h:73

KoPencilTool::ModeCurve

@ ModeCurve

Definition KoPencilTool.h:73

KoPencilTool::ModeStraight

@ ModeStraight

Definition KoPencilTool.h:73

Constructor & Destructor Documentation

◆ KoPencilTool()

KoPencilTool::KoPencilTool ( KoCanvasBase * canvas )

explicit

Definition at line 43 of file KoPencilTool.cpp.

    : KoToolBase(canvas)
{
}

◆ ~KoPencilTool()

KoPencilTool::~KoPencilTool ( )

override

Definition at line 48 of file KoPencilTool.cpp.

49{

50}

Member Function Documentation

◆ activate()

void KoPencilTool::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 156 of file KoPencilTool.cpp.

{
    KoToolBase::activate(shapes);
 
    m_points.clear();
    m_close = false;
    slotUpdatePencilCursor();
 
    if (m_strokeWidget) {
        m_strokeWidget->activate();
    }
    m_configGroup =  KSharedConfig::openConfig()->group(toolId());
}

References KoStrokeConfigWidget::activate(), KoToolBase::activate(), m_close, m_configGroup, m_points, m_strokeWidget, slotUpdatePencilCursor(), and KoToolBase::toolId().

◆ addPathShape()

void KoPencilTool::addPathShape	(	KoPathShape *	path,
		bool	closePath )

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 __KisToolPencilLocalTool.

Definition at line 369 of file KoPencilTool.cpp.

{
    KoShape * startShape = 0;
    KoShape * endShape = 0;
 
    if (closePath) {
        path->close();
        path->normalize();
    } else {
        path->normalize();
        if (connectPaths(path, m_existingStartPoint, m_existingEndPoint)) {
            if (m_existingStartPoint)
                startShape = m_existingStartPoint->parent();
            if (m_existingEndPoint && m_existingEndPoint != m_existingStartPoint)
                endShape = m_existingEndPoint->parent();
        }
    }
 
    KUndo2Command * cmd = canvas()->shapeController()->addShape(path, 0);
    if (cmd) {
        KoSelection *selection = canvas()->shapeManager()->selection();
        selection->deselectAll();
        selection->select(path);
 
        if (startShape)
            canvas()->shapeController()->removeShape(startShape, cmd);
        if (endShape && startShape != endShape)
            canvas()->shapeController()->removeShape(endShape, cmd);
 
        canvas()->addCommand(cmd);
    } else {
        canvas()->updateCanvas(path->boundingRect());
        delete path;
    }
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), connectPaths(), m_existingEndPoint, m_existingStartPoint, KoPathPoint::parent(), path(), KoShapeManager::selection, KoToolBase::selection(), KoCanvasBase::shapeController, KoCanvasBase::shapeManager(), and KoCanvasBase::updateCanvas().

◆ addPoint()

void KoPencilTool::addPoint ( const QPointF & point )

private

Definition at line 192 of file KoPencilTool.cpp.

{
    if (! m_shape)
        return;
 
    // do a moveTo for the first point added
    if (m_points.empty())
        m_shape->moveTo(point);
    // do not allow coincident points
    else if (point != m_points.last())
        m_shape->lineTo(point);
    else
        return;
 
    m_points.append(point);
    canvas()->updateCanvas(m_shape->boundingRect());
}

References KoPathShape::boundingRect(), KoToolBase::canvas(), KoPathShape::lineTo(), m_points, m_shape, KoPathShape::moveTo(), and KoCanvasBase::updateCanvas().

◆ connectPaths()

bool KoPencilTool::connectPaths	(	KoPathShape *	pathShape,
		KoPathPoint *	pointAtStart,
		KoPathPoint *	pointAtEnd )

private

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

Definition at line 491 of file KoPencilTool.cpp.

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

References KoPathShape::combine(), KoPathShape::moveSubpath(), KoPathPoint::parent(), KoPathShape::pathPointIndex(), KoPathShape::pointByIndex(), KoPathPointMergeCommand::redo(), KoPathShape::reverseSubpath(), KoPathShape::subpathCount(), and KoPathShape::subpathPointCount().

◆ createOptionWidgets()

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

overrideprotectedvirtual

Reimplemented from KoToolBase.

Definition at line 280 of file KoPencilTool.cpp.

{
    m_mode = static_cast<PencilMode>(m_configGroup.readEntry<int>("pencilMode", m_mode));
    m_optimizeRaw = m_configGroup.readEntry<bool>("optimizeRaw", m_optimizeRaw);
    m_optimizeCurve = m_configGroup.readEntry<bool>("optimizeCurve", m_optimizeCurve);
    m_combineAngle = m_configGroup.readEntry<qreal>("combineAngle", m_combineAngle);
    m_fittingError = m_configGroup.readEntry<qreal>("fittingError", m_fittingError);
 
    QList<QPointer<QWidget> > widgets;
    QWidget *optionWidget = new QWidget();
    QVBoxLayout * layout = new QVBoxLayout(optionWidget);
 
    QHBoxLayout *modeLayout = new QHBoxLayout;
    modeLayout->setSpacing(3);
    QLabel *modeLabel = new QLabel(i18n("Precision:"), optionWidget);
    QComboBox * modeBox = new QComboBox(optionWidget);
    modeBox->addItem(i18nc("The raw line data", "Raw"));
    modeBox->addItem(i18n("Curve"));
    modeBox->addItem(i18n("Straight"));
    modeLayout->addWidget(modeLabel);
    modeLayout->addWidget(modeBox, 1);
    layout->addLayout(modeLayout);
 
    QStackedWidget * stackedWidget = new QStackedWidget(optionWidget);
 
    QWidget * rawBox = new QWidget(stackedWidget);
    QVBoxLayout * rawLayout = new QVBoxLayout(rawBox);
    QCheckBox * optimizeRaw = new QCheckBox(i18n("Optimize"), rawBox);
    optimizeRaw->setChecked(m_optimizeRaw);
    rawLayout->addWidget(optimizeRaw);
    rawLayout->setContentsMargins(0, 0, 0, 0);
 
    QWidget * curveBox = new QWidget(stackedWidget);
    QHBoxLayout * curveLayout = new QHBoxLayout(curveBox);
    QCheckBox * optimizeCurve = new QCheckBox(i18n("Optimize"), curveBox);
    optimizeCurve->setChecked(m_optimizeCurve);
    QDoubleSpinBox * fittingError = new KisDoubleParseSpinBox(curveBox);
    fittingError->setSingleStep(0.50);
    fittingError->setMaximum(400.0);
    fittingError->setMinimum(0.0);
    fittingError->setValue(m_fittingError);
    fittingError->setToolTip(i18n("Exactness:"));
    curveLayout->addWidget(optimizeCurve);
    curveLayout->addWidget(fittingError);
    curveLayout->setContentsMargins(0, 0, 0, 0);
 
    QWidget *straightBox = new QWidget(stackedWidget);
    QVBoxLayout *straightLayout = new QVBoxLayout(straightBox);
    QDoubleSpinBox *combineAngle = new KisDoubleParseSpinBox(straightBox);
    combineAngle->setSingleStep(0.50);
    combineAngle->setMaximum(360.0);
    combineAngle->setMinimum(0.0);
    combineAngle->setValue(m_combineAngle);
    combineAngle->setSuffix(" deg");
    // QT5TODO
    //combineAngle->setLabel(i18n("Combine angle:"), Qt::AlignLeft | Qt::AlignVCenter);
    straightLayout->addWidget(combineAngle);
    straightLayout->setContentsMargins(0, 0, 0, 0);
 
    stackedWidget->addWidget(rawBox);
    stackedWidget->addWidget(curveBox);
    stackedWidget->addWidget(straightBox);
    layout->addWidget(stackedWidget);
    layout->addStretch(1);
 
    connect(modeBox, SIGNAL(activated(int)), stackedWidget, SLOT(setCurrentIndex(int)));
    connect(modeBox, SIGNAL(activated(int)), this, SLOT(selectMode(int)));
    connect(optimizeRaw, SIGNAL(stateChanged(int)), this, SLOT(setOptimize(int)));
    connect(optimizeCurve, SIGNAL(stateChanged(int)), this, SLOT(setOptimize(int)));
    connect(fittingError, SIGNAL(valueChanged(double)), this, SLOT(setDelta(double)));
    connect(combineAngle, SIGNAL(valueChanged(double)), this, SLOT(setDelta(double)));
 
    modeBox->setCurrentIndex(m_mode);
    stackedWidget->setCurrentIndex(m_mode);
    optionWidget->setObjectName(i18n("Pencil"));
    optionWidget->setWindowTitle(i18n("Pencil"));
    widgets.append(optionWidget);
 
    m_strokeWidget = new KoStrokeConfigWidget(canvas(), 0);
    m_strokeWidget->setNoSelectionTrackingMode(true);
    m_strokeWidget->setWindowTitle(i18n("Line"));
    connect(m_strokeWidget, SIGNAL(sigStrokeChanged()), SLOT(slotUpdatePencilCursor()));
    if (isActivated()) {
        m_strokeWidget->activate();
    }
    widgets.append(m_strokeWidget);
    return widgets;
}

References KoStrokeConfigWidget::activate(), KoToolBase::canvas(), connect(), KoToolBase::isActivated(), m_combineAngle, m_configGroup, m_fittingError, m_mode, m_optimizeCurve, m_optimizeRaw, m_strokeWidget, selectMode(), setDelta(), KoStrokeConfigWidget::setNoSelectionTrackingMode(), setOptimize(), and slotUpdatePencilCursor().

◆ createStroke()

KoShapeStrokeSP KoPencilTool::createStroke ( )

protected

Definition at line 435 of file KoPencilTool.cpp.

{
    KoShapeStrokeSP stroke;
    if (m_strokeWidget) {
        stroke = m_strokeWidget->createShapeStroke();
    }
    return stroke;
}

References KoStrokeConfigWidget::createShapeStroke(), and m_strokeWidget.

◆ deactivate()

void KoPencilTool::deactivate ( )

overridevirtual

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

See also: activate()

Reimplemented from KoToolBase.

Definition at line 170 of file KoPencilTool.cpp.

{
    m_points.clear();
    delete m_shape;
    m_shape = 0;
    m_existingStartPoint = 0;
    m_existingEndPoint = 0;
    m_hoveredPoint = 0;
 
    if (m_strokeWidget) {
        m_strokeWidget->deactivate();
    }
 
    KoToolBase::deactivate();
}

References KoToolBase::deactivate(), KoStrokeConfigWidget::deactivate(), m_existingEndPoint, m_existingStartPoint, m_hoveredPoint, m_points, m_shape, and m_strokeWidget.

◆ endPointAtPosition()

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

private

returns the nearest existing path point

Definition at line 449 of file KoPencilTool.cpp.

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

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

◆ finish()

void KoPencilTool::finish ( bool closePath )

private

Definition at line 219 of file KoPencilTool.cpp.

{
    if (m_points.count() < 2)
        return;
 
    KoPathShape * path = 0;
    QList<QPointF> complete;
    QList<QPointF> *points = &m_points;
 
    if (m_mode == ModeStraight || m_optimizeRaw || m_optimizeCurve) {
        float combineAngle;
 
        if (m_mode == ModeStraight)
            combineAngle = m_combineAngle;
        else
            combineAngle = 0.50f;
 
        //Add the first two points
        complete.append(m_points[0]);
        complete.append(m_points[1]);
 
        //Now we need to get the angle of the first line
        float lastAngle = lineAngle(complete[0], complete[1]);
 
        uint pointCount = m_points.count();
        for (uint i = 2; i < pointCount; ++i) {
            float angle = lineAngle(complete.last(), m_points[i]);
            if (qAbs(angle - lastAngle) < combineAngle)
                complete.removeLast();
            complete.append(m_points[i]);
            lastAngle = angle;
        }
 
        m_points.clear();
        points = &complete;
    }
 
    switch (m_mode) {
    case ModeCurve: {
        path = bezierFit(*points, m_fittingError);
    }
    break;
    case ModeStraight:
    case ModeRaw: {
        path = new KoPathShape();
        uint pointCount = points->count();
        path->moveTo(points->at(0));
        for (uint i = 1; i < pointCount; ++i)
            path->lineTo(points->at(i));
    }
    break;
    }
 
    if (! path)
        return;
 
    path->setShapeId(KoPathShapeId);
    path->setStroke(createStroke());
    addPathShape(path, closePath);
}

References addPathShape(), bezierFit(), createStroke(), KoPathShapeId, lineAngle(), m_combineAngle, m_fittingError, m_mode, m_optimizeCurve, m_optimizeRaw, m_points, ModeCurve, ModeRaw, and ModeStraight.

◆ getFittingError()

qreal KoPencilTool::getFittingError ( )

protected

Definition at line 571 of file KoPencilTool.cpp.

{
    return this->m_fittingError;
}

References m_fittingError.

◆ keyPressEvent()

void KoPencilTool::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 147 of file KoPencilTool.cpp.

{
    if (m_shape) {
        event->accept();
    } else {
        event->ignore();
    }
}

References m_shape.

◆ lineAngle()

qreal KoPencilTool::lineAngle	(	const QPointF &	p1,
		const QPointF &	p2 )

private

Definition at line 210 of file KoPencilTool.cpp.

{
    qreal angle = atan2(p2.y() - p1.y(), p2.x() - p1.x());
    if (angle < 0.0)
        angle += 2 * M_PI;
 
    return angle * 180.0 / M_PI;
}

References M_PI, p1, and p2.

◆ mouseMoveEvent()

void KoPencilTool::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 102 of file KoPencilTool.cpp.

{
    if (event->buttons() & Qt::LeftButton)
        addPoint(event->point);
 
    KoPathPoint * endPoint = endPointAtPosition(event->point);
    if (m_hoveredPoint != endPoint) {
        if (m_hoveredPoint) {
            QPointF nodePos = m_hoveredPoint->parent()->shapeToDocument(m_hoveredPoint->point());
            canvas()->updateCanvas(handlePaintRect(nodePos));
        }
        m_hoveredPoint = endPoint;
        if (m_hoveredPoint) {
            QPointF nodePos = m_hoveredPoint->parent()->shapeToDocument(m_hoveredPoint->point());
            canvas()->updateCanvas(handlePaintRect(nodePos));
        }
    }
}

References addPoint(), KoPointerEvent::buttons(), KoToolBase::canvas(), endPointAtPosition(), KoToolBase::handlePaintRect(), m_hoveredPoint, KoPathPoint::parent(), KoPathPoint::point, KoPointerEvent::point, KoShape::shapeToDocument(), and KoCanvasBase::updateCanvas().

◆ mousePressEvent()

void KoPencilTool::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 83 of file KoPencilTool.cpp.

{
    KoShapeStrokeSP stroke = createStroke();
 
    if (!m_shape && stroke && stroke->isVisible()) {
        m_shape = new KoPathShape();
        m_shape->setShapeId(KoPathShapeId);
        m_shape->setStroke(createStroke());
        m_points.clear();
 
        QPointF point = event->point;
        m_existingStartPoint = endPointAtPosition(point);
        if (m_existingStartPoint)
            point = m_existingStartPoint->parent()->shapeToDocument(m_existingStartPoint->point());
 
        addPoint(point);
    }
}

References addPoint(), createStroke(), endPointAtPosition(), KoPathShapeId, m_existingStartPoint, m_points, m_shape, KoPathPoint::parent(), KoPathPoint::point, KoShape::setShapeId(), KoShape::setStroke(), and KoShape::shapeToDocument().

◆ mouseReleaseEvent()

void KoPencilTool::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 121 of file KoPencilTool.cpp.

{
    if (! m_shape)
        return;
 
    QPointF point = event->point;
    m_existingEndPoint = endPointAtPosition(point);
    if (m_existingEndPoint)
        point = m_existingEndPoint->parent()->shapeToDocument(m_existingEndPoint->point());
 
    addPoint(point);
    finish(event->modifiers() & Qt::ShiftModifier);
 
    m_existingStartPoint = 0;
    m_existingEndPoint = 0;
    m_hoveredPoint = 0;
 
    // the original path may be different from the one added
    if (canvas() && m_shape) {
        canvas()->updateCanvas(m_shape->boundingRect());
    }
    delete m_shape;
    m_shape = 0;
    m_points.clear();
}

References addPoint(), KoPathShape::boundingRect(), KoToolBase::canvas(), endPointAtPosition(), finish(), m_existingEndPoint, m_existingStartPoint, m_hoveredPoint, m_points, m_shape, KoPointerEvent::modifiers(), KoPathPoint::parent(), KoPathPoint::point, KoShape::shapeToDocument(), and KoCanvasBase::updateCanvas().

◆ paint()

void KoPencilTool::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 52 of file KoPencilTool.cpp.

{
    if (m_shape) {
        painter.save();
 
        painter.setTransform(m_shape->absoluteTransformation() *
                             converter.documentToView() *
                             painter.transform());
 
        painter.save();
        m_shape->paint(painter);
        painter.restore();
 
        if (m_shape->stroke()) {
            painter.save();
            m_shape->stroke()->paint(m_shape, painter);
            painter.restore();
        }
 
        painter.restore();
    }
 
    if (m_hoveredPoint) {
        KisHandlePainterHelper helper =
            KoShape::createHandlePainterHelperView(&painter, m_hoveredPoint->parent(), converter, handleRadius(), decorationThickness());
 
        helper.setHandleStyle(KisHandleStyle::primarySelection());
        m_hoveredPoint->paint(helper, KoPathPoint::Node);
    }
}

References KoShape::absoluteTransformation(), KoShape::createHandlePainterHelperView(), KoToolBase::decorationThickness(), KoViewConverter::documentToView(), KoToolBase::handleRadius(), m_hoveredPoint, m_shape, KoPathPoint::Node, KoPathPoint::paint(), KoPathShape::paint(), KoPathPoint::parent(), KisHandleStyle::primarySelection(), KisHandlePainterHelper::setHandleStyle(), and KoShape::stroke().

◆ path()

KoPathShape * KoPencilTool::path ( )

protected

Definition at line 444 of file KoPencilTool.cpp.

{
    return m_shape;
}

References m_shape.

◆ selectMode

void KoPencilTool::selectMode ( int mode )

privateslot

Definition at line 405 of file KoPencilTool.cpp.

{
    m_mode = static_cast<PencilMode>(mode);
    m_configGroup.writeEntry("pencilMode", mode);
}

References m_configGroup, and m_mode.

◆ setDelta

void KoPencilTool::setDelta ( double delta )

privateslot

Definition at line 423 of file KoPencilTool.cpp.

{
    if (m_mode == ModeCurve) {
        m_fittingError = delta;
        m_configGroup.writeEntry("fittingError", m_fittingError);
    }
    else if (m_mode == ModeStraight) {
        m_combineAngle = delta;
        m_configGroup.writeEntry("combineAngle", m_combineAngle);
    }
}

References m_combineAngle, m_configGroup, m_fittingError, m_mode, ModeCurve, and ModeStraight.

◆ setFittingError()

void KoPencilTool::setFittingError ( qreal fittingError )

protected

Definition at line 576 of file KoPencilTool.cpp.

{
    this->m_fittingError = fittingError;
}

References m_fittingError.

◆ setOptimize

void KoPencilTool::setOptimize ( int state )

privateslot

Definition at line 411 of file KoPencilTool.cpp.

{
    if (m_mode == ModeRaw) {
        m_optimizeRaw = state == Qt::Checked ? true : false;
        m_configGroup.writeEntry("optimizeRaw", m_optimizeRaw);
    }
    else {
        m_optimizeCurve = state == Qt::Checked ? true : false;
        m_configGroup.writeEntry("optimizeCurve", m_optimizeCurve);
    }
}

References m_configGroup, m_mode, m_optimizeCurve, m_optimizeRaw, and ModeRaw.

◆ slotUpdatePencilCursor

void KoPencilTool::slotUpdatePencilCursor ( )

protectedvirtualslot

Reimplemented in __KisToolPencilLocalTool.

Definition at line 186 of file KoPencilTool.cpp.

{
    KoShapeStrokeSP stroke = createStroke();
    useCursor((stroke && stroke->isVisible()) ? Qt::ArrowCursor : Qt::ForbiddenCursor);
}

References createStroke(), and KoToolBase::useCursor().

Member Data Documentation

◆ m_close

bool KoPencilTool::m_close {false}

private

Definition at line 80 of file KoPencilTool.h.

80{false};

◆ m_combineAngle

qreal KoPencilTool::m_combineAngle {15.0}

private

Definition at line 78 of file KoPencilTool.h.

78{15.0};

◆ m_configGroup

KConfigGroup KoPencilTool::m_configGroup

private

Definition at line 90 of file KoPencilTool.h.

◆ m_existingEndPoint

KoPathPoint* KoPencilTool::m_existingEndPoint {0}

private

an existing path point we finished a new path at

Definition at line 86 of file KoPencilTool.h.

86{0};

◆ m_existingStartPoint

KoPathPoint* KoPencilTool::m_existingStartPoint {0}

private

an existing path point we started a new path at

Definition at line 85 of file KoPencilTool.h.

85{0};

◆ m_fittingError

qreal KoPencilTool::m_fittingError {5.0}

private

Definition at line 79 of file KoPencilTool.h.

79{5.0};

◆ m_hoveredPoint

KoPathPoint* KoPencilTool::m_hoveredPoint {0}

private

an existing path end point the mouse is hovering on

Definition at line 87 of file KoPencilTool.h.

87{0};

◆ m_mode

PencilMode KoPencilTool::m_mode {ModeCurve}

private

Definition at line 75 of file KoPencilTool.h.

75{ModeCurve};

◆ m_optimizeCurve

bool KoPencilTool::m_optimizeCurve {false}

private

Definition at line 77 of file KoPencilTool.h.

77{false};

◆ m_optimizeRaw

bool KoPencilTool::m_optimizeRaw {false}

private

Definition at line 76 of file KoPencilTool.h.

76{false};

◆ m_points

QList<QPointF> KoPencilTool::m_points

private

Definition at line 82 of file KoPencilTool.h.

◆ m_shape

KoPathShape* KoPencilTool::m_shape {0}

private

Definition at line 84 of file KoPencilTool.h.

84{0};

◆ m_strokeWidget

KoStrokeConfigWidget* KoPencilTool::m_strokeWidget {0}

private

Definition at line 88 of file KoPencilTool.h.

88{0};

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

libs/basicflakes/tools/KoPencilTool.h
libs/basicflakes/tools/KoPencilTool.cpp

Public Member Functions

Protected Slots

Protected Member Functions

Private Types

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ PencilMode

Constructor & Destructor Documentation

◆ KoPencilTool()

◆ ~KoPencilTool()

Member Function Documentation

◆ activate()

◆ addPathShape()

◆ addPoint()

◆ connectPaths()

◆ createOptionWidgets()

◆ createStroke()

◆ deactivate()

◆ endPointAtPosition()

◆ finish()

◆ getFittingError()

◆ keyPressEvent()

◆ lineAngle()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ paint()

◆ path()

◆ selectMode

◆ setDelta

◆ setFittingError()

◆ setOptimize

◆ slotUpdatePencilCursor

Member Data Documentation

◆ m_close

◆ m_combineAngle

◆ m_configGroup

◆ m_existingEndPoint

◆ m_existingStartPoint

◆ m_fittingError

◆ m_hoveredPoint

◆ m_mode

◆ m_optimizeCurve

◆ m_optimizeRaw

◆ m_points

◆ m_shape

◆ m_strokeWidget