#include <kis_tool_select_outline.h>

Inheritance diagram for KisToolSelectOutline:

Public Member Functions
bool	alternateActionSupportsHiResEvents (KisTool::AlternateAction action) const override

	KisToolSelectOutline (KoCanvasBase *canvas)

bool	primaryActionSupportsHiResEvents () const override

void	resetCursorStyle () override

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

void	activateAlternateAction (KisTool::AlternateAction action) override

SelectionAction	alternateSelectionAction () const

bool	antiAliasSelection () const

void	beginAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override

bool	beginMoveSelectionInteraction ()

void	beginPrimaryAction (KoPointerEvent *event) override

bool	beginSelectInteraction ()

QList< int >	colorLabelsSelected () const

void	continueAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

void	deactivate () override

void	deactivateAlternateAction (KisTool::AlternateAction action) override

void	endAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override

bool	endMoveSelectionInteraction ()

void	endPrimaryAction (KoPointerEvent *event) override

bool	endSelectInteraction ()

int	featherSelection () const

int	growSelection () const

bool	isMovingSelection () const

bool	isSelecting () const

void	keyPressEvent (QKeyEvent *event) override

void	keyReleaseEvent (QKeyEvent *event) override

	KisToolSelectBase (KoCanvasBase *canvas, const QCursor cursor, const QString toolName)

	KisToolSelectBase (KoCanvasBase *canvas, const QString toolName)

	KisToolSelectBase (KoCanvasBase canvas, QCursor cursor, QString toolName, KoToolBase delegateTool)

KisNodeSP	locateSelectionMaskUnderCursor (const QPointF &pos, Qt::KeyboardModifiers modifiers)

void	mouseMoveEvent (KoPointerEvent *event) override

QMenu *	popupActionsMenu () override

KisPopupWidgetInterface *	popupWidget () override

SampleLayersMode	sampleLayersMode () const

SelectionAction	selectionAction () const

bool	selectionDidMove () const

SelectionMode	selectionMode () const

KisSelectionOptions *	selectionOptionWidget ()

virtual void	setAlternateSelectionAction (SelectionAction action)

bool	stopGrowingAtDarkestPixel () const

void	updateActionShortcutToolTips ()

void	updateCursorDelayed ()

Public Member Functions inherited from __KisToolSelectOutlineLocal
	__KisToolSelectOutlineLocal (KoCanvasBase *canvas)

Public Member Functions inherited from KisToolOutlineBase
bool	eventFilter (QObject obj, QEvent event) override

bool	hasUserInteractionRunning () const

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

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

	~KisToolOutlineBase () 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	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

	~KisToolPaint () override

Public Member Functions inherited from KisTool
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	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

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

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

Private Member Functions
void	beginShape () override

void	endShape () override

void	finishOutline (const QVector< QPointF > &points) override

Additional Inherited Members
Public Types inherited from KisToolSelectBase< __KisToolSelectOutlineLocal >
enum	SampleLayersMode

Public Types inherited from KisToolOutlineBase
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 inherited from KisToolOutlineBase
void	activate (const QSet< KoShape * > &shapes) override

void	deactivate () override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

void	undoLastPoint ()

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	documentResourceChanged (int key, const QVariant &res)

virtual void	repaintDecorations ()

virtual void	requestRedoDuringStroke ()

virtual void	requestStrokeCancellation ()

virtual void	requestStrokeEnd ()

virtual void	requestUndoDuringStroke ()

void	setStatusText (const QString &statusText)

void	updateOptionsWidgetIcons ()

Signals inherited from 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 Slots inherited from KisTool
Protected Member Functions inherited from KisToolSelectBase< __KisToolSelectOutlineLocal >
virtual bool	isPixelOnly () const

virtual bool	usesColorLabels () const

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

void	addShape (KoShape *shape)

QWidget *	createOptionWidget () override

qreal	currentStrokeWidth () const

KisToolShapeUtils::FillStyle	fillStyle ()

QTransform	fillTransform ()

ShapeAddInfo	shouldAddShape (KisNodeSP currentNode) const

KisToolShapeUtils::StrokeStyle	strokeStyle ()

Protected Member Functions inherited from KisToolPaint
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	canvasResourceChanged (int key, const QVariant &v) override

void	deactivatePrimaryAction () override

void	enableControl (QWidget *control, bool value)

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

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 inherited from KisToolSelectBase< __KisToolSelectOutlineLocal >
SelectionAction	m_selectionActionAlternate

KisSelectionToolConfigWidgetHelper	m_widgetHelper

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 29 of file kis_tool_select_outline.h.

Constructor & Destructor Documentation

◆ KisToolSelectOutline()

KisToolSelectOutline::KisToolSelectOutline ( KoCanvasBase * canvas )

Definition at line 50 of file kis_tool_select_outline.cc.

51 : KisToolSelectBase<__KisToolSelectOutlineLocal>(canvas, i18n("Freehand Selection"))

52{}

KisToolSelectBase

Definition kis_tool_select_base.h:62

Private::canvas

KisCanvas2 * canvas

Definition KisFrameDisplayProxy.cpp:22

Member Function Documentation

◆ alternateActionSupportsHiResEvents()

bool KisToolSelectOutline::alternateActionSupportsHiResEvents ( KisTool::AlternateAction action ) const

overridevirtual

In selection tools we abuse alternate actions to switch different selection modes. So we should notify input manager that we need a good precision for them

Reimplemented from KisTool.

Definition at line 177 of file kis_tool_select_outline.cc.

{
    Q_UNUSED(action);
    return !isMovingSelection();
}

References KoToolBase::action(), and KisToolSelectBase< __KisToolSelectOutlineLocal >::isMovingSelection().

◆ beginShape()

void KisToolSelectOutline::beginShape ( )

overrideprivatevirtual

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

Reimplemented from KisToolShape.

Definition at line 162 of file kis_tool_select_outline.cc.

{
    beginSelectInteraction();
}

References KisToolSelectBase< __KisToolSelectOutlineLocal >::beginSelectInteraction().

◆ endShape()

void KisToolSelectOutline::endShape ( )

overrideprivatevirtual

Reimplemented from KisToolShape.

Definition at line 167 of file kis_tool_select_outline.cc.

{
    endSelectInteraction();
}

References KisToolSelectBase< __KisToolSelectOutlineLocal >::endSelectInteraction().

◆ finishOutline()

void KisToolSelectOutline::finishOutline ( const QVector< QPointF > & points )

overrideprivatevirtual

Implements KisToolOutlineBase.

Definition at line 54 of file kis_tool_select_outline.cc.

{
    KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
    kisCanvas->updateCanvas();
 
    const QRectF boundingRect = KisAlgebra2D::accumulateBounds(points);
    const QRectF boundingViewRect = pixelToView(boundingRect);
 
    KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Freehand Selection"));
 
    if (helper.tryDeselectCurrentSelection(boundingViewRect, selectionAction())) {
        endSelectInteraction();
        return;
    }
 
    if (points.count() < 3) {
        return;
    }
 
    KisCursorOverrideLock cursorLock(Qt::WaitCursor);
 
    const SelectionMode mode =
        helper.tryOverrideSelectionMode(kisCanvas->viewManager()->selection(),
                                        selectionMode(),
                                        selectionAction());
 
    if (mode == PIXEL_SELECTION) {
        KisProcessingApplicator applicator(currentImage(),
                                           currentNode(),
                                           KisProcessingApplicator::NONE,
                                           KisImageSignalVector(),
                                           kundo2_i18n("Freehand Selection"));
 
        KisPixelSelectionSP tmpSel =
            new KisPixelSelection(new KisDefaultBounds(currentImage()));
 
        const bool antiAlias = antiAliasSelection();
        const int grow = growSelection();
        const int feather = featherSelection();
 
        QPainterPath path;
        path.addPolygon(points);
        path.closeSubpath();
 
        KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
            [tmpSel, antiAlias, grow, feather, path]() mutable
            -> KUndo2Command * {
                KisPainter painter(tmpSel);
                painter.setPaintColor(KoColor(Qt::black, tmpSel->colorSpace()));
                // Since the feathering already smooths the selection, the
                // antiAlias is not applied if we must feather
                painter.setAntiAliasPolygonFill(antiAlias && feather == 0);
                painter.setFillStyle(KisPainter::FillStyleForegroundColor);
                painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
                painter.paintPainterPath(path);
 
                if (grow > 0) {
                    KisGrowSelectionFilter biggy(grow, grow);
                    biggy.process(tmpSel,
                                  tmpSel->selectedRect().adjusted(-grow,
                                                                  -grow,
                                                                  grow,
                                                                  grow));
                } else if (grow < 0) {
                    KisShrinkSelectionFilter tiny(-grow, -grow, false);
                    tiny.process(tmpSel, tmpSel->selectedRect());
                }
                if (feather > 0) {
                    KisFeatherSelectionFilter feathery(feather);
                    feathery.process(tmpSel,
                                     tmpSel->selectedRect().adjusted(-feather,
                                                                     -feather,
                                                                     feather,
                                                                     feather));
                }
 
                if (grow == 0 && feather == 0) {
                    tmpSel->setOutlineCache(path);
                } else {
                    tmpSel->invalidateOutlineCache();
                }
 
                return 0;
            });
 
        applicator.applyCommand(cmd, KisStrokeJobData::SEQUENTIAL);
        helper.selectPixelSelection(applicator, tmpSel, selectionAction());
        applicator.end();
 
    } else {
        KoPathShape *path = new KoPathShape();
        path->setShapeId(KoPathShapeId);
 
        QTransform resolutionMatrix;
        resolutionMatrix.scale(1 / currentImage()->xRes(),
                               1 / currentImage()->yRes());
        path->moveTo(resolutionMatrix.map(points[0]));
        for (int i = 1; i < points.count(); i++)
            path->lineTo(resolutionMatrix.map(points[i]));
        path->close();
        path->normalize();
 
        helper.addSelectionShape(path, selectionAction());
    }
}

References KisAlgebra2D::accumulateBounds(), KisSelectionToolHelper::addSelectionShape(), KisToolSelectBase< __KisToolSelectOutlineLocal >::antiAliasSelection(), KisProcessingApplicator::applyCommand(), Private::canvas, KisPaintDevice::colorSpace(), KisTool::currentImage(), KisTool::currentNode(), KisProcessingApplicator::end(), KisToolSelectBase< __KisToolSelectOutlineLocal >::endSelectInteraction(), KisToolSelectBase< __KisToolSelectOutlineLocal >::featherSelection(), KisPainter::FillStyleForegroundColor, KisToolSelectBase< __KisToolSelectOutlineLocal >::growSelection(), KisPixelSelection::invalidateOutlineCache(), KIS_ASSERT_RECOVER_RETURN, KoPathShapeId, kundo2_i18n(), KisTool::mode(), KisProcessingApplicator::NONE, KisPainter::paintPainterPath(), PIXEL_SELECTION, KisTool::pixelToView(), KisFeatherSelectionFilter::process(), KisGrowSelectionFilter::process(), KisShrinkSelectionFilter::process(), KisPixelSelection::selectedRect(), KisViewManager::selection(), KisToolSelectBase< __KisToolSelectOutlineLocal >::selectionAction(), KisToolSelectBase< __KisToolSelectOutlineLocal >::selectionMode(), KisSelectionToolHelper::selectPixelSelection(), KisStrokeJobData::SEQUENTIAL, KisPainter::setAntiAliasPolygonFill(), KisPainter::setFillStyle(), KisPixelSelection::setOutlineCache(), KisPainter::setPaintColor(), KisPainter::setStrokeStyle(), KisPainter::StrokeStyleNone, KisSelectionToolHelper::tryDeselectCurrentSelection(), KisSelectionToolHelper::tryOverrideSelectionMode(), KisCanvas2::updateCanvas(), and KisCanvas2::viewManager().

◆ primaryActionSupportsHiResEvents()

bool KisToolSelectOutline::primaryActionSupportsHiResEvents ( ) const

overridevirtual

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 172 of file kis_tool_select_outline.cc.

{
    return !isMovingSelection();
}

References KisToolSelectBase< __KisToolSelectOutlineLocal >::isMovingSelection().

◆ resetCursorStyle()

void KisToolSelectOutline::resetCursorStyle ( )

overridevirtual

Called whenever the configuration settings change.

Reimplemented from KisTool.

Definition at line 189 of file kis_tool_select_outline.cc.

{
    if (selectionAction() == SELECTION_ADD) {
        useCursor(KisCursor::load("tool_outline_selection_cursor_add.png", 5, 5));
    } else if (selectionAction() == SELECTION_SUBTRACT) {
        useCursor(KisCursor::load("tool_outline_selection_cursor_sub.png", 5, 5));
    } else if (selectionAction() == SELECTION_INTERSECT) {
        useCursor(KisCursor::load("tool_outline_selection_cursor_inter.png", 5, 5));
    } else if (selectionAction() == SELECTION_SYMMETRICDIFFERENCE) {
        useCursor(KisCursor::load("tool_outline_selection_cursor_symdiff.png", 5, 5));
    } else {
        KisToolSelectBase<__KisToolSelectOutlineLocal>::resetCursorStyle();
    }
}

References KisCursor::load(), SELECTION_ADD, SELECTION_INTERSECT, SELECTION_SUBTRACT, SELECTION_SYMMETRICDIFFERENCE, KisToolSelectBase< __KisToolSelectOutlineLocal >::selectionAction(), and KoToolBase::useCursor().

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

plugins/tools/selectiontools/kis_tool_select_outline.h
plugins/tools/selectiontools/kis_tool_select_outline.cc

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisToolSelectOutline()

Member Function Documentation

◆ alternateActionSupportsHiResEvents()

◆ beginShape()

◆ endShape()

◆ finishOutline()

◆ primaryActionSupportsHiResEvents()

◆ resetCursorStyle()