#include <KisToolEncloseAndFill.h>

Inheritance diagram for KisToolEncloseAndFill:

Public Types
enum	EnclosingMethod { Rectangle , Ellipse , Path , Lasso , Brush }

enum	FillType { FillWithForegroundColor , FillWithBackgroundColor , FillWithPattern }

enum	Reference { CurrentLayer , AllLayers , ColorLabeledLayers }

using	RegionSelectionMethod = KisEncloseAndFillPainter::RegionSelectionMethod

Public Types inherited from KisDynamicDelegatedTool< KisToolShape >
using	DelegateType

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

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

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

void	deactivate () override

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

void	repaintDecorations () override

void	requestRedoDuringStroke () override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

void	requestUndoDuringStroke () override

void	updateSettingsViews () override

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	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action) override

void	beginPrimaryAction (KoPointerEvent *event) override

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

QWidget *	createOptionWidget () override

void	deactivateAlternateAction (AlternateAction action) override

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

int	flags () const override

	KisToolEncloseAndFill (KoCanvasBase *canvas)

	~KisToolEncloseAndFill () override

Public Member Functions inherited from KisDynamicDelegatedTool< KisToolShape >
void	activateAlternateAction (typename BaseClass::AlternateAction action) override

void	activatePrimaryAction () override

bool	alternateActionSupportsHiResEvents (typename BaseClass::AlternateAction action) const override

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

void	beginAlternateDoubleClickAction (KoPointerEvent *event, typename BaseClass::AlternateAction action) override

void	beginPrimaryDoubleClickAction (KoPointerEvent *event) override

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

void	continuePrimaryAction (KoPointerEvent *event) override

void	deactivateAlternateAction (typename BaseClass::AlternateAction action) override

void	deactivatePrimaryAction () override

QRectF	decorationsRect () const override

DelegateType *	delegateTool () const

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

void	endPrimaryAction (KoPointerEvent *event) override

void	explicitUserStrokeEndRequest () override

void	keyPressEvent (QKeyEvent *event) override

void	keyReleaseEvent (QKeyEvent *event) override

	KisDynamicDelegatedTool ()=delete

	KisDynamicDelegatedTool (const KisDynamicDelegatedTool &)=delete

	KisDynamicDelegatedTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mouseMoveEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

void	newActivationWithExternalSource (KisPaintDeviceSP externalSource) override

KisDynamicDelegatedTool &	operator= (const KisDynamicDelegatedTool &)=delete

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

QMenu *	popupActionsMenu () override

KisPopupWidgetInterface *	popupWidget () override

bool	primaryActionSupportsHiResEvents () const override

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

void	setDelegateTool (DelegateType *newDelegateTool)

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

void	deleteSelection () override

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

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

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)

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

	~KoToolBase () override

Private Slots
void	resetCursorStyle () override

void	slot_angleSelectorPatternRotation_angleChanged (double value)

void	slot_buttonRegionSelectionColor_changed (const KoColor &color)

void	slot_buttonReset_clicked ()

void	slot_buttonStopGrowingAtDarkestPixel_toggled (bool enabled)

void	slot_checkBoxAntiAlias_toggled (bool checked)

void	slot_checkBoxRegionSelectionIncludeContourRegions_toggled (bool checked)

void	slot_checkBoxRegionSelectionInvert_toggled (bool checked)

void	slot_checkBoxSelectionAsBoundary_toggled (bool checked)

void	slot_checkBoxUseActiveLayer_toggled (bool checked)

void	slot_checkBoxUseCustomBlendingOptions_toggled (bool checked)

void	slot_colorSpaceChanged (const KoColorSpace *colorSpace)

void	slot_comboBoxCustomCompositeOp_currentIndexChanged (int index)

void	slot_comboBoxRegionSelectionMethod_currentIndexChanged (int)

void	slot_currentNodeChanged (const KisNodeSP node)

void	slot_delegateTool_enclosingMaskProduced (KisPixelSelectionSP enclosingMask)

void	slot_optionButtonStripEnclosingMethod_buttonToggled (KoGroupButton *button, bool checked)

void	slot_optionButtonStripFillWith_buttonToggled (KoGroupButton *button, bool checked)

void	slot_optionButtonStripReference_buttonToggled (KoGroupButton *button, bool checked)

void	slot_sliderCloseGap_valueChanged (int value)

void	slot_sliderCustomOpacity_valueChanged (int value)

void	slot_sliderExpand_valueChanged (int value)

void	slot_sliderFeather_valueChanged (int value)

void	slot_sliderFillOpacitySpread_valueChanged (int value)

void	slot_sliderFillThreshold_valueChanged (int value)

void	slot_sliderPatternScale_valueChanged (double value)

void	slot_widgetLabels_selectionChanged ()

Private Member Functions
EnclosingMethod	configStringToEnclosingMethod (const QString &configString) const

Reference	configStringToReference (const QString &configString) const

RegionSelectionMethod	configStringToRegionSelectionMethod (const QString &configString) const

QString	enclosingMethodToConfigString (EnclosingMethod enclosingMethod) const

void	loadConfiguration ()

EnclosingMethod	loadEnclosingMethodFromConfig () const

Reference	loadReferenceFromConfig () const

KoColor	loadRegionSelectionColorFromConfig ()

RegionSelectionMethod	loadRegionSelectionMethodFromConfig () const

QString	referenceToConfigString (Reference reference) const

QString	referenceToUserString (Reference reference) const

QString	regionSelectionMethodToConfigString (RegionSelectionMethod regionSelectionMethod) const

QString	regionSelectionMethodToUserString (RegionSelectionMethod regionSelectionMethod) const

void	saveEnclosingMethodToConfig (EnclosingMethod enclosingMethod)

void	saveReferenceToConfig (Reference reference)

void	saveRegionSelectionMethodToConfig (RegionSelectionMethod regionSelectionMethod)

void	setupEnclosingSubtool ()

bool	subtoolHasUserInteractionRunning () const

bool	wantsAutoScroll () const override

Static Private Member Functions
static constexpr EnclosingMethod	defaultEnclosingMethod ()

static constexpr Reference	defaultReference ()

static constexpr RegionSelectionMethod	defaultRegionSelectionMethod ()

Private Attributes
bool	m_alternateActionStarted {false}

KisAngleSelector *	m_angleSelectorPatternRotation {nullptr}

bool	m_antiAlias {false}

KoGroupButton *	m_buttonEnclosingMethodBrush {nullptr}

KoGroupButton *	m_buttonEnclosingMethodEllipse {nullptr}

KoGroupButton *	m_buttonEnclosingMethodLasso {nullptr}

KoGroupButton *	m_buttonEnclosingMethodPath {nullptr}

KoGroupButton *	m_buttonEnclosingMethodRectangle {nullptr}

KoGroupButton *	m_buttonFillWithBG {nullptr}

KoGroupButton *	m_buttonFillWithFG {nullptr}

KoGroupButton *	m_buttonFillWithPattern {nullptr}

KoGroupButton *	m_buttonReferenceAll {nullptr}

KoGroupButton *	m_buttonReferenceCurrent {nullptr}

KoGroupButton *	m_buttonReferenceLabeled {nullptr}

KisColorButton *	m_buttonRegionSelectionColor {nullptr}

QToolButton *	m_buttonStopGrowingAtDarkestPixel {nullptr}

QCheckBox *	m_checkBoxAntiAlias {nullptr}

QCheckBox *	m_checkBoxCustomBlendingOptions {nullptr}

QCheckBox *	m_checkBoxRegionSelectionIncludeContourRegions {nullptr}

QCheckBox *	m_checkBoxRegionSelectionInvert {nullptr}

QCheckBox *	m_checkBoxSelectionAsBoundary {nullptr}

QCheckBox *	m_checkBoxUseActiveLayer {nullptr}

int	m_closeGap {0}

KisCompositeOpComboBox *	m_comboBoxCustomCompositeOp {nullptr}

QComboBox *	m_comboBoxRegionSelectionMethod {nullptr}

KConfigGroup	m_configGroup

QString	m_customCompositeOp {COMPOSITE_OVER}

int	m_customOpacity {100}

QSharedPointer< QRect >	m_dirtyRect {nullptr}

EnclosingMethod	m_enclosingMethod {Lasso}

int	m_expand {0}

int	m_feather {0}

int	m_fillOpacitySpread {100}

KisStrokeId	m_fillStrokeId {nullptr}

int	m_fillThreshold {8}

FillType	m_fillType {FillWithForegroundColor}

KisOptionCollectionWidget *	m_optionWidget {nullptr}

qreal	m_patternRotation {0.0}

qreal	m_patternScale {100.0}

KisNodeSP	m_previousNode {nullptr}

int	m_previousTime {0}

Reference	m_reference {CurrentLayer}

KisMergeLabeledLayersCommand::ReferenceNodeInfoListSP	m_referenceNodeList {nullptr}

KisPaintDeviceSP	m_referencePaintDevice {nullptr}

KoColor	m_regionSelectionColor

bool	m_regionSelectionIncludeContourRegions {false}

bool	m_regionSelectionInvert {false}

RegionSelectionMethod	m_regionSelectionMethod {defaultRegionSelectionMethod()}

QList< int >	m_selectedColorLabels

KisSliderSpinBox *	m_sliderCloseGap {nullptr}

KisSliderSpinBox *	m_sliderCustomOpacity {nullptr}

KisSliderSpinBox *	m_sliderExpand {nullptr}

KisSliderSpinBox *	m_sliderFeather {nullptr}

KisSliderSpinBox *	m_sliderFillOpacitySpread {nullptr}

KisSliderSpinBox *	m_sliderFillThreshold {nullptr}

KisDoubleSliderSpinBox *	m_sliderPatternScale {nullptr}

int	m_stopGrowingAtDarkestPixel {false}

bool	m_useActiveLayer {false}

bool	m_useCustomBlendingOptions {false}

bool	m_useSelectionAsBoundary {true}

KisColorLabelSelectorWidget *	m_widgetLabels {nullptr}

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 Slots inherited from KisDynamicDelegatedTool< KisToolShape >
void	resetCursorStyle () override

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Protected Member Functions inherited from KisDynamicDelegatedTool< KisToolShape >
QCursor	cursor () const

bool	listeningToModifiers () override

void	listenToModifiers (bool listen) override

BaseClass::ToolMode	mode () const override

void	setCursor (const QCursor &cursor)

void	setMode (typename BaseClass::ToolMode mode) 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

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

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

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 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 40 of file KisToolEncloseAndFill.h.

Member Typedef Documentation

◆ RegionSelectionMethod

using KisToolEncloseAndFill::RegionSelectionMethod = KisEncloseAndFillPainter::RegionSelectionMethod

Definition at line 68 of file KisToolEncloseAndFill.h.

Member Enumeration Documentation

◆ EnclosingMethod

enum KisToolEncloseAndFill::EnclosingMethod

Enumerator
Rectangle
Ellipse
Path
Lasso
Brush

Definition at line 45 of file KisToolEncloseAndFill.h.

    {
        Rectangle,
        Ellipse,
        Path,
        Lasso,
        Brush
    };

◆ FillType

enum KisToolEncloseAndFill::FillType

Enumerator
FillWithForegroundColor
FillWithBackgroundColor
FillWithPattern

Definition at line 54 of file KisToolEncloseAndFill.h.

    {
        FillWithForegroundColor,
        FillWithBackgroundColor,
        FillWithPattern
    };

◆ Reference

enum KisToolEncloseAndFill::Reference

Enumerator
CurrentLayer
AllLayers
ColorLabeledLayers

Definition at line 61 of file KisToolEncloseAndFill.h.

    {
        CurrentLayer,
        AllLayers,
        ColorLabeledLayers
    };

Constructor & Destructor Documentation

◆ KisToolEncloseAndFill()

KisToolEncloseAndFill::KisToolEncloseAndFill ( KoCanvasBase * canvas )

Definition at line 70 of file KisToolEncloseAndFill.cpp.

    : KisDynamicDelegatedTool<KisToolShape>(canvas, QCursor())
{
    setObjectName("tool_enclose_and_fill");
}

◆ ~KisToolEncloseAndFill()

KisToolEncloseAndFill::~KisToolEncloseAndFill ( )

override

Definition at line 76 of file KisToolEncloseAndFill.cpp.

77{}

Member Function Documentation

◆ activate

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

overrideslot

Definition at line 85 of file KisToolEncloseAndFill.cpp.

{
    KisDynamicDelegatedTool::activate(shapes);
    m_configGroup = KSharedConfig::openConfig()->group(toolId());
    KisCanvas2 *kisCanvas = static_cast<KisCanvas2*>(canvas());
    KisCanvasResourceProvider *resourceProvider = kisCanvas->viewManager()->canvasResourceProvider();
    if (resourceProvider) {
        connect(resourceProvider,
                SIGNAL(sigNodeChanged(const KisNodeSP)),
                this,
                SLOT(slot_currentNodeChanged(const KisNodeSP)));
        slot_currentNodeChanged(currentNode());
    }
}

References KisDynamicDelegatedTool< BaseClass >::activate(), Private::canvas, KisViewManager::canvasResourceProvider(), connect(), KisTool::currentNode(), m_configGroup, slot_currentNodeChanged(), KoToolBase::toolId(), and KisCanvas2::viewManager().

◆ activateAlternateAction()

void KisToolEncloseAndFill::activateAlternateAction ( AlternateAction action )

overridevirtual

Reimplemented from KisTool.

Definition at line 193 of file KisToolEncloseAndFill.cpp.

{
    if (subtoolHasUserInteractionRunning()) {
        if (delegateTool()) {
            delegateTool()->activatePrimaryAction();
        }
        return;
    }
    KisDynamicDelegatedTool::activateAlternateAction(action);
}

References KoToolBase::action(), KisDynamicDelegatedTool< BaseClass >::activateAlternateAction(), KisDynamicDelegatedTool< KisToolShape >::delegateTool(), and subtoolHasUserInteractionRunning().

◆ beginAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 212 of file KisToolEncloseAndFill.cpp.

{
    if (subtoolHasUserInteractionRunning()) {
        if (delegateTool()) {
            delegateTool()->beginPrimaryAction(event);
        }
        return;
    }
    KisDynamicDelegatedTool::beginAlternateAction(event, action);
    m_alternateActionStarted = true;
}

References KoToolBase::action(), KisDynamicDelegatedTool< BaseClass >::beginAlternateAction(), KisDynamicDelegatedTool< KisToolShape >::delegateTool(), m_alternateActionStarted, and subtoolHasUserInteractionRunning().

◆ beginAlternateDoubleClickAction()

void KisToolEncloseAndFill::beginAlternateDoubleClickAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overridevirtual

Reimplemented from KisTool.

Definition at line 253 of file KisToolEncloseAndFill.cpp.

{
    if (subtoolHasUserInteractionRunning()) {
        if (delegateTool()) {
            delegateTool()->beginPrimaryDoubleClickAction(event);
        }
        return;
    }
    KisDynamicDelegatedTool::beginAlternateDoubleClickAction(event, action);
}

References KoToolBase::action(), KisDynamicDelegatedTool< BaseClass >::beginAlternateDoubleClickAction(), KisDynamicDelegatedTool< KisToolShape >::delegateTool(), and subtoolHasUserInteractionRunning().

◆ beginPrimaryAction()

void KisToolEncloseAndFill::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 KisDynamicDelegatedTool< KisToolShape >.

Definition at line 171 of file KisToolEncloseAndFill.cpp.

{
    // cannot use enclose and fill tool on non-painting layers.
    // this logic triggers with multiple layer types like vector layer, clone layer, file layer, group layer
    if (currentNode().isNull() || currentNode()->inherits("KisShapeLayer") || nodePaintAbility() != NodePaintAbility::PAINT) {
        KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
        kiscanvas->viewManager()->
                showFloatingMessage(
                    i18n("You cannot use this tool with the selected layer type"),
                    QIcon(), 2000, KisFloatingMessage::Medium, Qt::AlignCenter);
        event->ignore();
        return;
    }
 
    if (!nodeEditable()) {
        event->ignore();
        return;
    }
 
    KisDynamicDelegatedTool::beginPrimaryAction(event);
}

References KisDynamicDelegatedTool< BaseClass >::beginPrimaryAction(), Private::canvas, KisTool::currentNode(), KisFloatingMessage::Medium, KisTool::nodeEditable(), KisTool::nodePaintAbility(), KisTool::PAINT, and KisCanvas2::viewManager().

◆ configStringToEnclosingMethod()

KisToolEncloseAndFill::EnclosingMethod KisToolEncloseAndFill::configStringToEnclosingMethod ( const QString & configString ) const

private

Definition at line 888 of file KisToolEncloseAndFill.cpp.

{
    if (configString == "rectangle") {
        return Rectangle;
    } else if (configString == "ellipse") {
        return Ellipse;
    } else if (configString == "path") {
        return Path;
    } else if (configString == "brush") {
        return Brush;
    }
    return Lasso;
}

References Brush, Ellipse, Lasso, Path, and Rectangle.

◆ configStringToReference()

KisToolEncloseAndFill::Reference KisToolEncloseAndFill::configStringToReference ( const QString & configString ) const

private

Definition at line 1041 of file KisToolEncloseAndFill.cpp.

{
    if (configString == "allLayers") {
        return AllLayers;
    } else if (configString == "colorLabeledLayers") {
        return ColorLabeledLayers;
    }
    return CurrentLayer;
}

References AllLayers, ColorLabeledLayers, and CurrentLayer.

◆ configStringToRegionSelectionMethod()

KisToolEncloseAndFill::RegionSelectionMethod KisToolEncloseAndFill::configStringToRegionSelectionMethod ( const QString & configString ) const

private

Definition at line 974 of file KisToolEncloseAndFill.cpp.

{
    if (configString == "regionsFilledWithSpecificColor") {
        return RegionSelectionMethod::SelectRegionsFilledWithSpecificColor;
    } else if (configString == "regionsFilledWithTransparent") {
        return RegionSelectionMethod::SelectRegionsFilledWithTransparent;
    } else if (configString == "regionsFilledWithSpecificColorOrTransparent") {
        return RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent;
    } else if (configString == "allRegionsExceptFilledWithSpecificColor") {
        return RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor;
    } else if (configString == "allRegionsExceptFilledWithTransparent") {
        return RegionSelectionMethod::SelectAllRegionsExceptFilledWithTransparent;
    } else if (configString == "allRegionsExceptFilledWithSpecificColorOrTransparent") {
        return RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent;
    } else if (configString == "regionsSurroundedBySpecificColor") {
        return RegionSelectionMethod::SelectRegionsSurroundedBySpecificColor;
    } else if (configString == "regionsSurroundedByTransparent") {
        return RegionSelectionMethod::SelectRegionsSurroundedByTransparent;
    } else if (configString == "regionsSurroundedBySpecificColorOrTransparent") {
        return RegionSelectionMethod::SelectRegionsSurroundedBySpecificColorOrTransparent;
    }
    return RegionSelectionMethod::SelectAllRegions;
}

◆ continueAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 224 of file KisToolEncloseAndFill.cpp.

{
    if (subtoolHasUserInteractionRunning()) {
        if (delegateTool()) {
            delegateTool()->continuePrimaryAction(event);
        }
        return;
    }
    if (!m_alternateActionStarted) {
        return;
    }
    KisDynamicDelegatedTool::continueAlternateAction(event, action);
}

References KoToolBase::action(), KisDynamicDelegatedTool< BaseClass >::continueAlternateAction(), KisDynamicDelegatedTool< KisToolShape >::delegateTool(), m_alternateActionStarted, and subtoolHasUserInteractionRunning().

◆ createOptionWidget()

QWidget * KisToolEncloseAndFill::createOptionWidget ( )

overridevirtual

Reimplement this if your tool actually has an option widget. Sets the option widget to 0 by default.

Reimplemented from KisDynamicDelegatedTool< KisToolShape >.

Definition at line 382 of file KisToolEncloseAndFill.cpp.

{
    loadConfiguration();
 
    // Create widgets
    KisOptionButtonStrip *optionButtonStripEnclosingMethod =
        new KisOptionButtonStrip;
    m_buttonEnclosingMethodRectangle =
        optionButtonStripEnclosingMethod->addButton(
            KisIconUtils::loadIcon("tool_rect_selection"));
    m_buttonEnclosingMethodEllipse =
        optionButtonStripEnclosingMethod->addButton(
            KisIconUtils::loadIcon("tool_elliptical_selection"));
    m_buttonEnclosingMethodPath = optionButtonStripEnclosingMethod->addButton(
        KisIconUtils::loadIcon("tool_path_selection"));
    m_buttonEnclosingMethodLasso = optionButtonStripEnclosingMethod->addButton(
        KisIconUtils::loadIcon("tool_outline_selection"));
    m_buttonEnclosingMethodBrush = optionButtonStripEnclosingMethod->addButton(
        KisIconUtils::loadIcon("krita_tool_freehand"));
    m_buttonEnclosingMethodLasso->setChecked(true);
 
    m_comboBoxRegionSelectionMethod = new QComboBox;
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectAllRegions),
        static_cast<int>(RegionSelectionMethod::SelectAllRegions)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectRegionsFilledWithSpecificColor),
        static_cast<int>(RegionSelectionMethod::SelectRegionsFilledWithSpecificColor)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectRegionsFilledWithTransparent),
        static_cast<int>(RegionSelectionMethod::SelectRegionsFilledWithTransparent)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent),
        static_cast<int>(RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor),
        static_cast<int>(RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectAllRegionsExceptFilledWithTransparent),
        static_cast<int>(RegionSelectionMethod::SelectAllRegionsExceptFilledWithTransparent)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(
            RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent
        ),
        static_cast<int>(RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectRegionsSurroundedBySpecificColor),
        static_cast<int>(RegionSelectionMethod::SelectRegionsSurroundedBySpecificColor)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectRegionsSurroundedByTransparent),
        static_cast<int>(RegionSelectionMethod::SelectRegionsSurroundedByTransparent)
    );
    m_comboBoxRegionSelectionMethod->addItem(
        regionSelectionMethodToUserString(RegionSelectionMethod::SelectRegionsSurroundedBySpecificColorOrTransparent),
        static_cast<int>(RegionSelectionMethod::SelectRegionsSurroundedBySpecificColorOrTransparent)
    );
    m_comboBoxRegionSelectionMethod->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
    m_comboBoxRegionSelectionMethod->setMinimumContentsLength(15);
    m_comboBoxRegionSelectionMethod->view()->setMinimumWidth(
        m_comboBoxRegionSelectionMethod->view()->sizeHintForColumn(0)
    );
    m_buttonRegionSelectionColor = new KisColorButton;
    m_checkBoxRegionSelectionInvert =
        new QCheckBox(
            i18nc("The 'invert' checkbox in enclose and fill tool",
                  "Invert")
        );
    m_checkBoxRegionSelectionIncludeContourRegions =
        new QCheckBox(
            i18nc("The 'include contour regions' checkbox in enclose and fill tool",
                  "Include contour regions")
        );
    m_checkBoxRegionSelectionIncludeContourRegions->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Preferred);
 
    KisOptionButtonStrip *optionButtonStripFillWith = new KisOptionButtonStrip;
    m_buttonFillWithFG = optionButtonStripFillWith->addButton(
        KisIconUtils::loadIcon("object-order-lower-calligra"));
    m_buttonFillWithBG = optionButtonStripFillWith->addButton(
        KisIconUtils::loadIcon("object-order-raise-calligra"));
    m_buttonFillWithPattern =
        optionButtonStripFillWith->addButton(KisIconUtils::loadIcon("pattern"));
    m_buttonFillWithFG->setChecked(true);
    m_sliderPatternScale = new KisDoubleSliderSpinBox;
    m_sliderPatternScale->setRange(0, 10000, 2);
    m_sliderPatternScale->setSoftMaximum(500);
    KisSpinBoxI18nHelper::setText(m_sliderPatternScale,
                                  i18nc("The pattern 'scale' spinbox in enclose and fill tool options; {n} is the "
                                        "number value, % is the percent sign",
                                        "Scale: {n}%"));
    m_angleSelectorPatternRotation = new KisAngleSelector;
    m_angleSelectorPatternRotation->setFlipOptionsMode(KisAngleSelector::FlipOptionsMode_ContextMenu);
    m_angleSelectorPatternRotation->setIncreasingDirection(KisAngleGauge::IncreasingDirection_Clockwise);
    m_checkBoxCustomBlendingOptions = new QCheckBox(i18n("Use custom blending options"));
    m_checkBoxCustomBlendingOptions->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Preferred);
    m_sliderCustomOpacity = new KisSliderSpinBox;
    m_sliderCustomOpacity->setRange(0, 100);
    KisSpinBoxI18nHelper::setText(m_sliderCustomOpacity,
                                  i18nc("{n} is the number value, % is the percent sign", "Opacity: {n}%"));
    m_comboBoxCustomCompositeOp = new KisCompositeOpComboBox;
 
    m_sliderFillThreshold = new KisSliderSpinBox;
    m_sliderFillThreshold->setPrefix(i18nc("The 'threshold' spinbox prefix in enclose and fill tool options", "Threshold: "));
    m_sliderFillThreshold->setRange(1, 100);
    m_sliderFillOpacitySpread = new KisSliderSpinBox;
    KisSpinBoxI18nHelper::setText(
        m_sliderFillOpacitySpread,
        i18nc("The 'spread' spinbox in enclose and fill tool options; {n} is the number value, % is the percent sign",
              "Spread: {n}%"));
    m_sliderFillOpacitySpread->setRange(0, 100);
    m_sliderCloseGap = new KisSliderSpinBox;
    m_sliderCloseGap->setPrefix(i18nc("The 'close gap' spinbox prefix in enclose and fill tool options", "Close Gap: "));
    m_sliderCloseGap->setRange(0, 32);
    m_sliderCloseGap->setSuffix(i18n(" px"));
    m_checkBoxSelectionAsBoundary =
        new QCheckBox(
            i18nc("The 'use selection as boundary' checkbox in enclose and fill tool to use selection borders as boundary when filling",
                  "Use selection as boundary")
        );
    m_checkBoxSelectionAsBoundary->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Preferred);
 
    m_checkBoxAntiAlias = new QCheckBox(i18nc("The anti-alias checkbox in enclose and fill tool options", "Anti-aliasing"));
    KisOptionCollectionWidget *containerGrow = new KisOptionCollectionWidget;
    m_sliderExpand = new KisSliderSpinBox;
    m_sliderExpand->setPrefix(i18nc("The 'grow/shrink' spinbox prefix in enclose and fill tool options", "Grow: "));
    m_sliderExpand->setRange(-400, 400);
    m_sliderExpand->setSoftRange(-40, 40);
    m_sliderExpand->setSuffix(i18n(" px"));
    m_buttonStopGrowingAtDarkestPixel = new QToolButton;
    m_buttonStopGrowingAtDarkestPixel->setAutoRaise(true);
    m_buttonStopGrowingAtDarkestPixel->setCheckable(true);
    m_buttonStopGrowingAtDarkestPixel->setIcon(KisIconUtils::loadIcon("stop-at-boundary"));
    containerGrow->appendWidget("sliderExpand", m_sliderExpand);
    containerGrow->appendWidget("buttonStopGrowingAtDarkestPixel", m_buttonStopGrowingAtDarkestPixel);
    containerGrow->setOrientation(Qt::Horizontal);
    m_sliderFeather = new KisSliderSpinBox;
    m_sliderFeather->setPrefix(i18nc("The 'feather' spinbox prefix in enclose and fill tool options", "Feather: "));
    m_sliderFeather->setRange(0, 400);
    m_sliderFeather->setSoftRange(0, 40);
    m_sliderFeather->setSuffix(i18n(" px"));
 
    KisOptionButtonStrip *optionButtonStripReference = new KisOptionButtonStrip;
    m_buttonReferenceCurrent = optionButtonStripReference->addButton(
        KisIconUtils::loadIcon("current-layer"));
    m_buttonReferenceAll = optionButtonStripReference->addButton(
        KisIconUtils::loadIcon("all-layers"));
    m_buttonReferenceLabeled =
        optionButtonStripReference->addButton(KisIconUtils::loadIcon("tag"));
    m_buttonReferenceCurrent->setChecked(true);
    m_widgetLabels = new KisColorLabelSelectorWidget;
    m_widgetLabels->setExclusive(false);
    m_widgetLabels->setButtonSize(20);
    m_widgetLabels->setButtonWrapEnabled(true);
    m_widgetLabels->setMouseDragEnabled(true);
    m_checkBoxUseActiveLayer = new QCheckBox(i18n("Use active layer"));
 
    QPushButton *buttonReset = new QPushButton(i18nc("The 'reset' button in enclose and fill tool options", "Reset"));
 
    // Set the tooltips
    m_buttonEnclosingMethodRectangle->setToolTip(i18n("Rectangle"));
    m_buttonEnclosingMethodEllipse->setToolTip(i18n("Ellipse"));
    m_buttonEnclosingMethodPath->setToolTip(i18n("Bezier Curve"));
    m_buttonEnclosingMethodLasso->setToolTip(i18n("Lasso"));
    m_buttonEnclosingMethodBrush->setToolTip(i18n("Brush"));
    m_comboBoxRegionSelectionMethod->setToolTip(regionSelectionMethodToUserString(m_regionSelectionMethod));
    m_checkBoxRegionSelectionInvert->setToolTip(i18n("Enable to fill opposite regions instead"));
    m_checkBoxRegionSelectionIncludeContourRegions->setToolTip(i18n("Enable to also fill shapes that touch the contour of the enclosing region"));
    m_buttonFillWithFG->setToolTip(i18n("Foreground color"));
    m_buttonFillWithBG->setToolTip(i18n("Background color"));
    m_buttonFillWithPattern->setToolTip(i18n("Pattern"));
    m_sliderPatternScale->setToolTip(i18n("Set the scale of the pattern"));
    m_angleSelectorPatternRotation->setToolTip(i18n("Set the rotation of the pattern"));
    m_checkBoxCustomBlendingOptions->setToolTip(i18n("Set custom blending options instead of using the brush ones"));
    m_sliderCustomOpacity->setToolTip(i18n("Set a custom opacity for the fill"));
    m_comboBoxCustomCompositeOp->setToolTip(i18n("Set a custom blend mode for the fill"));
 
    m_sliderFillThreshold->setToolTip(i18n("Set the color similarity tolerance of the fill. Increasing threshold increases the range of similar colors to be filled."));
    m_sliderFillOpacitySpread->setToolTip(i18n("Set the extent of the opaque portion of the fill. Decreasing spread decreases opacity of fill areas depending on color similarity."));
    m_sliderCloseGap->setToolTip(i18n("Close gaps in lines up to the set amount"));
    m_checkBoxSelectionAsBoundary->setToolTip(i18n("Set if the contour of the active selection should be treated as a boundary when filling the region"));
 
    m_checkBoxAntiAlias->setToolTip(i18n("Smooths the edges of the fill"));
    m_sliderExpand->setToolTip(i18n("Grow or shrink the fill by the set amount"));
    m_buttonStopGrowingAtDarkestPixel->setToolTip(i18n("Stop growing at the darkest and/or most opaque pixels"));
    m_sliderFeather->setToolTip(i18n("Blur the fill by the set amount"));
 
    m_buttonReferenceCurrent->setToolTip(i18n("Fill regions found from the active layer"));
    m_buttonReferenceAll->setToolTip(i18n("Fill regions found from the merging of all layers"));
    m_buttonReferenceLabeled->setToolTip(i18n("Fill regions found from the merging of layers with specific color labels"));
    m_checkBoxUseActiveLayer->setToolTip(i18n("Includes the active layer in regions found from merging of layers with specific color labels"));
 
    buttonReset->setToolTip(i18n("Reset the options to their default values"));
 
    // Construct the option widget
    m_optionWidget = new KisOptionCollectionWidget;
    m_optionWidget->setContentsMargins(0, 10, 0, 10);
    m_optionWidget->setSeparatorsVisible(true);
 
    KisOptionCollectionWidgetWithHeader *sectionEnclosingMethod =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'enclosing method' section label in enclose and fill tool options", "Enclosing method")
        );
    sectionEnclosingMethod->setPrimaryWidget(optionButtonStripEnclosingMethod);
    m_optionWidget->appendWidget("sectionEnclosingMethod", sectionEnclosingMethod);
 
    KisOptionCollectionWidget *widgetLabelsGroup = new KisOptionCollectionWidget;
    widgetLabelsGroup->appendWidget("labelWidget", m_widgetLabels);
    widgetLabelsGroup->appendWidget("checkBoxUseActiveLayer", m_checkBoxUseActiveLayer);
    widgetLabelsGroup->setWidgetsMargin(0);
 
    KisOptionCollectionWidgetWithHeader *sectionReference =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'reference' section label in enclose and fill tool options", "Reference")
        );
    sectionReference->setPrimaryWidget(optionButtonStripReference);
    sectionReference->appendWidget("widgetLabels", widgetLabelsGroup);
    sectionReference->setWidgetVisible("widgetLabels", false);
    m_optionWidget->appendWidget("sectionReference", sectionReference);
 
 
    KisOptionCollectionWidgetWithHeader *sectionWhatToFill =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'target regions' section label in enclose and fill tool options", "Target regions")
        );
    sectionWhatToFill->setPrimaryWidget(m_comboBoxRegionSelectionMethod);
    sectionWhatToFill->appendWidget("buttonRegionSelectionColor", m_buttonRegionSelectionColor);
    sectionWhatToFill->appendWidget("checkBoxRegionSelectionInvert", m_checkBoxRegionSelectionInvert);
    sectionWhatToFill->appendWidget("checkBoxRegionSelectionIncludeContourRegions", m_checkBoxRegionSelectionIncludeContourRegions);
    m_optionWidget->appendWidget("sectionWhatToFill", sectionWhatToFill);
 
    KisOptionCollectionWidgetWithHeader *sectionFillWith =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'fill source' section label in enclose and fill tool options", "Fill source")
        );
    sectionFillWith->setPrimaryWidget(optionButtonStripFillWith);
    sectionFillWith->appendWidget("sliderPatternScale", m_sliderPatternScale);
    sectionFillWith->appendWidget("angleSelectorPatternRotation", m_angleSelectorPatternRotation);
    sectionFillWith->appendWidget("checkBoxCustomBlendingOptions", m_checkBoxCustomBlendingOptions);
    sectionFillWith->appendWidget("sliderCustomOpacity", m_sliderCustomOpacity);
    sectionFillWith->appendWidget("comboBoxCustomCompositeOp", m_comboBoxCustomCompositeOp);
    sectionFillWith->setWidgetVisible("sliderPatternScale", false);
    sectionFillWith->setWidgetVisible("angleSelectorPatternRotation", false);
    m_optionWidget->appendWidget("sectionFillWith", sectionFillWith);
 
    KisOptionCollectionWidgetWithHeader *sectionRegionExtent =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'fill extent' section label in enclose and fill tool options", "Fill extent")
        );
    sectionRegionExtent->appendWidget("sliderThreshold", m_sliderFillThreshold);
    sectionRegionExtent->appendWidget("sliderSpread", m_sliderFillOpacitySpread);
    sectionRegionExtent->appendWidget("sliderCloseGap", m_sliderCloseGap);
    sectionRegionExtent->appendWidget("checkBoxSelectionAsBoundary", m_checkBoxSelectionAsBoundary);
    m_optionWidget->appendWidget("sectionRegionExtent", sectionRegionExtent);
 
    KisOptionCollectionWidgetWithHeader *sectionAdjustments =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'adjustments' section label in enclose and fill tool options", "Adjustments")
        );
    sectionAdjustments->appendWidget("checkBoxAntiAlias", m_checkBoxAntiAlias);
    sectionAdjustments->appendWidget("containerGrow", containerGrow);
    sectionAdjustments->appendWidget("sliderFeather", m_sliderFeather);
    m_optionWidget->appendWidget("sectionAdjustments", sectionAdjustments);
 
    m_optionWidget->appendWidget("buttonReset", buttonReset);
 
    // Initialize widgets
    if (m_enclosingMethod == Rectangle) {
        m_buttonEnclosingMethodRectangle->setChecked(true);
    } else if (m_enclosingMethod == Ellipse) {
        m_buttonEnclosingMethodEllipse->setChecked(true);
    } else if (m_enclosingMethod == Path) {
        m_buttonEnclosingMethodPath->setChecked(true);
    } else if (m_enclosingMethod == Lasso) {
        m_buttonEnclosingMethodLasso->setChecked(true);
    } else {
        m_buttonEnclosingMethodBrush->setChecked(true);
    }
    m_comboBoxRegionSelectionMethod->setCurrentIndex(m_comboBoxRegionSelectionMethod->findData(static_cast<int>(m_regionSelectionMethod)));
    m_buttonRegionSelectionColor->setColor(m_regionSelectionColor);
    sectionWhatToFill->setWidgetVisible(
        "buttonRegionSelectionColor",
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColorOrTransparent
    );
    m_checkBoxRegionSelectionInvert->setChecked(m_regionSelectionInvert);
    m_checkBoxRegionSelectionIncludeContourRegions->setChecked(m_regionSelectionIncludeContourRegions);
    sectionWhatToFill->setWidgetVisible(
        "checkBoxRegionSelectionIncludeContourRegions",
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegions ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent
    );
    if (m_fillType == FillWithBackgroundColor) {
        m_buttonFillWithBG->setChecked(true);
    } else if (m_fillType == FillWithPattern) {
        m_buttonFillWithPattern->setChecked(true);
        sectionFillWith->setWidgetVisible("sliderPatternScale", true);
        sectionFillWith->setWidgetVisible("angleSelectorPatternRotation", true);
    }
    m_sliderPatternScale->setValue(m_patternScale);
    m_angleSelectorPatternRotation->setAngle(m_patternRotation);
    m_checkBoxCustomBlendingOptions->setChecked(m_useCustomBlendingOptions);
    m_sliderCustomOpacity->setValue(m_customOpacity);
    slot_colorSpaceChanged(currentNode() && currentNode()->paintDevice()
                           ? currentNode()->paintDevice()->colorSpace()
                           : nullptr);
    m_comboBoxCustomCompositeOp->selectCompositeOp(KoID(m_customCompositeOp));
    if (!m_useCustomBlendingOptions) {
        sectionFillWith->setWidgetVisible("sliderCustomOpacity", false);
        sectionFillWith->setWidgetVisible("comboBoxCustomCompositeOp", false);
    }
    m_sliderFillThreshold->setValue(m_fillThreshold);
    m_sliderFillOpacitySpread->setValue(m_fillOpacitySpread);
    m_sliderCloseGap->setValue(m_closeGap);
    m_checkBoxSelectionAsBoundary->setChecked(m_useSelectionAsBoundary);
    m_checkBoxAntiAlias->setChecked(m_antiAlias);
    m_sliderExpand->setValue(m_expand);
    m_buttonStopGrowingAtDarkestPixel->setChecked(m_stopGrowingAtDarkestPixel);
    m_sliderFeather->setValue(m_feather);
    if (m_reference == AllLayers) {
        m_buttonReferenceAll->setChecked(true);
    } else if (m_reference == ColorLabeledLayers) {
        m_buttonReferenceLabeled->setChecked(true);
        sectionReference->setWidgetVisible("widgetLabels", true);
    }
    m_widgetLabels->setSelection(m_selectedColorLabels);
    m_checkBoxUseActiveLayer->setChecked(m_useActiveLayer);
 
    // Make connections
    connect(optionButtonStripEnclosingMethod,
            SIGNAL(buttonToggled(KoGroupButton *, bool)),
            SLOT(slot_optionButtonStripEnclosingMethod_buttonToggled(
                KoGroupButton *,
                bool)));
    connect(m_comboBoxRegionSelectionMethod,
            SIGNAL(currentIndexChanged(int)),
            SLOT(slot_comboBoxRegionSelectionMethod_currentIndexChanged(int)));
    connect(m_buttonRegionSelectionColor,
            SIGNAL(changed(const KoColor&)),
            SLOT(slot_buttonRegionSelectionColor_changed(const KoColor&)));
    connect(m_checkBoxRegionSelectionInvert,
            SIGNAL(toggled(bool)),
            SLOT(slot_checkBoxRegionSelectionInvert_toggled(bool)));
    connect(m_checkBoxRegionSelectionIncludeContourRegions,
            SIGNAL(toggled(bool)),
            SLOT(slot_checkBoxRegionSelectionIncludeContourRegions_toggled(bool)));
    connect(optionButtonStripFillWith,
            SIGNAL(buttonToggled(KoGroupButton *, bool)),
            SLOT(slot_optionButtonStripFillWith_buttonToggled(KoGroupButton *, bool)));
    connect(m_sliderPatternScale,
            SIGNAL(valueChanged(double)),
            SLOT(slot_sliderPatternScale_valueChanged(double)));
    connect(m_angleSelectorPatternRotation,
            SIGNAL(angleChanged(double)),
            SLOT(slot_angleSelectorPatternRotation_angleChanged(double)));
    connect(m_checkBoxCustomBlendingOptions,
            SIGNAL(toggled(bool)),
            SLOT(slot_checkBoxUseCustomBlendingOptions_toggled(bool)));
    connect(m_sliderCustomOpacity,
            SIGNAL(valueChanged(int)),
            SLOT(slot_sliderCustomOpacity_valueChanged(int)));
    connect(m_comboBoxCustomCompositeOp,
            SIGNAL(currentIndexChanged(int)),
            SLOT(slot_comboBoxCustomCompositeOp_currentIndexChanged(int)));
    connect(m_sliderFillThreshold,
            SIGNAL(valueChanged(int)),
            SLOT(slot_sliderFillThreshold_valueChanged(int)));
    connect(m_sliderFillOpacitySpread,
            SIGNAL(valueChanged(int)),
            SLOT(slot_sliderFillOpacitySpread_valueChanged(int)));
    connect(m_sliderCloseGap,
            SIGNAL(valueChanged(int)),
            SLOT(slot_sliderCloseGap_valueChanged(int)));
    connect(m_checkBoxSelectionAsBoundary,
            SIGNAL(toggled(bool)),
            SLOT(slot_checkBoxSelectionAsBoundary_toggled(bool)));
    connect(m_checkBoxAntiAlias,
            SIGNAL(toggled(bool)),
            SLOT(slot_checkBoxAntiAlias_toggled(bool)));
    connect(m_sliderExpand,
            SIGNAL(valueChanged(int)),
            SLOT(slot_sliderExpand_valueChanged(int)));
    connect(m_buttonStopGrowingAtDarkestPixel,
            SIGNAL(toggled(bool)),
            SLOT(slot_buttonStopGrowingAtDarkestPixel_toggled(bool)));
    connect(m_sliderFeather,
            SIGNAL(valueChanged(int)),
            SLOT(slot_sliderFeather_valueChanged(int)));
    connect(optionButtonStripReference,
            SIGNAL(buttonToggled(KoGroupButton *, bool)),
            SLOT(slot_optionButtonStripReference_buttonToggled(KoGroupButton *, bool)));
    connect(m_widgetLabels,
            SIGNAL(selectionChanged()),
            SLOT(slot_widgetLabels_selectionChanged()));
    connect(m_checkBoxUseActiveLayer,
            SIGNAL(toggled(bool)),
            SLOT(slot_checkBoxUseActiveLayer_toggled(bool)));
    connect(buttonReset,
            SIGNAL(clicked()),
            SLOT(slot_buttonReset_clicked()));
    
    return m_optionWidget;
}

References KisOptionButtonStrip::addButton(), AllLayers, KisOptionCollectionWidget::appendWidget(), KisOptionCollectionWidgetWithHeader::appendWidget(), ColorLabeledLayers, connect(), KisTool::currentNode(), FillWithBackgroundColor, FillWithPattern, KisAngleSelector::FlipOptionsMode_ContextMenu, KisAngleGauge::IncreasingDirection_Clockwise, Lasso, loadConfiguration(), KisIconUtils::loadIcon(), m_angleSelectorPatternRotation, m_antiAlias, m_buttonEnclosingMethodBrush, m_buttonEnclosingMethodEllipse, m_buttonEnclosingMethodLasso, m_buttonEnclosingMethodPath, m_buttonEnclosingMethodRectangle, m_buttonFillWithBG, m_buttonFillWithFG, m_buttonFillWithPattern, m_buttonReferenceAll, m_buttonReferenceCurrent, m_buttonReferenceLabeled, m_buttonRegionSelectionColor, m_buttonStopGrowingAtDarkestPixel, m_checkBoxAntiAlias, m_checkBoxCustomBlendingOptions, m_checkBoxRegionSelectionIncludeContourRegions, m_checkBoxRegionSelectionInvert, m_checkBoxSelectionAsBoundary, m_checkBoxUseActiveLayer, m_closeGap, m_comboBoxCustomCompositeOp, m_comboBoxRegionSelectionMethod, m_customCompositeOp, m_customOpacity, m_enclosingMethod, m_expand, m_feather, m_fillOpacitySpread, m_fillThreshold, m_fillType, m_optionWidget, m_patternRotation, m_patternScale, m_reference, m_regionSelectionColor, m_regionSelectionIncludeContourRegions, m_regionSelectionInvert, m_regionSelectionMethod, m_selectedColorLabels, m_sliderCloseGap, m_sliderCustomOpacity, m_sliderExpand, m_sliderFeather, m_sliderFillOpacitySpread, m_sliderFillThreshold, m_sliderPatternScale, m_stopGrowingAtDarkestPixel, m_useActiveLayer, m_useCustomBlendingOptions, m_useSelectionAsBoundary, m_widgetLabels, Rectangle, regionSelectionMethodToUserString(), KisCompositeOpComboBox::selectCompositeOp(), KoToolBase::selectionChanged(), KisAngleSelector::setAngle(), KisColorLabelSelectorWidget::setButtonSize(), KisColorLabelSelectorWidget::setButtonWrapEnabled(), KisColorButton::setColor(), KisColorLabelSelectorWidget::setExclusive(), KisAngleSelector::setFlipOptionsMode(), KisAngleSelector::setIncreasingDirection(), KisColorLabelSelectorWidget::setMouseDragEnabled(), KisOptionCollectionWidget::setOrientation(), KisOptionCollectionWidgetWithHeader::setPrimaryWidget(), KisSliderSpinBox::setRange(), KisDoubleSliderSpinBox::setRange(), KisColorLabelSelectorWidget::setSelection(), KisOptionCollectionWidget::setSeparatorsVisible(), KisDoubleSliderSpinBox::setSoftMaximum(), KisSliderSpinBox::setSoftRange(), KisSpinBoxI18nHelper::setText(), KisSliderSpinBox::setValue(), KisDoubleSliderSpinBox::setValue(), KisOptionCollectionWidget::setWidgetsMargin(), KisOptionCollectionWidgetWithHeader::setWidgetVisible(), slot_angleSelectorPatternRotation_angleChanged(), slot_buttonRegionSelectionColor_changed(), slot_buttonReset_clicked(), slot_buttonStopGrowingAtDarkestPixel_toggled(), slot_checkBoxAntiAlias_toggled(), slot_checkBoxRegionSelectionIncludeContourRegions_toggled(), slot_checkBoxRegionSelectionInvert_toggled(), slot_checkBoxSelectionAsBoundary_toggled(), slot_checkBoxUseActiveLayer_toggled(), slot_checkBoxUseCustomBlendingOptions_toggled(), slot_colorSpaceChanged(), slot_comboBoxCustomCompositeOp_currentIndexChanged(), slot_comboBoxRegionSelectionMethod_currentIndexChanged(), slot_optionButtonStripEnclosingMethod_buttonToggled(), slot_optionButtonStripFillWith_buttonToggled(), slot_optionButtonStripReference_buttonToggled(), slot_sliderCloseGap_valueChanged(), slot_sliderCustomOpacity_valueChanged(), slot_sliderExpand_valueChanged(), slot_sliderFeather_valueChanged(), slot_sliderFillOpacitySpread_valueChanged(), slot_sliderFillThreshold_valueChanged(), slot_sliderPatternScale_valueChanged(), and slot_widgetLabels_selectionChanged().

◆ deactivate

void KisToolEncloseAndFill::deactivate ( )

overrideslot

Definition at line 100 of file KisToolEncloseAndFill.cpp.

{
    m_referencePaintDevice = nullptr;
    m_referenceNodeList = nullptr;
    KisCanvas2 *kisCanvas = static_cast<KisCanvas2*>(canvas());
    KisCanvasResourceProvider *resourceProvider = kisCanvas->viewManager()->canvasResourceProvider();
    if (resourceProvider) {
        disconnect(resourceProvider,
                   SIGNAL(sigNodeChanged(const KisNodeSP)),
                   this,
                   SLOT(slot_currentNodeChanged(const KisNodeSP)));
    }
    slot_currentNodeChanged(nullptr);
    KisDynamicDelegatedTool::deactivate();
}

References Private::canvas, KisViewManager::canvasResourceProvider(), KisDynamicDelegatedTool< BaseClass >::deactivate(), m_referenceNodeList, m_referencePaintDevice, slot_currentNodeChanged(), and KisCanvas2::viewManager().

◆ deactivateAlternateAction()

void KisToolEncloseAndFill::deactivateAlternateAction ( AlternateAction action )

overridevirtual

Reimplemented from KisTool.

Definition at line 204 of file KisToolEncloseAndFill.cpp.

{
    if (subtoolHasUserInteractionRunning()) {
        return;
    }
    KisDynamicDelegatedTool::deactivateAlternateAction(action);
}

References KoToolBase::action(), KisDynamicDelegatedTool< BaseClass >::deactivateAlternateAction(), and subtoolHasUserInteractionRunning().

◆ defaultEnclosingMethod()

static constexpr EnclosingMethod KisToolEncloseAndFill::defaultEnclosingMethod ( )

inlinestaticconstexprprivate

Definition at line 172 of file KisToolEncloseAndFill.h.

172{ return Lasso; }

References Lasso.

◆ defaultReference()

static constexpr Reference KisToolEncloseAndFill::defaultReference ( )

inlinestaticconstexprprivate

Definition at line 188 of file KisToolEncloseAndFill.h.

188{ return CurrentLayer; }

References CurrentLayer.

◆ defaultRegionSelectionMethod()

static constexpr RegionSelectionMethod KisToolEncloseAndFill::defaultRegionSelectionMethod ( )

inlinestaticconstexprprivate

Definition at line 179 of file KisToolEncloseAndFill.h.

179{ return RegionSelectionMethod::SelectAllRegions; }

◆ enclosingMethodToConfigString()

QString KisToolEncloseAndFill::enclosingMethodToConfigString ( EnclosingMethod enclosingMethod ) const

private

Definition at line 877 of file KisToolEncloseAndFill.cpp.

{
    switch (enclosingMethod) {
        case Rectangle: return "rectangle";
        case Ellipse: return "ellipse";
        case Path: return "path";
        case Brush: return "brush";
        default: return "lasso";
    }
}

References Brush, Ellipse, Path, and Rectangle.

◆ endAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 238 of file KisToolEncloseAndFill.cpp.

{
    if (subtoolHasUserInteractionRunning()) {
        if (delegateTool()) {
            delegateTool()->endPrimaryAction(event);
        }
        return;
    }
    if (!m_alternateActionStarted) {
        return;
    }
    KisDynamicDelegatedTool::endAlternateAction(event, action);
    m_alternateActionStarted = false;
}

References KoToolBase::action(), KisDynamicDelegatedTool< KisToolShape >::delegateTool(), KisDynamicDelegatedTool< BaseClass >::endAlternateAction(), m_alternateActionStarted, and subtoolHasUserInteractionRunning().

◆ flags()

int KisToolEncloseAndFill::flags ( ) const

overridevirtual

Reimplemented from KisTool.

Definition at line 377 of file KisToolEncloseAndFill.cpp.

{
    return KisDynamicDelegatedTool::flags() | KisTool::FLAG_USES_CUSTOM_SIZE | KisTool::FLAG_USES_CUSTOM_PRESET;
}

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

◆ loadConfiguration()

void KisToolEncloseAndFill::loadConfiguration ( )

private

Definition at line 801 of file KisToolEncloseAndFill.cpp.

{
    m_enclosingMethod = loadEnclosingMethodFromConfig();
    m_regionSelectionMethod = loadRegionSelectionMethodFromConfig();
    m_regionSelectionColor = loadRegionSelectionColorFromConfig();
    m_regionSelectionInvert = m_configGroup.readEntry<bool>("regionSelectionInvert", false);
    m_regionSelectionIncludeContourRegions = m_configGroup.readEntry<bool>("regionSelectionIncludeContourRegions", false);
    {
        const QString fillTypeStr = m_configGroup.readEntry<QString>("fillWith", "");
        if (fillTypeStr == "foregroundColor") {
            m_fillType = FillWithForegroundColor;
        } else if (fillTypeStr == "backgroundColor") {
            m_fillType = FillWithBackgroundColor;
        } else if (fillTypeStr == "pattern") {
            m_fillType = FillWithPattern;
        } else {
            if (m_configGroup.readEntry<bool>("usePattern", false)) {
                m_fillType = FillWithPattern;
            } else {
                m_fillType = FillWithForegroundColor;
            }
        }
    }
    m_patternScale = m_configGroup.readEntry<qreal>("patternScale", 100.0);
    m_patternRotation = m_configGroup.readEntry<qreal>("patternRotate", 0.0);
    m_useCustomBlendingOptions = m_configGroup.readEntry<bool>("useCustomBlendingOptions", false);
    m_customOpacity = qBound(0, m_configGroup.readEntry<int>("customOpacity", 100), 100);
    m_customCompositeOp = m_configGroup.readEntry<QString>("customCompositeOp", COMPOSITE_OVER);
    if (KoCompositeOpRegistry::instance().getKoID(m_customCompositeOp).id().isNull()) {
        m_customCompositeOp = COMPOSITE_OVER;
    }
    m_fillThreshold = m_configGroup.readEntry<int>("fillThreshold", 8);
    m_fillOpacitySpread = m_configGroup.readEntry<int>("fillOpacitySpread", 100);
    m_closeGap = m_configGroup.readEntry<int>("closeGapAmount", 0);
    m_useSelectionAsBoundary = m_configGroup.readEntry<bool>("useSelectionAsBoundary", true);
    m_antiAlias = m_configGroup.readEntry<bool>("antiAlias", false);
    m_expand = m_configGroup.readEntry<int>("expand", 0);
    m_stopGrowingAtDarkestPixel = m_configGroup.readEntry<bool>("stopGrowingAtDarkestPixel", false);
    m_feather = m_configGroup.readEntry<int>("feather", 0);
    {
        const QString sampleLayersModeStr = m_configGroup.readEntry<QString>("reference", "currentLayer");
        if (sampleLayersModeStr == "allLayers") {
            m_reference = AllLayers;
        } else if (sampleLayersModeStr == "colorLabeledLayers") {
            m_reference = ColorLabeledLayers;
        } else {
            m_reference = CurrentLayer;
        }
    }
    {
        const QStringList colorLabelsStr = m_configGroup.readEntry<QString>("colorLabels", "").split(',', Qt::SkipEmptyParts);
 
        m_selectedColorLabels.clear();
        for (const QString &colorLabelStr : colorLabelsStr) {
            bool ok;
            const int colorLabel = colorLabelStr.toInt(&ok);
            if (ok) {
                m_selectedColorLabels << colorLabel;
            }
        }
    }
    m_useActiveLayer = m_configGroup.readEntry<bool>("useActiveLayer", false);
 
    setupEnclosingSubtool();
}

References AllLayers, ColorLabeledLayers, COMPOSITE_OVER, CurrentLayer, FillWithBackgroundColor, FillWithForegroundColor, FillWithPattern, KoCompositeOpRegistry::getKoID(), KoID::id(), KoCompositeOpRegistry::instance(), loadEnclosingMethodFromConfig(), loadRegionSelectionColorFromConfig(), loadRegionSelectionMethodFromConfig(), m_antiAlias, m_closeGap, m_configGroup, m_customCompositeOp, m_customOpacity, m_enclosingMethod, m_expand, m_feather, m_fillOpacitySpread, m_fillThreshold, m_fillType, m_patternRotation, m_patternScale, m_reference, m_regionSelectionColor, m_regionSelectionIncludeContourRegions, m_regionSelectionInvert, m_regionSelectionMethod, m_selectedColorLabels, m_stopGrowingAtDarkestPixel, m_useActiveLayer, m_useCustomBlendingOptions, m_useSelectionAsBoundary, and setupEnclosingSubtool().

◆ loadEnclosingMethodFromConfig()

KisToolEncloseAndFill::EnclosingMethod KisToolEncloseAndFill::loadEnclosingMethodFromConfig ( ) const

private

Definition at line 867 of file KisToolEncloseAndFill.cpp.

{
    return configStringToEnclosingMethod(m_configGroup.readEntry("enclosingMethod", enclosingMethodToConfigString(defaultEnclosingMethod())));
}

References configStringToEnclosingMethod(), defaultEnclosingMethod(), enclosingMethodToConfigString(), and m_configGroup.

◆ loadReferenceFromConfig()

KisToolEncloseAndFill::Reference KisToolEncloseAndFill::loadReferenceFromConfig ( ) const

private

Definition at line 1015 of file KisToolEncloseAndFill.cpp.

{
    if (m_configGroup.hasKey("reference")) {
        return configStringToReference(m_configGroup.readEntry("reference", referenceToConfigString(defaultReference())));
    } else {
        bool sampleMerged = m_configGroup.readEntry("sampleMerged", false);
        return sampleMerged ? AllLayers : CurrentLayer;
    }
    return CurrentLayer;
}

References AllLayers, configStringToReference(), CurrentLayer, defaultReference(), m_configGroup, and referenceToConfigString().

◆ loadRegionSelectionColorFromConfig()

KoColor KisToolEncloseAndFill::loadRegionSelectionColorFromConfig ( )

private

Definition at line 998 of file KisToolEncloseAndFill.cpp.

{
    const QString xmlColor = m_configGroup.readEntry("regionSelectionColor", QString());
    QDomDocument doc;
    if (doc.setContent(xmlColor)) {
        QDomElement e = doc.documentElement().firstChild().toElement();
        QString channelDepthID = doc.documentElement().attribute("channeldepth", Integer16BitsColorDepthID.id());
        bool ok;
        if (e.hasAttribute("space") || e.tagName().toLower() == "srgb") {
            return KoColor::fromXML(e, channelDepthID, &ok);
        } else if (doc.documentElement().hasAttribute("space") || doc.documentElement().tagName().toLower() == "srgb"){
            return KoColor::fromXML(doc.documentElement(), channelDepthID, &ok);
        }
    }
    return KoColor();
}

References KoColor::fromXML(), KoID::id(), Integer16BitsColorDepthID, and m_configGroup.

◆ loadRegionSelectionMethodFromConfig()

KisToolEncloseAndFill::RegionSelectionMethod KisToolEncloseAndFill::loadRegionSelectionMethodFromConfig ( ) const

private

Definition at line 938 of file KisToolEncloseAndFill.cpp.

{
    return configStringToRegionSelectionMethod(m_configGroup.readEntry("regionSelectionMethod", regionSelectionMethodToConfigString(defaultRegionSelectionMethod())));
}

References configStringToRegionSelectionMethod(), defaultRegionSelectionMethod(), m_configGroup, and regionSelectionMethodToConfigString().

◆ referenceToConfigString()

QString KisToolEncloseAndFill::referenceToConfigString ( Reference reference ) const

private

Definition at line 1031 of file KisToolEncloseAndFill.cpp.

{
    if (reference == AllLayers) {
        return "allLayers";
    } else if (reference == ColorLabeledLayers) {
        return "colorLabeledLayers";
    }
    return "currentLayer";
}

References AllLayers, and ColorLabeledLayers.

◆ referenceToUserString()

QString KisToolEncloseAndFill::referenceToUserString ( Reference reference ) const

private

◆ regionSelectionMethodToConfigString()

QString KisToolEncloseAndFill::regionSelectionMethodToConfigString ( RegionSelectionMethod regionSelectionMethod ) const

private

Definition at line 948 of file KisToolEncloseAndFill.cpp.

{
    if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegions) {
        return "allRegions";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColor) {
        return "regionsFilledWithSpecificColor";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithTransparent) {
        return "regionsFilledWithTransparent";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent) {
        return "regionsFilledWithSpecificColorOrTransparent";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor) {
        return "allRegionsExceptFilledWithSpecificColor";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithTransparent) {
        return "allRegionsExceptFilledWithTransparent";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent) {
        return "allRegionsExceptFilledWithSpecificColorOrTransparent";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColor) {
        return "regionsSurroundedBySpecificColor";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedByTransparent) {
        return "regionsSurroundedByTransparent";
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColorOrTransparent) {
        return "regionsSurroundedBySpecificColorOrTransparent";
    }
    return QString();
}

◆ regionSelectionMethodToUserString()

QString KisToolEncloseAndFill::regionSelectionMethodToUserString ( RegionSelectionMethod regionSelectionMethod ) const

private

Definition at line 902 of file KisToolEncloseAndFill.cpp.

{
    if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegions) {
        return i18nc("Region selection method in enclose and fill tool",
                     "All");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColor) {
        return i18nc("Region selection method in enclose and fill tool",
                     "Specific color");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithTransparent) {
        return i18nc("Region selection method in enclose and fill tool",
                     "Transparency");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent) {
        return i18nc("Region selection method in enclose and fill tool",
                     "Specific color or transparency");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor) {
        return i18nc("Region selection method in enclose and fill tool",
                     "All, excluding a specific color");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithTransparent) {
        return i18nc("Region selection method in enclose and fill tool",
                     "All, excluding transparency");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent) {
        return i18nc("Region selection method in enclose and fill tool",
                     "All, excluding a specific color or transparency");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColor) {
        return i18nc("Region selection method in enclose and fill tool",
                     "Any surrounded by a specific color");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedByTransparent) {
        return i18nc("Region selection method in enclose and fill tool",
                     "Any surrounded by transparency");
    } else if (regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColorOrTransparent) {
        return i18nc("Region selection method in enclose and fill tool",
                     "Any surrounded by a specific color or transparency");
    }
    return QString();
}

◆ resetCursorStyle

void KisToolEncloseAndFill::resetCursorStyle ( )

overrideprivateslot

Definition at line 79 of file KisToolEncloseAndFill.cpp.

{
    KisDynamicDelegatedTool::resetCursorStyle();
    overrideCursorIfNotEditable();
}

References KisTool::overrideCursorIfNotEditable(), and KisDynamicDelegatedTool< BaseClass >::resetCursorStyle().

◆ saveEnclosingMethodToConfig()

void KisToolEncloseAndFill::saveEnclosingMethodToConfig ( EnclosingMethod enclosingMethod )

private

Definition at line 872 of file KisToolEncloseAndFill.cpp.

{
    m_configGroup.writeEntry("enclosingMethod", enclosingMethodToConfigString(enclosingMethod));
}

References enclosingMethodToConfigString(), and m_configGroup.

◆ saveReferenceToConfig()

void KisToolEncloseAndFill::saveReferenceToConfig ( Reference reference )

private

Definition at line 1026 of file KisToolEncloseAndFill.cpp.

{
    m_configGroup.writeEntry("reference", referenceToConfigString(reference));
}

References m_configGroup, and referenceToConfigString().

◆ saveRegionSelectionMethodToConfig()

void KisToolEncloseAndFill::saveRegionSelectionMethodToConfig ( RegionSelectionMethod regionSelectionMethod )

private

Definition at line 943 of file KisToolEncloseAndFill.cpp.

{
    m_configGroup.writeEntry("regionSelectionMethod", regionSelectionMethodToConfigString(regionSelectionMethod));
}

References m_configGroup, and regionSelectionMethodToConfigString().

◆ setupEnclosingSubtool()

void KisToolEncloseAndFill::setupEnclosingSubtool ( )

private

Definition at line 116 of file KisToolEncloseAndFill.cpp.

{
    if (delegateTool()) {
        delegateTool()->deactivate();
    }
 
    if (m_enclosingMethod == Ellipse) {
        KisEllipseEnclosingProducer *newDelegateTool = new KisEllipseEnclosingProducer(canvas());
        setDelegateTool(reinterpret_cast<KisDynamicDelegateTool<KisToolShape>*>(newDelegateTool));
        setCursor(newDelegateTool->cursor());
    } else if (m_enclosingMethod == Path) {
        KisPathEnclosingProducer *newDelegateTool = new KisPathEnclosingProducer(canvas());
        setDelegateTool(reinterpret_cast<KisDynamicDelegateTool<KisToolShape>*>(newDelegateTool));
        setCursor(newDelegateTool->cursor());
    } else if (m_enclosingMethod == Lasso) {
        KisLassoEnclosingProducer *newDelegateTool = new KisLassoEnclosingProducer(canvas());
        setDelegateTool(reinterpret_cast<KisDynamicDelegateTool<KisToolShape>*>(newDelegateTool));
        setCursor(newDelegateTool->cursor());
    } else if (m_enclosingMethod == Brush) {
        KisBrushEnclosingProducer *newDelegateTool = new KisBrushEnclosingProducer(canvas());
        setDelegateTool(reinterpret_cast<KisDynamicDelegateTool<KisToolShape>*>(newDelegateTool));
        setCursor(newDelegateTool->cursor());
    } else {
        KisRectangleEnclosingProducer *newDelegateTool = new KisRectangleEnclosingProducer(canvas());
        setDelegateTool(reinterpret_cast<KisDynamicDelegateTool<KisToolShape>*>(newDelegateTool));
        setCursor(newDelegateTool->cursor());
    }
 
    connect(delegateTool(), SIGNAL(enclosingMaskProduced(KisPixelSelectionSP)), SLOT(slot_delegateTool_enclosingMaskProduced(KisPixelSelectionSP)));
 
    if (isActivated()) {
        delegateTool()->activate(QSet<KoShape*>());
    }
}

References Brush, Private::canvas, connect(), KisTool::cursor, KisDynamicDelegatedTool< KisToolShape >::delegateTool(), KoToolBase::isActivated(), Lasso, m_enclosingMethod, KisDynamicDelegatedTool< KisToolShape >::setCursor(), KisDynamicDelegatedTool< KisToolShape >::setDelegateTool(), and slot_delegateTool_enclosingMaskProduced().

◆ slot_angleSelectorPatternRotation_angleChanged

void KisToolEncloseAndFill::slot_angleSelectorPatternRotation_angleChanged ( double value )

privateslot

Definition at line 1163 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_patternRotation) {
        return;
    }
    m_patternRotation = value;
    m_configGroup.writeEntry("patternRotate", value);
}

References m_configGroup, m_patternRotation, and value().

◆ slot_buttonRegionSelectionColor_changed

void KisToolEncloseAndFill::slot_buttonRegionSelectionColor_changed ( const KoColor & color )

privateslot

Definition at line 1105 of file KisToolEncloseAndFill.cpp.

{
    if (color == m_regionSelectionColor) {
        return;
    }
    m_regionSelectionColor = color;
    m_configGroup.writeEntry("regionSelectionColor", color.toXML());
}

References m_configGroup, m_regionSelectionColor, and KoColor::toXML().

◆ slot_buttonReset_clicked

void KisToolEncloseAndFill::slot_buttonReset_clicked ( )

privateslot

Definition at line 1311 of file KisToolEncloseAndFill.cpp.

{
    m_buttonEnclosingMethodLasso->setChecked(true);
    m_comboBoxRegionSelectionMethod->setCurrentIndex(
        m_comboBoxRegionSelectionMethod->findData(static_cast<int>(RegionSelectionMethod::SelectAllRegions))
    );
    m_buttonRegionSelectionColor->setColor(KoColor());
    m_checkBoxRegionSelectionInvert->setChecked(false);
    m_checkBoxRegionSelectionIncludeContourRegions->setChecked(false);
    m_buttonFillWithFG->setChecked(true);
    m_sliderPatternScale->setValue(100.0);
    m_angleSelectorPatternRotation->setAngle(0.0);
    m_checkBoxCustomBlendingOptions->setChecked(false);
    m_sliderCustomOpacity->setValue(100);
    m_comboBoxCustomCompositeOp->selectCompositeOp(KoID(COMPOSITE_OVER));
    m_sliderFillThreshold->setValue(8);
    m_sliderFillOpacitySpread->setValue(100);
    m_sliderCloseGap->setValue(0);
    m_checkBoxSelectionAsBoundary->setChecked(true);
    m_checkBoxAntiAlias->setChecked(false);
    m_sliderExpand->setValue(0);
    m_buttonStopGrowingAtDarkestPixel->setChecked(false);
    m_sliderFeather->setValue(0);
    m_buttonReferenceCurrent->setChecked(true);
    m_widgetLabels->setSelection({});
}

References COMPOSITE_OVER, m_angleSelectorPatternRotation, m_buttonEnclosingMethodLasso, m_buttonFillWithFG, m_buttonReferenceCurrent, m_buttonRegionSelectionColor, m_buttonStopGrowingAtDarkestPixel, m_checkBoxAntiAlias, m_checkBoxCustomBlendingOptions, m_checkBoxRegionSelectionIncludeContourRegions, m_checkBoxRegionSelectionInvert, m_checkBoxSelectionAsBoundary, m_comboBoxCustomCompositeOp, m_comboBoxRegionSelectionMethod, m_sliderCloseGap, m_sliderCustomOpacity, m_sliderExpand, m_sliderFeather, m_sliderFillOpacitySpread, m_sliderFillThreshold, m_sliderPatternScale, m_widgetLabels, KisCompositeOpComboBox::selectCompositeOp(), KisAngleSelector::setAngle(), KisColorButton::setColor(), KisColorLabelSelectorWidget::setSelection(), KisSliderSpinBox::setValue(), and KisDoubleSliderSpinBox::setValue().

◆ slot_buttonStopGrowingAtDarkestPixel_toggled

void KisToolEncloseAndFill::slot_buttonStopGrowingAtDarkestPixel_toggled ( bool enabled )

privateslot

Definition at line 1256 of file KisToolEncloseAndFill.cpp.

{
    if (enabled == m_stopGrowingAtDarkestPixel) {
        return;
    }
    m_stopGrowingAtDarkestPixel = enabled;
    m_configGroup.writeEntry("stopGrowingAtDarkestPixel", enabled);
}

References m_configGroup, and m_stopGrowingAtDarkestPixel.

◆ slot_checkBoxAntiAlias_toggled

void KisToolEncloseAndFill::slot_checkBoxAntiAlias_toggled ( bool checked )

privateslot

Definition at line 1238 of file KisToolEncloseAndFill.cpp.

{
    if (checked == m_antiAlias) {
        return;
    }
    m_antiAlias = checked;
    m_configGroup.writeEntry("antiAlias", checked);
}

References m_antiAlias, and m_configGroup.

◆ slot_checkBoxRegionSelectionIncludeContourRegions_toggled

void KisToolEncloseAndFill::slot_checkBoxRegionSelectionIncludeContourRegions_toggled ( bool checked )

privateslot

Definition at line 1123 of file KisToolEncloseAndFill.cpp.

{
    if (checked == m_regionSelectionIncludeContourRegions) {
        return;
    }
    m_regionSelectionIncludeContourRegions = checked;
    m_configGroup.writeEntry("regionSelectionIncludeContourRegions", checked);
}

References m_configGroup, and m_regionSelectionIncludeContourRegions.

◆ slot_checkBoxRegionSelectionInvert_toggled

void KisToolEncloseAndFill::slot_checkBoxRegionSelectionInvert_toggled ( bool checked )

privateslot

Definition at line 1114 of file KisToolEncloseAndFill.cpp.

{
    if (checked == m_regionSelectionInvert) {
        return;
    }
    m_regionSelectionInvert = checked;
    m_configGroup.writeEntry("regionSelectionInvert", checked);
}

References m_configGroup, and m_regionSelectionInvert.

◆ slot_checkBoxSelectionAsBoundary_toggled

void KisToolEncloseAndFill::slot_checkBoxSelectionAsBoundary_toggled ( bool checked )

privateslot

Definition at line 1229 of file KisToolEncloseAndFill.cpp.

{
    if (checked == m_useSelectionAsBoundary) {
        return;
    }
    m_useSelectionAsBoundary = checked;
    m_configGroup.writeEntry("useSelectionAsBoundary", checked);
}

References m_configGroup, and m_useSelectionAsBoundary.

◆ slot_checkBoxUseActiveLayer_toggled

void KisToolEncloseAndFill::slot_checkBoxUseActiveLayer_toggled ( bool checked )

privateslot

Definition at line 1371 of file KisToolEncloseAndFill.cpp.

{
    if (checked == m_useActiveLayer) {
        return;
    }
    m_useActiveLayer = checked;
    m_configGroup.writeEntry("useActiveLayer", checked);
}

References m_configGroup, and m_useActiveLayer.

◆ slot_checkBoxUseCustomBlendingOptions_toggled

void KisToolEncloseAndFill::slot_checkBoxUseCustomBlendingOptions_toggled ( bool checked )

privateslot

Definition at line 1172 of file KisToolEncloseAndFill.cpp.

{
    KisOptionCollectionWidgetWithHeader *sectionFillWith =
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionFillWith");
    sectionFillWith->setWidgetVisible("sliderCustomOpacity", checked);
    sectionFillWith->setWidgetVisible("comboBoxCustomCompositeOp", checked);
    m_useCustomBlendingOptions = checked;
    m_configGroup.writeEntry("useCustomBlendingOptions", checked);
}

References m_configGroup, m_optionWidget, m_useCustomBlendingOptions, KisOptionCollectionWidgetWithHeader::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_colorSpaceChanged

void KisToolEncloseAndFill::slot_colorSpaceChanged ( const KoColorSpace * colorSpace )

privateslot

Definition at line 1356 of file KisToolEncloseAndFill.cpp.

{
    if (!m_comboBoxCustomCompositeOp) {
        return;
    }
    const KoColorSpace *compositionSpace = colorSpace;
    if (currentNode() && currentNode()->paintDevice()) {
        // Currently, composition source is enough to determine the available blending mode,
        // because either destination is the same (paint layers), or composition happens
        // in source space (masks).
        compositionSpace = currentNode()->paintDevice()->compositionSourceColorSpace();
    }
    m_comboBoxCustomCompositeOp->validate(compositionSpace);
}

References KisPaintDevice::compositionSourceColorSpace(), KisTool::currentNode(), m_comboBoxCustomCompositeOp, KisBaseNode::paintDevice(), and KisCompositeOpComboBox::validate().

◆ slot_comboBoxCustomCompositeOp_currentIndexChanged

void KisToolEncloseAndFill::slot_comboBoxCustomCompositeOp_currentIndexChanged ( int index )

privateslot

Definition at line 1191 of file KisToolEncloseAndFill.cpp.

{
    Q_UNUSED(index);
    const QString compositeOpId = m_comboBoxCustomCompositeOp->selectedCompositeOp().id();
    if (compositeOpId == m_customCompositeOp) {
        return;
    }
    m_customCompositeOp = compositeOpId;
    m_configGroup.writeEntry("customCompositeOp", compositeOpId);
}

References KoID::id(), m_comboBoxCustomCompositeOp, m_configGroup, m_customCompositeOp, and KisCompositeOpComboBox::selectedCompositeOp().

◆ slot_comboBoxRegionSelectionMethod_currentIndexChanged

void KisToolEncloseAndFill::slot_comboBoxRegionSelectionMethod_currentIndexChanged ( int )

privateslot

Definition at line 1075 of file KisToolEncloseAndFill.cpp.

{
    m_regionSelectionMethod = static_cast<RegionSelectionMethod>(m_comboBoxRegionSelectionMethod->currentData().toInt());
 
    KisOptionCollectionWidgetWithHeader *sectionWhatToFill =
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionWhatToFill");
    sectionWhatToFill->setWidgetVisible("buttonRegionSelectionColor",
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsSurroundedBySpecificColorOrTransparent
    );
    sectionWhatToFill->setWidgetVisible(
        "checkBoxRegionSelectionIncludeContourRegions",
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegions ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectRegionsFilledWithSpecificColorOrTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColor ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithTransparent ||
        m_regionSelectionMethod == RegionSelectionMethod::SelectAllRegionsExceptFilledWithSpecificColorOrTransparent
    );
 
    m_comboBoxRegionSelectionMethod->setToolTip(m_comboBoxRegionSelectionMethod->currentText());
 
    saveRegionSelectionMethodToConfig(m_regionSelectionMethod);
}

References m_comboBoxRegionSelectionMethod, m_optionWidget, m_regionSelectionMethod, saveRegionSelectionMethodToConfig(), KisOptionCollectionWidgetWithHeader::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_currentNodeChanged

void KisToolEncloseAndFill::slot_currentNodeChanged ( const KisNodeSP node )

privateslot

Definition at line 1338 of file KisToolEncloseAndFill.cpp.

{
    if (m_previousNode && m_previousNode->paintDevice()) {
        disconnect(m_previousNode->paintDevice().data(),
                   SIGNAL(colorSpaceChanged(const KoColorSpace*)),
                   this,
                   SLOT(slot_colorSpaceChanged(const KoColorSpace*)));
    }
    if (node && node->paintDevice()) {
        connect(node->paintDevice().data(),
                SIGNAL(colorSpaceChanged(const KoColorSpace*)),
                this,
                SLOT(slot_colorSpaceChanged(const KoColorSpace*)));
        slot_colorSpaceChanged(node->paintDevice()->colorSpace());
    }
    m_previousNode = node;
}

References KisPaintDevice::colorSpace(), connect(), KisSharedPtr< T >::data(), m_previousNode, KisBaseNode::paintDevice(), and slot_colorSpaceChanged().

◆ slot_delegateTool_enclosingMaskProduced

void KisToolEncloseAndFill::slot_delegateTool_enclosingMaskProduced ( KisPixelSelectionSP enclosingMask )

privateslot

Definition at line 264 of file KisToolEncloseAndFill.cpp.

{
    KisStrokeStrategyUndoCommandBased *strategy =
            new KisStrokeStrategyUndoCommandBased(kundo2_i18n("Enclose and Fill"), false, image().data());
    strategy->setSupportsWrapAroundMode(true);
    m_fillStrokeId = image()->startStroke(strategy);
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_fillStrokeId);
 
    m_dirtyRect.reset(new QRect);
 
    KisResourcesSnapshotSP resources =
        new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
 
    if (m_reference == CurrentLayer) {
        m_referencePaintDevice = currentNode()->paintDevice();
    } else if (m_reference == AllLayers) {
        m_referencePaintDevice = currentImage()->projection();
    } else if (m_reference == ColorLabeledLayers) {
        if (!m_referenceNodeList) {
            m_referencePaintDevice = KisMergeLabeledLayersCommand::createRefPaintDevice(image(), "Enclose and Fill Tool Reference Result Paint Device");
            m_referenceNodeList.reset(new KisMergeLabeledLayersCommand::ReferenceNodeInfoList);
        }
        KisPaintDeviceSP newReferencePaintDevice = KisMergeLabeledLayersCommand::createRefPaintDevice(image(), "Enclose and Fill Tool Reference Result Paint Device");
        KisMergeLabeledLayersCommand::ReferenceNodeInfoListSP newReferenceNodeList(new KisMergeLabeledLayersCommand::ReferenceNodeInfoList);
        const int currentTime = image()->animationInterface()->currentTime();
        image()->addJob(
            m_fillStrokeId,
            new KisStrokeStrategyUndoCommandBased::Data(
                KUndo2CommandSP(new KisMergeLabeledLayersCommand(
                    image(),
                    m_referenceNodeList,
                    newReferenceNodeList,
                    m_referencePaintDevice,
                    newReferencePaintDevice,
                    m_selectedColorLabels,
                    KisMergeLabeledLayersCommand::GroupSelectionPolicy_SelectIfColorLabeled,
                    m_previousTime != currentTime,
                    m_useActiveLayer ? currentNode() : nullptr
                )),
                false,
                KisStrokeJobData::SEQUENTIAL,
                KisStrokeJobData::EXCLUSIVE
            )
        );
        m_referencePaintDevice = newReferencePaintDevice;
        m_referenceNodeList = newReferenceNodeList;
        m_previousTime = currentTime;
    }
 
    if (m_reference != ColorLabeledLayers) {
        // Reset this so that the device from color labeled layers gets
        // regenerated when that mode is selected again
        m_referenceNodeList.reset();
    }
 
    QTransform transform;
    transform.rotate(m_patternRotation);
    const qreal normalizedScale = m_patternScale * 0.01;
    transform.scale(normalizedScale, normalizedScale);
    resources->setFillTransform(transform);
 
    KisProcessingVisitorSP visitor =
        new KisEncloseAndFillProcessingVisitor(m_referencePaintDevice,
                                               enclosingMask,
                                               resources->activeSelection(),
                                               resources,
                                               m_regionSelectionMethod,
                                               m_regionSelectionColor,
                                               m_regionSelectionInvert,
                                               m_regionSelectionIncludeContourRegions,
                                               false,
                                               m_fillThreshold,
                                               m_fillOpacitySpread,
                                               m_closeGap,
                                               m_antiAlias,
                                               m_expand,
                                               m_stopGrowingAtDarkestPixel,
                                               m_feather,
                                               m_useSelectionAsBoundary,
                                               m_fillType == FillWithPattern,
                                               false,
                                               m_fillType == FillWithBackgroundColor,
                                               m_useCustomBlendingOptions,
                                               m_customOpacity / 100.0,
                                               m_customCompositeOp,
                                               m_dirtyRect);
 
    image()->addJob(
        m_fillStrokeId,
        new KisStrokeStrategyUndoCommandBased::Data(
            KUndo2CommandSP(new KisProcessingCommand(visitor, currentNode())),
            false,
            KisStrokeJobData::SEQUENTIAL,
            KisStrokeJobData::EXCLUSIVE
        )
    );
 
    image()->addJob(
        m_fillStrokeId,
        new KisStrokeStrategyUndoCommandBased::Data(
            KUndo2CommandSP(new KisUpdateCommand(currentNode(), m_dirtyRect, image().data())),
            false,
            KisStrokeJobData::SEQUENTIAL,
            KisStrokeJobData::EXCLUSIVE
        )
    );
 
    image()->endStroke(m_fillStrokeId);
 
    m_fillStrokeId = nullptr;
    m_dirtyRect = nullptr;
}

References KisResourcesSnapshot::activeSelection(), KisImage::addJob(), AllLayers, KisImage::animationInterface(), Private::canvas, ColorLabeledLayers, KisMergeLabeledLayersCommand::createRefPaintDevice(), KisTool::currentImage(), CurrentLayer, KisTool::currentNode(), KisImageAnimationInterface::currentTime(), KisImage::endStroke(), KisStrokeJobData::EXCLUSIVE, FillWithBackgroundColor, FillWithPattern, KisMergeLabeledLayersCommand::GroupSelectionPolicy_SelectIfColorLabeled, KisTool::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_i18n(), m_antiAlias, m_closeGap, m_customCompositeOp, m_customOpacity, m_dirtyRect, m_expand, m_feather, m_fillOpacitySpread, m_fillStrokeId, m_fillThreshold, m_fillType, m_patternRotation, m_patternScale, m_previousTime, m_reference, m_referenceNodeList, m_referencePaintDevice, m_regionSelectionColor, m_regionSelectionIncludeContourRegions, m_regionSelectionInvert, m_regionSelectionMethod, m_selectedColorLabels, m_stopGrowingAtDarkestPixel, m_useActiveLayer, m_useCustomBlendingOptions, m_useSelectionAsBoundary, KisBaseNode::paintDevice(), KisImage::projection(), KisStrokeJobData::SEQUENTIAL, KisResourcesSnapshot::setFillTransform(), KisStrokeStrategyUndoCommandBased::setSupportsWrapAroundMode(), and KisImage::startStroke().

◆ slot_optionButtonStripEnclosingMethod_buttonToggled

void KisToolEncloseAndFill::slot_optionButtonStripEnclosingMethod_buttonToggled	(	KoGroupButton *	button,
		bool	checked )

privateslot

Definition at line 1051 of file KisToolEncloseAndFill.cpp.

{
    if (!checked) {
        return;
    }
 
    if (button == m_buttonEnclosingMethodRectangle) {
        m_enclosingMethod = Rectangle;
    } else if (button == m_buttonEnclosingMethodEllipse) {
        m_enclosingMethod = Ellipse;
    } else if (button == m_buttonEnclosingMethodPath) {
        m_enclosingMethod = Path;
    } else if (button == m_buttonEnclosingMethodLasso) {
        m_enclosingMethod = Lasso;
    } else {
        m_enclosingMethod = Brush;
    }
 
    saveEnclosingMethodToConfig(m_enclosingMethod);
    setupEnclosingSubtool();
}

References Brush, button(), Ellipse, Lasso, m_buttonEnclosingMethodEllipse, m_buttonEnclosingMethodLasso, m_buttonEnclosingMethodPath, m_buttonEnclosingMethodRectangle, m_enclosingMethod, Path, Rectangle, saveEnclosingMethodToConfig(), and setupEnclosingSubtool().

◆ slot_optionButtonStripFillWith_buttonToggled

void KisToolEncloseAndFill::slot_optionButtonStripFillWith_buttonToggled	(	KoGroupButton *	button,
		bool	checked )

privateslot

Definition at line 1132 of file KisToolEncloseAndFill.cpp.

{
    if (!checked) {
        return;
    }
    const bool visible = button == m_buttonFillWithPattern;
    KisOptionCollectionWidgetWithHeader *sectionFillWith =
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionFillWith");
    sectionFillWith->setWidgetVisible("sliderPatternScale", visible);
    sectionFillWith->setWidgetVisible("angleSelectorPatternRotation", visible);
    
    m_fillType = button == m_buttonFillWithFG ? FillWithForegroundColor
                                              : (button == m_buttonFillWithBG ? FillWithBackgroundColor : FillWithPattern);
 
    m_configGroup.writeEntry(
        "fillWith",
        button == m_buttonFillWithFG ? "foregroundColor" : (button == m_buttonFillWithBG ? "backgroundColor" : "pattern")
    );
}

References button(), FillWithBackgroundColor, FillWithForegroundColor, FillWithPattern, m_buttonFillWithBG, m_buttonFillWithFG, m_buttonFillWithPattern, m_configGroup, m_fillType, m_optionWidget, KisOptionCollectionWidgetWithHeader::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_optionButtonStripReference_buttonToggled

void KisToolEncloseAndFill::slot_optionButtonStripReference_buttonToggled	(	KoGroupButton *	button,
		bool	checked )

privateslot

Definition at line 1274 of file KisToolEncloseAndFill.cpp.

{
    if (!checked) {
        return;
    }
    KisOptionCollectionWidgetWithHeader *sectionReference =
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionReference");
    sectionReference->setWidgetVisible("widgetLabels", button == m_buttonReferenceLabeled);
    
    m_reference = button == m_buttonReferenceCurrent ? CurrentLayer
                                                     : (button == m_buttonReferenceAll ? AllLayers : ColorLabeledLayers);
 
    m_configGroup.writeEntry(
        "reference",
        button == m_buttonReferenceCurrent ? "currentLayer" : (button == m_buttonReferenceAll ? "allLayers" : "colorLabeledLayers")
    );
}

References AllLayers, button(), ColorLabeledLayers, CurrentLayer, m_buttonReferenceAll, m_buttonReferenceCurrent, m_buttonReferenceLabeled, m_configGroup, m_optionWidget, m_reference, KisOptionCollectionWidgetWithHeader::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_sliderCloseGap_valueChanged

void KisToolEncloseAndFill::slot_sliderCloseGap_valueChanged ( int value )

privateslot

Definition at line 1220 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_closeGap) {
        return;
    }
    m_closeGap = value;
    m_configGroup.writeEntry("closeGapAmount", value);
}

References m_closeGap, m_configGroup, and value().

◆ slot_sliderCustomOpacity_valueChanged

void KisToolEncloseAndFill::slot_sliderCustomOpacity_valueChanged ( int value )

privateslot

Definition at line 1182 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_customOpacity) {
        return;
    }
    m_customOpacity = value;
    m_configGroup.writeEntry("customOpacity", value);
}

References m_configGroup, m_customOpacity, and value().

◆ slot_sliderExpand_valueChanged

void KisToolEncloseAndFill::slot_sliderExpand_valueChanged ( int value )

privateslot

Definition at line 1247 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_expand) {
        return;
    }
    m_expand = value;
    m_configGroup.writeEntry("expand", value);
}

References m_configGroup, m_expand, and value().

◆ slot_sliderFeather_valueChanged

void KisToolEncloseAndFill::slot_sliderFeather_valueChanged ( int value )

privateslot

Definition at line 1265 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_feather) {
        return;
    }
    m_feather = value;
    m_configGroup.writeEntry("feather", value);
}

References m_configGroup, m_feather, and value().

◆ slot_sliderFillOpacitySpread_valueChanged

void KisToolEncloseAndFill::slot_sliderFillOpacitySpread_valueChanged ( int value )

privateslot

Definition at line 1211 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_fillOpacitySpread) {
        return;
    }
    m_fillOpacitySpread = value;
    m_configGroup.writeEntry("fillOpacitySpread", value);
}

References m_configGroup, m_fillOpacitySpread, and value().

◆ slot_sliderFillThreshold_valueChanged

void KisToolEncloseAndFill::slot_sliderFillThreshold_valueChanged ( int value )

privateslot

Definition at line 1202 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_fillThreshold) {
        return;
    }
    m_fillThreshold = value;
    m_configGroup.writeEntry("fillThreshold", value);
}

References m_configGroup, m_fillThreshold, and value().

◆ slot_sliderPatternScale_valueChanged

void KisToolEncloseAndFill::slot_sliderPatternScale_valueChanged ( double value )

privateslot

Definition at line 1154 of file KisToolEncloseAndFill.cpp.

{
    if (value == m_patternScale) {
        return;
    }
    m_patternScale = value;
    m_configGroup.writeEntry("patternScale", value);
}

References m_configGroup, m_patternScale, and value().

◆ slot_widgetLabels_selectionChanged

void KisToolEncloseAndFill::slot_widgetLabels_selectionChanged ( )

privateslot

Definition at line 1294 of file KisToolEncloseAndFill.cpp.

{
    QList<int> labels = m_widgetLabels->selection();
    if (labels == m_selectedColorLabels) {
        return;
    }
    m_selectedColorLabels = labels;
    if (labels.isEmpty()) {
        return;
    }
    QString colorLabels = QString::number(labels.first());
    for (int i = 1; i < labels.size(); ++i) {
        colorLabels += "," + QString::number(labels[i]);
    }
    m_configGroup.writeEntry("colorLabels", colorLabels);
}

References m_configGroup, m_selectedColorLabels, m_widgetLabels, and KisColorLabelSelectorWidget::selection().

◆ subtoolHasUserInteractionRunning()

bool KisToolEncloseAndFill::subtoolHasUserInteractionRunning ( ) const

private

Definition at line 151 of file KisToolEncloseAndFill.cpp.

{
    if (!delegateTool()) {
        return false;
    }
    
    if (m_enclosingMethod == Rectangle) {
        return reinterpret_cast<KisRectangleEnclosingProducer*>(delegateTool())->hasUserInteractionRunning();
    } else if (m_enclosingMethod == Ellipse) {
        return reinterpret_cast<KisEllipseEnclosingProducer*>(delegateTool())->hasUserInteractionRunning();
    } else if (m_enclosingMethod == Path) {
        return reinterpret_cast<KisPathEnclosingProducer*>(delegateTool())->hasUserInteractionRunning();
    } else if (m_enclosingMethod == Lasso) {
        return reinterpret_cast<KisLassoEnclosingProducer*>(delegateTool())->hasUserInteractionRunning();
    } else if (m_enclosingMethod == Brush) {
        return reinterpret_cast<KisBrushEnclosingProducer*>(delegateTool())->hasUserInteractionRunning();
    }
    return false;
}

References Brush, KisDynamicDelegatedTool< KisToolShape >::delegateTool(), Lasso, m_enclosingMethod, and Rectangle.

◆ wantsAutoScroll()

bool KisToolEncloseAndFill::wantsAutoScroll ( ) const

inlineoverrideprivatevirtual

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 KisDynamicDelegatedTool< KisToolShape >.

Definition at line 166 of file KisToolEncloseAndFill.h.

166{ return false; }

Member Data Documentation

◆ m_alternateActionStarted

bool KisToolEncloseAndFill::m_alternateActionStarted {false}

private

Definition at line 164 of file KisToolEncloseAndFill.h.

164{false};

◆ m_angleSelectorPatternRotation

KisAngleSelector* KisToolEncloseAndFill::m_angleSelectorPatternRotation {nullptr}

private

Definition at line 141 of file KisToolEncloseAndFill.h.

141{nullptr};

◆ m_antiAlias

bool KisToolEncloseAndFill::m_antiAlias {false}

private

Definition at line 108 of file KisToolEncloseAndFill.h.

108{false};

◆ m_buttonEnclosingMethodBrush

KoGroupButton* KisToolEncloseAndFill::m_buttonEnclosingMethodBrush {nullptr}

private

Definition at line 130 of file KisToolEncloseAndFill.h.

130{nullptr};

◆ m_buttonEnclosingMethodEllipse

KoGroupButton* KisToolEncloseAndFill::m_buttonEnclosingMethodEllipse {nullptr}

private

Definition at line 127 of file KisToolEncloseAndFill.h.

127{nullptr};

◆ m_buttonEnclosingMethodLasso

KoGroupButton* KisToolEncloseAndFill::m_buttonEnclosingMethodLasso {nullptr}

private

Definition at line 129 of file KisToolEncloseAndFill.h.

129{nullptr};

◆ m_buttonEnclosingMethodPath

KoGroupButton* KisToolEncloseAndFill::m_buttonEnclosingMethodPath {nullptr}

private

Definition at line 128 of file KisToolEncloseAndFill.h.

128{nullptr};

◆ m_buttonEnclosingMethodRectangle

KoGroupButton* KisToolEncloseAndFill::m_buttonEnclosingMethodRectangle {nullptr}

private

Definition at line 126 of file KisToolEncloseAndFill.h.

126{nullptr};

◆ m_buttonFillWithBG

KoGroupButton* KisToolEncloseAndFill::m_buttonFillWithBG {nullptr}

private

Definition at line 138 of file KisToolEncloseAndFill.h.

138{nullptr};

◆ m_buttonFillWithFG

KoGroupButton* KisToolEncloseAndFill::m_buttonFillWithFG {nullptr}

private

Definition at line 137 of file KisToolEncloseAndFill.h.

137{nullptr};

◆ m_buttonFillWithPattern

KoGroupButton* KisToolEncloseAndFill::m_buttonFillWithPattern {nullptr}

private

Definition at line 139 of file KisToolEncloseAndFill.h.

139{nullptr};

◆ m_buttonReferenceAll

KoGroupButton* KisToolEncloseAndFill::m_buttonReferenceAll {nullptr}

private

Definition at line 157 of file KisToolEncloseAndFill.h.

157{nullptr};

◆ m_buttonReferenceCurrent

KoGroupButton* KisToolEncloseAndFill::m_buttonReferenceCurrent {nullptr}

private

Definition at line 156 of file KisToolEncloseAndFill.h.

156{nullptr};

◆ m_buttonReferenceLabeled

KoGroupButton* KisToolEncloseAndFill::m_buttonReferenceLabeled {nullptr}

private

Definition at line 158 of file KisToolEncloseAndFill.h.

158{nullptr};

◆ m_buttonRegionSelectionColor

KisColorButton* KisToolEncloseAndFill::m_buttonRegionSelectionColor {nullptr}

private

Definition at line 133 of file KisToolEncloseAndFill.h.

133{nullptr};

◆ m_buttonStopGrowingAtDarkestPixel

QToolButton* KisToolEncloseAndFill::m_buttonStopGrowingAtDarkestPixel {nullptr}

private

Definition at line 153 of file KisToolEncloseAndFill.h.

153{nullptr};

◆ m_checkBoxAntiAlias

QCheckBox* KisToolEncloseAndFill::m_checkBoxAntiAlias {nullptr}

private

Definition at line 151 of file KisToolEncloseAndFill.h.

151{nullptr};

◆ m_checkBoxCustomBlendingOptions

QCheckBox* KisToolEncloseAndFill::m_checkBoxCustomBlendingOptions {nullptr}

private

Definition at line 142 of file KisToolEncloseAndFill.h.

142{nullptr};

◆ m_checkBoxRegionSelectionIncludeContourRegions

QCheckBox* KisToolEncloseAndFill::m_checkBoxRegionSelectionIncludeContourRegions {nullptr}

private

Definition at line 135 of file KisToolEncloseAndFill.h.

135{nullptr};

◆ m_checkBoxRegionSelectionInvert

QCheckBox* KisToolEncloseAndFill::m_checkBoxRegionSelectionInvert {nullptr}

private

Definition at line 134 of file KisToolEncloseAndFill.h.

134{nullptr};

◆ m_checkBoxSelectionAsBoundary

QCheckBox* KisToolEncloseAndFill::m_checkBoxSelectionAsBoundary {nullptr}

private

Definition at line 149 of file KisToolEncloseAndFill.h.

149{nullptr};

◆ m_checkBoxUseActiveLayer

QCheckBox* KisToolEncloseAndFill::m_checkBoxUseActiveLayer {nullptr}

private

Definition at line 160 of file KisToolEncloseAndFill.h.

160{nullptr};

◆ m_closeGap

int KisToolEncloseAndFill::m_closeGap {0}

private

Definition at line 105 of file KisToolEncloseAndFill.h.

105{0};

◆ m_comboBoxCustomCompositeOp

KisCompositeOpComboBox* KisToolEncloseAndFill::m_comboBoxCustomCompositeOp {nullptr}

private

Definition at line 144 of file KisToolEncloseAndFill.h.

144{nullptr};

◆ m_comboBoxRegionSelectionMethod

QComboBox* KisToolEncloseAndFill::m_comboBoxRegionSelectionMethod {nullptr}

private

Definition at line 132 of file KisToolEncloseAndFill.h.

132{nullptr};

◆ m_configGroup

KConfigGroup KisToolEncloseAndFill::m_configGroup

private

Definition at line 162 of file KisToolEncloseAndFill.h.

◆ m_customCompositeOp

QString KisToolEncloseAndFill::m_customCompositeOp {COMPOSITE_OVER}

private

Definition at line 101 of file KisToolEncloseAndFill.h.

101{COMPOSITE_OVER};

◆ m_customOpacity

int KisToolEncloseAndFill::m_customOpacity {100}

private

Definition at line 100 of file KisToolEncloseAndFill.h.

100{100};

◆ m_dirtyRect

QSharedPointer<QRect> KisToolEncloseAndFill::m_dirtyRect {nullptr}

private

Definition at line 121 of file KisToolEncloseAndFill.h.

121{nullptr};

◆ m_enclosingMethod

EnclosingMethod KisToolEncloseAndFill::m_enclosingMethod {Lasso}

private

Definition at line 89 of file KisToolEncloseAndFill.h.

89{Lasso};

◆ m_expand

int KisToolEncloseAndFill::m_expand {0}

private

Definition at line 109 of file KisToolEncloseAndFill.h.

109{0};

◆ m_feather

int KisToolEncloseAndFill::m_feather {0}

private

Definition at line 111 of file KisToolEncloseAndFill.h.

111{0};

◆ m_fillOpacitySpread

int KisToolEncloseAndFill::m_fillOpacitySpread {100}

private

Definition at line 104 of file KisToolEncloseAndFill.h.

104{100};

◆ m_fillStrokeId

KisStrokeId KisToolEncloseAndFill::m_fillStrokeId {nullptr}

private

Definition at line 122 of file KisToolEncloseAndFill.h.

122{nullptr};

◆ m_fillThreshold

int KisToolEncloseAndFill::m_fillThreshold {8}

private

Definition at line 103 of file KisToolEncloseAndFill.h.

103{8};

◆ m_fillType

FillType KisToolEncloseAndFill::m_fillType {FillWithForegroundColor}

private

Definition at line 96 of file KisToolEncloseAndFill.h.

96{FillWithForegroundColor};

◆ m_optionWidget

KisOptionCollectionWidget* KisToolEncloseAndFill::m_optionWidget {nullptr}

private

Definition at line 124 of file KisToolEncloseAndFill.h.

124{nullptr};

◆ m_patternRotation

qreal KisToolEncloseAndFill::m_patternRotation {0.0}

private

Definition at line 98 of file KisToolEncloseAndFill.h.

98{0.0};

◆ m_patternScale

qreal KisToolEncloseAndFill::m_patternScale {100.0}

private

Definition at line 97 of file KisToolEncloseAndFill.h.

97{100.0};

◆ m_previousNode

KisNodeSP KisToolEncloseAndFill::m_previousNode {nullptr}

private

Definition at line 120 of file KisToolEncloseAndFill.h.

120{nullptr};

◆ m_previousTime

int KisToolEncloseAndFill::m_previousTime {0}

private

Definition at line 119 of file KisToolEncloseAndFill.h.

119{0};

◆ m_reference

Reference KisToolEncloseAndFill::m_reference {CurrentLayer}

private

Definition at line 114 of file KisToolEncloseAndFill.h.

114{CurrentLayer};

◆ m_referenceNodeList

KisMergeLabeledLayersCommand::ReferenceNodeInfoListSP KisToolEncloseAndFill::m_referenceNodeList {nullptr}

private

Definition at line 118 of file KisToolEncloseAndFill.h.

118{nullptr};

◆ m_referencePaintDevice

KisPaintDeviceSP KisToolEncloseAndFill::m_referencePaintDevice {nullptr}

private

Definition at line 117 of file KisToolEncloseAndFill.h.

117{nullptr};

◆ m_regionSelectionColor

KoColor KisToolEncloseAndFill::m_regionSelectionColor

private

Definition at line 92 of file KisToolEncloseAndFill.h.

◆ m_regionSelectionIncludeContourRegions

bool KisToolEncloseAndFill::m_regionSelectionIncludeContourRegions {false}

private

Definition at line 94 of file KisToolEncloseAndFill.h.

94{false};

◆ m_regionSelectionInvert

bool KisToolEncloseAndFill::m_regionSelectionInvert {false}

private

Definition at line 93 of file KisToolEncloseAndFill.h.

93{false};

◆ m_regionSelectionMethod

RegionSelectionMethod KisToolEncloseAndFill::m_regionSelectionMethod {defaultRegionSelectionMethod()}

private

Definition at line 91 of file KisToolEncloseAndFill.h.

91{defaultRegionSelectionMethod()};

◆ m_selectedColorLabels

QList<int> KisToolEncloseAndFill::m_selectedColorLabels

private

Definition at line 115 of file KisToolEncloseAndFill.h.

◆ m_sliderCloseGap

KisSliderSpinBox* KisToolEncloseAndFill::m_sliderCloseGap {nullptr}

private

Definition at line 148 of file KisToolEncloseAndFill.h.

148{nullptr};

◆ m_sliderCustomOpacity

KisSliderSpinBox* KisToolEncloseAndFill::m_sliderCustomOpacity {nullptr}

private

Definition at line 143 of file KisToolEncloseAndFill.h.

143{nullptr};

◆ m_sliderExpand

KisSliderSpinBox* KisToolEncloseAndFill::m_sliderExpand {nullptr}

private

Definition at line 152 of file KisToolEncloseAndFill.h.

152{nullptr};

◆ m_sliderFeather

KisSliderSpinBox* KisToolEncloseAndFill::m_sliderFeather {nullptr}

private

Definition at line 154 of file KisToolEncloseAndFill.h.

154{nullptr};

◆ m_sliderFillOpacitySpread

KisSliderSpinBox* KisToolEncloseAndFill::m_sliderFillOpacitySpread {nullptr}

private

Definition at line 147 of file KisToolEncloseAndFill.h.

147{nullptr};

◆ m_sliderFillThreshold

KisSliderSpinBox* KisToolEncloseAndFill::m_sliderFillThreshold {nullptr}

private

Definition at line 146 of file KisToolEncloseAndFill.h.

146{nullptr};

◆ m_sliderPatternScale

KisDoubleSliderSpinBox* KisToolEncloseAndFill::m_sliderPatternScale {nullptr}

private

Definition at line 140 of file KisToolEncloseAndFill.h.

140{nullptr};

◆ m_stopGrowingAtDarkestPixel

int KisToolEncloseAndFill::m_stopGrowingAtDarkestPixel {false}

private

Definition at line 110 of file KisToolEncloseAndFill.h.

110{false};

◆ m_useActiveLayer

bool KisToolEncloseAndFill::m_useActiveLayer {false}

private

Definition at line 112 of file KisToolEncloseAndFill.h.

112{false};

◆ m_useCustomBlendingOptions

bool KisToolEncloseAndFill::m_useCustomBlendingOptions {false}

private

Definition at line 99 of file KisToolEncloseAndFill.h.

99{false};

◆ m_useSelectionAsBoundary

bool KisToolEncloseAndFill::m_useSelectionAsBoundary {true}

private

Definition at line 106 of file KisToolEncloseAndFill.h.

106{true};

◆ m_widgetLabels

KisColorLabelSelectorWidget* KisToolEncloseAndFill::m_widgetLabels {nullptr}

private

Definition at line 159 of file KisToolEncloseAndFill.h.

159{nullptr};

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

plugins/tools/tool_enclose_and_fill/KisToolEncloseAndFill.h
plugins/tools/tool_enclose_and_fill/KisToolEncloseAndFill.cpp

Public Types

Public Slots

Public Member Functions

Private Slots

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ RegionSelectionMethod

Member Enumeration Documentation

◆ EnclosingMethod

◆ FillType

◆ Reference

Constructor & Destructor Documentation

◆ KisToolEncloseAndFill()

◆ ~KisToolEncloseAndFill()

Member Function Documentation

◆ activate

◆ activateAlternateAction()

◆ beginAlternateAction()

◆ beginAlternateDoubleClickAction()

◆ beginPrimaryAction()

◆ configStringToEnclosingMethod()

◆ configStringToReference()

◆ configStringToRegionSelectionMethod()

◆ continueAlternateAction()

◆ createOptionWidget()

◆ deactivate

◆ deactivateAlternateAction()

◆ defaultEnclosingMethod()

◆ defaultReference()

◆ defaultRegionSelectionMethod()

◆ enclosingMethodToConfigString()

◆ endAlternateAction()

◆ flags()

◆ loadConfiguration()

◆ loadEnclosingMethodFromConfig()

◆ loadReferenceFromConfig()

◆ loadRegionSelectionColorFromConfig()

◆ loadRegionSelectionMethodFromConfig()

◆ referenceToConfigString()

◆ referenceToUserString()

◆ regionSelectionMethodToConfigString()

◆ regionSelectionMethodToUserString()

◆ resetCursorStyle

◆ saveEnclosingMethodToConfig()

◆ saveReferenceToConfig()

◆ saveRegionSelectionMethodToConfig()

◆ setupEnclosingSubtool()

◆ slot_angleSelectorPatternRotation_angleChanged

◆ slot_buttonRegionSelectionColor_changed

◆ slot_buttonReset_clicked

◆ slot_buttonStopGrowingAtDarkestPixel_toggled

◆ slot_checkBoxAntiAlias_toggled

◆ slot_checkBoxRegionSelectionIncludeContourRegions_toggled

◆ slot_checkBoxRegionSelectionInvert_toggled

◆ slot_checkBoxSelectionAsBoundary_toggled

◆ slot_checkBoxUseActiveLayer_toggled

◆ slot_checkBoxUseCustomBlendingOptions_toggled

◆ slot_colorSpaceChanged

◆ slot_comboBoxCustomCompositeOp_currentIndexChanged

◆ slot_comboBoxRegionSelectionMethod_currentIndexChanged

◆ slot_currentNodeChanged

◆ slot_delegateTool_enclosingMaskProduced

◆ slot_optionButtonStripEnclosingMethod_buttonToggled

◆ slot_optionButtonStripFillWith_buttonToggled

◆ slot_optionButtonStripReference_buttonToggled

◆ slot_sliderCloseGap_valueChanged

◆ slot_sliderCustomOpacity_valueChanged

◆ slot_sliderExpand_valueChanged

◆ slot_sliderFeather_valueChanged

◆ slot_sliderFillOpacitySpread_valueChanged

◆ slot_sliderFillThreshold_valueChanged

◆ slot_sliderPatternScale_valueChanged

◆ slot_widgetLabels_selectionChanged

◆ subtoolHasUserInteractionRunning()

◆ wantsAutoScroll()

Member Data Documentation