#include <kis_tool_fill.h>

Inheritance diagram for KisToolFill:

Public Types
enum	ContiguousFillMode { ContiguousFillMode_FloodFill , ContiguousFillMode_BoundaryFill }

enum	ContinuousFillMode { ContinuousFillMode_DoNotUse , ContinuousFillMode_FillAnyRegion , ContinuousFillMode_FillSimilarRegions }

enum	FillMode { FillMode_FillSelection , FillMode_FillContiguousRegion , FillMode_FillSimilarRegions }

enum	FillType { FillType_FillWithForegroundColor , FillType_FillWithBackgroundColor , FillType_FillWithPattern }

enum	Reference { Reference_CurrentLayer , Reference_AllLayers , Reference_ColorLabeledLayers }

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

void	beginPrimaryAction (KoPointerEvent *event) override

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	endPrimaryAction (KoPointerEvent *event) override

	KisToolFill (KoCanvasBase *canvas)

	~KisToolFill () override

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

	KisToolPaint (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseMoveEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

KisPopupWidgetInterface *	popupWidget () override

	~KisToolPaint () override

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

virtual void	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action)

virtual void	beginPrimaryDoubleClickAction (KoPointerEvent *event)

void	deleteSelection () override

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

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

KisTool::NodePaintAbility	nodePaintAbility ()

virtual bool	primaryActionSupportsHiResEvents () const

virtual bool	supportsPaintingAssistants () const

	~KisTool () override

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

Public Member Functions inherited from KoToolBase
QAction *	action (const QString &name) const

KoCanvasBase *	canvas () const
	Returns the canvas the tool is working on.

virtual void	copy () const

QCursor	cursor () const
	return the last emitted cursor

virtual void	customMoveEvent (KoPointerEvent *event)

virtual void	customPressEvent (KoPointerEvent *event)

virtual void	customReleaseEvent (KoPointerEvent *event)

virtual void	cut ()

virtual QRectF	decorationsRect () const

int	decorationThickness () const
	decorationThickness The minimum thickness for tool decoration lines, this is derived from the screen magnification, thus the HiDPI settings. Note: to use this effectively, also set the pen to isCosmetic(true);

virtual void	deselect ()
	deselect the tool should clear the selection if it has one.

virtual void	dragLeaveEvent (QDragLeaveEvent *event)

virtual void	dragMoveEvent (QDragMoveEvent *event, const QPointF &point)

virtual void	dropEvent (QDropEvent *event, const QPointF &point)

virtual void	explicitUserStrokeEndRequest ()
	explicitUserStrokeEndRequest is called by the input manager when the user presses Enter key or any equivalent. This callback comes before requestStrokeEnd(), which comes from a different source.

KoToolFactoryBase *	factory () const

virtual void	focusInEvent (QFocusEvent *event)

virtual void	focusOutEvent (QFocusEvent *event)

virtual bool	hasSelection ()

virtual void	inputMethodEvent (QInputMethodEvent *event)

virtual QVariant	inputMethodQuery (Qt::InputMethodQuery query) const

bool	isInTextMode () const

bool	isOpacityPresetMode () const

virtual void	keyPressEvent (QKeyEvent *event)

virtual void	keyReleaseEvent (QKeyEvent *event)

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

virtual QMenu *	popupActionsMenu ()

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

virtual KoToolSelection *	selection ()

Q_INVOKABLE QString	toolId () const

	~KoToolBase () override

Protected Slots
void	resetCursorStyle () override

void	slotUpdateFill ()

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Protected Member Functions
bool	wantsAutoScroll () const override

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

void	activatePrimaryAction () override

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

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

void	beginAlternateAction (KoPointerEvent *event, AlternateAction action) override

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

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

QWidget *	createOptionWidget () override

void	deactivateAlternateAction (AlternateAction action) override

void	deactivatePrimaryAction () override

void	enableControl (QWidget *control, bool value)

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

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

bool	isEraser () const

bool	isOutlineEnabled () const

bool	isOutlineVisible () const

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

virtual QString	quickHelp () const

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

void	setMode (ToolMode mode) override

void	setOutlineEnabled (bool enabled)

void	setOutlineVisible (bool visible)

void	setSupportOutline (bool supportOutline)

void	showControl (QWidget *control, bool value)

Protected Member Functions inherited from KisTool
bool	blockUntilOperationsFinished ()

void	blockUntilOperationsFinishedForced ()

QPointF	convertDocumentToWidget (const QPointF &pt)

QPoint	convertToImagePixelCoordFloored (KoPointerEvent *e)

QPointF	convertToPixelCoord (const QPointF &pt)

QPointF	convertToPixelCoord (KoPointerEvent *e)

QPointF	convertToPixelCoordAndAlignOnWidget (const QPointF &pt)

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

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

QRectF	convertToPt (const QRectF &rect)

qreal	convertToPt (qreal value)

KoColor	currentBgColor ()

KoColor	currentFgColor ()

KisFilterConfigurationSP	currentGenerator ()

KoAbstractGradientSP	currentGradient ()

KisImageWSP	currentImage ()

KisNodeSP	currentNode () const

KisPaintOpPresetSP	currentPaintOpPreset ()

KoPatternSP	currentPattern ()

QCursor	cursor () const

KisImageWSP	image () const

virtual bool	listeningToModifiers ()

virtual void	listenToModifiers (bool listen)

virtual ToolMode	mode () const

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

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

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

KisOptimizedBrushOutline	pixelToView (const KisOptimizedBrushOutline &path) const

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

QPointF	pixelToView (const QPoint &pixelCoord) const

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

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

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

KisNodeList	selectedNodes () const

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

void	setCursor (const QCursor &cursor)

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

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

QPointF	viewToPixel (const QPointF &viewCoord) const

QPointF	widgetCenterInWidgetPixels ()

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

int	grabSensitivity () const
	Convenience function to get the current grab sensitivity.

qreal	handleDocRadius () const

QRectF	handleGrabRect (const QPointF &position) const

QRectF	handlePaintRect (const QPointF &position) const

int	handleRadius () const
	Convenience function to get the current handle radius.

bool	isActivated () const

	KoToolBase (KoToolBasePrivate &dd)

KoPointerEvent *	lastDeliveredPointerEvent () const

void	setAbstractResource (KoAbstractCanvasResourceInterfaceSP abstractResource)

void	setConverter (KoDerivedResourceConverterSP converter)

void	setIsOpacityPresetMode (bool value)

void	setMaskSyntheticEvents (bool value)

void	setTextMode (bool value)

QHash< int, KoAbstractCanvasResourceInterfaceSP >	toolAbstractResources ()

QHash< int, KoDerivedResourceConverterSP >	toolConverters ()

void	useCursor (const QCursor &cursor)

Private Slots
void	slot_angleSelectorPatternRotation_angleChanged (double value)

void	slot_buttonContiguousFillBoundaryColor_changed (const KoColor &color)

void	slot_buttonReset_clicked ()

void	slot_buttonStopGrowingAtDarkestPixel_toggled (bool enabled)

void	slot_checkBoxAntiAlias_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_currentNodeChanged (const KisNodeSP node)

void	slot_optionButtonStripContiguousFillMode_buttonToggled (KoGroupButton *button, bool checked)

void	slot_optionButtonStripDragFill_buttonToggled (KoGroupButton *button, bool checked)

void	slot_optionButtonStripFillWith_buttonToggled (KoGroupButton *button, bool checked)

void	slot_optionButtonStripReference_buttonToggled (KoGroupButton *button, bool checked)

void	slot_optionButtonStripWhatToFill_buttonToggled (KoGroupButton *button, bool checked)

void	slot_sliderCloseGap_valueChanged (int value)

void	slot_sliderCustomOpacity_valueChanged (int value)

void	slot_sliderFeather_valueChanged (int value)

void	slot_sliderGrow_valueChanged (int value)

void	slot_sliderPatternScale_valueChanged (double value)

void	slot_sliderSpread_valueChanged (int value)

void	slot_sliderThreshold_valueChanged (int value)

void	slot_widgetLabels_selectionChanged ()

Private Member Functions
void	addFillingOperation (const QPoint &seedPoint)

void	addFillingOperation (const QVector< QPoint > &seedPoints)

void	addUpdateOperation ()

void	beginFilling (const QPoint &seedPoint)

void	endFilling ()

void	loadConfiguration ()

KoColor	loadContiguousFillBoundaryColorFromConfig ()

Private Attributes
KisAngleSelector *	m_angleSelectorPatternRotation {nullptr}

bool	m_antiAlias {true}

KisColorButton *	m_buttonContiguousFillBoundaryColor {nullptr}

KoGroupButton *	m_buttonContiguousFillModeBoundaryFill {nullptr}

KoGroupButton *	m_buttonContiguousFillModeFloodFill {nullptr}

KoGroupButton *	m_buttonDragFillAny {nullptr}

KoGroupButton *	m_buttonDragFillDoNotUse {nullptr}

KoGroupButton *	m_buttonDragFillSimilar {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}

QToolButton *	m_buttonStopGrowingAtDarkestPixel {nullptr}

KoGroupButton *	m_buttonWhatToFillContiguous {nullptr}

KoGroupButton *	m_buttonWhatToFillSelection {nullptr}

KoGroupButton *	m_buttonWhatToFillSimilar {nullptr}

QCheckBox *	m_checkBoxAntiAlias {nullptr}

QCheckBox *	m_checkBoxCustomBlendingOptions {nullptr}

QCheckBox *	m_checkBoxSelectionAsBoundary {nullptr}

QCheckBox *	m_checkBoxUseActiveLayer {nullptr}

int	m_closeGap {0}

KisCompositeOpComboBox *	m_comboBoxCustomCompositeOp {nullptr}

KisSignalCompressor	m_compressorFillUpdate

KConfigGroup	m_configGroup

KoColor	m_contiguousFillBoundaryColor

ContiguousFillMode	m_contiguousFillMode {ContiguousFillMode_FloodFill}

ContinuousFillMode	m_continuousFillMode {ContinuousFillMode_FillAnyRegion}

QString	m_customCompositeOp {COMPOSITE_OVER}

int	m_customOpacity {100}

QSharedPointer< QRect >	m_dirtyRect

FillMode	m_effectiveFillMode {FillMode_FillSelection}

int	m_feather {0}

KisSelectionSP	m_fillMask

FillMode	m_fillMode {FillMode_FillContiguousRegion}

QPoint	m_fillStartWidgetPosition

KisStrokeId	m_fillStrokeId

FillType	m_fillType {FillType_FillWithForegroundColor}

bool	m_isDragging {false}

bool	m_isFilling {false}

int	m_opacitySpread {100}

KisOptionCollectionWidget *	m_optionWidget {nullptr}

qreal	m_patternRotation {0.0}

qreal	m_patternScale {100.0}

KisNodeSP	m_previousNode {nullptr}

int	m_previousTime

Reference	m_reference {Reference_CurrentLayer}

QSharedPointer< KoColor >	m_referenceColor

KisMergeLabeledLayersCommand::ReferenceNodeInfoListSP	m_referenceNodeList

KisPaintDeviceSP	m_referencePaintDevice

KisResourcesSnapshotSP	m_resourcesSnapshot

QVector< QPoint >	m_seedPoints

QList< int >	m_selectedColorLabels

int	m_sizemod {0}

KisSliderSpinBox *	m_sliderCloseGap {nullptr}

KisSliderSpinBox *	m_sliderCustomOpacity {nullptr}

KisSliderSpinBox *	m_sliderFeather {nullptr}

KisSliderSpinBox *	m_sliderGrow {nullptr}

KisDoubleSliderSpinBox *	m_sliderPatternScale {nullptr}

KisSliderSpinBox *	m_sliderSpread {nullptr}

KisSliderSpinBox *	m_sliderThreshold {nullptr}

int	m_stopGrowingAtDarkestPixel {false}

int	m_threshold {8}

QTransform	m_transform

bool	m_useActiveLayer {false}

bool	m_useCustomBlendingOptions {false}

bool	m_useSelectionAsBoundary {true}

KisColorLabelSelectorWidget *	m_widgetLabels {nullptr}

Static Private Attributes
static constexpr int	minimumDragDistance {4}

static constexpr int	minimumDragDistanceSquared {minimumDragDistance * minimumDragDistance}

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 KisTool
KoColor	currentBgColor

float	currentExposure {1.0}

KoColor	currentFgColor

KisFilterConfigurationSP	currentGenerator

KoAbstractGradientSP	currentGradient

KoPatternSP	currentPattern

QCursor	cursor

bool	m_isActive {false}

ToolMode	m_mode {HOVER_MODE}

QWidget *	optionWidget {0}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

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

Protected Attributes inherited from 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 kis_tool_fill.h.

Member Enumeration Documentation

◆ ContiguousFillMode

enum KisToolFill::ContiguousFillMode

Enumerator
ContiguousFillMode_FloodFill
ContiguousFillMode_BoundaryFill

Definition at line 59 of file kis_tool_fill.h.

    {
        ContiguousFillMode_FloodFill,
        ContiguousFillMode_BoundaryFill
    };

◆ ContinuousFillMode

enum KisToolFill::ContinuousFillMode

Enumerator
ContinuousFillMode_DoNotUse
ContinuousFillMode_FillAnyRegion
ContinuousFillMode_FillSimilarRegions

Definition at line 72 of file kis_tool_fill.h.

    {
        ContinuousFillMode_DoNotUse,
        ContinuousFillMode_FillAnyRegion,
        ContinuousFillMode_FillSimilarRegions
    };

◆ FillMode

enum KisToolFill::FillMode

Enumerator
FillMode_FillSelection
FillMode_FillContiguousRegion
FillMode_FillSimilarRegions

Definition at line 45 of file kis_tool_fill.h.

    {
        FillMode_FillSelection,
        FillMode_FillContiguousRegion,
        FillMode_FillSimilarRegions
    };

◆ FillType

enum KisToolFill::FillType

Enumerator
FillType_FillWithForegroundColor
FillType_FillWithBackgroundColor
FillType_FillWithPattern

Definition at line 52 of file kis_tool_fill.h.

    {
        FillType_FillWithForegroundColor,
        FillType_FillWithBackgroundColor,
        FillType_FillWithPattern
    };

◆ Reference

enum KisToolFill::Reference

Enumerator
Reference_CurrentLayer
Reference_AllLayers
Reference_ColorLabeledLayers

Definition at line 65 of file kis_tool_fill.h.

    {
        Reference_CurrentLayer,
        Reference_AllLayers,
        Reference_ColorLabeledLayers
    };

Constructor & Destructor Documentation

◆ KisToolFill()

KisToolFill::KisToolFill ( KoCanvasBase * canvas )

Definition at line 67 of file kis_tool_fill.cc.

    : KisToolPaint(canvas, KisCursor::load("tool_fill_cursor.png", 6, 6))
    , m_fillMask(nullptr)
    , m_referencePaintDevice(nullptr)
    , m_referenceNodeList(nullptr)
    , m_previousTime(0)
    , m_compressorFillUpdate(150, KisSignalCompressor::FIRST_ACTIVE)
    , m_dirtyRect(nullptr)
    , m_fillStrokeId(nullptr)
{
    setObjectName("tool_fill");
    connect(&m_compressorFillUpdate, SIGNAL(timeout()), SLOT(slotUpdateFill()));
 
    KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas);
 
    connect(kritaCanvas->viewManager()->canvasResourceProvider(), SIGNAL(sigEffectiveCompositeOpChanged()), SLOT(resetCursorStyle()));
}

References Private::canvas, KisViewManager::canvasResourceProvider(), connect(), m_compressorFillUpdate, resetCursorStyle(), slotUpdateFill(), and KisCanvas2::viewManager().

◆ ~KisToolFill()

KisToolFill::~KisToolFill ( )

override

Definition at line 85 of file kis_tool_fill.cc.

86{

87}

Member Function Documentation

◆ activate

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

overrideslot

Definition at line 100 of file kis_tool_fill.cc.

{
    KisToolPaint::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 KisToolPaint::activate(), Private::canvas, KisViewManager::canvasResourceProvider(), connect(), KisTool::currentNode(), m_configGroup, slot_currentNodeChanged(), KoToolBase::toolId(), and KisCanvas2::viewManager().

◆ addFillingOperation() [1/2]

void KisToolFill::addFillingOperation ( const QPoint & seedPoint )

private

Definition at line 342 of file kis_tool_fill.cc.

{
    const QVector<QPoint> seedPoints({seedPoint});
    addFillingOperation(seedPoints);
}

References addFillingOperation().

◆ addFillingOperation() [2/2]

void KisToolFill::addFillingOperation ( const QVector< QPoint > & seedPoints )

private

Definition at line 348 of file kis_tool_fill.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_fillStrokeId);
 
    const qreal customOpacity = m_customOpacity / 100.0;
 
    if (m_effectiveFillMode != FillMode_FillSimilarRegions) {
        FillProcessingVisitor *visitor =  new FillProcessingVisitor(m_referencePaintDevice,
                                                                    m_resourcesSnapshot->activeSelection(),
                                                                    m_resourcesSnapshot);
 
        const bool blendingOptionsAreNoOp = m_useCustomBlendingOptions
                                            ? (qFuzzyCompare(customOpacity, OPACITY_OPAQUE_F) &&
                                               m_customCompositeOp == COMPOSITE_OVER)
                                            : (qFuzzyCompare(m_resourcesSnapshot->opacity(), OPACITY_OPAQUE_F) &&
                                               m_resourcesSnapshot->compositeOpId() == COMPOSITE_OVER);
 
        const bool useFastMode = !m_resourcesSnapshot->activeSelection() &&
                                 blendingOptionsAreNoOp &&
                                 m_fillType != FillType_FillWithPattern &&
                                 m_opacitySpread == 100 &&
                                 m_useSelectionAsBoundary == false &&
                                 !m_antiAlias && m_sizemod == 0 && m_feather == 0 &&
                                 m_closeGap == 0 &&
                                 m_reference == Reference_CurrentLayer;
 
        visitor->setSeedPoints(seedPoints);
        visitor->setUseFastMode(useFastMode);
        visitor->setSelectionOnly(m_effectiveFillMode == FillMode_FillSelection);
        visitor->setUseBgColor(m_fillType == FillType_FillWithBackgroundColor);
        visitor->setUsePattern(m_fillType == FillType_FillWithPattern);
        visitor->setUseCustomBlendingOptions(m_useCustomBlendingOptions);
        if (m_useCustomBlendingOptions) {
            visitor->setCustomOpacity(customOpacity);
            visitor->setCustomCompositeOp(m_customCompositeOp);
        }
        visitor->setRegionFillingMode(
            m_contiguousFillMode == ContiguousFillMode_FloodFill
            ? KisFillPainter::RegionFillingMode_FloodFill
            : KisFillPainter::RegionFillingMode_BoundaryFill
        );
        if (m_contiguousFillMode == ContiguousFillMode_BoundaryFill) {
            visitor->setRegionFillingBoundaryColor(m_contiguousFillBoundaryColor);
        }
        visitor->setFillThreshold(m_threshold);
        visitor->setOpacitySpread(m_opacitySpread);
        visitor->setCloseGap(m_closeGap);
        visitor->setUseSelectionAsBoundary(m_useSelectionAsBoundary);
        visitor->setAntiAlias(m_antiAlias);
        visitor->setSizeMod(m_sizemod);
        visitor->setStopGrowingAtDarkestPixel(m_stopGrowingAtDarkestPixel);
        visitor->setFeather(m_feather);
        if (m_isDragging) {
            visitor->setContinuousFillMode(
                m_continuousFillMode == ContinuousFillMode_FillAnyRegion
                ? FillProcessingVisitor::ContinuousFillMode_FillAnyRegion
                : FillProcessingVisitor::ContinuousFillMode_FillSimilarRegions
            );
            visitor->setContinuousFillMask(m_fillMask);
            visitor->setContinuousFillReferenceColor(m_referenceColor);
        }
        visitor->setOutDirtyRect(m_dirtyRect);
 
        image()->addJob(
            m_fillStrokeId,
            new KisStrokeStrategyUndoCommandBased::Data(
                KUndo2CommandSP(new KisProcessingCommand(visitor, currentNode())),
                false,
                KisStrokeJobData::SEQUENTIAL,
                KisStrokeJobData::EXCLUSIVE
            )
        );
    } else {
        KisSelectionSP fillMask = m_fillMask;
        QSharedPointer<KisProcessingVisitor::ProgressHelper>
            progressHelper(new KisProcessingVisitor::ProgressHelper(currentNode()));
 
        {
            KisSelectionSP selection = m_resourcesSnapshot->activeSelection();
            KisFillPainter painter;
            QRect bounds = currentImage()->bounds();
            if (selection) {
                bounds = bounds.intersected(selection->projection()->selectedRect());
            }
 
            painter.setFillThreshold(m_threshold);
            painter.setOpacitySpread(m_opacitySpread);
            painter.setAntiAlias(m_antiAlias);
            painter.setSizemod(m_sizemod);
            painter.setStopGrowingAtDarkestPixel(m_stopGrowingAtDarkestPixel);
            painter.setFeather(m_feather);
 
            QVector<KisStrokeJobData*> jobs =
                painter.createSimilarColorsSelectionJobs(
                    fillMask->pixelSelection(), m_referenceColor, m_referencePaintDevice,
                    bounds, selection ? selection->projection() : nullptr, progressHelper
                );
 
            for (KisStrokeJobData *job : jobs) {
                image()->addJob(m_fillStrokeId, job);
            }
        }
 
        {
            FillProcessingVisitor *visitor =  new FillProcessingVisitor(nullptr,
                                                                        fillMask,
                                                                        m_resourcesSnapshot);
 
            visitor->setSeedPoints(seedPoints);
            visitor->setSelectionOnly(true);
            visitor->setUseBgColor(m_fillType == FillType_FillWithBackgroundColor);
            visitor->setUsePattern(m_fillType == FillType_FillWithPattern);
            visitor->setUseCustomBlendingOptions(m_useCustomBlendingOptions);
            if (m_useCustomBlendingOptions) {
                visitor->setCustomOpacity(customOpacity);
                visitor->setCustomCompositeOp(m_customCompositeOp);
            }
            visitor->setOutDirtyRect(m_dirtyRect);
            visitor->setProgressHelper(progressHelper);
 
            image()->addJob(
                m_fillStrokeId,
                new KisStrokeStrategyUndoCommandBased::Data(
                    KUndo2CommandSP(new KisProcessingCommand(visitor, currentNode())),
                    false,
                    KisStrokeJobData::SEQUENTIAL,
                    KisStrokeJobData::EXCLUSIVE
                )
            );
        }
    }
}

◆ addUpdateOperation()

void KisToolFill::addUpdateOperation ( )

private

Definition at line 481 of file kis_tool_fill.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_fillStrokeId);
 
    image()->addJob(
        m_fillStrokeId,
        new KisStrokeStrategyUndoCommandBased::Data(
            KUndo2CommandSP(new KisUpdateCommand(currentNode(), m_dirtyRect, image().data())),
            false,
            KisStrokeJobData::SEQUENTIAL,
            KisStrokeJobData::EXCLUSIVE
        )
    );
}

References KisImage::addJob(), KisTool::currentNode(), KisStrokeJobData::EXCLUSIVE, KisTool::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_dirtyRect, m_fillStrokeId, and KisStrokeJobData::SEQUENTIAL.

◆ beginAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 220 of file kis_tool_fill.cc.

{
    if (action == ChangeSize) {
        beginPrimaryAction(event);
        return;
    }
    KisToolPaint::beginAlternateAction(event, action);
}

References KoToolBase::action(), KisToolPaint::beginAlternateAction(), beginPrimaryAction(), and KisTool::ChangeSize.

◆ beginFilling()

void KisToolFill::beginFilling ( const QPoint & seedPoint )

private

Definition at line 247 of file kis_tool_fill.cc.

{
    setMode(KisTool::PAINT_MODE);
 
    KisStrokeStrategyUndoCommandBased *strategy =
            new KisStrokeStrategyUndoCommandBased(kundo2_i18n("Flood Fill"), false, image().data());
    strategy->setSupportsWrapAroundMode(true);
    m_fillStrokeId = image()->startStroke(strategy);
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_fillStrokeId);
 
    m_resourcesSnapshot = new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
 
    KisPaintDeviceSP referencePaintDevice = nullptr;
    if (m_effectiveFillMode != FillMode_FillSelection) {
        if (m_reference == Reference_CurrentLayer) {
            referencePaintDevice = currentNode()->paintDevice();
        } else if (m_reference == Reference_AllLayers) {
            referencePaintDevice = currentImage()->projection();
        } else if (m_reference == Reference_ColorLabeledLayers) {
            if (!m_referenceNodeList) {
                referencePaintDevice = KisMergeLabeledLayersCommand::createRefPaintDevice(image(), "Fill Tool Reference Result Paint Device");
                m_referenceNodeList.reset(new KisMergeLabeledLayersCommand::ReferenceNodeInfoList);
            } else {
                referencePaintDevice = m_referencePaintDevice;
            }
            KisPaintDeviceSP newReferencePaintDevice = KisMergeLabeledLayersCommand::createRefPaintDevice(image(), "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,
                        referencePaintDevice,
                        newReferencePaintDevice,
                        m_selectedColorLabels,
                        KisMergeLabeledLayersCommand::GroupSelectionPolicy_SelectIfColorLabeled,
                        m_previousTime != currentTime,
                        m_useActiveLayer ? currentNode() : nullptr
                    )),
                    false,
                    KisStrokeJobData::SEQUENTIAL,
                    KisStrokeJobData::EXCLUSIVE
                )
            );
            referencePaintDevice = newReferencePaintDevice;
            m_referenceNodeList = newReferenceNodeList;
            m_previousTime = currentTime;
        }
 
        QSharedPointer<KoColor> referenceColor(new KoColor);
        if (m_reference == Reference_ColorLabeledLayers) {
            // We need to obtain the reference color from the reference paint
            // device, but it is produced in a stroke, so we must get the color
            // after the device is ready. So we get it in the stroke
            image()->addJob(
                m_fillStrokeId,
                new KisStrokeStrategyUndoCommandBased::Data(
                    KUndo2CommandSP(new KisCommandUtils::LambdaCommand(
                        [referencePaintDevice, referenceColor, seedPoint]() -> KUndo2Command*
                        {
                            *referenceColor = referencePaintDevice->pixel(seedPoint);
                            return 0;
                        }
                    )),
                    false,
                    KisStrokeJobData::SEQUENTIAL,
                    KisStrokeJobData::EXCLUSIVE
                )
            );
        } else {
            // Here the reference device is already ready, so we obtain the
            // reference color directly
            *referenceColor = referencePaintDevice->pixel(seedPoint);
            // Reset this so that the device from color labeled layers gets
            // regenerated when that mode is selected again
            m_referenceNodeList.reset();
        }
 
        m_referencePaintDevice = referencePaintDevice;
        m_referenceColor = referenceColor;
 
        m_fillMask = new KisSelection;
    }
 
    m_dirtyRect.reset(new QRect);
    m_transform.reset();
    m_transform.rotate(m_patternRotation);
    const qreal normalizedScale = m_patternScale * 0.01;
    m_transform.scale(normalizedScale, normalizedScale);
    m_resourcesSnapshot->setFillTransform(m_transform);
}

References KisImage::addJob(), KisImage::animationInterface(), Private::canvas, KisMergeLabeledLayersCommand::createRefPaintDevice(), KisTool::currentImage(), KisTool::currentNode(), KisImageAnimationInterface::currentTime(), KisStrokeJobData::EXCLUSIVE, FillMode_FillSelection, KisMergeLabeledLayersCommand::GroupSelectionPolicy_SelectIfColorLabeled, KisTool::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_i18n(), m_dirtyRect, m_effectiveFillMode, m_fillMask, m_fillStrokeId, m_patternRotation, m_patternScale, m_previousTime, m_reference, m_referenceColor, m_referenceNodeList, m_referencePaintDevice, m_resourcesSnapshot, m_selectedColorLabels, m_transform, m_useActiveLayer, KisTool::PAINT_MODE, KisBaseNode::paintDevice(), KisPaintDevice::pixel(), KisImage::projection(), Reference_AllLayers, Reference_ColorLabeledLayers, Reference_CurrentLayer, KisStrokeJobData::SEQUENTIAL, KisResourcesSnapshot::setFillTransform(), KisToolPaint::setMode(), KisStrokeStrategyUndoCommandBased::setSupportsWrapAroundMode(), and KisImage::startStroke().

◆ beginPrimaryAction()

void KisToolFill::beginPrimaryAction ( KoPointerEvent * event )

overridevirtual

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

Reimplemented from KisTool.

Definition at line 131 of file kis_tool_fill.cc.

{
    // cannot use 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;
    }
 
    m_fillStartWidgetPosition = event->pos();
    const QPoint lastImagePosition = convertToImagePixelCoordFloored(event);
 
    if (!currentNode() ||
        (!image()->wrapAroundModePermitted() &&
         !image()->bounds().contains(lastImagePosition))) {
        return;
    }
    
    // Switch the fill mode if shift or alt modifiers are pressed
    if (event->modifiers() == Qt::ShiftModifier) {
        if (m_fillMode == FillMode_FillSimilarRegions) {
            m_effectiveFillMode = FillMode_FillSelection;
        } else {
            m_effectiveFillMode = FillMode_FillSimilarRegions;
        }
    } else if (event->modifiers() == Qt::AltModifier) {
        if (m_fillMode == FillMode_FillContiguousRegion) {
            m_effectiveFillMode = FillMode_FillSelection;
        } else {
            m_effectiveFillMode = FillMode_FillContiguousRegion;
        }
    } else {
        m_effectiveFillMode = m_fillMode;
    }
 
    m_seedPoints.append(lastImagePosition);
    beginFilling(lastImagePosition);
    m_isFilling = true;
 
    slotUpdateFill();
}

References beginFilling(), bounds, Private::canvas, KisTool::convertToImagePixelCoordFloored(), KisTool::currentNode(), FillMode_FillContiguousRegion, FillMode_FillSelection, FillMode_FillSimilarRegions, KisTool::image(), m_effectiveFillMode, m_fillMode, m_fillStartWidgetPosition, m_isFilling, m_seedPoints, KisFloatingMessage::Medium, KoPointerEvent::modifiers(), KisTool::nodeEditable(), KisTool::nodePaintAbility(), KisTool::PAINT, slotUpdateFill(), and KisCanvas2::viewManager().

◆ continueAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 229 of file kis_tool_fill.cc.

{
    if (action == ChangeSize) {
        continuePrimaryAction(event);
        return;
    }
    KisToolPaint::continueAlternateAction(event, action);
}

References KoToolBase::action(), KisTool::ChangeSize, KisToolPaint::continueAlternateAction(), and continuePrimaryAction().

◆ continuePrimaryAction()

void KisToolFill::continuePrimaryAction ( KoPointerEvent * event )

overridevirtual

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

Reimplemented from KisTool.

Definition at line 183 of file kis_tool_fill.cc.

{
    if (!m_isFilling || m_effectiveFillMode != FillMode_FillContiguousRegion ||
        m_continuousFillMode == ContinuousFillMode_DoNotUse) {
        return;
    }
    
    if (!m_isDragging) {
        const int dragDistanceSquared =
            pow2(event->pos().x() - m_fillStartWidgetPosition.x()) +
            pow2(event->pos().y() - m_fillStartWidgetPosition.y());
 
        if (dragDistanceSquared < minimumDragDistanceSquared) {
            return;
        }
 
        m_isDragging = true;
    }
 
    const QPoint newImagePosition = convertToImagePixelCoordFloored(event);
    m_seedPoints.append(newImagePosition);
 
    m_compressorFillUpdate.start();
}

References ContinuousFillMode_DoNotUse, KisTool::convertToImagePixelCoordFloored(), FillMode_FillContiguousRegion, m_compressorFillUpdate, m_continuousFillMode, m_effectiveFillMode, m_fillStartWidgetPosition, m_isDragging, m_isFilling, m_seedPoints, minimumDragDistanceSquared, KoPointerEvent::pos(), pow2(), and KisSignalCompressor::start().

◆ createOptionWidget()

QWidget * KisToolFill::createOptionWidget ( )

overridevirtual

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

Reimplemented from KisTool.

Definition at line 522 of file kis_tool_fill.cc.

{
    loadConfiguration();
 
    // Create widgets
    KisOptionButtonStrip *optionButtonStripWhatToFill =
        new KisOptionButtonStrip;
    m_buttonWhatToFillSelection = optionButtonStripWhatToFill->addButton(
        KisIconUtils::loadIcon("tool_outline_selection"));
    m_buttonWhatToFillContiguous = optionButtonStripWhatToFill->addButton(
        KisIconUtils::loadIcon("contiguous-selection"));
    m_buttonWhatToFillSimilar = optionButtonStripWhatToFill->addButton(
        KisIconUtils::loadIcon("similar-selection"));
    m_buttonWhatToFillContiguous->setChecked(true);
 
    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 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_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;
 
    KisOptionButtonStrip *optionButtonStripContiguousFillMode = new KisOptionButtonStrip;
    m_buttonContiguousFillModeFloodFill = optionButtonStripContiguousFillMode->addButton(
        KisIconUtils::loadIcon("region-filling-flood-fill"));
    m_buttonContiguousFillModeBoundaryFill = optionButtonStripContiguousFillMode->addButton(
        KisIconUtils::loadIcon("region-filling-boundary-fill"));
    m_buttonContiguousFillModeFloodFill->setChecked(true);
    m_buttonContiguousFillBoundaryColor = new KisColorButton;
    m_sliderThreshold = new KisSliderSpinBox;
    m_sliderThreshold->setPrefix(i18nc("The 'threshold' spinbox prefix in fill tool options", "Threshold: "));
    m_sliderThreshold->setRange(1, 100);
    m_sliderSpread = new KisSliderSpinBox;
    m_sliderSpread->setRange(0, 100);
    KisSpinBoxI18nHelper::setText(
        m_sliderSpread,
        i18nc("The 'spread' spinbox in fill tool options; {n} is the number value, % is the percent sign",
              "Spread: {n}%"));
 
    m_sliderCloseGap = new KisSliderSpinBox;
    m_sliderCloseGap->setPrefix(i18nc("The 'close gap' spinbox prefix in 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 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 fill tool options", "Anti-aliasing"));
 
    KisOptionCollectionWidget *containerGrow = new KisOptionCollectionWidget;
    m_sliderGrow = new KisSliderSpinBox;
    m_sliderGrow->setPrefix(i18nc("The 'grow/shrink' spinbox prefix in fill tool options", "Grow: "));
    m_sliderGrow->setRange(-400, 400);
    m_sliderGrow->setSoftRange(-40, 40);
    m_sliderGrow->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("sliderGrow", m_sliderGrow);
    containerGrow->appendWidget("buttonStopGrowingAtDarkestPixel", m_buttonStopGrowingAtDarkestPixel);
    containerGrow->setOrientation(Qt::Horizontal);
    m_sliderFeather = new KisSliderSpinBox;
    m_sliderFeather->setPrefix(i18nc("The 'feather' spinbox prefix in 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"));
 
    KisOptionButtonStrip *optionButtonStripDragFill =
        new KisOptionButtonStrip;
    m_buttonDragFillDoNotUse = optionButtonStripDragFill->addButton(
        KisIconUtils::loadIcon("dialog-cancel"));
    m_buttonDragFillAny = optionButtonStripDragFill->addButton(
        KisIconUtils::loadIcon("different-regions"));
    m_buttonDragFillSimilar = optionButtonStripDragFill->addButton(
        KisIconUtils::loadIcon("similar-regions"));
    m_buttonDragFillAny->setChecked(true);
 
    QPushButton *buttonReset = new QPushButton(i18nc("The 'reset' button in fill tool options", "Reset"));
 
    // Set the tooltips
    m_buttonWhatToFillSelection->setToolTip(i18n("Fill the active selection, or the entire canvas"));
    m_buttonWhatToFillContiguous->setToolTip(i18n("Fill a contiguous region"));
    m_buttonWhatToFillSimilar->setToolTip(i18n("Fill all regions of a similar color"));
 
    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_buttonContiguousFillModeFloodFill->setToolTip(i18n("Fill regions similar in color to the clicked region"));
    m_buttonContiguousFillModeBoundaryFill->setToolTip(i18n("Fill all regions until a specific boundary color"));
    m_buttonContiguousFillBoundaryColor->setToolTip(i18n("Boundary color"));
    m_sliderThreshold->setToolTip(i18n("Set the color similarity tolerance of the fill. Increasing threshold increases the range of similar colors to be filled."));
    m_sliderSpread->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_sliderGrow->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"));
 
    m_buttonDragFillDoNotUse->setToolTip(i18n("Dragging will not fill different regions"));
    m_buttonDragFillAny->setToolTip(i18n("Dragging will fill regions of any color"));
    m_buttonDragFillSimilar->setToolTip(i18n("Dragging will fill only regions similar in color to the initial region (useful for filling line-art)"));
 
    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 *sectionWhatToFill =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'fill mode' section label in fill tool options", "Fill mode")
        );
    sectionWhatToFill->setPrimaryWidget(optionButtonStripWhatToFill);
    m_optionWidget->appendWidget("sectionWhatToFill", sectionWhatToFill);
 
    KisOptionCollectionWidgetWithHeader *sectionFillWith =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'fill source' section label in 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);
 
    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 fill tool options", "Reference")
        );
    sectionReference->setPrimaryWidget(optionButtonStripReference);
    sectionReference->appendWidget("widgetLabels", widgetLabelsGroup);
    sectionReference->setWidgetVisible("widgetLabels", false);
    m_optionWidget->appendWidget("sectionReference", sectionReference);
 
    KisOptionCollectionWidgetWithHeader *sectionRegionExtent =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'fill extent' section label in fill tool options", "Fill extent")
        );
    sectionRegionExtent->setPrimaryWidget(optionButtonStripContiguousFillMode);
    sectionRegionExtent->appendWidget("buttonContiguousFillBoundaryColor", m_buttonContiguousFillBoundaryColor);
    sectionRegionExtent->setWidgetVisible("buttonContiguousFillBoundaryColor", false);
    sectionRegionExtent->appendWidget("sliderThreshold", m_sliderThreshold);
    sectionRegionExtent->appendWidget("sliderSpread", m_sliderSpread);
    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 fill tool options", "Adjustments")
        );
    sectionAdjustments->appendWidget("checkBoxAntiAlias", m_checkBoxAntiAlias);
    sectionAdjustments->appendWidget("containerGrow", containerGrow);
    sectionAdjustments->appendWidget("sliderFeather", m_sliderFeather);
    m_optionWidget->appendWidget("sectionAdjustments", sectionAdjustments);
 
    KisOptionCollectionWidgetWithHeader *sectionDragFill =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'drag-fill mode' section label in fill tool options", "Drag-fill mode")
        );
    sectionDragFill->setPrimaryWidget(optionButtonStripDragFill);
    m_optionWidget->appendWidget("sectionDragFill", sectionDragFill);
 
    m_optionWidget->appendWidget("buttonReset", buttonReset);
 
    // Initialize widgets
    if (m_fillMode == FillMode_FillSelection) {
        m_buttonWhatToFillSelection->setChecked(true);
        m_optionWidget->setWidgetVisible("sectionRegionExtent", false);
        m_optionWidget->setWidgetVisible("sectionAdjustments", false);
        m_optionWidget->setWidgetVisible("sectionReference", false);
        m_optionWidget->setWidgetVisible("sectionDragFill", false);
    } else if (m_fillMode == FillMode_FillSimilarRegions) {
        m_buttonWhatToFillSimilar->setChecked(true);
        m_optionWidget->setWidgetVisible("sectionDragFill", false);
        sectionRegionExtent->setWidgetVisible("checkBoxSelectionAsBoundary", false);
        sectionRegionExtent->setWidgetVisible("sliderCloseGap", false);
    }
    sectionRegionExtent->setPrimaryWidgetVisible(m_fillMode == FillMode_FillContiguousRegion);
    if (m_fillType == FillType_FillWithBackgroundColor) {
        m_buttonFillWithBG->setChecked(true);
    } else if (m_fillType == 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);
    }
    if (m_contiguousFillMode == ContiguousFillMode_BoundaryFill) {
        m_buttonContiguousFillModeBoundaryFill->setChecked(true);
        sectionRegionExtent->setWidgetVisible("buttonContiguousFillBoundaryColor",
                                              m_fillMode == FillMode_FillContiguousRegion);
    }
    m_buttonContiguousFillBoundaryColor->setColor(m_contiguousFillBoundaryColor);
    m_sliderThreshold->setValue(m_threshold);
    m_sliderSpread->setValue(m_opacitySpread);
    m_sliderCloseGap->setValue(m_closeGap);
    m_checkBoxSelectionAsBoundary->setChecked(m_useSelectionAsBoundary);
    m_checkBoxAntiAlias->setChecked(m_antiAlias);
    m_sliderGrow->setValue(m_sizemod);
    m_buttonStopGrowingAtDarkestPixel->setChecked(m_stopGrowingAtDarkestPixel);
    m_sliderFeather->setValue(m_feather);
    if (m_reference == Reference_AllLayers) {
        m_buttonReferenceAll->setChecked(true);
    } else if (m_reference == Reference_ColorLabeledLayers) {
        m_buttonReferenceLabeled->setChecked(true);
        sectionReference->setWidgetVisible("widgetLabels", true);
    }
    if (m_continuousFillMode == ContinuousFillMode_DoNotUse) {
        m_buttonDragFillDoNotUse->setChecked(true);
    } else if (m_continuousFillMode == ContinuousFillMode_FillSimilarRegions) {
        m_buttonDragFillSimilar->setChecked(true);
    }
    m_widgetLabels->setSelection(m_selectedColorLabels);
    m_checkBoxUseActiveLayer->setChecked(m_useActiveLayer);
 
    // Make connections
    connect(optionButtonStripWhatToFill,
            SIGNAL(buttonToggled(KoGroupButton *, bool)),
            SLOT(slot_optionButtonStripWhatToFill_buttonToggled(KoGroupButton *, 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(optionButtonStripContiguousFillMode,
            SIGNAL(buttonToggled(KoGroupButton *, bool)),
            SLOT(slot_optionButtonStripContiguousFillMode_buttonToggled(KoGroupButton *, bool)));
    connect(m_buttonContiguousFillBoundaryColor,
            SIGNAL(changed(const KoColor&)),
            SLOT(slot_buttonContiguousFillBoundaryColor_changed(const KoColor&)));
    connect(m_sliderThreshold, SIGNAL(valueChanged(int)), SLOT(slot_sliderThreshold_valueChanged(int)));
    connect(m_sliderSpread, SIGNAL(valueChanged(int)), SLOT(slot_sliderSpread_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_sliderGrow, SIGNAL(valueChanged(int)), SLOT(slot_sliderGrow_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(
        optionButtonStripDragFill,
        SIGNAL(buttonToggled(KoGroupButton *, bool)),
        SLOT(slot_optionButtonStripDragFill_buttonToggled(KoGroupButton *, bool)));
    connect(buttonReset, SIGNAL(clicked()), SLOT(slot_buttonReset_clicked()));
    
    return m_optionWidget;
}

◆ deactivate

void KisToolFill::deactivate ( )

overrideslot

Definition at line 115 of file kis_tool_fill.cc.

{
    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);
    KisToolPaint::deactivate();
}

References Private::canvas, KisViewManager::canvasResourceProvider(), KisToolPaint::deactivate(), m_referenceNodeList, m_referencePaintDevice, slot_currentNodeChanged(), and KisCanvas2::viewManager().

◆ endAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 238 of file kis_tool_fill.cc.

{
    if (action == ChangeSize) {
        endPrimaryAction(event);
        return;
    }
    KisToolPaint::endAlternateAction(event, action);
}

References KoToolBase::action(), KisTool::ChangeSize, KisToolPaint::endAlternateAction(), and endPrimaryAction().

◆ endFilling()

void KisToolFill::endFilling ( )

private

Definition at line 496 of file kis_tool_fill.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_fillStrokeId);
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    setMode(KisTool::HOVER_MODE);
    image()->endStroke(m_fillStrokeId);
    m_fillStrokeId = nullptr;
    m_fillMask = nullptr;
    m_dirtyRect = nullptr;
}

References CHECK_MODE_SANITY_OR_RETURN, KisImage::endStroke(), KisTool::HOVER_MODE, KisTool::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_dirtyRect, m_fillMask, m_fillStrokeId, KisTool::PAINT_MODE, and KisToolPaint::setMode().

◆ endPrimaryAction()

void KisToolFill::endPrimaryAction ( KoPointerEvent * event )

overridevirtual

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

Reimplemented from KisTool.

Definition at line 208 of file kis_tool_fill.cc.

{
    if (m_isFilling) {
        m_compressorFillUpdate.stop();
        endFilling();
    }
 
    m_isFilling = false;
    m_isDragging = false;
    m_seedPoints.clear();
}

References endFilling(), m_compressorFillUpdate, m_isDragging, m_isFilling, m_seedPoints, and KisSignalCompressor::stop().

◆ loadConfiguration()

void KisToolFill::loadConfiguration ( )

private

Definition at line 863 of file kis_tool_fill.cc.

{
    {
        const QString whatToFillStr = m_configGroup.readEntry<QString>("whatToFill", "");
        if (whatToFillStr == "fillSelection") {
            m_fillMode = FillMode_FillSelection;
        } else if (whatToFillStr == "fillContiguousRegion") {
            m_fillMode = FillMode_FillContiguousRegion;
        } else if (whatToFillStr == "fillSimilarRegions") {
            m_fillMode = FillMode_FillSimilarRegions;
        } else {
            if (m_configGroup.readEntry<bool>("fillSelection", false)) {
                m_fillMode = FillMode_FillSelection;
            } else {
                m_fillMode = FillMode_FillContiguousRegion;
            }
        }
    }
    {
        const QString fillTypeStr = m_configGroup.readEntry<QString>("fillWith", "");
        if (fillTypeStr == "foregroundColor") {
            m_fillType = FillType_FillWithForegroundColor;
        } else if (fillTypeStr == "backgroundColor") {
            m_fillType = FillType_FillWithBackgroundColor;
        } else if (fillTypeStr == "pattern") {
            m_fillType = FillType_FillWithPattern;
        } else {
            if (m_configGroup.readEntry<bool>("usePattern", false)) {
                m_fillType = FillType_FillWithPattern;
            } else {
                m_fillType = 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;
    }
    {
        const QString contiguousFillModeStr = m_configGroup.readEntry<QString>("contiguousFillMode", "");
        m_contiguousFillMode = contiguousFillModeStr == "boundaryFill"
                               ? ContiguousFillMode_BoundaryFill
                               : ContiguousFillMode_FloodFill;
    }
    m_contiguousFillBoundaryColor = loadContiguousFillBoundaryColorFromConfig();
    m_threshold = m_configGroup.readEntry<int>("thresholdAmount", 8);
    m_opacitySpread = m_configGroup.readEntry<int>("opacitySpread", 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_sizemod = m_configGroup.readEntry<int>("growSelection", 0);
    m_stopGrowingAtDarkestPixel = m_configGroup.readEntry<bool>("stopGrowingAtDarkestPixel", false);
    m_feather = m_configGroup.readEntry<int>("featherAmount", 0);
    {
        const QString sampleLayersModeStr = m_configGroup.readEntry<QString>("sampleLayersMode", "");
        if (sampleLayersModeStr == "currentLayer") {
            m_reference = Reference_CurrentLayer;
        } else if (sampleLayersModeStr == "allLayers") {
            m_reference = Reference_AllLayers;
        } else if (sampleLayersModeStr == "colorLabeledLayers") {
            m_reference = Reference_ColorLabeledLayers;
        } else {
            if (m_configGroup.readEntry<bool>("sampleMerged", false)) {
                m_reference = Reference_AllLayers;
            } else {
                m_reference = 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);
    }
    {
        const QString continuousFillModeStr = m_configGroup.readEntry<QString>("continuousFillMode", "fillAnyRegion");
        if (continuousFillModeStr == "doNotUse") {
            m_continuousFillMode = ContinuousFillMode_DoNotUse;
        } else if (continuousFillModeStr == "fillSimilarRegions") {
            m_continuousFillMode = ContinuousFillMode_FillSimilarRegions;
        } else {
            m_continuousFillMode = ContinuousFillMode_FillAnyRegion;
        }
    }
}

References COMPOSITE_OVER, ContiguousFillMode_BoundaryFill, ContiguousFillMode_FloodFill, ContinuousFillMode_DoNotUse, ContinuousFillMode_FillAnyRegion, ContinuousFillMode_FillSimilarRegions, FillMode_FillContiguousRegion, FillMode_FillSelection, FillMode_FillSimilarRegions, FillType_FillWithBackgroundColor, FillType_FillWithForegroundColor, FillType_FillWithPattern, KoCompositeOpRegistry::getKoID(), KoID::id(), KoCompositeOpRegistry::instance(), loadContiguousFillBoundaryColorFromConfig(), m_antiAlias, m_closeGap, m_configGroup, m_contiguousFillBoundaryColor, m_contiguousFillMode, m_continuousFillMode, m_customCompositeOp, m_customOpacity, m_feather, m_fillMode, m_fillType, m_opacitySpread, m_patternRotation, m_patternScale, m_reference, m_selectedColorLabels, m_sizemod, m_stopGrowingAtDarkestPixel, m_threshold, m_useActiveLayer, m_useCustomBlendingOptions, m_useSelectionAsBoundary, Reference_AllLayers, Reference_ColorLabeledLayers, and Reference_CurrentLayer.

◆ loadContiguousFillBoundaryColorFromConfig()

KoColor KisToolFill::loadContiguousFillBoundaryColorFromConfig ( )

private

Definition at line 960 of file kis_tool_fill.cc.

{
    const QString xmlColor = m_configGroup.readEntry("contiguousFillBoundaryColor", 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.

◆ resetCursorStyle

void KisToolFill::resetCursorStyle ( )

overrideprotectedslot

Definition at line 89 of file kis_tool_fill.cc.

{
    if (isEraser() && !m_useCustomBlendingOptions) {
        useCursor(KisCursor::load("tool_fill_eraser_cursor.png", 6, 6));
    } else {
        KisToolPaint::resetCursorStyle();
    }
 
    overrideCursorIfNotEditable();
}

References KisToolPaint::isEraser(), KisCursor::load(), m_useCustomBlendingOptions, KisTool::overrideCursorIfNotEditable(), KisTool::resetCursorStyle(), and KoToolBase::useCursor().

◆ slot_angleSelectorPatternRotation_angleChanged

void KisToolFill::slot_angleSelectorPatternRotation_angleChanged ( double value )

privateslot

Definition at line 1060 of file kis_tool_fill.cc.

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

References m_configGroup, m_patternRotation, and value().

◆ slot_buttonContiguousFillBoundaryColor_changed

void KisToolFill::slot_buttonContiguousFillBoundaryColor_changed ( const KoColor & color )

privateslot

Definition at line 1124 of file kis_tool_fill.cc.

{
    if (color == m_contiguousFillBoundaryColor) {
        return;
    }
    m_contiguousFillBoundaryColor = color;
    m_configGroup.writeEntry("contiguousFillBoundaryColor", color.toXML());
}

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

◆ slot_buttonReset_clicked

void KisToolFill::slot_buttonReset_clicked ( )

privateslot

Definition at line 1268 of file kis_tool_fill.cc.

{
    m_buttonWhatToFillContiguous->setChecked(true);
    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_sliderThreshold->setValue(8);
    m_sliderSpread->setValue(100);
    m_sliderCloseGap->setValue(0);
    m_checkBoxSelectionAsBoundary->setChecked(true);
    m_checkBoxAntiAlias->setChecked(false);
    m_sliderGrow->setValue(0);
    m_buttonStopGrowingAtDarkestPixel->setChecked(false);
    m_sliderFeather->setValue(0);
    m_buttonReferenceCurrent->setChecked(true);
    m_widgetLabels->setSelection({});
    m_buttonDragFillAny->setChecked(true);
}

References COMPOSITE_OVER, m_angleSelectorPatternRotation, m_buttonDragFillAny, m_buttonFillWithFG, m_buttonReferenceCurrent, m_buttonStopGrowingAtDarkestPixel, m_buttonWhatToFillContiguous, m_checkBoxAntiAlias, m_checkBoxCustomBlendingOptions, m_checkBoxSelectionAsBoundary, m_comboBoxCustomCompositeOp, m_sliderCloseGap, m_sliderCustomOpacity, m_sliderFeather, m_sliderGrow, m_sliderPatternScale, m_sliderSpread, m_sliderThreshold, m_widgetLabels, KisCompositeOpComboBox::selectCompositeOp(), KisAngleSelector::setAngle(), KisColorLabelSelectorWidget::setSelection(), KisSliderSpinBox::setValue(), and KisDoubleSliderSpinBox::setValue().

◆ slot_buttonStopGrowingAtDarkestPixel_toggled

void KisToolFill::slot_buttonStopGrowingAtDarkestPixel_toggled ( bool enabled )

privateslot

Definition at line 1187 of file kis_tool_fill.cc.

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

References m_configGroup, and m_stopGrowingAtDarkestPixel.

◆ slot_checkBoxAntiAlias_toggled

void KisToolFill::slot_checkBoxAntiAlias_toggled ( bool checked )

privateslot

Definition at line 1169 of file kis_tool_fill.cc.

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

References m_antiAlias, and m_configGroup.

◆ slot_checkBoxSelectionAsBoundary_toggled

void KisToolFill::slot_checkBoxSelectionAsBoundary_toggled ( bool checked )

privateslot

Definition at line 1160 of file kis_tool_fill.cc.

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

References m_configGroup, and m_useSelectionAsBoundary.

◆ slot_checkBoxUseActiveLayer_toggled

void KisToolFill::slot_checkBoxUseActiveLayer_toggled ( bool checked )

privateslot

Definition at line 1323 of file kis_tool_fill.cc.

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

References m_configGroup, and m_useActiveLayer.

◆ slot_checkBoxUseCustomBlendingOptions_toggled

void KisToolFill::slot_checkBoxUseCustomBlendingOptions_toggled ( bool checked )

privateslot

Definition at line 1069 of file kis_tool_fill.cc.

{
    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 KisToolFill::slot_colorSpaceChanged ( const KoColorSpace * colorSpace )

privateslot

Definition at line 1308 of file kis_tool_fill.cc.

{
    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 KisToolFill::slot_comboBoxCustomCompositeOp_currentIndexChanged ( int index )

privateslot

Definition at line 1088 of file kis_tool_fill.cc.

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

void KisToolFill::slot_currentNodeChanged ( const KisNodeSP node )

privateslot

Definition at line 1290 of file kis_tool_fill.cc.

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

void KisToolFill::slot_optionButtonStripContiguousFillMode_buttonToggled	(	KoGroupButton *	button,
		bool	checked )

privateslot

Definition at line 1099 of file kis_tool_fill.cc.

{
    if (!checked) {
        return;
    }
 
    const bool visible = button == m_buttonContiguousFillModeBoundaryFill;
    KisOptionCollectionWidgetWithHeader *sectionRegionExtent =
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent");
    sectionRegionExtent->setWidgetVisible("buttonContiguousFillBoundaryColor", visible);
 
    m_contiguousFillMode = button == m_buttonContiguousFillModeFloodFill
                           ? ContiguousFillMode_FloodFill
                           : ContiguousFillMode_BoundaryFill;
 
    m_configGroup.writeEntry(
        "contiguousFillMode",
        button == m_buttonContiguousFillModeFloodFill
        ? "floodFill"
        : "boundaryFill"
    );
}

References button(), ContiguousFillMode_BoundaryFill, ContiguousFillMode_FloodFill, m_buttonContiguousFillModeBoundaryFill, m_buttonContiguousFillModeFloodFill, m_configGroup, m_contiguousFillMode, m_optionWidget, KisOptionCollectionWidgetWithHeader::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_optionButtonStripDragFill_buttonToggled

void KisToolFill::slot_optionButtonStripDragFill_buttonToggled	(	KoGroupButton *	button,
		bool	checked )

privateslot

Definition at line 1246 of file kis_tool_fill.cc.

{
    if (!checked) {
        return;
    }
    m_continuousFillMode = button == m_buttonDragFillAny
                            ? ContinuousFillMode_FillAnyRegion
                            : button == m_buttonDragFillDoNotUse
                                ? ContinuousFillMode_DoNotUse
                                : ContinuousFillMode_FillSimilarRegions;
    m_configGroup.writeEntry(
        "continuousFillMode",
        button == m_buttonDragFillAny
            ? "fillAnyRegion"
            : button == m_buttonDragFillDoNotUse
                ? "doNotUse"
                : "fillSimilarRegions"
    );
}

References button(), ContinuousFillMode_DoNotUse, ContinuousFillMode_FillAnyRegion, ContinuousFillMode_FillSimilarRegions, m_buttonDragFillAny, m_buttonDragFillDoNotUse, m_configGroup, and m_continuousFillMode.

◆ slot_optionButtonStripFillWith_buttonToggled

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

privateslot

Definition at line 1025 of file kis_tool_fill.cc.

{
    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 ? FillType_FillWithForegroundColor
                                              : (button == m_buttonFillWithBG
                                                 ? FillType_FillWithBackgroundColor
                                                 : FillType_FillWithPattern);
 
    m_configGroup.writeEntry(
        "fillWith",
        button == m_buttonFillWithFG
        ? "foregroundColor"
        : (button == m_buttonFillWithBG ? "backgroundColor" : "pattern")
    );
}

References button(), FillType_FillWithBackgroundColor, FillType_FillWithForegroundColor, FillType_FillWithPattern, m_buttonFillWithBG, m_buttonFillWithFG, m_buttonFillWithPattern, m_configGroup, m_fillType, m_optionWidget, KisOptionCollectionWidgetWithHeader::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_optionButtonStripReference_buttonToggled

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

privateslot

Definition at line 1205 of file kis_tool_fill.cc.

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

References button(), m_buttonReferenceAll, m_buttonReferenceCurrent, m_buttonReferenceLabeled, m_configGroup, m_optionWidget, m_reference, Reference_AllLayers, Reference_ColorLabeledLayers, Reference_CurrentLayer, KisOptionCollectionWidgetWithHeader::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_optionButtonStripWhatToFill_buttonToggled

void KisToolFill::slot_optionButtonStripWhatToFill_buttonToggled	(	KoGroupButton *	button,
		bool	checked )

privateslot

Definition at line 977 of file kis_tool_fill.cc.

{
    if (!checked) {
        return;
    }
 
    if (button == m_buttonWhatToFillSelection) {
        m_optionWidget->setWidgetVisible("sectionRegionExtent", false);
        m_optionWidget->setWidgetVisible("sectionAdjustments", false);
        m_optionWidget->setWidgetVisible("sectionReference", false);
        m_optionWidget->setWidgetVisible("sectionDragFill", false);
        m_fillMode = FillMode_FillSelection;
        m_configGroup.writeEntry("whatToFill", "fillSelection");
    } else if (button == m_buttonWhatToFillContiguous) {
        m_optionWidget->setWidgetVisible("sectionRegionExtent", true);
        m_optionWidget->setWidgetVisible("sectionAdjustments", true);
        m_optionWidget->setWidgetVisible("sectionReference", true);
        m_optionWidget->setWidgetVisible("sectionDragFill", true);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setPrimaryWidgetVisible(true);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setWidgetVisible("buttonContiguousFillBoundaryColor", m_contiguousFillMode == ContiguousFillMode_BoundaryFill);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setWidgetVisible("sliderCloseGap", true);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setWidgetVisible("checkBoxSelectionAsBoundary", true);
        m_fillMode = FillMode_FillContiguousRegion;
        m_configGroup.writeEntry("whatToFill", "fillContiguousRegion");
    } else {
        m_optionWidget->setWidgetVisible("sectionRegionExtent", true);
        m_optionWidget->setWidgetVisible("sectionAdjustments", true);
        m_optionWidget->setWidgetVisible("sectionReference", true);
        m_optionWidget->setWidgetVisible("sectionDragFill", false);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setPrimaryWidgetVisible(false);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setWidgetVisible("buttonContiguousFillBoundaryColor", false);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setWidgetVisible("sliderCloseGap", false);
        m_optionWidget->widgetAs<KisOptionCollectionWidgetWithHeader*>("sectionRegionExtent")
            ->setWidgetVisible("checkBoxSelectionAsBoundary", false);
        m_fillMode = FillMode_FillSimilarRegions;
        m_configGroup.writeEntry("whatToFill", "fillSimilarRegions");
    }
}

References button(), ContiguousFillMode_BoundaryFill, FillMode_FillContiguousRegion, FillMode_FillSelection, FillMode_FillSimilarRegions, m_buttonWhatToFillContiguous, m_buttonWhatToFillSelection, m_configGroup, m_contiguousFillMode, m_fillMode, m_optionWidget, KisOptionCollectionWidget::setWidgetVisible(), and KisOptionCollectionWidget::widgetAs().

◆ slot_sliderCloseGap_valueChanged

void KisToolFill::slot_sliderCloseGap_valueChanged ( int value )

privateslot

Definition at line 1151 of file kis_tool_fill.cc.

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

References m_closeGap, m_configGroup, and value().

◆ slot_sliderCustomOpacity_valueChanged

void KisToolFill::slot_sliderCustomOpacity_valueChanged ( int value )

privateslot

Definition at line 1079 of file kis_tool_fill.cc.

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

References m_configGroup, m_customOpacity, and value().

◆ slot_sliderFeather_valueChanged

void KisToolFill::slot_sliderFeather_valueChanged ( int value )

privateslot

Definition at line 1196 of file kis_tool_fill.cc.

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

References m_configGroup, m_feather, and value().

◆ slot_sliderGrow_valueChanged

void KisToolFill::slot_sliderGrow_valueChanged ( int value )

privateslot

Definition at line 1178 of file kis_tool_fill.cc.

{
    if (value == m_sizemod) {
        return;
    }
    m_sizemod = value;
    m_configGroup.writeEntry("growSelection", value);
}

References m_configGroup, m_sizemod, and value().

◆ slot_sliderPatternScale_valueChanged

void KisToolFill::slot_sliderPatternScale_valueChanged ( double value )

privateslot

Definition at line 1051 of file kis_tool_fill.cc.

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

References m_configGroup, m_patternScale, and value().

◆ slot_sliderSpread_valueChanged

void KisToolFill::slot_sliderSpread_valueChanged ( int value )

privateslot

Definition at line 1142 of file kis_tool_fill.cc.

{
    if (value == m_opacitySpread) {
        return;
    }
    m_opacitySpread = value;
    m_configGroup.writeEntry("opacitySpread", value);
}

References m_configGroup, m_opacitySpread, and value().

◆ slot_sliderThreshold_valueChanged

void KisToolFill::slot_sliderThreshold_valueChanged ( int value )

privateslot

Definition at line 1133 of file kis_tool_fill.cc.

{
    if (value == m_threshold) {
        return;
    }
    m_threshold = value;
    m_configGroup.writeEntry("thresholdAmount", value);
}

References m_configGroup, m_threshold, and value().

◆ slot_widgetLabels_selectionChanged

void KisToolFill::slot_widgetLabels_selectionChanged ( )

privateslot

Definition at line 1229 of file kis_tool_fill.cc.

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

◆ slotUpdateFill

void KisToolFill::slotUpdateFill ( )

protectedslot

Definition at line 508 of file kis_tool_fill.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_fillStrokeId);
 
    if (m_effectiveFillMode == FillMode_FillContiguousRegion) {
        addFillingOperation(KritaUtils::rasterizePolylineDDA(m_seedPoints));
        // clear to not re-add the segments, but retain the last point to maintain continuity
        m_seedPoints = {m_seedPoints.last()};
    } else {
        addFillingOperation(m_seedPoints.last());
    }
    addUpdateOperation();
}

References addFillingOperation(), addUpdateOperation(), FillMode_FillContiguousRegion, KIS_SAFE_ASSERT_RECOVER_RETURN, m_effectiveFillMode, m_fillStrokeId, m_seedPoints, and KritaUtils::rasterizePolylineDDA().

◆ wantsAutoScroll()

bool KisToolFill::wantsAutoScroll ( ) const

inlineoverrideprotectedvirtual

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

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

Reimplemented from KoToolBase.

Definition at line 96 of file kis_tool_fill.h.

96{ return false; }

Member Data Documentation

◆ m_angleSelectorPatternRotation

KisAngleSelector* KisToolFill::m_angleSelectorPatternRotation {nullptr}

private

Definition at line 163 of file kis_tool_fill.h.

163{nullptr};

◆ m_antiAlias

bool KisToolFill::m_antiAlias {true}

private

Definition at line 122 of file kis_tool_fill.h.

122{true};

◆ m_buttonContiguousFillBoundaryColor

KisColorButton* KisToolFill::m_buttonContiguousFillBoundaryColor {nullptr}

private

Definition at line 170 of file kis_tool_fill.h.

170{nullptr};

◆ m_buttonContiguousFillModeBoundaryFill

KoGroupButton* KisToolFill::m_buttonContiguousFillModeBoundaryFill {nullptr}

private

Definition at line 169 of file kis_tool_fill.h.

169{nullptr};

◆ m_buttonContiguousFillModeFloodFill

KoGroupButton* KisToolFill::m_buttonContiguousFillModeFloodFill {nullptr}

private

Definition at line 168 of file kis_tool_fill.h.

168{nullptr};

◆ m_buttonDragFillAny

KoGroupButton* KisToolFill::m_buttonDragFillAny {nullptr}

private

Definition at line 188 of file kis_tool_fill.h.

188{nullptr};

◆ m_buttonDragFillDoNotUse

KoGroupButton* KisToolFill::m_buttonDragFillDoNotUse {nullptr}

private

Definition at line 187 of file kis_tool_fill.h.

187{nullptr};

◆ m_buttonDragFillSimilar

KoGroupButton* KisToolFill::m_buttonDragFillSimilar {nullptr}

private

Definition at line 189 of file kis_tool_fill.h.

189{nullptr};

◆ m_buttonFillWithBG

KoGroupButton* KisToolFill::m_buttonFillWithBG {nullptr}

private

Definition at line 160 of file kis_tool_fill.h.

160{nullptr};

◆ m_buttonFillWithFG

KoGroupButton* KisToolFill::m_buttonFillWithFG {nullptr}

private

Definition at line 159 of file kis_tool_fill.h.

159{nullptr};

◆ m_buttonFillWithPattern

KoGroupButton* KisToolFill::m_buttonFillWithPattern {nullptr}

private

Definition at line 161 of file kis_tool_fill.h.

161{nullptr};

◆ m_buttonReferenceAll

KoGroupButton* KisToolFill::m_buttonReferenceAll {nullptr}

private

Definition at line 182 of file kis_tool_fill.h.

182{nullptr};

◆ m_buttonReferenceCurrent

KoGroupButton* KisToolFill::m_buttonReferenceCurrent {nullptr}

private

Definition at line 181 of file kis_tool_fill.h.

181{nullptr};

◆ m_buttonReferenceLabeled

KoGroupButton* KisToolFill::m_buttonReferenceLabeled {nullptr}

private

Definition at line 183 of file kis_tool_fill.h.

183{nullptr};

◆ m_buttonStopGrowingAtDarkestPixel

QToolButton* KisToolFill::m_buttonStopGrowingAtDarkestPixel {nullptr}

private

Definition at line 178 of file kis_tool_fill.h.

178{nullptr};

◆ m_buttonWhatToFillContiguous

KoGroupButton* KisToolFill::m_buttonWhatToFillContiguous {nullptr}

private

Definition at line 156 of file kis_tool_fill.h.

156{nullptr};

◆ m_buttonWhatToFillSelection

KoGroupButton* KisToolFill::m_buttonWhatToFillSelection {nullptr}

private

Definition at line 155 of file kis_tool_fill.h.

155{nullptr};

◆ m_buttonWhatToFillSimilar

KoGroupButton* KisToolFill::m_buttonWhatToFillSimilar {nullptr}

private

Definition at line 157 of file kis_tool_fill.h.

157{nullptr};

◆ m_checkBoxAntiAlias

QCheckBox* KisToolFill::m_checkBoxAntiAlias {nullptr}

private

Definition at line 176 of file kis_tool_fill.h.

176{nullptr};

◆ m_checkBoxCustomBlendingOptions

QCheckBox* KisToolFill::m_checkBoxCustomBlendingOptions {nullptr}

private

Definition at line 164 of file kis_tool_fill.h.

164{nullptr};

◆ m_checkBoxSelectionAsBoundary

QCheckBox* KisToolFill::m_checkBoxSelectionAsBoundary {nullptr}

private

Definition at line 174 of file kis_tool_fill.h.

174{nullptr};

◆ m_checkBoxUseActiveLayer

QCheckBox* KisToolFill::m_checkBoxUseActiveLayer {nullptr}

private

Definition at line 185 of file kis_tool_fill.h.

185{nullptr};

◆ m_closeGap

int KisToolFill::m_closeGap {0}

private

Definition at line 119 of file kis_tool_fill.h.

119{0};

◆ m_comboBoxCustomCompositeOp

KisCompositeOpComboBox* KisToolFill::m_comboBoxCustomCompositeOp {nullptr}

private

Definition at line 166 of file kis_tool_fill.h.

166{nullptr};

◆ m_compressorFillUpdate

KisSignalCompressor KisToolFill::m_compressorFillUpdate

private

Definition at line 145 of file kis_tool_fill.h.

◆ m_configGroup

KConfigGroup KisToolFill::m_configGroup

private

Definition at line 151 of file kis_tool_fill.h.

◆ m_contiguousFillBoundaryColor

KoColor KisToolFill::m_contiguousFillBoundaryColor

private

Definition at line 116 of file kis_tool_fill.h.

◆ m_contiguousFillMode

ContiguousFillMode KisToolFill::m_contiguousFillMode {ContiguousFillMode_FloodFill}

private

Definition at line 115 of file kis_tool_fill.h.

115{ContiguousFillMode_FloodFill};

◆ m_continuousFillMode

ContinuousFillMode KisToolFill::m_continuousFillMode {ContinuousFillMode_FillAnyRegion}

private

Definition at line 131 of file kis_tool_fill.h.

131{ContinuousFillMode_FillAnyRegion};

◆ m_customCompositeOp

QString KisToolFill::m_customCompositeOp {COMPOSITE_OVER}

private

Definition at line 113 of file kis_tool_fill.h.

113{COMPOSITE_OVER};

◆ m_customOpacity

int KisToolFill::m_customOpacity {100}

private

Definition at line 112 of file kis_tool_fill.h.

112{100};

◆ m_dirtyRect

QSharedPointer<QRect> KisToolFill::m_dirtyRect

private

Definition at line 146 of file kis_tool_fill.h.

◆ m_effectiveFillMode

FillMode KisToolFill::m_effectiveFillMode {FillMode_FillSelection}

private

Definition at line 141 of file kis_tool_fill.h.

141{FillMode_FillSelection};

◆ m_feather

int KisToolFill::m_feather {0}

private

Definition at line 125 of file kis_tool_fill.h.

125{0};

◆ m_fillMask

KisSelectionSP KisToolFill::m_fillMask

private

Definition at line 133 of file kis_tool_fill.h.

◆ m_fillMode

FillMode KisToolFill::m_fillMode {FillMode_FillContiguousRegion}

private

Definition at line 106 of file kis_tool_fill.h.

106{FillMode_FillContiguousRegion};

◆ m_fillStartWidgetPosition

QPoint KisToolFill::m_fillStartWidgetPosition

private

Definition at line 144 of file kis_tool_fill.h.

◆ m_fillStrokeId

KisStrokeId KisToolFill::m_fillStrokeId

private

Definition at line 148 of file kis_tool_fill.h.

◆ m_fillType

FillType KisToolFill::m_fillType {FillType_FillWithForegroundColor}

private

Definition at line 108 of file kis_tool_fill.h.

108{FillType_FillWithForegroundColor};

◆ m_isDragging

bool KisToolFill::m_isDragging {false}

private

Definition at line 143 of file kis_tool_fill.h.

143{false};

◆ m_isFilling

bool KisToolFill::m_isFilling {false}

private

Definition at line 142 of file kis_tool_fill.h.

142{false};

◆ m_opacitySpread

int KisToolFill::m_opacitySpread {100}

private

Definition at line 118 of file kis_tool_fill.h.

118{100};

◆ m_optionWidget

KisOptionCollectionWidget* KisToolFill::m_optionWidget {nullptr}

private

Definition at line 153 of file kis_tool_fill.h.

153{nullptr};

◆ m_patternRotation

qreal KisToolFill::m_patternRotation {0.0}

private

Definition at line 110 of file kis_tool_fill.h.

110{0.0};

◆ m_patternScale

qreal KisToolFill::m_patternScale {100.0}

private

Definition at line 109 of file kis_tool_fill.h.

109{100.0};

◆ m_previousNode

KisNodeSP KisToolFill::m_previousNode {nullptr}

private

Definition at line 149 of file kis_tool_fill.h.

149{nullptr};

◆ m_previousTime

int KisToolFill::m_previousTime

private

Definition at line 137 of file kis_tool_fill.h.

◆ m_reference

Reference KisToolFill::m_reference {Reference_CurrentLayer}

private

Definition at line 127 of file kis_tool_fill.h.

127{Reference_CurrentLayer};

◆ m_referenceColor

QSharedPointer<KoColor> KisToolFill::m_referenceColor

private

Definition at line 134 of file kis_tool_fill.h.

◆ m_referenceNodeList

KisMergeLabeledLayersCommand::ReferenceNodeInfoListSP KisToolFill::m_referenceNodeList

private

Definition at line 136 of file kis_tool_fill.h.

◆ m_referencePaintDevice

KisPaintDeviceSP KisToolFill::m_referencePaintDevice

private

Definition at line 135 of file kis_tool_fill.h.

◆ m_resourcesSnapshot

KisResourcesSnapshotSP KisToolFill::m_resourcesSnapshot

private

Definition at line 138 of file kis_tool_fill.h.

◆ m_seedPoints

QVector<QPoint> KisToolFill::m_seedPoints

private

Definition at line 147 of file kis_tool_fill.h.

◆ m_selectedColorLabels

QList<int> KisToolFill::m_selectedColorLabels

private

Definition at line 128 of file kis_tool_fill.h.

◆ m_sizemod

int KisToolFill::m_sizemod {0}

private

Definition at line 123 of file kis_tool_fill.h.

123{0};

◆ m_sliderCloseGap

KisSliderSpinBox* KisToolFill::m_sliderCloseGap {nullptr}

private

Definition at line 173 of file kis_tool_fill.h.

173{nullptr};

◆ m_sliderCustomOpacity

KisSliderSpinBox* KisToolFill::m_sliderCustomOpacity {nullptr}

private

Definition at line 165 of file kis_tool_fill.h.

165{nullptr};

◆ m_sliderFeather

KisSliderSpinBox* KisToolFill::m_sliderFeather {nullptr}

private

Definition at line 179 of file kis_tool_fill.h.

179{nullptr};

◆ m_sliderGrow

KisSliderSpinBox* KisToolFill::m_sliderGrow {nullptr}

private

Definition at line 177 of file kis_tool_fill.h.

177{nullptr};

◆ m_sliderPatternScale

KisDoubleSliderSpinBox* KisToolFill::m_sliderPatternScale {nullptr}

private

Definition at line 162 of file kis_tool_fill.h.

162{nullptr};

◆ m_sliderSpread

KisSliderSpinBox* KisToolFill::m_sliderSpread {nullptr}

private

Definition at line 172 of file kis_tool_fill.h.

172{nullptr};

◆ m_sliderThreshold

KisSliderSpinBox* KisToolFill::m_sliderThreshold {nullptr}

private

Definition at line 171 of file kis_tool_fill.h.

171{nullptr};

◆ m_stopGrowingAtDarkestPixel

int KisToolFill::m_stopGrowingAtDarkestPixel {false}

private

Definition at line 124 of file kis_tool_fill.h.

124{false};

◆ m_threshold

int KisToolFill::m_threshold {8}

private

Definition at line 117 of file kis_tool_fill.h.

117{8};

◆ m_transform

QTransform KisToolFill::m_transform

private

Definition at line 139 of file kis_tool_fill.h.

◆ m_useActiveLayer

bool KisToolFill::m_useActiveLayer {false}

private

Definition at line 129 of file kis_tool_fill.h.

129{false};

◆ m_useCustomBlendingOptions

bool KisToolFill::m_useCustomBlendingOptions {false}

private

Definition at line 111 of file kis_tool_fill.h.

111{false};

◆ m_useSelectionAsBoundary

bool KisToolFill::m_useSelectionAsBoundary {true}

private

Definition at line 120 of file kis_tool_fill.h.

120{true};

◆ m_widgetLabels

KisColorLabelSelectorWidget* KisToolFill::m_widgetLabels {nullptr}

private

Definition at line 184 of file kis_tool_fill.h.

184{nullptr};

◆ minimumDragDistance

constexpr int KisToolFill::minimumDragDistance {4}

staticconstexprprivate

Definition at line 103 of file kis_tool_fill.h.

103{4};

◆ minimumDragDistanceSquared

constexpr int KisToolFill::minimumDragDistanceSquared {minimumDragDistance * minimumDragDistance}

staticconstexprprivate

Definition at line 104 of file kis_tool_fill.h.

104{minimumDragDistance * minimumDragDistance};

KisToolFill::minimumDragDistance

static constexpr int minimumDragDistance

Definition kis_tool_fill.h:103

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

plugins/tools/basictools/kis_tool_fill.h
plugins/tools/basictools/kis_tool_fill.cc

Public Types

Public Slots

Public Member Functions

Protected Slots

Protected Member Functions

Private Slots

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ ContiguousFillMode

◆ ContinuousFillMode

◆ FillMode

◆ FillType

◆ Reference

Constructor & Destructor Documentation

◆ KisToolFill()

◆ ~KisToolFill()

Member Function Documentation

◆ activate

◆ addFillingOperation() [1/2]

◆ addFillingOperation() [2/2]

◆ addUpdateOperation()

◆ beginAlternateAction()

◆ beginFilling()

◆ beginPrimaryAction()

◆ continueAlternateAction()

◆ continuePrimaryAction()

◆ createOptionWidget()

◆ deactivate

◆ endAlternateAction()

◆ endFilling()

◆ endPrimaryAction()

◆ loadConfiguration()

◆ loadContiguousFillBoundaryColorFromConfig()

◆ resetCursorStyle

◆ slot_angleSelectorPatternRotation_angleChanged

◆ slot_buttonContiguousFillBoundaryColor_changed

◆ slot_buttonReset_clicked

◆ slot_buttonStopGrowingAtDarkestPixel_toggled

◆ slot_checkBoxAntiAlias_toggled

◆ slot_checkBoxSelectionAsBoundary_toggled

◆ slot_checkBoxUseActiveLayer_toggled

◆ slot_checkBoxUseCustomBlendingOptions_toggled

◆ slot_colorSpaceChanged

◆ slot_comboBoxCustomCompositeOp_currentIndexChanged

◆ slot_currentNodeChanged

◆ slot_optionButtonStripContiguousFillMode_buttonToggled

◆ slot_optionButtonStripDragFill_buttonToggled

◆ slot_optionButtonStripFillWith_buttonToggled

◆ slot_optionButtonStripReference_buttonToggled

◆ slot_optionButtonStripWhatToFill_buttonToggled

◆ slot_sliderCloseGap_valueChanged

◆ slot_sliderCustomOpacity_valueChanged

◆ slot_sliderFeather_valueChanged

◆ slot_sliderGrow_valueChanged

◆ slot_sliderPatternScale_valueChanged

◆ slot_sliderSpread_valueChanged

◆ slot_sliderThreshold_valueChanged

◆ slot_widgetLabels_selectionChanged

◆ slotUpdateFill

◆ wantsAutoScroll()

Member Data Documentation

◆ m_angleSelectorPatternRotation

◆ m_antiAlias

◆ m_buttonContiguousFillBoundaryColor

◆ m_buttonContiguousFillModeBoundaryFill

◆ m_buttonContiguousFillModeFloodFill

◆ m_buttonDragFillAny

◆ m_buttonDragFillDoNotUse

◆ m_buttonDragFillSimilar

◆ m_buttonFillWithBG

◆ m_buttonFillWithFG

◆ m_buttonFillWithPattern

◆ m_buttonReferenceAll

◆ m_buttonReferenceCurrent

◆ m_buttonReferenceLabeled

◆ m_buttonStopGrowingAtDarkestPixel