#include <KisToolBasicBrushBase.h>

Inheritance diagram for KisToolBasicBrushBase:

Public Types
enum	ToolType { PAINT , SELECT }

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 }

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

void	deactivate () override

void	setPreviewColor (const QColor &color)

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

virtual void	fillSettingChanged (int value)

virtual void	outlineSettingChanged (int value)

virtual void	patternRotationSettingChanged (qreal value)

virtual void	patternScaleSettingChanged (qreal value)

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

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	endPrimaryAction (KoPointerEvent *event) override

	KisToolBasicBrushBase (KoCanvasBase *canvas, ToolType type, const QCursor &cursor=KisCursor::load("tool_outline_selection_cursor.png", 5, 5))

void	mouseMoveEvent (KoPointerEvent *event) override

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

qreal	pressureToCurve (qreal pressure)

	~KisToolBasicBrushBase () override

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

	KisToolShape (KoCanvasBase *canvas, const QCursor &cursor)

	~KisToolShape () override

Public Member Functions inherited from KisToolPaint
	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 ()

virtual bool	primaryActionSupportsHiResEvents () const

virtual bool	supportsPaintingAssistants () const

	~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

virtual bool	wantsAutoScroll () const

	~KoToolBase () override

Protected Slots
void	resetCursorStyle () override

void	updateSettings ()

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Protected Member Functions
virtual void	finishStroke (const QPainterPath &stroke)=0

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

Protected Member Functions inherited from KisToolShape
void	addPathShape (KoPathShape *pathShape, const KUndo2MagicString &name)

void	addShape (KoShape *shape)

virtual void	beginShape ()

QWidget *	createOptionWidget () override

qreal	currentStrokeWidth () const

virtual void	endShape ()

KisToolShapeUtils::FillStyle	fillStyle ()

QTransform	fillTransform ()

ShapeAddInfo	shouldAddShape (KisNodeSP currentNode) const

KisToolShapeUtils::StrokeStyle	strokeStyle ()

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

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)

Private Member Functions
QPainterPath	generateSegment (const QPointF &point1, qreal radius1, const QPointF &point2, qreal radius2) const

void	update (const QRectF &strokeSegmentRect)

Private Attributes
QPointF	m_changeSizeInitialGestureDocPoint

QPoint	m_changeSizeInitialGestureGlobalPoint

QPointF	m_changeSizeLastDocumentPoint

qreal	m_changeSizeLastPaintOpSize {0.0}

bool	m_forceAlwaysFullSizedOutline {true}

QPointF	m_lastPosition

qreal	m_lastPressure {1.0}

OutlineStyle	m_outlineStyle {OUTLINE_FULL}

QPainterPath	m_path

QVector< qreal >	m_pressureSamples

QColor	m_previewColor

bool	m_showOutlineWhilePainting {true}

ToolType	m_type {PAINT}

Static Private Attributes
static constexpr int	feedbackLineWidth {2}

static constexpr int	levelOfPressureResolution = 1024

Additional Inherited Members
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 KisToolShape
WdgGeometryOptions *	m_shapeOptionsWidget

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 }

Protected Attributes inherited from KisToolShape
KConfigGroup	m_configGroup

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

Properties inherited from KisTool
bool	isActive

Detailed Description

Definition at line 13 of file KisToolBasicBrushBase.h.

Member Enumeration Documentation

◆ ToolType

enum KisToolBasicBrushBase::ToolType

Enumerator
PAINT
SELECT

Definition at line 18 of file KisToolBasicBrushBase.h.

                  {
        PAINT,
        SELECT
    };

Constructor & Destructor Documentation

◆ KisToolBasicBrushBase()

KisToolBasicBrushBase::KisToolBasicBrushBase	(	KoCanvasBase *	canvas,
		ToolType	type,
		const QCursor &	cursor = KisCursor::load("tool_outline_selection_cursor.png", 5, 5) )

Definition at line 25 of file KisToolBasicBrushBase.cpp.

    : KisToolShape(canvas, cursor)
    , m_type(type)
    , m_previewColor(0, 255, 0, 128)
{
    setSupportOutline(true);
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(updateSettings()));
    updateSettings();
}

References connect(), KisConfigNotifier::instance(), KisToolPaint::setSupportOutline(), and updateSettings().

◆ ~KisToolBasicBrushBase()

KisToolBasicBrushBase::~KisToolBasicBrushBase ( )

override

Definition at line 35 of file KisToolBasicBrushBase.cpp.

36{}

Member Function Documentation

◆ activate

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

overrideslot

Definition at line 281 of file KisToolBasicBrushBase.cpp.

{
    m_lastPressure = 1.0;
    
    KisToolShape::activate(shapes);
}

References KisToolShape::activate(), and m_lastPressure.

◆ activateAlternateAction()

void KisToolBasicBrushBase::activateAlternateAction ( AlternateAction action )

overridevirtual

Reimplemented from KisTool.

Definition at line 124 of file KisToolBasicBrushBase.cpp.

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

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

◆ beginAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 146 of file KisToolBasicBrushBase.cpp.

{
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolShape::beginAlternateAction(event, action);
        return;
    }
 
    setMode(GESTURE_MODE);
    m_changeSizeInitialGestureDocPoint = event->point;
    m_changeSizeInitialGestureGlobalPoint = QCursor::pos();
 
    m_changeSizeLastDocumentPoint = event->point;
    m_changeSizeLastPaintOpSize = currentPaintOpPreset()->settings()->paintOpSize();
}

References KoToolBase::action(), KisTool::beginAlternateAction(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisTool::currentPaintOpPreset(), KisTool::GESTURE_MODE, m_changeSizeInitialGestureDocPoint, m_changeSizeInitialGestureGlobalPoint, m_changeSizeLastDocumentPoint, m_changeSizeLastPaintOpSize, and KisToolPaint::setMode().

◆ beginPrimaryAction()

void KisToolBasicBrushBase::beginPrimaryAction ( KoPointerEvent * event )

overridevirtual

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.

Definition at line 58 of file KisToolBasicBrushBase.cpp.

{
    NodePaintAbility paintability = nodePaintAbility();
    if ((m_type == PAINT && (!nodeEditable() || paintability == UNPAINTABLE || paintability  == KisToolPaint::CLONE || paintability == KisToolPaint::MYPAINTBRUSH_UNPAINTABLE)) || (m_type == SELECT && !selectionEditable())) {
 
        if (paintability == KisToolPaint::CLONE){
            KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
            QString message = i18n("This tool cannot paint on clone layers.  Please select a paint or vector layer or mask.");
            kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
        }
 
        if (paintability == KisToolPaint::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;
    }
 
    setMode(KisTool::PAINT_MODE);
 
    beginShape();
 
    const QPointF position = convertToPixelCoord(event);
    const qreal pressure = pressureToCurve(event->pressure());
    const qreal radius = pressure * currentPaintOpPreset()->settings()->paintOpSize() / 2.0;
    m_path = QPainterPath(position);
    m_path.setFillRule(Qt::WindingFill);
    m_path.addEllipse(position, radius, radius);
 
    m_lastPosition = position;
    m_lastPressure = pressure;
 
    update(m_path.boundingRect());
}

References KisToolShape::beginShape(), Private::canvas, KisTool::CLONE, KisTool::convertToPixelCoord(), KisTool::currentPaintOpPreset(), koIcon, m_lastPosition, m_lastPressure, m_path, m_type, KisTool::MYPAINTBRUSH_UNPAINTABLE, KisTool::nodeEditable(), KisTool::nodePaintAbility(), PAINT, KisTool::PAINT_MODE, KoPointerEvent::pressure(), pressureToCurve(), SELECT, KisTool::selectionEditable(), KisToolPaint::setMode(), KisViewManager::showFloatingMessage(), KisTool::UNPAINTABLE, update(), and KisCanvas2::viewManager().

◆ continueAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 161 of file KisToolBasicBrushBase.cpp.

{
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolShape::continueAlternateAction(event, action);
        return;
    }
 
    QPointF lastWidgetPosition = convertDocumentToWidget(m_changeSizeLastDocumentPoint);
    QPointF actualWidgetPosition = convertDocumentToWidget(event->point);
 
    QPointF offset = actualWidgetPosition - lastWidgetPosition;
 
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    KIS_ASSERT(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_changeSizeLastPaintOpSize + sizeDiff;
 
        if (action == ChangeSizeSnap) {
            newSize = qMax(qRound(newSize), 1);
        }
 
        newSize = qBound(0.01, newSize, maxBrushSize);
 
        settings->setPaintOpSize(newSize);
 
        requestUpdateOutline(m_changeSizeInitialGestureDocPoint, 0);
 
        m_changeSizeLastDocumentPoint = event->point;
        m_changeSizeLastPaintOpSize = newSize;
    }
}

References KoToolBase::action(), Private::canvas, KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisTool::continueAlternateAction(), KisTool::convertDocumentToWidget(), KisCanvas2::coordinatesConverter, KisTool::currentPaintOpPreset(), KisCoordinatesConverter::imageScale(), KIS_ASSERT, m_changeSizeInitialGestureDocPoint, m_changeSizeLastDocumentPoint, m_changeSizeLastPaintOpSize, KisImageConfig::maxBrushSize(), KoPointerEvent::point, and KisToolPaint::requestUpdateOutline().

◆ continuePrimaryAction()

void KisToolBasicBrushBase::continuePrimaryAction ( KoPointerEvent * event )

overridevirtual

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.

Reimplemented from KisTool.

Definition at line 96 of file KisToolBasicBrushBase.cpp.

{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    const QPointF position = convertToPixelCoord(event);
    const qreal pressure = pressureToCurve(event->pressure());
    const qreal brushRadius = currentPaintOpPreset()->settings()->paintOpSize() / 2.0;
    const QPainterPath segment = generateSegment(m_lastPosition, m_lastPressure * brushRadius, position, pressure * brushRadius);
    m_path.addPath(segment);
 
    m_lastPosition = position;
    m_lastPressure = pressure;
 
    requestUpdateOutline(event->point, event);
    update(segment.boundingRect());
}

References CHECK_MODE_SANITY_OR_RETURN, KisTool::convertToPixelCoord(), KisTool::currentPaintOpPreset(), generateSegment(), m_lastPosition, m_lastPressure, m_path, KisTool::PAINT_MODE, KoPointerEvent::point, KoPointerEvent::pressure(), pressureToCurve(), KisToolPaint::requestUpdateOutline(), and update().

◆ deactivate

void KisToolBasicBrushBase::deactivate ( )

overrideslot

Definition at line 288 of file KisToolBasicBrushBase.cpp.

{
    KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
    kisCanvas->updateCanvas();
 
    KisToolShape::deactivate();
}

References Private::canvas, KoToolBase::deactivate(), KIS_ASSERT_RECOVER_RETURN, and KisCanvas2::updateCanvas().

◆ deactivateAlternateAction()

void KisToolBasicBrushBase::deactivateAlternateAction ( AlternateAction action )

overridevirtual

Reimplemented from KisTool.

Definition at line 135 of file KisToolBasicBrushBase.cpp.

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

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

◆ endAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 208 of file KisToolBasicBrushBase.cpp.

{
    if (action != ChangeSize && action != ChangeSizeSnap) {
        KisToolShape::endAlternateAction(event, action);
        return;
    }
 
    KisToolUtils::setCursorPos(m_changeSizeInitialGestureGlobalPoint);
    requestUpdateOutline(m_changeSizeInitialGestureDocPoint, 0);
 
    setMode(HOVER_MODE);
}

References KoToolBase::action(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisTool::endAlternateAction(), KisTool::HOVER_MODE, m_changeSizeInitialGestureDocPoint, m_changeSizeInitialGestureGlobalPoint, KisToolPaint::requestUpdateOutline(), KisToolUtils::setCursorPos(), and KisToolPaint::setMode().

◆ endPrimaryAction()

void KisToolBasicBrushBase::endPrimaryAction ( KoPointerEvent * event )

overridevirtual

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.

Definition at line 113 of file KisToolBasicBrushBase.cpp.

{
    Q_UNUSED(event);
 
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
    setMode(KisTool::HOVER_MODE);
 
    endShape();
    finishStroke(m_path);
}

References CHECK_MODE_SANITY_OR_RETURN, KisToolShape::endShape(), finishStroke(), KisTool::HOVER_MODE, m_path, KisTool::PAINT_MODE, and KisToolPaint::setMode().

◆ finishStroke()

virtual void KisToolBasicBrushBase::finishStroke ( const QPainterPath & stroke )

protectedpure virtual

Implemented in KisBrushEnclosingProducer.

◆ generateSegment()

QPainterPath KisToolBasicBrushBase::generateSegment	(	const QPointF &	point1,
		qreal	radius1,
		const QPointF &	point2,
		qreal	radius2 ) const

private

Definition at line 343 of file KisToolBasicBrushBase.cpp.

{
    const QPointF &p1 = radius1 < radius2 ? point2 : point1;
    const QPointF &p2 = radius1 < radius2 ? point1 : point2;
    const qreal &r1 = radius1 < radius2 ? radius2 : radius1;
    const qreal &r2 = radius1 < radius2 ? radius1 : radius2;
    const QPointF deltaP1P2 = p2 - p1;
    const qreal deltaR1R2 = r1 - r2;
    QPointF tangentPointP11, tangentPointP12, tangentPointP21, tangentPointP22;
 
    if (qFuzzyIsNull(deltaR1R2)) {
        // Same radius case
        const qreal deltaP1P2Length = std::sqrt(deltaP1P2.x() * deltaP1P2.x() + deltaP1P2.y() * deltaP1P2.y());
        const QPointF deltaP1P2Normalized = deltaP1P2 / deltaP1P2Length;
        tangentPointP11 = p1 + QPointF(deltaP1P2Normalized.y(), -deltaP1P2Normalized.x()) * r1;
        tangentPointP12 = p1 + QPointF(-deltaP1P2Normalized.y(), deltaP1P2Normalized.x()) * r1;
        tangentPointP21 = p2 + QPointF(deltaP1P2Normalized.y(), -deltaP1P2Normalized.x()) * r2;
        tangentPointP22 = p2 + QPointF(-deltaP1P2Normalized.y(), deltaP1P2Normalized.x()) * r2;
    } else {
        // General case
        const QPointF tangentIntersectionPoint(
            (p2.x() * r1 - p1.x() * r2) / deltaR1R2,
            (p2.y() * r1 - p1.y() * r2) / deltaR1R2
        );
        auto f = [](qreal t1, qreal t2, qreal t3, qreal t4, qreal sign) -> qreal
        {
            return (t1 + sign * t2) / t3 + t4;
        };
        {
            const qreal r1Squared = r1 * r1;
            const QPointF deltaP1TangentIntersectionPoint = tangentIntersectionPoint - p1;
            const qreal deltaP1TangentIntersectionPointLengthSquared = 
                deltaP1TangentIntersectionPoint.x() * deltaP1TangentIntersectionPoint.x() +
                deltaP1TangentIntersectionPoint.y() * deltaP1TangentIntersectionPoint.y();
            const QPointF t11 = r1Squared * deltaP1TangentIntersectionPoint;
            const QPointF t12 = r1 * deltaP1TangentIntersectionPoint * std::sqrt(deltaP1TangentIntersectionPointLengthSquared - r1Squared);
            tangentPointP11 = QPointF(
                f(t11.x(), t12.y(), deltaP1TangentIntersectionPointLengthSquared, p1.x(), 1.0),
                f(t11.y(), t12.x(), deltaP1TangentIntersectionPointLengthSquared, p1.y(), -1.0)
            );
            tangentPointP12 = QPointF(
                f(t11.x(), t12.y(), deltaP1TangentIntersectionPointLengthSquared, p1.x(), -1.0),
                f(t11.y(), t12.x(), deltaP1TangentIntersectionPointLengthSquared, p1.y(), 1.0)
            );
        }
        {
            const qreal r2Squared = r2 * r2;
            const QPointF deltaP2TangentIntersectionPoint = tangentIntersectionPoint - p2;
            const qreal deltaP2TangentIntersectionPointLengthSquared = 
                deltaP2TangentIntersectionPoint.x() * deltaP2TangentIntersectionPoint.x() +
                deltaP2TangentIntersectionPoint.y() * deltaP2TangentIntersectionPoint.y();
            const QPointF t11 = r2Squared * deltaP2TangentIntersectionPoint;
            const QPointF t12 = r2 * deltaP2TangentIntersectionPoint * std::sqrt(deltaP2TangentIntersectionPointLengthSquared - r2Squared);
            tangentPointP21 = QPointF(
                f(t11.x(), t12.y(), deltaP2TangentIntersectionPointLengthSquared, p2.x(), 1.0),
                f(t11.y(), t12.x(), deltaP2TangentIntersectionPointLengthSquared, p2.y(), -1.0)
            );
            tangentPointP22 = QPointF(
                f(t11.x(), t12.y(), deltaP2TangentIntersectionPointLengthSquared, p2.x(), -1.0),
                f(t11.y(), t12.x(), deltaP2TangentIntersectionPointLengthSquared, p2.y(), 1.0)
            );
        }
    }
 
    QPainterPath path;
    path.setFillRule(Qt::WindingFill);
    path.moveTo(tangentPointP11);
    path.lineTo(tangentPointP21);
    path.lineTo(tangentPointP22);
    path.lineTo(tangentPointP12);
    path.closeSubpath();
    path.addEllipse(point2, radius2, radius2);
    return path;
}

References p1, p2, qFuzzyIsNull(), r1, r2, and sign().

◆ getOutlinePath()

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

overrideprotectedvirtual

Reimplemented from KisToolPaint.

Definition at line 254 of file KisToolBasicBrushBase.cpp.

{
    Q_UNUSED(documentPos);
    Q_UNUSED(event);
 
    if (!outlineMode.isVisible) {
        return {};
    }
    const qreal radius =
        mode() != KisTool::PAINT_MODE || outlineMode.forceFullSize
        ? currentPaintOpPreset()->settings()->paintOpSize() / 2.0
        : m_lastPressure * currentPaintOpPreset()->settings()->paintOpSize() / 2.0;
    QPainterPath outline;
    outline.addEllipse(m_lastPosition, radius, radius);
    return outline;
}

References KisTool::currentPaintOpPreset(), KisPaintOpSettings::OutlineMode::forceFullSize, KisPaintOpSettings::OutlineMode::isVisible, m_lastPosition, m_lastPressure, KisTool::mode(), and KisTool::PAINT_MODE.

◆ mouseMoveEvent()

void KisToolBasicBrushBase::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.

Definition at line 50 of file KisToolBasicBrushBase.cpp.

{
    if (mode() == KisTool::HOVER_MODE) {
        m_lastPosition = convertToPixelCoord(event);
    }
    KisToolShape::mouseMoveEvent(event);
}

References KisTool::convertToPixelCoord(), KisTool::HOVER_MODE, m_lastPosition, KisTool::mode(), and KoToolBase::mouseMoveEvent().

◆ paint()

void KisToolBasicBrushBase::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 273 of file KisToolBasicBrushBase.cpp.

{
    if (mode() == KisTool::PAINT_MODE) {
        gc.fillPath(pixelToView(m_path), m_previewColor);
    }
    KisToolShape::paint(gc, converter);
}

References m_path, m_previewColor, KisTool::mode(), KoToolBase::paint(), KisTool::PAINT_MODE, and KisTool::pixelToView().

◆ pressureToCurve()

qreal KisToolBasicBrushBase::pressureToCurve ( qreal pressure )

Definition at line 338 of file KisToolBasicBrushBase.cpp.

{
    return KisCubicCurve::interpolateLinear(pressure, m_pressureSamples);
}

References KisCubicCurve::interpolateLinear(), and m_pressureSamples.

◆ resetCursorStyle

void KisToolBasicBrushBase::resetCursorStyle ( )

overrideprotectedslot

Definition at line 302 of file KisToolBasicBrushBase.cpp.

{
    KisConfig cfg(true);
 
    switch (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_TOOLICON:
    default:
        KisToolPaint::resetCursorStyle();
        break;
    }
}

References KisCursor::arrowCursor(), KisCursor::blankCursor(), KisCursor::crossCursor(), CURSOR_STYLE_BLACK_PIXEL, CURSOR_STYLE_CROSSHAIR, 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, KisConfig::newCursorStyle(), KisCursor::pixelBlackCursor(), KisCursor::pixelWhiteCursor(), KisTool::resetCursorStyle(), KisCursor::roundCursor(), KisCursor::triangleLeftHandedCursor(), KisCursor::triangleRightHandedCursor(), and KoToolBase::useCursor().

◆ setPreviewColor

void KisToolBasicBrushBase::setPreviewColor ( const QColor & color )

slot

Definition at line 297 of file KisToolBasicBrushBase.cpp.

{
    m_previewColor = color;
}

References m_previewColor.

◆ update()

void KisToolBasicBrushBase::update ( const QRectF & strokeSegmentRect )

private

Definition at line 221 of file KisToolBasicBrushBase.cpp.

{
    QRectF segmentRect;
    QRectF outlineRect;
    // Segment rect
    if (mode() == KisTool::PAINT_MODE) {
        if (strokeSegmentRect.isValid()) {
            segmentRect = kisGrowRect(strokeSegmentRect, feedbackLineWidth);
        }
    }
    // Outline rect
    if (m_outlineStyle != OUTLINE_NONE &&
        (mode() != KisTool::PAINT_MODE || m_showOutlineWhilePainting)) {
        const qreal radius =
            m_forceAlwaysFullSizedOutline
            ? currentPaintOpPreset()->settings()->paintOpSize() / 2.0
            : m_lastPressure * currentPaintOpPreset()->settings()->paintOpSize() / 2.0;
        outlineRect = 
            kisGrowRect(
                QRectF(m_lastPosition - QPointF(radius, radius), m_lastPosition + QPointF(radius, radius)),
                feedbackLineWidth
            );
    }
    // Update
    if (segmentRect.isValid() && outlineRect.isValid()) {
        updateCanvasPixelRect(segmentRect.united(outlineRect));
    } else if (segmentRect.isValid()) {
        updateCanvasPixelRect(segmentRect);
    } else if (outlineRect.isValid()) {
        updateCanvasPixelRect(outlineRect);
    }
}

References KisTool::currentPaintOpPreset(), feedbackLineWidth, kisGrowRect(), m_forceAlwaysFullSizedOutline, m_lastPosition, m_lastPressure, m_outlineStyle, m_showOutlineWhilePainting, KisTool::mode(), OUTLINE_NONE, KisTool::PAINT_MODE, and KisTool::updateCanvasPixelRect().

◆ updateSettings

void KisToolBasicBrushBase::updateSettings ( )

protectedslot

Definition at line 38 of file KisToolBasicBrushBase.cpp.

{
    KisConfig cfg(true);
    // Pressure curve
    KisCubicCurve curve(cfg.pressureTabletCurve());
    m_pressureSamples = curve.floatTransfer(levelOfPressureResolution + 1);
    // Outline options
    m_outlineStyle = cfg.newOutlineStyle();
    m_showOutlineWhilePainting = cfg.showOutlineWhilePainting();
    m_forceAlwaysFullSizedOutline = cfg.forceAlwaysFullSizedOutline();
}

References KisCubicCurve::floatTransfer(), KisConfig::forceAlwaysFullSizedOutline(), levelOfPressureResolution, m_forceAlwaysFullSizedOutline, m_outlineStyle, m_pressureSamples, m_showOutlineWhilePainting, KisConfig::newOutlineStyle(), KisConfig::pressureTabletCurve(), and KisConfig::showOutlineWhilePainting().

Member Data Documentation

◆ feedbackLineWidth

constexpr int KisToolBasicBrushBase::feedbackLineWidth {2}

staticconstexprprivate

Definition at line 58 of file KisToolBasicBrushBase.h.

58{2};

◆ levelOfPressureResolution

constexpr int KisToolBasicBrushBase::levelOfPressureResolution = 1024

staticconstexprprivate

Definition at line 57 of file KisToolBasicBrushBase.h.

◆ m_changeSizeInitialGestureDocPoint

QPointF KisToolBasicBrushBase::m_changeSizeInitialGestureDocPoint

private

Definition at line 70 of file KisToolBasicBrushBase.h.

◆ m_changeSizeInitialGestureGlobalPoint

QPoint KisToolBasicBrushBase::m_changeSizeInitialGestureGlobalPoint

private

Definition at line 73 of file KisToolBasicBrushBase.h.

◆ m_changeSizeLastDocumentPoint

QPointF KisToolBasicBrushBase::m_changeSizeLastDocumentPoint

private

Definition at line 71 of file KisToolBasicBrushBase.h.

◆ m_changeSizeLastPaintOpSize

qreal KisToolBasicBrushBase::m_changeSizeLastPaintOpSize {0.0}

private

Definition at line 72 of file KisToolBasicBrushBase.h.

72{0.0};

◆ m_forceAlwaysFullSizedOutline

bool KisToolBasicBrushBase::m_forceAlwaysFullSizedOutline {true}

private

Definition at line 68 of file KisToolBasicBrushBase.h.

68{true};

◆ m_lastPosition

QPointF KisToolBasicBrushBase::m_lastPosition

private

Definition at line 61 of file KisToolBasicBrushBase.h.

◆ m_lastPressure

qreal KisToolBasicBrushBase::m_lastPressure {1.0}

private

Definition at line 62 of file KisToolBasicBrushBase.h.

62{1.0};

◆ m_outlineStyle

OutlineStyle KisToolBasicBrushBase::m_outlineStyle {OUTLINE_FULL}

private

Definition at line 66 of file KisToolBasicBrushBase.h.

66{OUTLINE_FULL};

OUTLINE_FULL

@ OUTLINE_FULL

Definition kis_global.h:56

◆ m_path

QPainterPath KisToolBasicBrushBase::m_path

private

Definition at line 60 of file KisToolBasicBrushBase.h.

◆ m_pressureSamples

QVector<qreal> KisToolBasicBrushBase::m_pressureSamples

private

Definition at line 65 of file KisToolBasicBrushBase.h.

◆ m_previewColor

QColor KisToolBasicBrushBase::m_previewColor

private

Definition at line 75 of file KisToolBasicBrushBase.h.

◆ m_showOutlineWhilePainting

bool KisToolBasicBrushBase::m_showOutlineWhilePainting {true}

private

Definition at line 67 of file KisToolBasicBrushBase.h.

67{true};

◆ m_type

ToolType KisToolBasicBrushBase::m_type {PAINT}

private

Definition at line 63 of file KisToolBasicBrushBase.h.

63{PAINT};

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

plugins/tools/tool_enclose_and_fill/subtools/KisToolBasicBrushBase.h
plugins/tools/tool_enclose_and_fill/subtools/KisToolBasicBrushBase.cpp

Public Types

Public Slots

Public Member Functions

Protected Slots

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ ToolType

Constructor & Destructor Documentation

◆ KisToolBasicBrushBase()

◆ ~KisToolBasicBrushBase()

Member Function Documentation

◆ activate

◆ activateAlternateAction()

◆ beginAlternateAction()

◆ beginPrimaryAction()

◆ continueAlternateAction()

◆ continuePrimaryAction()

◆ deactivate

◆ deactivateAlternateAction()

◆ endAlternateAction()

◆ endPrimaryAction()

◆ finishStroke()

◆ generateSegment()

◆ getOutlinePath()

◆ mouseMoveEvent()

◆ paint()

◆ pressureToCurve()

◆ resetCursorStyle

◆ setPreviewColor

◆ update()

◆ updateSettings

Member Data Documentation

◆ feedbackLineWidth

◆ levelOfPressureResolution

◆ m_changeSizeInitialGestureDocPoint

◆ m_changeSizeInitialGestureGlobalPoint

◆ m_changeSizeLastDocumentPoint

◆ m_changeSizeLastPaintOpSize

◆ m_forceAlwaysFullSizedOutline

◆ m_lastPosition

◆ m_lastPressure

◆ m_outlineStyle

◆ m_path

◆ m_pressureSamples

◆ m_previewColor

◆ m_showOutlineWhilePainting

◆ m_type