#include <kis_tool_freehand.h>

Inheritance diagram for KisToolFreehand:

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

void	deactivate () override

Public Slots inherited from KisToolPaint
void	activate (const QSet< KoShape * > &shapes) override

void	deactivate () override

Public Slots inherited from KisTool
void	activate (const QSet< KoShape * > &shapes) override

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

void	deactivate () override

virtual void	updateSettingsViews ()

Public Slots inherited from KoToolBase
virtual void	activate (const QSet< KoShape * > &shapes)

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

Public Member Functions
int	flags () const override

	KisToolFreehand (KoCanvasBase *canvas, const QCursor &cursor, const KUndo2MagicString &transactionText, bool useSavedSmoothing=true)

void	mouseMoveEvent (KoPointerEvent *event) override

	~KisToolFreehand () override

Public Member Functions inherited from KisToolPaint
int	flags () const override

	KisToolPaint (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseMoveEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

KisPopupWidgetInterface *	popupWidget () override

	~KisToolPaint () override

Public Member Functions inherited from KisTool
virtual bool	alternateActionSupportsHiResEvents (AlternateAction action) const

virtual void	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action)

virtual void	beginPrimaryDoubleClickAction (KoPointerEvent *event)

void	deleteSelection () override

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

virtual void	newActivationWithExternalSource (KisPaintDeviceSP externalSource)
	newActivationWithExternalSource Makes sure that the tool is active and starts a new stroke, which will be able to access the pixels from the specified external source.

KisTool::NodePaintAbility	nodePaintAbility ()

	~KisTool () override

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

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	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	keyPressEvent (QKeyEvent *event)

virtual void	keyReleaseEvent (QKeyEvent *event)

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

virtual QMenu *	popupActionsMenu ()

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

virtual KoToolSelection *	selection ()

Q_INVOKABLE QString	toolId () const

	~KoToolBase () override

Protected Slots
void	explicitUpdateOutline ()

void	resetCursorStyle () override

void	setAssistant (bool assistant)

void	setOnlyOneAssistantSnap (bool assistant)

void	setSnapEraser (bool assistant)

void	slotDoResizeBrush (qreal newSize)

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Protected Member Functions
void	activateAlternateAction (AlternateAction action) override

void	beginAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	beginPrimaryAction (KoPointerEvent *event) override

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

void	deactivateAlternateAction (AlternateAction action) override

virtual void	doStroke (KoPointerEvent *event)

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	endPrimaryAction (KoPointerEvent *event) override

virtual void	endStroke ()

KisOptimizedBrushOutline	getOutlinePath (const QPointF &documentPos, const KoPointerEvent *event, KisPaintOpSettings::OutlineMode outlineMode) override

virtual void	initStroke (KoPointerEvent *event)

KisPaintingInformationBuilder *	paintingInformationBuilder () const

bool	primaryActionSupportsHiResEvents () const override

void	resetHelper (KisToolFreehandHelper *helper)

KisSmoothingOptionsSP	smoothingOptions () const

bool	supportsPaintingAssistants () const override

bool	trySampleByPaintOp (KoPointerEvent *event, AlternateAction action)

bool	wantsAutoScroll () const override

Protected Member Functions inherited from KisToolPaint
void	activateAlternateAction (AlternateAction action) override

void	activatePrimaryAction () override

void	addOptionWidgetLayout (QLayout *layout)
	Add the tool-specific layout to the default option widget layout.

virtual void	addOptionWidgetOption (QWidget control, QWidget label=nullptr)
	Add a widget and a label to the current option widget layout.

void	beginAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	canvasResourceChanged (int key, const QVariant &v) override

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

QWidget *	createOptionWidget () override

void	deactivateAlternateAction (AlternateAction action) override

void	deactivatePrimaryAction () override

void	enableControl (QWidget *control, bool value)

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

bool	isEraser () const

bool	isOutlineEnabled () const

bool	isOutlineVisible () const

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

virtual QString	quickHelp () const

virtual void	requestUpdateOutline (const QPointF &outlineDocPoint, const KoPointerEvent *event)

void	setMode (ToolMode mode) override

void	setOutlineEnabled (bool enabled)

void	setOutlineVisible (bool visible)

void	setSupportOutline (bool supportOutline)

void	showControl (QWidget *control, bool value)

Protected Member Functions inherited from KisTool
bool	blockUntilOperationsFinished ()

void	blockUntilOperationsFinishedForced ()

QPointF	convertDocumentToWidget (const QPointF &pt)

QPoint	convertToImagePixelCoordFloored (KoPointerEvent *e)

QPointF	convertToPixelCoord (const QPointF &pt)

QPointF	convertToPixelCoord (KoPointerEvent *e)

QPointF	convertToPixelCoordAndAlignOnWidget (const QPointF &pt)

QPointF	convertToPixelCoordAndSnap (const QPointF &pt, const QPointF &offset=QPointF())

QPointF	convertToPixelCoordAndSnap (KoPointerEvent *e, const QPointF &offset=QPointF(), bool useModifiers=true)

QRectF	convertToPt (const QRectF &rect)

qreal	convertToPt (qreal value)

KoColor	currentBgColor ()

KoColor	currentFgColor ()

KisFilterConfigurationSP	currentGenerator ()

KoAbstractGradientSP	currentGradient ()

KisImageWSP	currentImage ()

KisNodeSP	currentNode () const

KisPaintOpPresetSP	currentPaintOpPreset ()

KoPatternSP	currentPattern ()

QCursor	cursor () const

KisImageWSP	image () const

virtual bool	listeningToModifiers ()

virtual void	listenToModifiers (bool listen)

virtual ToolMode	mode () const

bool	nodeEditable ()
	Checks checks if the current node is editable.

bool	overrideCursorIfNotEditable ()
	Override the cursor appropriately if current node is not editable.

void	paintToolOutline (QPainter *painter, const KisOptimizedBrushOutline &path)

KisOptimizedBrushOutline	pixelToView (const KisOptimizedBrushOutline &path) const

QPainterPath	pixelToView (const QPainterPath &pixelPath) const
	Convert a pixel path into a view path.

QPointF	pixelToView (const QPoint &pixelCoord) const

QPointF	pixelToView (const QPointF &pixelCoord) const
	Convert a floating point pixel coordinate into a view coordinate.

QPolygonF	pixelToView (const QPolygonF &pixelPolygon) const
	Convert a pixel polygon into a view path.

QRectF	pixelToView (const QRectF &pixelRect) const
	Convert a pixel rectangle into a view rectangle.

KisNodeList	selectedNodes () const

bool	selectionEditable ()
	Checks checks if the selection is editable, only applies to local selection as global selection is always editable.

void	setCursor (const QCursor &cursor)

void	updateCanvasPixelRect (const QRectF &pixelRect)
	Update the canvas for the given rectangle in image pixel coordinates.

void	updateCanvasViewRect (const QRectF &viewRect)
	Update the canvas for the given rectangle in view coordinates.

QPointF	viewToPixel (const QPointF &viewCoord) const

QPointF	widgetCenterInWidgetPixels ()

Protected Member Functions inherited from KoToolBase
virtual QList< QPointer< QWidget > >	createOptionWidgets ()

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
bool	m_assistant {false}

bool	m_eraser_snapping {false}

double	m_magnetism {1.0}

bool	m_only_one_assistant {true}

Protected Attributes inherited from KisToolPaint
KisOptimizedBrushOutline	m_currentOutline

QRectF	m_oldColorPreviewUpdateRect

QRectF	m_oldOutlineRect

QPointF	m_outlineDocPoint

bool	m_paintOutline {false}

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Private Slots
void	updateMaskSyntheticEventsFromTouch ()

Private Member Functions
QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin)

qreal	calculatePerspective (const QPointF &documentPoint)

void	lockTemporaryStraightRuler (const QPointF &documentPoint, Qt::KeyboardModifiers modifiers)

bool	temporaryStraightRulerActive () const

QPointF	temporaryStraightRulerOutlinePosition (const QPointF &documentPoint)

void	updateTemporaryStraightRulerPreview (const QPointF &documentPoint, Qt::KeyboardModifiers modifiers)

Private Attributes
std::optional< KoPointerEventWrapper >	m_beginAlternateActionEvent

KisSignalCompressorWithParam< qreal >	m_brushResizeCompressor

KisToolFreehandHelper *	m_helper {nullptr}

KisPaintingInformationBuilder *	m_infoBuilder {nullptr}

QPointF	m_initialGestureDocPoint

QPoint	m_initialGestureGlobalPoint

QPointF	m_lastDocumentPoint

qreal	m_lastPaintOpSize {0.0}

bool	m_paintopBasedSamplingInAction {false}

Friends
class	KisToolFreehandPaintingInformationBuilder

class	KisView

class	KisViewManager

Additional Inherited Members
Public Types inherited from KisTool
enum	{ FLAG_USES_CUSTOM_PRESET =0x01 , FLAG_USES_CUSTOM_COMPOSITEOP =0x02 , FLAG_USES_CUSTOM_SIZE =0x04 }

enum	AlternateAction { ChangeSize = AlternateChangeSize , ChangeSizeSnap = AlternateChangeSizeSnap , SampleFgNode = AlternateSampleFgNode , SampleBgNode = AlternateSampleBgNode , SampleFgImage = AlternateSampleFgImage , SampleBgImage = AlternateSampleBgImage , Secondary = AlternateSecondary , Third = AlternateThird , Fourth = AlternateFourth , Fifth = AlternateFifth , NONE = 10000 }

enum	NodePaintAbility { VECTOR , CLONE , PAINT , UNPAINTABLE , MYPAINTBRUSH_UNPAINTABLE }

enum	ToolAction { Primary , AlternateChangeSize , AlternateChangeSizeSnap , AlternateSampleFgNode , AlternateSampleBgNode , AlternateSampleFgImage , AlternateSampleBgImage , AlternateSecondary , AlternateThird , AlternateFourth , AlternateFifth , Alternate_NONE = 10000 }

Signals inherited from KisToolPaint
void	sigPaintingFinished ()

Signals inherited from KisTool
void	isActiveChanged (bool isActivated)

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)

Static Public Member Functions inherited from KisTool
static AlternateAction	actionToAlternateAction (ToolAction action)

Public Attributes inherited from KisTool
KoColor	currentBgColor

float	currentExposure {1.0}

KoColor	currentFgColor

KisFilterConfigurationSP	currentGenerator

KoAbstractGradientSP	currentGradient

KoPatternSP	currentPattern

QCursor	cursor

bool	m_isActive {false}

ToolMode	m_mode {HOVER_MODE}

QWidget *	optionWidget {0}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Protected Types inherited from KisTool
enum	ToolMode : int { HOVER_MODE , PAINT_MODE , SECONDARY_PAINT_MODE , MIRROR_AXIS_SETUP_MODE , GESTURE_MODE , PAN_MODE , OTHER , OTHER_1 }

Properties inherited from KisTool
bool	isActive

Detailed Description

Definition at line 32 of file kis_tool_freehand.h.

Constructor & Destructor Documentation

◆ KisToolFreehand()

KisToolFreehand::KisToolFreehand	(	KoCanvasBase *	canvas,
		const QCursor &	cursor,
		const KUndo2MagicString &	transactionText,
		bool	useSavedSmoothing = true )

Definition at line 72 of file kis_tool_freehand.cc.

    : KisToolPaint(canvas, cursor),
      m_brushResizeCompressor(200, std::bind(&KisToolFreehand::slotDoResizeBrush, this, _1))
{
 
    setSupportOutline(true);
    updateMaskSyntheticEventsFromTouch();
    connect(KisConfigNotifier::instance(), SIGNAL(touchPaintingChanged()),
            SLOT(updateMaskSyntheticEventsFromTouch()));
 
    m_infoBuilder = new KisToolFreehandPaintingInformationBuilder(this);
    m_helper = new KisToolFreehandHelper(m_infoBuilder, canvas->resourceManager(), transactionText,
                                         new KisSmoothingOptions(useSavedSmoothing));
 
    connect(m_helper, SIGNAL(requestExplicitUpdateOutline()), SLOT(explicitUpdateOutline()));
 
    connect(qobject_cast<KisCanvas2*>(canvas)->viewManager(), SIGNAL(brushOutlineToggled()), SLOT(explicitUpdateOutline()));
 
    KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas)->viewManager()->canvasResourceProvider();
 
    connect(provider, SIGNAL(sigEffectiveCompositeOpChanged()), SLOT(explicitUpdateOutline()));
    connect(provider, SIGNAL(sigEffectiveCompositeOpChanged()), SLOT(resetCursorStyle()));
    connect(provider, SIGNAL(sigPaintOpPresetChanged(KisPaintOpPresetSP)), SLOT(explicitUpdateOutline()));
    connect(provider, SIGNAL(sigPaintOpPresetChanged(KisPaintOpPresetSP)), SLOT(resetCursorStyle()));
 
    KisPaintingAssistantsDecorationSP decoration = qobject_cast<KisCanvas2*>(canvas)->paintingAssistantsDecoration();
    connect(decoration.data(), SIGNAL(temporaryConstraintAvailabilityChanged()), SLOT(explicitUpdateOutline()));
    connect(decoration.data(), SIGNAL(temporaryConstraintAvailabilityChanged()), SLOT(resetCursorStyle()));
}

References Private::canvas, KisSharedPtr< T >::data(), explicitUpdateOutline(), KisConfigNotifier::instance(), KisToolFreehandPaintingInformationBuilder, m_helper, m_infoBuilder, resetCursorStyle(), KoCanvasBase::resourceManager, KisToolPaint::setSupportOutline(), and updateMaskSyntheticEventsFromTouch().

◆ ~KisToolFreehand()

KisToolFreehand::~KisToolFreehand ( )

override

Definition at line 103 of file kis_tool_freehand.cc.

{
    delete m_helper;
    delete m_infoBuilder;
}

References m_helper, and m_infoBuilder.

Member Function Documentation

◆ activate

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

overrideslot

Definition at line 196 of file kis_tool_freehand.cc.

{
    KisToolPaint::activate(shapes);
}

References KisToolPaint::activate().

◆ activateAlternateAction()

void KisToolFreehand::activateAlternateAction ( AlternateAction action )

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolLazyBrush.

Definition at line 418 of file kis_tool_freehand.cc.

{
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::activateAlternateAction(action);
        return;
    }
 
    useCursor(KisCursor::blankCursor());
    setOutlineVisible(true);
}

References KoToolBase::action(), KisToolPaint::activateAlternateAction(), KisCursor::blankCursor(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisToolPaint::setOutlineVisible(), and KoToolBase::useCursor().

◆ adjustPosition()

QPointF KisToolFreehand::adjustPosition	(	const QPointF &	point,
		const QPointF &	strokeBegin )

private

Adjusts a coordinates according to a KisPaintingAssistant, if available.

Definition at line 564 of file kis_tool_freehand.cc.

{
    KisCanvas2* c = static_cast<KisCanvas2*>(canvas());
    if (!c || !c->paintingAssistantsDecoration()) {
        return point;
    }
 
    if (hasLockedValidTemporaryStraightRuler(c->paintingAssistantsDecoration()->temporaryConstraint())) {
        c->paintingAssistantsDecoration()->setEraserSnap(m_eraser_snapping);
        QPointF ap = c->paintingAssistantsDecoration()->adjustPosition(point, strokeBegin);
        c->paintingAssistantsDecoration()->setAdjustedBrushPosition(ap);
        return ap;
    }
 
    if (m_assistant) {
        c->paintingAssistantsDecoration()->setOnlyOneAssistantSnap(m_only_one_assistant);
        c->paintingAssistantsDecoration()->setEraserSnap(m_eraser_snapping);
        QPointF ap = c->paintingAssistantsDecoration()->adjustPosition(point, strokeBegin);
        QPointF fp = (1.0 - m_magnetism) * point + m_magnetism * ap;
        // Report the final position back to the assistant so the guides
        // can follow the brush
        c->paintingAssistantsDecoration()->setAdjustedBrushPosition(fp);
        return fp;
    }
    return point;
}

References KisPaintingAssistantsDecoration::adjustPosition(), Private::canvas, m_assistant, m_eraser_snapping, m_magnetism, m_only_one_assistant, KisCanvas2::paintingAssistantsDecoration(), KisPaintingAssistantsDecoration::setAdjustedBrushPosition(), KisPaintingAssistantsDecoration::setEraserSnap(), KisPaintingAssistantsDecoration::setOnlyOneAssistantSnap(), and KisPaintingAssistantsDecoration::temporaryConstraint().

◆ beginAlternateAction()

void KisToolFreehand::beginAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolMultihand, and KisToolLazyBrush.

Definition at line 440 of file kis_tool_freehand.cc.

{
    if (trySampleByPaintOp(event, action)) {
        m_paintopBasedSamplingInAction = true;
        return;
    }
 
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::beginAlternateAction(event, action);
        return;
    }
 
    setMode(GESTURE_MODE);
    m_initialGestureDocPoint = event->point;
    m_initialGestureGlobalPoint = event->globalPos();
 
    m_lastDocumentPoint = event->point;
    m_lastPaintOpSize = currentPaintOpPreset()->settings()->paintOpSize();
 
    m_beginAlternateActionEvent = event->deepCopyEvent();
    requestUpdateOutline(m_initialGestureDocPoint, &m_beginAlternateActionEvent->event);
}

References KoToolBase::action(), KisToolPaint::beginAlternateAction(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisTool::currentPaintOpPreset(), KisTool::GESTURE_MODE, m_beginAlternateActionEvent, m_initialGestureDocPoint, m_initialGestureGlobalPoint, m_lastDocumentPoint, m_lastPaintOpSize, m_paintopBasedSamplingInAction, KisToolPaint::requestUpdateOutline(), KisToolPaint::setMode(), and trySampleByPaintOp().

◆ beginPrimaryAction()

void KisToolFreehand::beginPrimaryAction ( KoPointerEvent * event )

overrideprotectedvirtual

Called by KisToolProxy when a primary action for the tool is started. The event stores the original event that started the stroke. The event is accepted by default. If the tool decides to ignore this particular action (e.g. when the node is not editable), it should call event->ignore(). Then no further continuePrimaryAction() or endPrimaryAction() will be called until the next user action.

Reimplemented from KisTool.

Reimplemented in KisToolMultihand, and KisToolLazyBrush.

Definition at line 318 of file kis_tool_freehand.cc.

{
    // FIXME: workaround for the Duplicate Op
    trySampleByPaintOp(event, SampleFgImage);
 
    lockTemporaryStraightRuler(event->point, event->modifiers());
 
    requestUpdateOutline(temporaryStraightRulerOutlinePosition(event->point), event);
 
    NodePaintAbility paintability = nodePaintAbility();
    // XXX: move this to KisTool and make it work properly for clone layers: for clone layers, the shape paint tools don't work either
    if (!nodeEditable() || paintability != PAINT) {
        if (paintability == KisToolPaint::VECTOR || paintability == KisToolPaint::CLONE){
            KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
            QString message = i18n("The brush tool cannot paint on this layer.  Please select a paint layer or mask.");
            kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
        }
        else if (paintability == MYPAINTBRUSH_UNPAINTABLE) {
            KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
            QString message = i18n("The MyPaint Brush Engine is not available for this colorspace");
            kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
        }
        event->ignore();
 
        return;
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_helper->isRunning());
 
    setMode(KisTool::PAINT_MODE);
 
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    if (canvas2) {
        canvas2->viewManager()->disableControls();
    }
 
    initStroke(event);
}

References Private::canvas, KisTool::CLONE, KisViewManager::disableControls(), initStroke(), KisToolFreehandHelper::isRunning(), KIS_SAFE_ASSERT_RECOVER_RETURN, koIcon, lockTemporaryStraightRuler(), m_helper, KoPointerEvent::modifiers(), KisTool::MYPAINTBRUSH_UNPAINTABLE, KisTool::nodeEditable(), KisTool::nodePaintAbility(), KisTool::PAINT, KisTool::PAINT_MODE, KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), KisTool::SampleFgImage, KisToolPaint::setMode(), KisViewManager::showFloatingMessage(), temporaryStraightRulerOutlinePosition(), trySampleByPaintOp(), KisTool::VECTOR, and KisCanvas2::viewManager().

◆ calculatePerspective()

qreal KisToolFreehand::calculatePerspective ( const QPointF & documentPoint )

private

Calculates a coefficient for KisPaintInformation according to perspective grid values

Definition at line 591 of file kis_tool_freehand.cc.

{
    qreal perspective = 1.0;
    Q_FOREACH (const KisPaintingAssistantSP assistant, static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->assistants()) {
        QPointer<KisAbstractPerspectiveGrid> grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
        if (grid && grid->isActive() && grid->contains(documentPoint)) {
            perspective = grid->distance(documentPoint);
            break;
        }
    }
    return perspective;
}

References Private::canvas.

◆ continueAlternateAction()

void KisToolFreehand::continueAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolMultihand, and KisToolLazyBrush.

Definition at line 463 of file kis_tool_freehand.cc.

{
    if (trySampleByPaintOp(event, action) || m_paintopBasedSamplingInAction) return;
 
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::continueAlternateAction(event, action);
        return;
    }
 
    QPointF lastWidgetPosition = convertDocumentToWidget(m_lastDocumentPoint);
    QPointF actualWidgetPosition = convertDocumentToWidget(event->point);
 
    QPointF offset = actualWidgetPosition - lastWidgetPosition;
 
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    KIS_SAFE_ASSERT_RECOVER_RETURN(canvas2);
    QRect screenRect = QGuiApplication::primaryScreen()->availableVirtualGeometry();
 
    qreal scaleX = 0;
    qreal scaleY = 0;
    canvas2->coordinatesConverter()->imageScale(&scaleX, &scaleY);
 
    const qreal maxBrushSize = KisImageConfig(true).maxBrushSize();
    const qreal effectiveMaxDragSize = 0.5 * screenRect.width();
    const qreal effectiveMaxBrushSize = qMin(maxBrushSize, effectiveMaxDragSize / scaleX);
 
    const qreal scaleCoeff = effectiveMaxBrushSize / effectiveMaxDragSize;
    const qreal sizeDiff = scaleCoeff * offset.x() ;
 
    if (qAbs(sizeDiff) > 0.01) {
        KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
 
        qreal newSize = m_lastPaintOpSize + sizeDiff;
 
        if (action == ChangeSizeSnap) {
            newSize = qMax(qRound(newSize), 1);
        }
 
        newSize = qBound(0.01, newSize, maxBrushSize);
 
        settings->setPaintOpSize(newSize);
 
        requestUpdateOutline(
            m_initialGestureDocPoint,
            m_beginAlternateActionEvent.has_value() ? &m_beginAlternateActionEvent->event : nullptr);
        //m_brushResizeCompressor.start(newSize);
 
        m_lastDocumentPoint = event->point;
        m_lastPaintOpSize = newSize;
    }
}

References KoToolBase::action(), Private::canvas, KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisToolPaint::continueAlternateAction(), KisTool::convertDocumentToWidget(), KisCanvas2::coordinatesConverter, KisTool::currentPaintOpPreset(), KisCoordinatesConverter::imageScale(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_beginAlternateActionEvent, m_initialGestureDocPoint, m_lastDocumentPoint, m_lastPaintOpSize, m_paintopBasedSamplingInAction, KisImageConfig::maxBrushSize(), KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), and trySampleByPaintOp().

◆ continuePrimaryAction()

void KisToolFreehand::continuePrimaryAction ( KoPointerEvent * event )

overrideprotectedvirtual

Called by KisToolProxy when the primary action is in progress of pointer movement. If the tool has ignored the event in beginPrimaryAction(), this method will not be called.

Actual painting

Reimplemented from KisTool.

Reimplemented in KisToolMultihand, and KisToolLazyBrush.

Definition at line 357 of file kis_tool_freehand.cc.

{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    requestUpdateOutline(temporaryStraightRulerOutlinePosition(event->point), event);
 
    doStroke(event);
}

References CHECK_MODE_SANITY_OR_RETURN, doStroke(), KisTool::PAINT_MODE, KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), and temporaryStraightRulerOutlinePosition().

◆ deactivate

void KisToolFreehand::deactivate ( )

overrideslot

Definition at line 201 of file kis_tool_freehand.cc.

{
    if (mode() == PAINT_MODE) {
        endStroke();
        setMode(KisTool::HOVER_MODE);
    }
    if (KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas())) {
        if (canvas2->paintingAssistantsDecoration()) {
            canvas2->paintingAssistantsDecoration()->setTemporaryConstraint(std::nullopt);
        }
    }
    KisToolPaint::deactivate();
}

References Private::canvas, KisToolPaint::deactivate(), endStroke(), KisTool::HOVER_MODE, KisTool::mode(), KisTool::PAINT_MODE, and KisToolPaint::setMode().

◆ deactivateAlternateAction()

void KisToolFreehand::deactivateAlternateAction ( AlternateAction action )

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolLazyBrush.

Definition at line 429 of file kis_tool_freehand.cc.

{
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::deactivateAlternateAction(action);
        return;
    }
 
    resetCursorStyle();
    setOutlineVisible(false);
}

References KoToolBase::action(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisToolPaint::deactivateAlternateAction(), resetCursorStyle(), and KisToolPaint::setOutlineVisible().

◆ doStroke()

void KisToolFreehand::doStroke ( KoPointerEvent * event )

protectedvirtual

Definition at line 301 of file kis_tool_freehand.cc.

{
    m_helper->paintEvent(event);
}

References m_helper, and KisToolFreehandHelper::paintEvent().

◆ endAlternateAction()

void KisToolFreehand::endAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolMultihand, and KisToolLazyBrush.

Definition at line 515 of file kis_tool_freehand.cc.

{
    if (trySampleByPaintOp(event, action) || m_paintopBasedSamplingInAction) {
        m_paintopBasedSamplingInAction = false;
        return;
    }
 
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolPaint::endAlternateAction(event, action);
        return;
    }
 
    KisToolUtils::setCursorPos(m_initialGestureGlobalPoint);
    requestUpdateOutline(m_initialGestureDocPoint, 0);
 
    setMode(HOVER_MODE);
 
    m_beginAlternateActionEvent.reset();
}

References KoToolBase::action(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisToolPaint::endAlternateAction(), KisTool::HOVER_MODE, m_beginAlternateActionEvent, m_initialGestureDocPoint, m_initialGestureGlobalPoint, m_paintopBasedSamplingInAction, KisToolPaint::requestUpdateOutline(), KisToolUtils::setCursorPos(), KisToolPaint::setMode(), and trySampleByPaintOp().

◆ endPrimaryAction()

void KisToolFreehand::endPrimaryAction ( KoPointerEvent * event )

overrideprotectedvirtual

Called by KisToolProxy when the primary action is being finished, that is while mouseRelease or tabletRelease event. If the tool has ignored the event in beginPrimaryAction(), this method will not be called.

Reimplemented from KisTool.

Reimplemented in KisToolMultihand, and KisToolLazyBrush.

Definition at line 369 of file kis_tool_freehand.cc.

{
    Q_UNUSED(event);
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    endStroke();
 
    if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
        static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->endStroke();
    }
 
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    if (canvas2) {
        canvas2->viewManager()->enableControls();
    }
 
    setMode(KisTool::HOVER_MODE);
}

References Private::canvas, CHECK_MODE_SANITY_OR_RETURN, KisViewManager::enableControls(), endStroke(), KisTool::HOVER_MODE, m_assistant, KisTool::PAINT_MODE, KisToolPaint::setMode(), and KisCanvas2::viewManager().

◆ endStroke()

void KisToolFreehand::endStroke ( )

protectedvirtual

Definition at line 306 of file kis_tool_freehand.cc.

{
    m_helper->endPaint();
    bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->mouseReleaseEvent();
    Q_UNUSED(paintOpIgnoredEvent);
}

References KisTool::currentPaintOpPreset(), KisToolFreehandHelper::endPaint(), and m_helper.

◆ explicitUpdateOutline

void KisToolFreehand::explicitUpdateOutline ( )

protectedslot

Definition at line 609 of file kis_tool_freehand.cc.

{
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References KisToolPaint::m_outlineDocPoint, and KisToolPaint::requestUpdateOutline().

◆ flags()

int KisToolFreehand::flags ( ) const

overridevirtual

Reimplemented from KisTool.

Definition at line 190 of file kis_tool_freehand.cc.

{
    return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP|KisTool::FLAG_USES_CUSTOM_PRESET
           |KisTool::FLAG_USES_CUSTOM_SIZE;
}

References KisTool::FLAG_USES_CUSTOM_COMPOSITEOP, KisTool::FLAG_USES_CUSTOM_PRESET, and KisTool::FLAG_USES_CUSTOM_SIZE.

◆ getOutlinePath()

KisOptimizedBrushOutline KisToolFreehand::getOutlinePath	(	const QPointF &	documentPos,
		const KoPointerEvent *	event,
		KisPaintOpSettings::OutlineMode	outlineMode )

overrideprotectedvirtual

Reimplemented from KisToolPaint.

Definition at line 614 of file kis_tool_freehand.cc.

{
    if (temporaryStraightRulerActive()) {
        return KisOptimizedBrushOutline();
    }
 
    if (currentPaintOpPreset())
        return m_helper->paintOpOutline(convertToPixelCoord(documentPos),
                                        event,
                                        currentPaintOpPreset()->settings(),
                                        outlineMode);
    else
        return KisOptimizedBrushOutline();
}

References KisTool::convertToPixelCoord(), KisTool::currentPaintOpPreset(), m_helper, KisToolFreehandHelper::paintOpOutline(), and temporaryStraightRulerActive().

◆ initStroke()

void KisToolFreehand::initStroke ( KoPointerEvent * event )

protectedvirtual

Reimplemented in KisToolDyna.

Definition at line 292 of file kis_tool_freehand.cc.

{
    m_helper->initPaint(event,
                        convertToPixelCoord(event),
                        image(),
                        currentNode(),
                        image().data());
}

References KisTool::convertToPixelCoord(), KisTool::currentNode(), KisTool::image(), KisToolFreehandHelper::initPaint(), and m_helper.

◆ lockTemporaryStraightRuler()

void KisToolFreehand::lockTemporaryStraightRuler	(	const QPointF &	documentPoint,
		Qt::KeyboardModifiers	modifiers )

private

Definition at line 259 of file kis_tool_freehand.cc.

{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    if (!canvas2 || !canvas2->paintingAssistantsDecoration()) {
        return;
    }
 
    std::optional<KisTemporaryPaintConstraint> constraint =
        canvas2->paintingAssistantsDecoration()->temporaryConstraint();
 
    if (!constraint) {
        return;
    }
 
    if (!constraint->hasLine()) {
        return;
    }
 
    if (!constraint->isLocked()) {
        constraint->updateLine(documentPoint, snapsTemporaryStraightRuler(*constraint, modifiers));
    }
 
    if (constraint->hasValidLine()) {
        constraint->setLocked(true);
    } else {
        const KisTemporaryPaintConstraint::InteractionMode interactionMode = constraint->interactionMode();
        constraint = KisTemporaryPaintConstraint();
        constraint->setInteractionMode(interactionMode);
    }
 
    canvas2->paintingAssistantsDecoration()->setTemporaryConstraint(constraint);
}

References Private::canvas, KisCanvas2::paintingAssistantsDecoration(), KisPaintingAssistantsDecoration::setTemporaryConstraint(), and KisPaintingAssistantsDecoration::temporaryConstraint().

◆ mouseMoveEvent()

void KisToolFreehand::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

Reimplemented from KisTool.

Reimplemented in KisToolMultihand.

Definition at line 109 of file kis_tool_freehand.cc.

{
    m_helper->cursorMoved(convertToPixelCoord(event));
 
    if (temporaryStraightRulerActive()) {
        if (mode() == HOVER_MODE) {
            updateTemporaryStraightRulerPreview(event->point, event->modifiers());
            requestUpdateOutline(temporaryStraightRulerOutlinePosition(event->point), event);
        }
    } else {
        KisToolPaint::mouseMoveEvent(event);
    }
}

References KisTool::convertToPixelCoord(), KisToolFreehandHelper::cursorMoved(), KisTool::HOVER_MODE, m_helper, KisTool::mode(), KoPointerEvent::modifiers(), KisToolPaint::mouseMoveEvent(), KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), temporaryStraightRulerActive(), temporaryStraightRulerOutlinePosition(), and updateTemporaryStraightRulerPreview().

◆ paintingInformationBuilder()

KisPaintingInformationBuilder * KisToolFreehand::paintingInformationBuilder ( ) const

protected

Definition at line 174 of file kis_tool_freehand.cc.

{
    return m_infoBuilder;
}

References m_infoBuilder.

◆ primaryActionSupportsHiResEvents()

bool KisToolFreehand::primaryActionSupportsHiResEvents ( ) const

overrideprotectedvirtual

Returns true if the tool can handle (and wants to handle) a very tight flow of input events from the tablet

Reimplemented from KisTool.

Definition at line 313 of file kis_tool_freehand.cc.

{
    return true;
}

◆ resetCursorStyle

void KisToolFreehand::resetCursorStyle ( )

overrideprotectedslot

Definition at line 128 of file kis_tool_freehand.cc.

{
    if (temporaryStraightRulerActive()) {
        useCursor(KisCursor::loadWithSize("cursor-cross-full.svg", 31, 31));
        return;
    }
 
    KisConfig cfg(true);
 
    bool useSeparateEraserCursor = cfg.separateEraserCursor() && isEraser();
 
    switch (useSeparateEraserCursor ? cfg.eraserCursorStyle() : cfg.newCursorStyle()) {
    case CURSOR_STYLE_NO_CURSOR:
        useCursor(KisCursor::blankCursor());
        break;
    case CURSOR_STYLE_POINTER:
        useCursor(KisCursor::arrowCursor());
        break;
    case CURSOR_STYLE_SMALL_ROUND:
        useCursor(KisCursor::roundCursor());
        break;
    case CURSOR_STYLE_CROSSHAIR:
        useCursor(KisCursor::crossCursor());
        break;
    case CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
        useCursor(KisCursor::triangleRightHandedCursor());
        break;
    case CURSOR_STYLE_TRIANGLE_LEFTHANDED:
        useCursor(KisCursor::triangleLeftHandedCursor());
        break;
    case CURSOR_STYLE_BLACK_PIXEL:
        useCursor(KisCursor::pixelBlackCursor());
        break;
    case CURSOR_STYLE_WHITE_PIXEL:
        useCursor(KisCursor::pixelWhiteCursor());
        break;
    case CURSOR_STYLE_ERASER:
        useCursor(KisCursor::eraserCursor());
        break;
    case CURSOR_STYLE_TOOLICON:
    default:
        KisToolPaint::resetCursorStyle();
        break;
    }
}

References KisCursor::arrowCursor(), KisCursor::blankCursor(), KisCursor::crossCursor(), CURSOR_STYLE_BLACK_PIXEL, CURSOR_STYLE_CROSSHAIR, CURSOR_STYLE_ERASER, CURSOR_STYLE_NO_CURSOR, CURSOR_STYLE_POINTER, CURSOR_STYLE_SMALL_ROUND, CURSOR_STYLE_TOOLICON, CURSOR_STYLE_TRIANGLE_LEFTHANDED, CURSOR_STYLE_TRIANGLE_RIGHTHANDED, CURSOR_STYLE_WHITE_PIXEL, KisCursor::eraserCursor(), KisConfig::eraserCursorStyle(), KisToolPaint::isEraser(), KisCursor::loadWithSize(), KisConfig::newCursorStyle(), KisCursor::pixelBlackCursor(), KisCursor::pixelWhiteCursor(), KisTool::resetCursorStyle(), KisCursor::roundCursor(), KisConfig::separateEraserCursor(), temporaryStraightRulerActive(), KisCursor::triangleLeftHandedCursor(), KisCursor::triangleRightHandedCursor(), and KoToolBase::useCursor().

◆ resetHelper()

void KisToolFreehand::resetHelper ( KisToolFreehandHelper * helper )

protected

Definition at line 179 of file kis_tool_freehand.cc.

{
    delete m_helper;
    m_helper = helper;
}

References m_helper.

◆ setAssistant

void KisToolFreehand::setAssistant ( bool assistant )

protectedslot

Definition at line 540 of file kis_tool_freehand.cc.

{
    m_assistant = assistant;
}

References m_assistant.

◆ setOnlyOneAssistantSnap

void KisToolFreehand::setOnlyOneAssistantSnap ( bool assistant )

protectedslot

Definition at line 545 of file kis_tool_freehand.cc.

{
    m_only_one_assistant = assistant;
}

References m_only_one_assistant.

◆ setSnapEraser

void KisToolFreehand::setSnapEraser ( bool assistant )

protectedslot

Definition at line 550 of file kis_tool_freehand.cc.

{
    m_eraser_snapping = assistant;
}

References m_eraser_snapping.

◆ slotDoResizeBrush

void KisToolFreehand::slotDoResizeBrush ( qreal newSize )

protectedslot

Definition at line 555 of file kis_tool_freehand.cc.

{
    KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
 
    settings->setPaintOpSize(newSize);
    requestUpdateOutline(m_initialGestureDocPoint, 0);
 
}

References KisTool::currentPaintOpPreset(), m_initialGestureDocPoint, and KisToolPaint::requestUpdateOutline().

◆ smoothingOptions()

KisSmoothingOptionsSP KisToolFreehand::smoothingOptions ( ) const

protected

Definition at line 123 of file kis_tool_freehand.cc.

{
    return m_helper->smoothingOptions();
}

References m_helper, and KisToolFreehandHelper::smoothingOptions().

◆ supportsPaintingAssistants()

bool KisToolFreehand::supportsPaintingAssistants ( ) const

overrideprotectedvirtual

Reimplemented from KisTool.

Definition at line 185 of file kis_tool_freehand.cc.

{
    return true;
}

◆ temporaryStraightRulerActive()

bool KisToolFreehand::temporaryStraightRulerActive ( ) const

private

Definition at line 215 of file kis_tool_freehand.cc.

{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    return canvas2 &&
        canvas2->paintingAssistantsDecoration() &&
        canvas2->paintingAssistantsDecoration()->temporaryConstraint().has_value();
}

References Private::canvas, KisCanvas2::paintingAssistantsDecoration(), and KisPaintingAssistantsDecoration::temporaryConstraint().

◆ temporaryStraightRulerOutlinePosition()

QPointF KisToolFreehand::temporaryStraightRulerOutlinePosition ( const QPointF & documentPoint )

private

Definition at line 223 of file kis_tool_freehand.cc.

{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    if (!canvas2 ||
        !canvas2->paintingAssistantsDecoration() ||
        !hasLockedValidTemporaryStraightRuler(canvas2->paintingAssistantsDecoration()->temporaryConstraint())) {
 
        return documentPoint;
    }
 
    return adjustPosition(documentPoint, documentPoint);
}

References adjustPosition(), Private::canvas, KisCanvas2::paintingAssistantsDecoration(), and KisPaintingAssistantsDecoration::temporaryConstraint().

◆ trySampleByPaintOp()

bool KisToolFreehand::trySampleByPaintOp	(	KoPointerEvent *	event,
		AlternateAction	action )

protected

FIXME: we need some better way to implement modifiers for a paintop level. This method is used in DuplicateOp only!

Definition at line 388 of file kis_tool_freehand.cc.

{
    if (action != SampleFgNode && action != SampleFgImage) return false;
 
    QPointF pos = adjustPosition(event->point, event->point);
    qreal perspective = calculatePerspective(pos);
    if (!currentPaintOpPreset()) {
        return false;
    }
    KisPaintInformation info(convertToPixelCoord(event->point),
                             m_infoBuilder->pressureToCurve(event->pressure()),
                             event->xTilt(), event->yTilt(),
                             event->rotation(),
                             event->tangentialPressure(),
                             perspective, 0, 0);
    info.setRandomSource(new KisRandomSource());
    info.setPerStrokeRandomSource(new KisPerStrokeRandomSource());
 
    bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->mousePressEvent(info,
                                                                                   event->modifiers(),
                                                                                   currentNode());
    // DuplicateOP during the sampling of new source point (origin)
    // is the only paintop that returns "false" here
    return !paintOpIgnoredEvent;
}

References KoToolBase::action(), adjustPosition(), calculatePerspective(), KisTool::convertToPixelCoord(), KisTool::currentNode(), KisTool::currentPaintOpPreset(), m_infoBuilder, KoPointerEvent::modifiers(), KoPointerEvent::point, KoPointerEvent::pressure(), KisPaintingInformationBuilder::pressureToCurve(), KoPointerEvent::rotation(), KisTool::SampleFgImage, KisTool::SampleFgNode, KisPaintInformation::setPerStrokeRandomSource(), KisPaintInformation::setRandomSource(), KoPointerEvent::tangentialPressure(), KoPointerEvent::xTilt(), and KoPointerEvent::yTilt().

◆ updateMaskSyntheticEventsFromTouch

void KisToolFreehand::updateMaskSyntheticEventsFromTouch ( )

privateslot

Definition at line 604 of file kis_tool_freehand.cc.

{
    setMaskSyntheticEvents(KisConfig(true).disableTouchOnCanvas());
}

References KoToolBase::setMaskSyntheticEvents().

◆ updateTemporaryStraightRulerPreview()

void KisToolFreehand::updateTemporaryStraightRulerPreview	(	const QPointF &	documentPoint,
		Qt::KeyboardModifiers	modifiers )

private

Definition at line 236 of file kis_tool_freehand.cc.

{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2*>(canvas());
    if (!canvas2 || !canvas2->paintingAssistantsDecoration()) {
        return;
    }
 
    std::optional<KisTemporaryPaintConstraint> constraint =
        canvas2->paintingAssistantsDecoration()->temporaryConstraint();
 
    if (!constraint || constraint->isLocked()) {
        return;
    }
 
    if (!constraint->hasLine()) {
        constraint->beginLine(documentPoint);
    } else {
        constraint->updateLine(documentPoint, snapsTemporaryStraightRuler(*constraint, modifiers));
    }
 
    canvas2->paintingAssistantsDecoration()->setTemporaryConstraint(constraint);
}

References Private::canvas, KisCanvas2::paintingAssistantsDecoration(), KisPaintingAssistantsDecoration::setTemporaryConstraint(), and KisPaintingAssistantsDecoration::temporaryConstraint().

◆ wantsAutoScroll()

bool KisToolFreehand::wantsAutoScroll ( ) const

overrideprotectedvirtual

Return if dragging (moving with the mouse down) to the edge of a canvas should scroll the canvas (default is true).

Returns: if this tool wants mouse events to cause scrolling of canvas.

Reimplemented from KoToolBase.

Definition at line 535 of file kis_tool_freehand.cc.

{
    return false;
}

Friends And Related Symbol Documentation

◆ KisToolFreehandPaintingInformationBuilder

friend class KisToolFreehandPaintingInformationBuilder

friend

Definition at line 93 of file kis_tool_freehand.h.

◆ KisView

friend class KisView

friend

Definition at line 116 of file kis_tool_freehand.h.

◆ KisViewManager

friend class KisViewManager

friend

Definition at line 115 of file kis_tool_freehand.h.

Member Data Documentation

◆ m_assistant

bool KisToolFreehand::m_assistant {false}

protected

Definition at line 118 of file kis_tool_freehand.h.

118{false};

◆ m_beginAlternateActionEvent

std::optional<KoPointerEventWrapper> KisToolFreehand::m_beginAlternateActionEvent

private

Definition at line 135 of file kis_tool_freehand.h.

◆ m_brushResizeCompressor

KisSignalCompressorWithParam<qreal> KisToolFreehand::m_brushResizeCompressor

private

Definition at line 133 of file kis_tool_freehand.h.

◆ m_eraser_snapping

bool KisToolFreehand::m_eraser_snapping {false}

protected

Definition at line 121 of file kis_tool_freehand.h.

121{false};

◆ m_helper

KisToolFreehandHelper* KisToolFreehand::m_helper {nullptr}

private

Definition at line 125 of file kis_tool_freehand.h.

125{nullptr};

◆ m_infoBuilder

KisPaintingInformationBuilder* KisToolFreehand::m_infoBuilder {nullptr}

private

Definition at line 124 of file kis_tool_freehand.h.

124{nullptr};

◆ m_initialGestureDocPoint

QPointF KisToolFreehand::m_initialGestureDocPoint

private

Definition at line 127 of file kis_tool_freehand.h.

◆ m_initialGestureGlobalPoint

QPoint KisToolFreehand::m_initialGestureGlobalPoint

private

Definition at line 130 of file kis_tool_freehand.h.

◆ m_lastDocumentPoint

QPointF KisToolFreehand::m_lastDocumentPoint

private

Definition at line 128 of file kis_tool_freehand.h.

◆ m_lastPaintOpSize

qreal KisToolFreehand::m_lastPaintOpSize {0.0}

private

Definition at line 129 of file kis_tool_freehand.h.

129{0.0};

◆ m_magnetism

double KisToolFreehand::m_magnetism {1.0}

protected

Definition at line 119 of file kis_tool_freehand.h.

119{1.0};

◆ m_only_one_assistant

bool KisToolFreehand::m_only_one_assistant {true}

protected

Definition at line 120 of file kis_tool_freehand.h.

120{true};

◆ m_paintopBasedSamplingInAction

bool KisToolFreehand::m_paintopBasedSamplingInAction {false}

private

Definition at line 132 of file kis_tool_freehand.h.

132{false};

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

libs/ui/tool/kis_tool_freehand.h
libs/ui/tool/kis_tool_freehand.cc

Public Slots

Public Member Functions

Protected Slots

Protected Member Functions

Protected Attributes

Private Slots

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisToolFreehand()

◆ ~KisToolFreehand()

Member Function Documentation

◆ activate

◆ activateAlternateAction()

◆ adjustPosition()

◆ beginAlternateAction()

◆ beginPrimaryAction()

◆ calculatePerspective()

◆ continueAlternateAction()

◆ continuePrimaryAction()

◆ deactivate

◆ deactivateAlternateAction()

◆ doStroke()

◆ endAlternateAction()

◆ endPrimaryAction()

◆ endStroke()

◆ explicitUpdateOutline

◆ flags()

◆ getOutlinePath()

◆ initStroke()

◆ lockTemporaryStraightRuler()

◆ mouseMoveEvent()

◆ paintingInformationBuilder()

◆ primaryActionSupportsHiResEvents()

◆ resetCursorStyle

◆ resetHelper()

◆ setAssistant

◆ setOnlyOneAssistantSnap

◆ setSnapEraser

◆ slotDoResizeBrush

◆ smoothingOptions()

◆ supportsPaintingAssistants()

◆ temporaryStraightRulerActive()

◆ temporaryStraightRulerOutlinePosition()

◆ trySampleByPaintOp()

◆ updateMaskSyntheticEventsFromTouch

◆ updateTemporaryStraightRulerPreview()

◆ wantsAutoScroll()

Friends And Related Symbol Documentation

◆ KisToolFreehandPaintingInformationBuilder

◆ KisView

◆ KisViewManager

Member Data Documentation

◆ m_assistant

◆ m_beginAlternateActionEvent

◆ m_brushResizeCompressor

◆ m_eraser_snapping

◆ m_helper

◆ m_infoBuilder

◆ m_initialGestureDocPoint

◆ m_initialGestureGlobalPoint

◆ m_lastDocumentPoint

◆ m_lastPaintOpSize

◆ m_magnetism

◆ m_only_one_assistant

◆ m_paintopBasedSamplingInAction