#include <kis_fill_painter.h>

Inheritance diagram for KisFillPainter:

Public Types
enum	RegionFillingMode { RegionFillingMode_FloodFill , RegionFillingMode_BoundaryFill }

Public Types inherited from KisPainter
enum	FillStyle { FillStyleNone , FillStyleForegroundColor , FillStyleBackgroundColor , FillStylePattern , FillStyleGenerator }
	This enum contains the styles with which we can fill things like polygons and ellipses. More...

enum	StrokeStyle { StrokeStyleNone , StrokeStyleBrush }
	The style of the brush stroke around polygons and so. More...

Public Member Functions
bool	antiAlias () const

bool	careForSelection () const

uint	closeGap () const

KisPixelSelectionSP	createFloodSelection (int startX, int startY, KisPaintDeviceSP sourceDevice, KisPaintDeviceSP existingSelection)

KisPixelSelectionSP	createFloodSelection (KisPixelSelectionSP newSelection, int startX, int startY, KisPaintDeviceSP sourceDevice, KisPaintDeviceSP existingSelection)

void	createSimilarColorsSelection (KisPixelSelectionSP outSelection, const KoColor &referenceColor, KisPaintDeviceSP referenceDevice, const QRect &rect, KisPixelSelectionSP mask)

QVector< KisStrokeJobData * >	createSimilarColorsSelectionJobs (KisPixelSelectionSP outSelection, const QSharedPointer< KoColor > referenceColor, KisPaintDeviceSP referenceDevice, const QRect &rect, KisPixelSelectionSP mask, QSharedPointer< KisProcessingVisitor::ProgressHelper > progressHelper=nullptr)

void	eraseRect (const QRect &rc)

void	eraseRect (qint32 x1, qint32 y1, qint32 w, qint32 h)

uint	feather () const

void	fillColor (int startX, int startY, KisPaintDeviceSP sourceDevice)

void	fillPattern (int startX, int startY, KisPaintDeviceSP sourceDevice, QTransform patternTransform=QTransform())

void	fillRect (const QRect &rc, const KisPaintDeviceSP device, const QRect &deviceRect)

void	fillRect (const QRect &rc, const KoColor &c)

void	fillRect (const QRect &rc, const KoColor &c, quint8 opacity)

void	fillRect (const QRect &rc, const KoPatternSP pattern, const QPoint &offset=QPoint())

void	fillRect (qint32 x, qint32 y, qint32 w, qint32 h, const KoColor &c)

void	fillRect (qint32 x, qint32 y, qint32 w, qint32 h, const KoColor &c, quint8 opacity)

void	fillRect (qint32 x1, qint32 y1, qint32 w, qint32 h, const KisFilterConfigurationSP generator)

void	fillRect (qint32 x1, qint32 y1, qint32 w, qint32 h, const KisPaintDeviceSP device, const QRect &deviceRect)

void	fillRect (qint32 x1, qint32 y1, qint32 w, qint32 h, const KoPatternSP pattern, const QPoint &offset=QPoint())

void	fillRectNoCompose (const QRect &rc, const KoPatternSP pattern, const QTransform transform)
	fillRect Fill a rectangle with a certain pattern. The pattern is repeated if it does not fit the entire rectangle. Differs from other functions that it uses a transform, does not support composite ops in turn.

void	fillRectNoCompose (qint32 x1, qint32 y1, qint32 w, qint32 h, const KisPaintDeviceSP device, const QRect &deviceRect, const QTransform transform)

void	fillSelection (const QRect &rc, const KoColor &color)

int	fillThreshold () const

	KisFillPainter ()

	KisFillPainter (KisPaintDeviceSP device)

	KisFillPainter (KisPaintDeviceSP device, KisSelectionSP selection)

int	opacitySpread () const

KoColor	regionFillingBoundaryColor () const

RegionFillingMode	regionFillingMode () const

void	setAntiAlias (bool antiAlias)

void	setCareForSelection (bool set)

void	setCloseGap (int gap)

void	setFeather (int feather)

void	setFillThreshold (int threshold)

void	setHeight (int h)

void	setOpacitySpread (int opacitySpread)

void	setRegionFillingBoundaryColor (const KoColor &regionFillingBoundaryColor)

void	setRegionFillingMode (RegionFillingMode regionFillingMode)

void	setSizemod (int sizemod)

void	setStopGrowingAtDarkestPixel (bool stopGrowingAtDarkestPixel)

void	setUseCompositing (bool useCompositing)

void	setUseSelectionAsBoundary (bool useSelectionAsBoundary)

void	setWidth (int w)

int	sizemod () const

bool	stopGrowingAtDarkestPixel () const

bool	useCompositing () const

uint	useSelectionAsBoundary () const

Public Member Functions inherited from KisPainter
void	addDirtyRect (const QRect &r)

void	addDirtyRects (const QVector< QRect > &rects)

bool	antiAliasPolygonFill ()
	Return whether a polygon's filled area should be anti-aliased or not.

void	applyDevice (const QRect &applyRect, const KisRenderedDab &dab, KisRandomAccessorSP dstIt, const KoColorSpace *srcColorSpace, KoCompositeOp::ParameterInfo &localParamInfo)

void	applyDeviceWithSelection (const QRect &applyRect, const KisRenderedDab &dab, KisRandomAccessorSP dstIt, KisRandomConstAccessorSP maskIt, const KoColorSpace *srcColorSpace, KoCompositeOp::ParameterInfo &localParamInfo)

const KoColor &	backgroundColor () const
	Returns the current background color.

void	begin (KisPaintDeviceSP device)

void	begin (KisPaintDeviceSP device, KisSelectionSP selection)

void	beginTransaction (const KUndo2MagicString &transactionName=KUndo2MagicString(), int timedID=-1)
	Begin an undoable paint operation.

void	bitBlt (const QPoint &pos, const KisPaintDeviceSP srcDev, const QRect &srcRect)

void	bitBlt (qint32 dstX, qint32 dstY, const KisPaintDeviceSP srcDev, qint32 srcX, qint32 srcY, qint32 srcWidth, qint32 srcHeight)

void	bitBltOldData (const QPoint &pos, const KisPaintDeviceSP srcDev, const QRect &srcRect)

void	bitBltOldData (qint32 dstX, qint32 dstY, const KisPaintDeviceSP srcDev, qint32 srcX, qint32 srcY, qint32 srcWidth, qint32 srcHeight)

void	bitBltWithFixedSelection (qint32 dstX, qint32 dstY, const KisPaintDeviceSP srcDev, const KisFixedPaintDeviceSP selection, qint32 selX, qint32 selY, qint32 srcX, qint32 srcY, qint32 srcWidth, qint32 srcHeight)

void	bitBltWithFixedSelection (qint32 dstX, qint32 dstY, const KisPaintDeviceSP srcDev, const KisFixedPaintDeviceSP selection, qint32 srcWidth, qint32 srcHeight)

void	bltFixed (const QPoint &pos, const KisFixedPaintDeviceSP srcDev, const QRect &srcRect)

void	bltFixed (const QRect &rc, const QList< KisRenderedDab > allSrcDevices)

void	bltFixed (qint32 dstX, qint32 dstY, const KisFixedPaintDeviceSP srcDev, qint32 srcX, qint32 srcY, qint32 srcWidth, qint32 srcHeight)

void	bltFixedWithFixedSelection (qint32 dstX, qint32 dstY, const KisFixedPaintDeviceSP srcDev, const KisFixedPaintDeviceSP selection, qint32 selX, qint32 selY, qint32 srcX, qint32 srcY, quint32 srcWidth, quint32 srcHeight)

void	bltFixedWithFixedSelection (qint32 dstX, qint32 dstY, const KisFixedPaintDeviceSP srcDev, const KisFixedPaintDeviceSP selection, quint32 srcWidth, quint32 srcHeight)

const QVector< QPair< QPointF, QPointF > >	calculateAllMirroredPoints (const QPair< QPointF, QPointF > &pair)

const QVector< QPointF >	calculateAllMirroredPoints (const QPointF &pos)

const QVector< QRect >	calculateAllMirroredRects (const QRect &rc)

template<class T >
QVector< T >	calculateMirroredObjects (const T &object)

QBitArray	channelFlags ()

const KoCompositeOp *	compositeOp (const KoColorSpace *srcCS)

QString	compositeOpId ()
	Returns the current composite op Id.

void	copyMirrorInformationFrom (const KisPainter *other)

void	deleteTransaction ()

KisPaintDeviceSP	device ()

const KisPaintDeviceSP	device () const
	Returns the current paint device.

void	drawDDALine (const QPointF &start, const QPointF &end)

void	drawLine (const QPointF &start, const QPointF &end)

void	drawLine (const QPointF &start, const QPointF &end, qreal width, bool antialias)

void	drawPainterPath (const QPainterPath &path, const QPen &pen)

void	drawPainterPath (const QPainterPath &path, const QPen &pen, const QRect &requestedRect)

void	drawThickLine (const QPointF &start, const QPointF &end, int startWidth, int endWidth)

void	drawWobblyLine (const QPointF &start, const QPointF &end)

void	drawWuLine (const QPointF &start, const QPointF &end)

void	end ()

KUndo2Command *	endAndTakeTransaction ()

void	endTransaction (KisPostExecutionUndoAdapter *undoAdapter)

void	endTransaction (KisUndoAdapter *undoAdapter)
	Finish the undoable paint operation.

void	fill (qint32 x, qint32 y, qint32 width, qint32 height, const KoColor &color)

void	fillPainterPath (const QPainterPath &path)

void	fillPainterPath (const QPainterPath &path, const QRect &requestedRect)

void	fillPainterPathImpl (const QPainterPath &path, const QRect &requestedRect)

FillStyle	fillStyle () const
	Returns the current fill style.

qreal	flow () const

const KisFilterConfigurationSP	generator () const

void	getBezierCurvePoints (const QPointF &pos1, const QPointF &control1, const QPointF &control2, const QPointF &pos2, vQPointF &points) const

const KoAbstractGradientSP	gradient () const

bool	hasDirtyRegion () const

bool	hasHorizontalMirroring () const

bool	hasMirroring () const

bool	hasVerticalMirroring () const

bool	isOpacityUnit () const

	KisPainter ()
	Construct painter without a device.

	KisPainter (KisPaintDeviceSP device)
	Construct a painter, and begin painting on the device.

	KisPainter (KisPaintDeviceSP device, KisSelectionSP selection)
	Construct a painter, and begin painting on the device. All actions will be masked by the given selection.

void	mirrorDab (Qt::Orientation direction, KisRenderedDab *dab, bool skipMirrorPixels=false) const

void	mirrorRect (Qt::Orientation direction, QRect *rc) const

qreal	opacityF () const
	Returns the opacity that is used in painting.

void	paintAt (const KisPaintInformation &pos, KisDistanceInformation *savedDist)

void	paintBezierCurve (const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)

const KoColor &	paintColor () const
	Returns the color that will be used to paint with.

void	paintEllipse (const qreal x, const qreal y, const qreal w, const qreal h)

void	paintEllipse (const QRectF &rect)

void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)

KisPaintOp *	paintOp () const

void	paintPainterPath (const QPainterPath &path)

void	paintPolygon (const vQPointF &points)

void	paintPolyline (const QVector< QPointF > &points, int index=0, int numPoints=-1)

void	paintRect (const qreal x, const qreal y, const qreal w, const qreal h)

void	paintRect (const QRectF &rect)

const KoPatternSP	pattern () const
	Returns the currently set pattern.

QTransform	patternTransform ()
	get the current transform on the pattern.

KisPaintOpPresetSP	preset () const
	Return the paintop preset.

	Private (KisPainter *_q)

	Private (KisPainter _q, const KoColorSpace cs)

void	putTransaction (KisTransaction *transaction)
	continue a transaction started somewhere else

void	renderDabWithMirroringNonIncremental (QRect rc, KisPaintDeviceSP dab)

void	renderMirrorMask (QRect rc, KisFixedPaintDeviceSP dab)

void	renderMirrorMask (QRect rc, KisFixedPaintDeviceSP dab, KisFixedPaintDeviceSP mask)

void	renderMirrorMask (QRect rc, KisPaintDeviceSP dab)

void	renderMirrorMask (QRect rc, KisPaintDeviceSP dab, int sx, int sy, KisFixedPaintDeviceSP mask)

void	renderMirrorMaskSafe (QRect rc, KisFixedPaintDeviceSP dab, bool preserveDab)

void	renderMirrorMaskSafe (QRect rc, KisFixedPaintDeviceSP dab, KisFixedPaintDeviceSP mask, bool preserveDab)

void	renderMirrorMaskSafe (QRect rc, KisPaintDeviceSP dab, int sx, int sy, KisFixedPaintDeviceSP mask, bool preserveMask)

void	revertTransaction ()
	Cancel all the changes made by the painter.

KisRunnableStrokeJobsInterface *	runnableStrokeJobsInterface () const

KisSelectionSP	selection ()

void	setAntiAliasPolygonFill (bool antiAliasPolygonFill)
	Set whether a polygon's filled area should be anti-aliased or not. The default is true.

void	setAverageOpacity (qreal averageOpacity)

void	setBackgroundColor (const KoColor &color)

void	setChannelFlags (QBitArray channelFlags)

void	setColorConversionFlags (KoColorConversionTransformation::ConversionFlags conversionFlags)

void	setCompositeOpId (const KoCompositeOp *op)

void	setCompositeOpId (const QString &op)
	Set the composite op for this painter by string.

void	setFillStyle (FillStyle fillStyle)
	Set the current style with which to fill.

void	setFlow (qreal flow)

void	setGenerator (KisFilterConfigurationSP generator)
	Set the current generator (a generator can be used to fill an area.

void	setGradient (const KoAbstractGradientSP gradient)

void	setMaskImageSize (qint32 width, qint32 height)

void	setMirrorInformation (const QPointF &axesCenter, bool mirrorHorizontally, bool mirrorVertically)

void	setOpacityF (qreal opacity)

void	setOpacityToUnit ()

void	setOpacityU8 (quint8 opacity)
	Set the opacity which is used in painting (like filling polygons)

void	setOpacityUpdateAverage (qreal opacity)

void	setPaintColor (const KoColor &color)

void	setPaintOpPreset (KisPaintOpPresetSP preset, KisNodeSP node, KisImageSP image)

void	setPattern (const KoPatternSP pattern)
	Set the current pattern.

void	setPatternTransform (QTransform transform)
	Set the transform on the pattern.

void	setProgress (KoUpdater *progressUpdater)

void	setRenderingIntent (KoColorConversionTransformation::Intent intent)

void	setRunnableStrokeJobsInterface (KisRunnableStrokeJobsInterface *interface)

void	setSelection (KisSelectionSP selection)

void	setStrokeStyle (StrokeStyle strokeStyle)
	Set the current brush stroke style.

StrokeStyle	strokeStyle () const
	Returns the current brush stroke style.

QVector< QRect >	takeDirtyRegion ()

KisTransaction *	takeTransaction ()
	take transaction out of the reach of KisPainter

bool	tryReduceSourceRect (const KisPaintDevice srcDev, QRect srcRect, qint32 srcX, qint32 srcY, qint32 srcWidth, qint32 srcHeight, qint32 dstX, qint32 dstY)

virtual	~KisPainter ()

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

Protected Member Functions
KisSelectionSP	currentFillSelection () const

void	genericFillEnd (KisPaintDeviceSP filled)

void	genericFillStart (int startX, int startY, KisPaintDeviceSP sourceDevice)

void	setCurrentFillSelection (KisSelectionSP fillSelection)

Protected Member Functions inherited from KisPainter
void	fillPolygon (const vQPointF &points, FillStyle fillStyle)
	Fill the polygon defined by points with the fillStyle.

void	init ()
	Initialize, set everything to '0' or defaults.

KoUpdater *	progressUpdater ()

Private Member Functions
void	initFillPainter ()

Private Attributes
bool	m_antiAlias

bool	m_careForSelection

int	m_closeGap

int	m_feather

KisSelectionSP	m_fillSelection

int	m_height

int	m_opacitySpread

QRect	m_rect

KoColor	m_regionFillingBoundaryColor

RegionFillingMode	m_regionFillingMode

int	m_sizemod

bool	m_stopGrowingAtDarkestPixel

int	m_threshold

bool	m_useCompositing

bool	m_useSelectionAsBoundary

int	m_width

Additional Inherited Members
Static Public Member Functions inherited from KisPainter
static qreal	blendAverageOpacity (qreal opacity, qreal averageOpacity)

static bool	checkDeviceHasTransparency (KisPaintDeviceSP dev)

static KisPaintDeviceSP	convertToAlphaAsAlpha (KisPaintDeviceSP src)

static KisPaintDeviceSP	convertToAlphaAsGray (KisPaintDeviceSP src)

static KisPaintDeviceSP	convertToAlphaAsPureAlpha (KisPaintDeviceSP src)

static void	copyAreaOptimized (const QPoint &dstPt, KisPaintDeviceSP src, KisPaintDeviceSP dst, const QRect &originalSrcRect)

static void	copyAreaOptimized (const QPoint &dstPt, KisPaintDeviceSP src, KisPaintDeviceSP dst, const QRect &originalSrcRect, KisSelectionSP selection)

static void	copyAreaOptimizedOldData (const QPoint &dstPt, KisPaintDeviceSP src, KisPaintDeviceSP dst, const QRect &originalSrcRect)

Public Attributes inherited from KisPainter
bool	antiAliasPolygonFill {true}

QPointF	axesCenter

KoColor	backgroundColor

const KoCompositeOp *	cachedCompositeOp {nullptr}

const KoColorSpace *	cachedSourceColorSpace {nullptr}

const KoColorSpace *	colorSpace {nullptr}

QString	compositeOpId

KoColorConversionTransformation::ConversionFlags	conversionFlags {KoColorConversionTransformation::Empty}

KoColor	customColor

KisPaintDeviceSP	device

QVector< QRect >	dirtyRects

QPointF	duplicateOffset

QScopedPointer< KisRunnableStrokeJobsInterface >	fakeRunnableStrokeJobsInterface

KisFillPainter *	fillPainter {nullptr}

FillStyle	fillStyle {FillStyleNone}

KisFilterConfigurationSP	generator

KoAbstractGradientSP	gradient

bool	isOpacityUnit {true}

qint32	maskImageHeight {255}

qint32	maskImageWidth {255}

QPainter *	maskPainter {nullptr}

bool	mirrorHorizontally {false}

bool	mirrorVertically {false}

KoColor	paintColor

KisPaintOp *	paintOp {nullptr}

KisPaintOpPresetSP	paintOpPreset

KoCompositeOp::ParameterInfo	paramInfo

KoPatternSP	pattern

QTransform	patternTransform

quint32	pixelSize {0}

KisPaintDeviceSP	polygon

QImage	polygonMaskImage

KoColorProfile *	profile {nullptr}

KoUpdater *	progressUpdater {nullptr}

KisPainter *	q {nullptr}

KoColorConversionTransformation::Intent	renderingIntent {KoColorConversionTransformation::IntentPerceptual}

KisRunnableStrokeJobsInterface *	runnableStrokeJobsInterface {nullptr}

KisSelectionSP	selection

KisPaintLayer *	sourceLayer {nullptr}

StrokeStyle	strokeStyle {StrokeStyleBrush}

KisTransaction *	transaction {nullptr}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Detailed Description

This painter can be used to fill paint devices in different ways. This can also be used for flood filling related operations.

Definition at line 33 of file kis_fill_painter.h.

Member Enumeration Documentation

◆ RegionFillingMode

enum KisFillPainter::RegionFillingMode

Enumerator
RegionFillingMode_FloodFill
RegionFillingMode_BoundaryFill

Definition at line 37 of file kis_fill_painter.h.

    {
        RegionFillingMode_FloodFill,
        RegionFillingMode_BoundaryFill
    };

Constructor & Destructor Documentation

◆ KisFillPainter() [1/3]

KisFillPainter::KisFillPainter ( )

Construct an empty painter. Use the begin(KisPaintDeviceSP) method to attach to a paint device

Definition at line 51 of file kis_fill_painter.cc.

        : KisPainter()
{
    initFillPainter();
}

References initFillPainter().

◆ KisFillPainter() [2/3]

KisFillPainter::KisFillPainter ( KisPaintDeviceSP device )

Start painting on the specified paint device

Definition at line 57 of file kis_fill_painter.cc.

        : KisPainter(device)
{
    initFillPainter();
}

References initFillPainter().

◆ KisFillPainter() [3/3]

KisFillPainter::KisFillPainter	(	KisPaintDeviceSP	device,
		KisSelectionSP	selection )

Definition at line 63 of file kis_fill_painter.cc.

        : KisPainter(device, selection)
{
    initFillPainter();
}

References initFillPainter().

Member Function Documentation

◆ antiAlias()

bool KisFillPainter::antiAlias ( ) const

inline

Get if antiAlias should be applied to the selection

Definition at line 353 of file kis_fill_painter.h.

                           {
        return m_antiAlias;
    }

◆ careForSelection()

bool KisFillPainter::careForSelection ( ) const

inline

If true, floodfill doesn't fill outside the selected area of a layer

Definition at line 338 of file kis_fill_painter.h.

                                  {
        return m_careForSelection;
    }

◆ closeGap()

uint KisFillPainter::closeGap ( ) const

inline

Defines the gap closing radius for the contiguous selection and fill operations. Does not affect the fill similar regions operation.

Definition at line 315 of file kis_fill_painter.h.

                          {
        return m_closeGap;
    }

◆ createFloodSelection() [1/2]

KisPixelSelectionSP KisFillPainter::createFloodSelection	(	int	startX,
		int	startY,
		KisPaintDeviceSP	sourceDevice,
		KisPaintDeviceSP	existingSelection )

Returns a selection mask for the floodfill starting at the specified position. This variant basically creates a new selection object and passes it down to the other variant of the function.

Parameters

startX	the X position where the floodfill starts
startY	the Y position where the floodfill starts
sourceDevice	the sourceDevice that determines the area that is floodfilled if sampleMerged is on

Definition at line 342 of file kis_fill_painter.cc.

{
    KisPixelSelectionSP newSelection = new KisPixelSelection(new KisSelectionDefaultBounds(device()));
    return createFloodSelection(newSelection, startX, startY, sourceDevice, existingSelection);
}

References createFloodSelection(), and KisPainter::device.

◆ createFloodSelection() [2/2]

KisPixelSelectionSP KisFillPainter::createFloodSelection	(	KisPixelSelectionSP	newSelection,
		int	startX,
		int	startY,
		KisPaintDeviceSP	sourceDevice,
		KisPaintDeviceSP	existingSelection )

Returns a selection mask for the floodfill starting at the specified position. This variant requires an empty selection object. It is used in cases where the pointer to the selection must be known beforehand, for example when the selection is filled in a stroke and then the pointer to the pixel selection is needed later.

Parameters

selection	empty new selection object
startX	the X position where the floodfill starts
startY	the Y position where the floodfill starts
sourceDevice	the sourceDevice that determines the area that is floodfilled if sampleMerged is on

Definition at line 349 of file kis_fill_painter.cc.

{
 
    if (m_width < 0 || m_height < 0) {
        if (selection() && m_careForSelection) {
            QRect rc = selection()->selectedExactRect();
            m_width = rc.width() - (startX - rc.x());
            m_height = rc.height() - (startY - rc.y());
        }
    }
    dbgImage << "Width: " << m_width << " Height: " << m_height;
    // Otherwise the width and height should have been set
    Q_ASSERT(m_width > 0 && m_height > 0);
 
    QRect fillBoundsRect(0, 0, m_width, m_height);
    QPoint startPoint(startX, startY);
 
    if (!fillBoundsRect.contains(startPoint)) {
        return pixelSelection;
    }
 
    KisScanlineFill gc(sourceDevice, startPoint, fillBoundsRect);
    gc.setThreshold(m_threshold);
    gc.setOpacitySpread(m_useCompositing ? m_opacitySpread : 100);
    gc.setCloseGap(m_closeGap);
 
    if (m_regionFillingMode == RegionFillingMode_FloodFill) {
        if (m_useSelectionAsBoundary && !pixelSelection.isNull()) {
            gc.fillSelection(pixelSelection, existingSelection);
        } else {
            gc.fillSelection(pixelSelection);
        }
    } else {
        if (m_useSelectionAsBoundary && !pixelSelection.isNull()) {
            gc.fillSelectionUntilColor(pixelSelection, m_regionFillingBoundaryColor, existingSelection);
        } else {
            gc.fillSelectionUntilColor(pixelSelection, m_regionFillingBoundaryColor);
        }
    }
 
    if (m_useCompositing) {
        if (m_sizemod > 0) {
            if (m_stopGrowingAtDarkestPixel) {
                KisGrowUntilDarkestPixelSelectionFilter biggy(m_sizemod, sourceDevice);
                biggy.process(pixelSelection, pixelSelection->selectedRect().adjusted(-m_sizemod, -m_sizemod, m_sizemod, m_sizemod));
            } else {
                KisGrowSelectionFilter biggy(m_sizemod, m_sizemod);
                biggy.process(pixelSelection, pixelSelection->selectedRect().adjusted(-m_sizemod, -m_sizemod, m_sizemod, m_sizemod));
            }
        }
        else if (m_sizemod < 0) {
            KisShrinkSelectionFilter tiny(-m_sizemod, -m_sizemod, false);
            tiny.process(pixelSelection, pixelSelection->selectedRect());
        }
        // Since the feathering already smooths the selection, the antiAlias
        // is not applied if we must feather
        if (m_feather > 0) {
            KisFeatherSelectionFilter feathery(m_feather);
            feathery.process(pixelSelection, pixelSelection->selectedRect().adjusted(-m_feather, -m_feather, m_feather, m_feather));
        } else if (m_antiAlias) {
            KisAntiAliasSelectionFilter antiAliasFilter;
            antiAliasFilter.process(pixelSelection, pixelSelection->selectedRect());
        }
    }
 
    return pixelSelection;
}

References dbgImage, KisScanlineFill::fillSelection(), KisScanlineFill::fillSelectionUntilColor(), KisSharedPtr< T >::isNull(), m_antiAlias, m_careForSelection, m_closeGap, m_feather, m_height, m_opacitySpread, m_regionFillingBoundaryColor, m_regionFillingMode, m_sizemod, m_stopGrowingAtDarkestPixel, m_threshold, m_useCompositing, m_useSelectionAsBoundary, m_width, KisFeatherSelectionFilter::process(), KisGrowSelectionFilter::process(), KisShrinkSelectionFilter::process(), KisAntiAliasSelectionFilter::process(), KisGrowUntilDarkestPixelSelectionFilter::process(), RegionFillingMode_FloodFill, KisSelection::selectedExactRect(), KisPixelSelection::selectedRect(), KisPainter::selection, KisScanlineFill::setCloseGap(), KisScanlineFill::setOpacitySpread(), and KisScanlineFill::setThreshold().

◆ createSimilarColorsSelection()

void KisFillPainter::createSimilarColorsSelection	(	KisPixelSelectionSP	outSelection,
		const KoColor &	referenceColor,
		KisPaintDeviceSP	referenceDevice,
		const QRect &	rect,
		KisPixelSelectionSP	mask )

Fills all the pixels of the outSelection device inside rect if the corresponding pixels on referenceDevice are similar to referenceColor

Parameters

outSelection	the selection where the values are written to
referenceColor	the color that we have to compare pixels to
referenceDevice	the device that we have to use to compare colors
rect	the rectangle that defines the area to be processed
mask	a selection to mask the results. Set to nullptr if not needed

Definition at line 476 of file kis_fill_painter.cc.

{
    if (rect.isEmpty()) {
        return;
    }
 
    KoColor srcColor(referenceColor);
    srcColor.convertTo(referenceDevice->colorSpace());
 
    const int pixelSize = referenceDevice->pixelSize();
    const int softness = 100 - opacitySpread();
 
    using namespace KisColorSelectionPolicies;
 
    if (softness == 0) {
        HardSelectionPolicy sp(fillThreshold());
        if (pixelSize == 1) {
            OptimizedDifferencePolicy<quint8> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else if (pixelSize == 2) {
            OptimizedDifferencePolicy<quint16> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else if (pixelSize == 4) {
            OptimizedDifferencePolicy<quint32> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else if (pixelSize == 8) {
            OptimizedDifferencePolicy<quint64> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else {
            SlowDifferencePolicy dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        }
    } else {
        SoftSelectionPolicy sp(fillThreshold(), softness);
        if (pixelSize == 1) {
            OptimizedDifferencePolicy<quint8> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else if (pixelSize == 2) {
            OptimizedDifferencePolicy<quint16> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else if (pixelSize == 4) {
            OptimizedDifferencePolicy<quint32> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else if (pixelSize == 8) {
            OptimizedDifferencePolicy<quint64> dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        } else {
            SlowDifferencePolicy dp(srcColor, fillThreshold());
            createSimilarColorsSelectionImpl(outSelection, referenceDevice, rect, mask, dp, sp);
        }
    }
}

References KisPaintDevice::colorSpace(), KoColor::convertTo(), createSimilarColorsSelectionImpl(), fillThreshold(), opacitySpread(), KisPaintDevice::pixelSize(), and KisPainter::pixelSize.

◆ createSimilarColorsSelectionJobs()

QVector< KisStrokeJobData * > KisFillPainter::createSimilarColorsSelectionJobs	(	KisPixelSelectionSP	outSelection,
		const QSharedPointer< KoColor >	referenceColor,
		KisPaintDeviceSP	referenceDevice,
		const QRect &	rect,
		KisPixelSelectionSP	mask,
		QSharedPointer< KisProcessingVisitor::ProgressHelper >	progressHelper = nullptr )

Create a list of jobs that will fill synchronously all the pixels of the outSelection device inside rect if the corresponding pixels on referenceDevice are similar to referenceColor. rect is split into smaller rects if needed, and the painting of each one is distributed on several jobs

Parameters

outSelection	the selection where the values are written to
referenceColor	the color that we have to compare pixels to
referenceDevice	the device that we have to use to compare colors
rect	the rectangle that defines the area to be processed
mask	a selection to mask the results. Set to nullptr if not needed

Definition at line 533 of file kis_fill_painter.cc.

{
    if (rect.isEmpty()) {
        return {};
    }
 
    QVector<KisStrokeJobData*> jobsData;
    QVector<QRect> fillPatches =
        KritaUtils::splitRectIntoPatches(rect, KritaUtils::optimalPatchSize());
    const int threshold = fillThreshold();
    const int softness = 100 - opacitySpread();
    const int sizemod = this->sizemod();
    const bool stopGrowingAtDarkestPixel = this->stopGrowingAtDarkestPixel();
    const int feather = this->feather();
    const bool antiAlias = this->antiAlias();
 
    KritaUtils::addJobBarrier(jobsData, nullptr);
 
    for (const QRect &patch : fillPatches) {
        KritaUtils::addJobConcurrent(
            jobsData,
            [referenceDevice, outSelection, mask, referenceColor,
             threshold, softness, patch, progressHelper]() mutable
            {
                if (patch.isEmpty()) {
                    return;
                }
 
                KoUpdater *updater = progressHelper ? progressHelper->updater() : nullptr;
 
                using namespace KisColorSelectionPolicies;
 
                const int pixelSize = referenceDevice->pixelSize();
                KoColor srcColor(*referenceColor);
                srcColor.convertTo(referenceDevice->colorSpace());
 
                if (softness == 0) {
                    HardSelectionPolicy sp(threshold);
                    if (pixelSize == 1) {
                        OptimizedDifferencePolicy<quint8> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else if (pixelSize == 2) {
                        OptimizedDifferencePolicy<quint16> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else if (pixelSize == 4) {
                        OptimizedDifferencePolicy<quint32> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else if (pixelSize == 8) {
                        OptimizedDifferencePolicy<quint64> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else {
                        SlowDifferencePolicy dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    }
                } else {
                    SoftSelectionPolicy sp(threshold, softness);
                    if (pixelSize == 1) {
                        OptimizedDifferencePolicy<quint8> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else if (pixelSize == 2) {
                        OptimizedDifferencePolicy<quint16> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else if (pixelSize == 4) {
                        OptimizedDifferencePolicy<quint32> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else if (pixelSize == 8) {
                        OptimizedDifferencePolicy<quint64> dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    } else {
                        SlowDifferencePolicy dp(srcColor, threshold);
                        createSimilarColorsSelectionImpl(outSelection, referenceDevice, patch, mask, dp, sp, updater);
                    }
                }
            }
        );
    }
 
    KritaUtils::addJobSequential(
        jobsData,
        [outSelection, referenceDevice, mask,
         sizemod, stopGrowingAtDarkestPixel, feather, antiAlias, progressHelper]() mutable
        {
            KoUpdater *updater = progressHelper ? progressHelper->updater() : nullptr;
 
            if (sizemod > 0) {
                if (stopGrowingAtDarkestPixel) {
                    KisGrowUntilDarkestPixelSelectionFilter biggy(sizemod, referenceDevice);
                    biggy.process(outSelection, outSelection->selectedRect().adjusted(-sizemod, -sizemod, sizemod, sizemod));
                } else {
                    KisGrowSelectionFilter biggy(sizemod, sizemod);
                    biggy.process(outSelection, outSelection->selectedRect().adjusted(-sizemod, -sizemod, sizemod, sizemod));
                }
            } else if (sizemod < 0) {
                KisShrinkSelectionFilter tiny(-sizemod, -sizemod, false);
                tiny.process(outSelection, outSelection->selectedRect());
            }
            if (updater) {
                updater->setProgress(33);
            }
 
            // Since the feathering already smooths the selection, the antiAlias
            // is not applied if we must feather
            if (feather > 0) {
                KisFeatherSelectionFilter feathery(feather);
                feathery.process(outSelection, outSelection->selectedRect().adjusted(-feather, -feather, feather, feather));
            } else if (antiAlias) {
                KisAntiAliasSelectionFilter antiAliasFilter;
                antiAliasFilter.process(outSelection, outSelection->selectedRect());
            }
            if (updater) {
                updater->setProgress(66);
            }
 
            if (mask) {
                outSelection->applySelection(mask, SELECTION_INTERSECT);
            }
            if (updater) {
                updater->setProgress(100);
            }
        }
    );
 
    return jobsData;
}

References KritaUtils::addJobBarrier(), KritaUtils::addJobConcurrent(), KritaUtils::addJobSequential(), antiAlias(), KisPixelSelection::applySelection(), KisPaintDevice::colorSpace(), KoColor::convertTo(), createSimilarColorsSelectionImpl(), feather(), fillThreshold(), opacitySpread(), KritaUtils::optimalPatchSize(), KisPaintDevice::pixelSize(), KisPainter::pixelSize, KisFeatherSelectionFilter::process(), KisGrowSelectionFilter::process(), KisShrinkSelectionFilter::process(), KisAntiAliasSelectionFilter::process(), KisGrowUntilDarkestPixelSelectionFilter::process(), KisPixelSelection::selectedRect(), SELECTION_INTERSECT, KoUpdater::setProgress(), sizemod(), KritaUtils::splitRectIntoPatches(), and stopGrowingAtDarkestPixel().

◆ currentFillSelection()

KisSelectionSP KisFillPainter::currentFillSelection ( ) const

inlineprotected

Definition at line 435 of file kis_fill_painter.h.

    {
        return m_fillSelection;
    }

◆ eraseRect() [1/2]

void KisFillPainter::eraseRect ( const QRect & rc )

inline

Overloaded version of the above function.

Definition at line 140 of file kis_fill_painter.h.

    {
        const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
        KoColor c(Qt::black, cs);
        fillRect(rc.x(),
                 rc.y(),
                 rc.width(),
                 rc.height(),
                 c,
                 OPACITY_TRANSPARENT_U8);
    }

References KoColorSpaceRegistry::instance(), OPACITY_TRANSPARENT_U8, and KoColorSpaceRegistry::rgb8().

◆ eraseRect() [2/2]

void KisFillPainter::eraseRect	(	qint32	x1,
		qint32	y1,
		qint32	w,
		qint32	h )

inline

Fill a rectangle with black transparent pixels (0, 0, 0, 0 for RGBA).

Definition at line 130 of file kis_fill_painter.h.

    {
        const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
        KoColor c(Qt::black, cs);
        fillRect(x1, y1, w, h, c, OPACITY_TRANSPARENT_U8);
    }

References KoColorSpaceRegistry::instance(), OPACITY_TRANSPARENT_U8, and KoColorSpaceRegistry::rgb8().

◆ feather()

uint KisFillPainter::feather ( ) const

inline

defines the feathering radius for selection flood operations, this affects every fill operation except fillRect

Definition at line 375 of file kis_fill_painter.h.

                         {
        return m_feather;
    }

◆ fillColor()

void KisFillPainter::fillColor	(	int	startX,
		int	startY,
		KisPaintDeviceSP	sourceDevice )

Fills the enclosed area around the point with the set color. If there is a selection, the whole selection is filled. Note that you must have set the width and height on the painter if you don't have a selection.

Parameters

startX	the X position where the floodfill starts
startY	the Y position where the floodfill starts
sourceDevice	the sourceDevice that determines the area that is floodfilled if sampleMerged is on

Definition at line 234 of file kis_fill_painter.cc.

{
    if (!m_useCompositing) {
        if (m_sizemod || m_feather ||
            compositeOpId() != COMPOSITE_OVER ||
            !isOpacityUnit() ||
            sourceDevice != device()) {
 
            warnKrita << "WARNING: Fast Flood Fill (no compositing mode)"
                       << "does not support compositeOps, opacity, "
                       << "selection enhancements and separate source "
                       << "devices";
        }
 
        QRect fillBoundsRect(0, 0, m_width, m_height);
        QPoint startPoint(startX, startY);
 
        if (!fillBoundsRect.contains(startPoint)) return;
 
        KisScanlineFill gc(device(), startPoint, fillBoundsRect);
        gc.setThreshold(m_threshold);
        if (m_regionFillingMode == RegionFillingMode_FloodFill) {
            gc.fill(paintColor());
        } else {
            gc.fillUntilColor(paintColor(), m_regionFillingBoundaryColor);
        }
 
        addDirtyRect(gc.fillExtent());
 
    } else {
        genericFillStart(startX, startY, sourceDevice);
 
        // Now create a layer and fill it
        KisPaintDeviceSP filled = device()->createCompositionSourceDevice();
        Q_CHECK_PTR(filled);
        KisFillPainter painter(filled);
        painter.fillRect(0, 0, m_width, m_height, paintColor());
        painter.end();
 
        genericFillEnd(filled);
    }
}

References KisPainter::addDirtyRect(), COMPOSITE_OVER, KisPainter::compositeOpId, KisPaintDevice::createCompositionSourceDevice(), KisPainter::device, KisPainter::end(), KisScanlineFill::fill(), KisScanlineFill::fillExtent, fillRect(), KisScanlineFill::fillUntilColor(), genericFillEnd(), genericFillStart(), KisPainter::isOpacityUnit, m_feather, m_height, m_regionFillingBoundaryColor, m_regionFillingMode, m_sizemod, m_threshold, m_useCompositing, m_width, KisPainter::paintColor, RegionFillingMode_FloodFill, KisScanlineFill::setThreshold(), and warnKrita.

◆ fillPattern()

void KisFillPainter::fillPattern	(	int	startX,
		int	startY,
		KisPaintDeviceSP	sourceDevice,
		QTransform	patternTransform = QTransform() )

Fills the enclosed area around the point with the set pattern. If there is a selection, the whole selection is filled. Note that you must have set the width and height on the painter if you don't have a selection.

Parameters

startX	the X position where the floodfill starts
startY	the Y position where the floodfill starts
sourceDevice	the sourceDevice that determines the area that is floodfilled if sampleMerged is on
patternTransform	transform applied to the pattern;

Definition at line 277 of file kis_fill_painter.cc.

{
    genericFillStart(startX, startY, sourceDevice);
 
    // Now create a layer and fill it
    KisPaintDeviceSP filled = device()->createCompositionSourceDevice();
    Q_CHECK_PTR(filled);
    KisFillPainter painter(filled);
    painter.fillRectNoCompose(QRect(0, 0, m_width, m_height), pattern(), patternTransform);
    painter.end();
 
    genericFillEnd(filled);
}

References KisPaintDevice::createCompositionSourceDevice(), KisPainter::device, KisPainter::end(), fillRectNoCompose(), genericFillEnd(), genericFillStart(), m_height, m_width, KisPainter::pattern, and KisPainter::patternTransform.

◆ fillRect() [1/9]

void KisFillPainter::fillRect	(	const QRect &	rc,
		const KisPaintDeviceSP	device,
		const QRect &	deviceRect )

Overloaded version of the above function.

Definition at line 174 of file kis_fill_painter.cc.

{
    fillRect(rc.x(), rc.y(), rc.width(), rc.height(), device, deviceRect);
}

References KisPainter::device, and fillRect().

◆ fillRect() [2/9]

void KisFillPainter::fillRect	(	const QRect &	rc,
		const KoColor &	c )

inline

Overloaded version of the above function.

Definition at line 98 of file kis_fill_painter.h.

    {
        fillRect(rc.x(), rc.y(), rc.width(), rc.height(), c, OPACITY_OPAQUE_U8);
    }

References OPACITY_OPAQUE_U8.

◆ fillRect() [3/9]

void KisFillPainter::fillRect	(	const QRect &	rc,
		const KoColor &	c,
		quint8	opacity )

inline

Overloaded version of the above function.

Definition at line 81 of file kis_fill_painter.h.

    {
        fillRect(rc.x(), rc.y(), rc.width(), rc.height(), c, opacity);
    }

◆ fillRect() [4/9]

void KisFillPainter::fillRect	(	const QRect &	rc,
		const KoPatternSP	pattern,
		const QPoint &	offset = QPoint() )

Overloaded version of the above function.

Definition at line 112 of file kis_fill_painter.cc.

{
    fillRect(rc.x(), rc.y(), rc.width(), rc.height(), pattern, offset);
}

References fillRect(), and KisPainter::pattern.

◆ fillRect() [5/9]

void KisFillPainter::fillRect	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		const KoColor &	c )

inline

Fill a rectangle with a certain color.

Definition at line 90 of file kis_fill_painter.h.

    {
        fillRect(x, y, w, h, c, OPACITY_OPAQUE_U8);
    }

References OPACITY_OPAQUE_U8.

◆ fillRect() [6/9]

void KisFillPainter::fillRect	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		const KoColor &	c,
		quint8	opacity )

Fill a rectangle with a certain color and opacity.

Definition at line 96 of file kis_fill_painter.cc.

{
    if (w > 0 && h > 0) {
        // Make sure we're in the right colorspace
 
        KoColor kc2(kc); // get rid of const
        kc2.convertTo(device()->colorSpace());
        quint8 * data = kc2.data();
        device()->colorSpace()->setOpacity(data, opacity, 1);
 
        device()->fill(x1, y1, w, h, data);
 
        addDirtyRect(QRect(x1, y1, w, h));
    }
}

References KisPainter::addDirtyRect(), KisPaintDevice::colorSpace(), KisPainter::colorSpace, KoColor::convertTo(), KoColor::data(), KisPainter::device, KisPaintDevice::fill(), and KoColorSpace::setOpacity().

◆ fillRect() [7/9]

void KisFillPainter::fillRect	(	qint32	x1,
		qint32	y1,
		qint32	w,
		qint32	h,
		const KisFilterConfigurationSP	generator )

Fill the specified area with the output of the generator plugin that is configured in the generator parameter

Definition at line 215 of file kis_fill_painter.cc.

{
    if (!generator) return;
    KisGeneratorSP g = KisGeneratorRegistry::instance()->value(generator->name());
    if (!device()) return;
    if (w < 1) return;
    if (h < 1) return;
 
    QRect tmpRc(x1, y1, w, h);
 
    KisProcessingInformation dstCfg(device(), tmpRc.topLeft(), 0);
 
    g->generate(dstCfg, tmpRc.size(), generator);
 
    addDirtyRect(tmpRc);
}

References KisPainter::addDirtyRect(), KisPainter::device, KisGenerator::generate(), KisPainter::generator, KisGeneratorRegistry::instance(), and KoGenericRegistry< T >::value().

◆ fillRect() [8/9]

void KisFillPainter::fillRect	(	qint32	x1,
		qint32	y1,
		qint32	w,
		qint32	h,
		const KisPaintDeviceSP	device,
		const QRect &	deviceRect )

Fill a rectangle with a certain pattern. The pattern is repeated if it does not fit the entire rectangle.

This one uses blitting and thus makes use of proper composition.

Definition at line 179 of file kis_fill_painter.cc.

{
    const QRect &patternRect = deviceRect;
    const QRect fillRect(x1, y1, w, h);
 
    auto toPatternLocal = [](int value, int offset, int width) {
        const int normalizedValue = value - offset;
        return offset + (normalizedValue >= 0 ?
                         normalizedValue % width :
                         width - (-normalizedValue - 1) % width - 1);
    };
 
    int dstY = fillRect.y();
    while (dstY <= fillRect.bottom()) {
        const int dstRowsRemaining = fillRect.bottom() - dstY + 1;
 
        const int srcY = toPatternLocal(dstY, patternRect.y(), patternRect.height());
        const int height = qMin(patternRect.height() - srcY + patternRect.y(), dstRowsRemaining);
 
        int dstX = fillRect.x();
        while (dstX <= fillRect.right()) {
            const int dstColumnsRemaining = fillRect.right() - dstX + 1;
 
            const int srcX = toPatternLocal(dstX, patternRect.x(), patternRect.width());
            const int width = qMin(patternRect.width() - srcX  + patternRect.x(), dstColumnsRemaining);
 
            bitBlt(dstX, dstY, device, srcX, srcY, width, height);
 
            dstX += width;
        }
        dstY += height;
    }
 
    addDirtyRect(QRect(x1, y1, w, h));
}

References KisPainter::addDirtyRect(), KisPainter::bitBlt(), KisPainter::device, fillRect(), and value().

◆ fillRect() [9/9]

void KisFillPainter::fillRect	(	qint32	x1,
		qint32	y1,
		qint32	w,
		qint32	h,
		const KoPatternSP	pattern,
		const QPoint &	offset = QPoint() )

Fill a rectangle with a certain pattern. The pattern is repeated if it does not fit the entire rectangle.

Definition at line 117 of file kis_fill_painter.cc.

{
    if (!pattern) return;
    if (!pattern->valid()) return;
    if (!device()) return;
    if (w < 1) return;
    if (h < 1) return;
 
    KisPaintDeviceSP patternLayer = new KisPaintDevice(device()->compositionSourceColorSpace(), pattern->name());
    patternLayer->convertFromQImage(pattern->pattern(), 0);
 
    if (!offset.isNull()) {
        patternLayer->moveTo(offset);
    }
 
    fillRect(x1, y1, w, h, patternLayer, QRect(offset.x(), offset.y(), pattern->width(), pattern->height()));
}

References KisPaintDevice::convertFromQImage(), KisPainter::device, fillRect(), KisPaintDevice::moveTo(), and KisPainter::pattern.

◆ fillRectNoCompose() [1/2]

void KisFillPainter::fillRectNoCompose	(	const QRect &	rc,
		const KoPatternSP	pattern,
		const QTransform	transform )

fillRect Fill a rectangle with a certain pattern. The pattern is repeated if it does not fit the entire rectangle. Differs from other functions that it uses a transform, does not support composite ops in turn.

Parameters

rc	rectangle to fill.
pattern	pattern to use.
transform	transformation to apply to the pattern.

Definition at line 135 of file kis_fill_painter.cc.

{
    if (!pattern) return;
    if (!pattern->valid()) return;
    if (!device()) return;
    if (rc.width() < 1) return;
    if (rc.height() < 1) return;
 
    KisPaintDeviceSP patternLayer = new KisPaintDevice(device()->colorSpace(), pattern->name());
    patternLayer->convertFromQImage(pattern->pattern(), 0);
 
    fillRectNoCompose(rc.x(), rc.y(), rc.width(), rc.height(), patternLayer, QRect(0, 0, pattern->width(), pattern->height()), transform);
}

References KisPainter::colorSpace, KisPaintDevice::convertFromQImage(), KisPainter::device, fillRectNoCompose(), and KisPainter::pattern.

◆ fillRectNoCompose() [2/2]

void KisFillPainter::fillRectNoCompose	(	qint32	x1,
		qint32	y1,
		qint32	w,
		qint32	h,
		const KisPaintDeviceSP	device,
		const QRect &	deviceRect,
		const QTransform	transform )

Fill a rectangle with a certain pattern. The pattern is repeated if it does not fit the entire rectangle.

This one supports transforms, but does not use blitting.

Since this function doesn't do any kind of compositing, so the pixel size of the source and destination devices must be exactly the same. The color space should ideally be also the same.

Definition at line 149 of file kis_fill_painter.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(device->pixelSize() == this->device()->pixelSize());
    KIS_SAFE_ASSERT_RECOVER_NOOP(*device->colorSpace() == *this->device()->colorSpace());
 
    KisPaintDeviceSP wrapped = device;
    KisDefaultBoundsBaseSP oldBounds = wrapped->defaultBounds();
    wrapped->setDefaultBounds(new KisWrapAroundBoundsWrapper(oldBounds, deviceRect));
    const bool oldSupportsWrapAroundMode = wrapped->supportsWraproundMode();
    wrapped->setSupportsWraparoundMode(true);
 
 
    KisPerspectiveTransformWorker worker(this->device(), transform, false, this->progressUpdater());
    worker.runPartialDst(device, this->device(), QRect(x1, y1, w, h));
 
    addDirtyRect(QRect(x1, y1, w, h));
    wrapped->setDefaultBounds(oldBounds);
    wrapped->setSupportsWraparoundMode(oldSupportsWrapAroundMode);
}

References KisPainter::addDirtyRect(), KisPaintDevice::colorSpace(), KisPaintDevice::defaultBounds(), KisPainter::device, KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintDevice::pixelSize(), KisPainter::progressUpdater, KisPerspectiveTransformWorker::runPartialDst(), KisPaintDevice::setDefaultBounds(), KisPaintDevice::setSupportsWraparoundMode(), and KisPaintDevice::supportsWraproundMode().

◆ fillSelection()

void KisFillPainter::fillSelection	(	const QRect &	rc,
		const KoColor &	color )

Fill current selection of KisPainter with a specified color.

The filling rect is limited by rc to allow multithreaded filling/processing.

Definition at line 85 of file kis_fill_painter.cc.

{
    KisPaintDeviceSP fillDevice = new KisPaintDevice(device()->colorSpace());
    fillDevice->setDefaultPixel(color);
 
    bitBlt(rc.topLeft(), fillDevice, rc);
}

References KisPainter::bitBlt(), KisPainter::colorSpace, KisPainter::device, and KisPaintDevice::setDefaultPixel().

◆ fillThreshold()

int KisFillPainter::fillThreshold ( ) const

inline

Returns the fill threshold, see setFillThreshold for details

Definition at line 281 of file kis_fill_painter.h.

                              {
        return m_threshold;
    }

◆ genericFillEnd()

void KisFillPainter::genericFillEnd ( KisPaintDeviceSP filled )

protected

Apply the real selection to a filled one

Definition at line 306 of file kis_fill_painter.cc.

{
    if (progressUpdater() && progressUpdater()->interrupted()) {
        m_width = m_height = -1;
        return;
    }
 
//  TODO: filling using the correct bound of the selection would be better, *but*
//  the selection is limited to the exact bound of a layer, while in reality, we don't
//  want that, since we want a transparent layer to be completely filled
//     QRect rc = m_fillSelection->selectedExactRect();
 
 
    KisSelectionSP realSelection = selection();
    QRect rc;
 
    if (realSelection) {
        rc = m_fillSelection->selectedExactRect().intersected(realSelection->projection()->selectedExactRect());
        m_fillSelection->pixelSelection()->applySelection(
            realSelection->projection(), SELECTION_INTERSECT);
    } else {
        rc = m_fillSelection->selectedExactRect();
    }
 
    setSelection(m_fillSelection);
    bitBlt(rc.topLeft(), filled, rc);
    setSelection(realSelection);
 
    if (progressUpdater()) progressUpdater()->setProgress(100);
 
    m_width = m_height = -1;
}

References KisPixelSelection::applySelection(), KisPainter::bitBlt(), m_fillSelection, m_height, m_width, KisSelection::pixelSelection, KisPainter::progressUpdater, KisSelection::projection(), KisPixelSelection::selectedExactRect(), KisSelection::selectedExactRect(), KisPainter::selection, SELECTION_INTERSECT, KoUpdater::setProgress(), and KisPainter::setSelection().

◆ genericFillStart()

void KisFillPainter::genericFillStart	(	int	startX,
		int	startY,
		KisPaintDeviceSP	sourceDevice )

protected

Definition at line 291 of file kis_fill_painter.cc.

{
    Q_ASSERT(m_width > 0);
    Q_ASSERT(m_height > 0);
 
    // Create a selection from the surrounding area
 
    KisPixelSelectionSP pixelSelection = createFloodSelection(startX, startY, sourceDevice,
                                                              (selection().isNull() ? 0 : selection()->pixelSelection()));
    KisSelectionSP newSelection = new KisSelection(pixelSelection->defaultBounds(),
                                                   selection() ? selection()->resolutionProxy() : KisImageResolutionProxy::identity());
    newSelection->pixelSelection()->applySelection(pixelSelection, SELECTION_REPLACE);
    m_fillSelection = newSelection;
}

References KisPixelSelection::applySelection(), createFloodSelection(), KisPaintDevice::defaultBounds(), KisImageResolutionProxy::identity(), m_fillSelection, m_height, m_width, KisSelection::pixelSelection, KisPainter::selection, and SELECTION_REPLACE.

◆ initFillPainter()

void KisFillPainter::initFillPainter ( )

private

Definition at line 69 of file kis_fill_painter.cc.

{
    m_width = m_height = -1;
    m_careForSelection = false;
    m_sizemod = 0;
    m_feather = 0;
    m_useCompositing = false;
    m_threshold = 0;
    m_opacitySpread = 0;
    m_closeGap = 0;
    m_useSelectionAsBoundary = false;
    m_antiAlias = false;
    m_regionFillingMode = RegionFillingMode_FloodFill;
    m_stopGrowingAtDarkestPixel = false;
}

References m_antiAlias, m_careForSelection, m_closeGap, m_feather, m_height, m_opacitySpread, m_regionFillingMode, m_sizemod, m_stopGrowingAtDarkestPixel, m_threshold, m_useCompositing, m_useSelectionAsBoundary, m_width, and RegionFillingMode_FloodFill.

◆ opacitySpread()

int KisFillPainter::opacitySpread ( ) const

inline

Returns the fill opacity spread, see setOpacitySpread for details

Definition at line 302 of file kis_fill_painter.h.

                              {
        return m_opacitySpread;
    }

◆ regionFillingBoundaryColor()

KoColor KisFillPainter::regionFillingBoundaryColor ( ) const

inline

Gets the color of the boundary used when the region filling mode is RegionFillingMode_BoundaryFill

Definition at line 409 of file kis_fill_painter.h.

                                               {
        return m_regionFillingBoundaryColor;
    }

◆ regionFillingMode()

RegionFillingMode KisFillPainter::regionFillingMode ( ) const

inline

Gets the region filling mode

Definition at line 395 of file kis_fill_painter.h.

                                                {
        return m_regionFillingMode;
    }

◆ setAntiAlias()

void KisFillPainter::setAntiAlias ( bool antiAlias )

inline

Sets if antiAlias should be applied to the selection

Definition at line 348 of file kis_fill_painter.h.

                                      {
        m_antiAlias = antiAlias;
    }

◆ setCareForSelection()

void KisFillPainter::setCareForSelection ( bool set )

inline

Set caring for selection. See careForSelection for details

Definition at line 343 of file kis_fill_painter.h.

                                       {
        m_careForSelection = set;
    }

◆ setCloseGap()

void KisFillPainter::setCloseGap ( int gap )

inline

Sets the gap radius for a gap closing fill.

Definition at line 307 of file kis_fill_painter.h.

                              {
        m_closeGap = gap;
    }

◆ setCurrentFillSelection()

void KisFillPainter::setCurrentFillSelection ( KisSelectionSP fillSelection )

inlineprotected

Definition at line 430 of file kis_fill_painter.h.

    {
        m_fillSelection = fillSelection;
    }

◆ setFeather()

void KisFillPainter::setFeather ( int feather )

inline

Sets feathering radius

Definition at line 369 of file kis_fill_painter.h.

                                 {
        m_feather = feather;
    }

◆ setFillThreshold()

void KisFillPainter::setFillThreshold ( int threshold )

inline

Set the threshold for floodfill. The range is 0-255: 0 means the fill will only fill parts that are the exact same color, 255 means anything will be filled

Definition at line 275 of file kis_fill_painter.h.

    {
        m_threshold = threshold;
    }

◆ setHeight()

void KisFillPainter::setHeight ( int h )

inline

Sets the height of the paint device

Definition at line 333 of file kis_fill_painter.h.

                          {
        m_height = h;
    }

◆ setOpacitySpread()

void KisFillPainter::setOpacitySpread ( int opacitySpread )

inline

Set the opacity spread for floodfill. The range is 0-100: 0% means that the fully opaque area only encompasses the pixels exactly equal to the seed point with the other pixels of the selected region being semi-transparent (depending on how similar they are to the seed pixel) up to the region boundary (given by the threshold value). 100 means that the fully opaque area will encompass all the pixels of the selected region up to the contour. Any value in between will make the fully opaque portion of the region vary in size, with semi-transparent pixels in between it and the region boundary

Definition at line 296 of file kis_fill_painter.h.

    {
        m_opacitySpread = opacitySpread;
    }

◆ setRegionFillingBoundaryColor()

void KisFillPainter::setRegionFillingBoundaryColor ( const KoColor & regionFillingBoundaryColor )

inline

Sets the color of the boundary used when the region filling mode is RegionFillingMode_BoundaryFill

Definition at line 402 of file kis_fill_painter.h.

                                                                                  {
        m_regionFillingBoundaryColor = regionFillingBoundaryColor;
    }

◆ setRegionFillingMode()

void KisFillPainter::setRegionFillingMode ( RegionFillingMode regionFillingMode )

inline

Sets the region filling mode

Definition at line 390 of file kis_fill_painter.h.

                                                                   {
        m_regionFillingMode = regionFillingMode;
    }

◆ setSizemod()

void KisFillPainter::setSizemod ( int sizemod )

inline

Sets the auto growth/shrinking radius

Definition at line 358 of file kis_fill_painter.h.

                                 {
        m_sizemod = sizemod;
    }

◆ setStopGrowingAtDarkestPixel()

void KisFillPainter::setStopGrowingAtDarkestPixel ( bool stopGrowingAtDarkestPixel )

inline

Sets if the selection should stop growing at the darkest and/or more opaque pixel when using a positive grow value (sizemod)

Definition at line 417 of file kis_fill_painter.h.

                                                                      {
        m_stopGrowingAtDarkestPixel = stopGrowingAtDarkestPixel;
    }

◆ setUseCompositing()

void KisFillPainter::setUseCompositing ( bool useCompositing )

inline

Definition at line 323 of file kis_fill_painter.h.

                                                {
        m_useCompositing = useCompositing;
    }

◆ setUseSelectionAsBoundary()

void KisFillPainter::setUseSelectionAsBoundary ( bool useSelectionAsBoundary )

inline

Sets selection borders being treated as boundary

Definition at line 380 of file kis_fill_painter.h.

                                                                {
        m_useSelectionAsBoundary = useSelectionAsBoundary;
    }

◆ setWidth()

void KisFillPainter::setWidth ( int w )

inline

Sets the width of the paint device

Definition at line 328 of file kis_fill_painter.h.

                         {
        m_width = w;
    }

◆ sizemod()

int KisFillPainter::sizemod ( ) const

inline

Sets how much to auto-grow or shrink (if sizemod is negative) the selection flood before painting, this affects every fill operation except fillRect

Definition at line 364 of file kis_fill_painter.h.

                        {
        return m_sizemod;
    }

◆ stopGrowingAtDarkestPixel()

bool KisFillPainter::stopGrowingAtDarkestPixel ( ) const

inline

Gets if the selection should stop growing at the darkest and/or more opaque pixel when using a positive grow value (sizemod)

Definition at line 425 of file kis_fill_painter.h.

                                           {
        return m_stopGrowingAtDarkestPixel;
    }

◆ useCompositing()

bool KisFillPainter::useCompositing ( ) const

inline

Definition at line 319 of file kis_fill_painter.h.

                                {
        return m_useCompositing;
    }

◆ useSelectionAsBoundary()

uint KisFillPainter::useSelectionAsBoundary ( ) const

inline

defines if the selection borders are treated as boundary in flood fill or not

Definition at line 385 of file kis_fill_painter.h.

                                        {
        return m_useSelectionAsBoundary;
    }

Member Data Documentation

◆ m_antiAlias

bool KisFillPainter::m_antiAlias

private

Definition at line 449 of file kis_fill_painter.h.

◆ m_careForSelection

bool KisFillPainter::m_careForSelection

private

Definition at line 455 of file kis_fill_painter.h.

◆ m_closeGap

int KisFillPainter::m_closeGap

private

Definition at line 452 of file kis_fill_painter.h.

◆ m_feather

int KisFillPainter::m_feather

private

Definition at line 447 of file kis_fill_painter.h.

◆ m_fillSelection

KisSelectionSP KisFillPainter::m_fillSelection

private

Definition at line 445 of file kis_fill_painter.h.

◆ m_height

int KisFillPainter::m_height

private

Definition at line 453 of file kis_fill_painter.h.

◆ m_opacitySpread

int KisFillPainter::m_opacitySpread

private

Definition at line 451 of file kis_fill_painter.h.

◆ m_rect

QRect KisFillPainter::m_rect

private

Definition at line 454 of file kis_fill_painter.h.

◆ m_regionFillingBoundaryColor

KoColor KisFillPainter::m_regionFillingBoundaryColor

private

Definition at line 459 of file kis_fill_painter.h.

◆ m_regionFillingMode

RegionFillingMode KisFillPainter::m_regionFillingMode

private

Definition at line 458 of file kis_fill_painter.h.

◆ m_sizemod

int KisFillPainter::m_sizemod

private

Definition at line 448 of file kis_fill_painter.h.

◆ m_stopGrowingAtDarkestPixel

bool KisFillPainter::m_stopGrowingAtDarkestPixel

private

Definition at line 460 of file kis_fill_painter.h.

◆ m_threshold

int KisFillPainter::m_threshold

private

Definition at line 450 of file kis_fill_painter.h.

◆ m_useCompositing

bool KisFillPainter::m_useCompositing

private

Definition at line 456 of file kis_fill_painter.h.

◆ m_useSelectionAsBoundary

bool KisFillPainter::m_useSelectionAsBoundary

private

Definition at line 457 of file kis_fill_painter.h.

◆ m_width

int KisFillPainter::m_width

private

Definition at line 453 of file kis_fill_painter.h.

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

libs/image/kis_fill_painter.h
libs/image/kis_fill_painter.cc

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ RegionFillingMode

Constructor & Destructor Documentation

◆ KisFillPainter() [1/3]

◆ KisFillPainter() [2/3]

◆ KisFillPainter() [3/3]

Member Function Documentation

◆ antiAlias()

◆ careForSelection()

◆ closeGap()

◆ createFloodSelection() [1/2]

◆ createFloodSelection() [2/2]

◆ createSimilarColorsSelection()

◆ createSimilarColorsSelectionJobs()

◆ currentFillSelection()

◆ eraseRect() [1/2]

◆ eraseRect() [2/2]

◆ feather()

◆ fillColor()

◆ fillPattern()

◆ fillRect() [1/9]

◆ fillRect() [2/9]

◆ fillRect() [3/9]

◆ fillRect() [4/9]

◆ fillRect() [5/9]

◆ fillRect() [6/9]

◆ fillRect() [7/9]

◆ fillRect() [8/9]

◆ fillRect() [9/9]

◆ fillRectNoCompose() [1/2]

◆ fillRectNoCompose() [2/2]

◆ fillSelection()

◆ fillThreshold()

◆ genericFillEnd()

◆ genericFillStart()

◆ initFillPainter()

◆ opacitySpread()

◆ regionFillingBoundaryColor()

◆ regionFillingMode()

◆ setAntiAlias()

◆ setCareForSelection()

◆ setCloseGap()

◆ setCurrentFillSelection()

◆ setFeather()

◆ setFillThreshold()

◆ setHeight()

◆ setOpacitySpread()

◆ setRegionFillingBoundaryColor()

◆ setRegionFillingMode()

◆ setSizemod()

◆ setStopGrowingAtDarkestPixel()

◆ setUseCompositing()

◆ setUseSelectionAsBoundary()

◆ setWidth()

◆ sizemod()

◆ stopGrowingAtDarkestPixel()

◆ useCompositing()

◆ useSelectionAsBoundary()

Member Data Documentation

◆ m_antiAlias

◆ m_careForSelection

◆ m_closeGap

◆ m_feather

◆ m_fillSelection

◆ m_height

◆ m_opacitySpread

◆ m_rect

◆ m_regionFillingBoundaryColor

◆ m_regionFillingMode

◆ m_sizemod

◆ m_stopGrowingAtDarkestPixel

◆ m_threshold

◆ m_useCompositing