#include <kis_gradient_painter.h>

Inheritance diagram for KisGradientPainter:

Classes
struct	ProcessRegion

Public Types
enum	enumDither { DitherNone , DitherBlueNoise , DitherBayer2 , DitherBayer4 , DitherBayer8 }

enum	enumGradientRepeat { GradientRepeatNone , GradientRepeatForwards , GradientRepeatAlternate }

enum	enumGradientShape { GradientShapeLinear , GradientShapeBiLinear , GradientShapeRadial , GradientShapeSquare , GradientShapeConical , GradientShapeConicalSymetric , GradientShapeSpiral , GradientShapeReverseSpiral , GradientShapePolygonal }

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

	KisGradientPainter (KisPaintDeviceSP device)

	KisGradientPainter (KisPaintDeviceSP device, KisSelectionSP selection)

bool	paintGradient (const QPointF &gradientVectorStart, const QPointF &gradientVectorEnd, enumGradientRepeat repeat, double antiAliasThreshold, bool reverseGradient, const QRect &applyRect, enumDither dither=DitherNone, int ditherSteps=defaultDitherSteps)

template<class T >
bool	paintGradient (const QPointF &gradientVectorStart, const QPointF &gradientVectorEnd, enumGradientRepeat repeat, double antiAliasThreshold, bool reverseGradient, enumDither dither, int ditherSteps, const QRect &applyRect, T &paintPolicy)

bool	paintGradient (const QPointF &gradientVectorStart, const QPointF &gradientVectorEnd, enumGradientRepeat repeat, double antiAliasThreshold, bool reverseGradient, qint32 startx, qint32 starty, qint32 width, qint32 height, enumDither dither=DitherNone, int ditherSteps=defaultDitherSteps)

void	precalculateShape ()

void	setGradientShape (enumGradientShape shape)

	~KisGradientPainter () override

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

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

Static Public Member Functions
static bool	isBayerDither (enumDither dither)

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
QVector< ProcessRegion >	processRegions

enumGradientShape	shape

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

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}

Static Public Attributes
static constexpr int	defaultDitherSteps = 2

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
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 ()

Detailed Description

XXX: Docs!

Definition at line 1045 of file kis_gradient_painter.cc.

Member Enumeration Documentation

◆ enumDither

enum KisGradientPainter::enumDither

Enumerator
DitherNone
DitherBlueNoise
DitherBayer2
DitherBayer4
DitherBayer8

Definition at line 52 of file kis_gradient_painter.h.

                    {
        DitherNone,
        DitherBlueNoise,
        DitherBayer2,
        DitherBayer4,
        DitherBayer8
    };

◆ enumGradientRepeat

enum KisGradientPainter::enumGradientRepeat

Enumerator
GradientRepeatNone
GradientRepeatForwards
GradientRepeatAlternate

Definition at line 46 of file kis_gradient_painter.h.

                            {
        GradientRepeatNone,
        GradientRepeatForwards,
        GradientRepeatAlternate
    };

◆ enumGradientShape

enum KisGradientPainter::enumGradientShape

Enumerator
GradientShapeLinear
GradientShapeBiLinear
GradientShapeRadial
GradientShapeSquare
GradientShapeConical
GradientShapeConicalSymetric
GradientShapeSpiral
GradientShapeReverseSpiral
GradientShapePolygonal

Definition at line 34 of file kis_gradient_painter.h.

                           {
        GradientShapeLinear,
        GradientShapeBiLinear,
        GradientShapeRadial,
        GradientShapeSquare,
        GradientShapeConical,
        GradientShapeConicalSymetric,
        GradientShapeSpiral,
        GradientShapeReverseSpiral,
        GradientShapePolygonal
    };

Constructor & Destructor Documentation

◆ KisGradientPainter() [1/3]

KisGradientPainter::KisGradientPainter ( )

Definition at line 1063 of file kis_gradient_painter.cc.

    : m_d(new Private())
{
}

◆ KisGradientPainter() [2/3]

KisGradientPainter::KisGradientPainter ( KisPaintDeviceSP device )

Definition at line 1068 of file kis_gradient_painter.cc.

    : KisPainter(device),
      m_d(new Private())
{
}

◆ KisGradientPainter() [3/3]

KisGradientPainter::KisGradientPainter	(	KisPaintDeviceSP	device,
		KisSelectionSP	selection )

Definition at line 1074 of file kis_gradient_painter.cc.

    : KisPainter(device, selection),
      m_d(new Private())
{
}

◆ ~KisGradientPainter()

KisGradientPainter::~KisGradientPainter ( )

override

Definition at line 1080 of file kis_gradient_painter.cc.

1081{

1082}

Member Function Documentation

◆ isBayerDither()

bool KisGradientPainter::isBayerDither ( enumDither dither )

static

Definition at line 1414 of file kis_gradient_painter.cc.

{
    return dither == KisGradientPainter::DitherBayer2 ||
           dither == KisGradientPainter::DitherBayer4 ||
           dither == KisGradientPainter::DitherBayer8;
}

References DitherBayer2, DitherBayer4, and DitherBayer8.

◆ paintGradient() [1/3]

bool KisGradientPainter::paintGradient	(	const QPointF &	gradientVectorStart,
		const QPointF &	gradientVectorEnd,
		enumGradientRepeat	repeat,
		double	antiAliasThreshold,
		bool	reverseGradient,
		const QRect &	applyRect,
		enumDither	dither = DitherNone,
		int	ditherSteps = defaultDitherSteps )

Definition at line 1164 of file kis_gradient_painter.cc.

{
    // The following combinations of options have aliasing artifacts
    // where the first color meets the last color of the gradient.
    // so antialias threshold is used to compute if the pixel is in
    // the smoothing area. Then linear interpolation is used to blend
    // between the first and last colors
    if (antiAliasThreshold > DBL_EPSILON) {
        if ((m_d->shape == GradientShapeLinear || m_d->shape == GradientShapeBiLinear ||
            m_d->shape == GradientShapeRadial || m_d->shape == GradientShapeSquare ||
            m_d->shape == GradientShapeSpiral || m_d->shape == GradientShapeReverseSpiral)
            && repeat == GradientRepeatForwards) {
            RepeatForwardsPaintPolicy paintPolicy(m_d->shape);
            return paintGradient(gradientVectorStart,
                                 gradientVectorEnd,
                                 repeat,
                                 antiAliasThreshold,
                                 reverseGradient,
                                 dither,
                                 ditherSteps,
                                 applyRect,
                                 paintPolicy);
 
        } else if (m_d->shape == GradientShapeConical) {
            ConicalGradientPaintPolicy paintPolicy;
            return paintGradient(gradientVectorStart,
                                 gradientVectorEnd,
                                 repeat,
                                 antiAliasThreshold,
                                 reverseGradient,
                                 dither,
                                 ditherSteps,
                                 applyRect,
                                 paintPolicy);
 
        } else if ((m_d->shape == GradientShapeSpiral || m_d->shape == GradientShapeReverseSpiral) &&
                   repeat == GradientRepeatNone) {
            SpyralGradientRepeatNonePaintPolicy paintPolicy(m_d->shape == GradientShapeReverseSpiral);
            return paintGradient(gradientVectorStart,
                                 gradientVectorEnd,
                                 repeat,
                                 antiAliasThreshold,
                                 reverseGradient,
                                 dither,
                                 ditherSteps,
                                 applyRect,
                                 paintPolicy);
        }
    }
 
    // Default behavior: no antialiasing required
    NoAntialiasPaintPolicy paintPolicy;
    return paintGradient(gradientVectorStart,
                         gradientVectorEnd,
                         repeat,
                         antiAliasThreshold,
                         reverseGradient,
                         dither,
                         ditherSteps,
                         applyRect,
                         paintPolicy);
}

References GradientRepeatForwards, GradientRepeatNone, GradientShapeBiLinear, GradientShapeConical, GradientShapeLinear, GradientShapeRadial, GradientShapeReverseSpiral, GradientShapeSpiral, GradientShapeSquare, m_d, and paintGradient().

◆ paintGradient() [2/3]

template<class T >

bool KisGradientPainter::paintGradient	(	const QPointF &	gradientVectorStart,
		const QPointF &	gradientVectorEnd,
		enumGradientRepeat	repeat,
		double	antiAliasThreshold,
		bool	reverseGradient,
		enumDither	dither,
		int	ditherSteps,
		const QRect &	applyRect,
		T &	paintPolicy )

Definition at line 1235 of file kis_gradient_painter.cc.

{
    if (!gradient()) return false;
 
    QRect requestedRect = applyRect;
 
    //If the device has a selection only iterate over that selection united with our area of interest
    if (selection()) {
        requestedRect &= selection()->selectedExactRect();
    }
 
    QSharedPointer<KisGradientShapeStrategy> shapeStrategy;
 
    switch (m_d->shape) {
    case GradientShapeLinear: {
        Private::ProcessRegion r(toQShared(new LinearGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapeBiLinear: {
        Private::ProcessRegion r(toQShared(new BiLinearGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapeRadial: {
        Private::ProcessRegion r(toQShared(new RadialGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapeSquare: {
        Private::ProcessRegion r(toQShared(new SquareGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapeConical: {
        Private::ProcessRegion r(toQShared(new ConicalGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapeConicalSymetric: {
        Private::ProcessRegion r(toQShared(new ConicalSymetricGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapeSpiral: {
        Private::ProcessRegion r(toQShared(new SpiralGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapeReverseSpiral: {
        Private::ProcessRegion r(toQShared(new ReverseSpiralGradientStrategy(gradientVectorStart, gradientVectorEnd)),
                                 requestedRect);
        m_d->processRegions.clear();
        m_d->processRegions << r;
        break;
    }
    case GradientShapePolygonal:
        precalculateShape();
        repeat = GradientRepeatNone;
        break;
    }
 
    if (isBayerDither(dither)) {
        // Wrap each shape strategy in a dithering filter.
        for (Private::ProcessRegion& region : m_d->processRegions) {
            region.precalculatedShapeStrategy = toQShared(new DitheredGradientStrategy(dither, ditherSteps, region.precalculatedShapeStrategy));
        }
    }
 
    GradientRepeatStrategy *repeatStrategy = 0;
 
    switch (repeat) {
    case GradientRepeatNone:
        repeatStrategy = GradientRepeatNoneStrategy::instance();
        break;
    case GradientRepeatForwards:
        repeatStrategy = GradientRepeatForwardsStrategy::instance();
        break;
    case GradientRepeatAlternate:
        if (m_d->shape == GradientShapeSpiral || m_d->shape == GradientShapeReverseSpiral) {repeatStrategy = GradientRepeatModuloDivisiveContinuousHalfStrategy::instance();}
        else {repeatStrategy = GradientRepeatAlternateStrategy::instance();}
        break;
    }
    Q_ASSERT(repeatStrategy != 0);
 
 
    KisPaintDeviceSP dev = device()->createCompositionSourceDevice();
 
    KoID depthId;
    const KoColorSpace *destCs = dev->colorSpace();
 
    if (destCs->colorDepthId() == Integer8BitsColorDepthID) {
        depthId = Integer16BitsColorDepthID;
    } else {
        depthId = destCs->colorDepthId();
    }
 
    const KoColorSpace *mixCs = KoColorSpaceRegistry::instance()->colorSpace(destCs->colorModelId().id(), depthId.id(), destCs->profile());
    const quint32 mixPixelSize = mixCs->pixelSize();
 
    KisPaintDeviceSP tmp(new KisPaintDevice(mixCs));
    tmp->setDefaultBounds(dev->defaultBounds());
    tmp->clear();
 
    const KisDitherOp* op = mixCs->ditherOp(destCs->colorDepthId().id(), dither == DitherBlueNoise ? DITHER_BEST : DITHER_NONE);
 
    Q_FOREACH (const Private::ProcessRegion &r, m_d->processRegions) {
        QRect processRect = r.processRect;
        QSharedPointer<KisGradientShapeStrategy> shapeStrategy = r.precalculatedShapeStrategy;
 
        KoCachedGradient cachedGradient(gradient(), qMax(processRect.width(), processRect.height()), mixCs);
 
        KisSequentialIteratorProgress it(tmp, processRect, progressUpdater());
 
        paintPolicy.setup(gradientVectorStart,
                          gradientVectorEnd,
                          shapeStrategy,
                          repeatStrategy,
                          antiAliasThreshold,
                          reverseGradient,
                          &cachedGradient);
 
        while (it.nextPixel()) {
            const quint8 *const pixel {paintPolicy.colorAt(it.x(), it.y())};
            memcpy(it.rawData(), pixel, mixPixelSize);
        }
 
        KisRandomAccessorSP dstIt = dev->createRandomAccessorNG();
        KisRandomConstAccessorSP srcIt = tmp->createRandomConstAccessorNG();
 
        int rows = 1;
        int columns = 1;
 
        for (int y = processRect.y(); y <= processRect.bottom(); y += rows) {
            rows = qMin(srcIt->numContiguousRows(y), qMin(dstIt->numContiguousRows(y), processRect.bottom() - y + 1));
 
            for (int x = processRect.x(); x <= processRect.right(); x += columns) {
                columns = qMin(srcIt->numContiguousColumns(x), qMin(dstIt->numContiguousColumns(x), processRect.right() - x + 1));
 
                srcIt->moveTo(x, y);
                dstIt->moveTo(x, y);
 
                const qint32 srcRowStride = srcIt->rowStride(x, y);
                const qint32 dstRowStride = dstIt->rowStride(x, y);
                const quint8 *srcPtr = srcIt->rawDataConst();
                quint8 *dstPtr = dstIt->rawData();
 
                op->dither(srcPtr, srcRowStride, dstPtr, dstRowStride, x, y, columns, rows);
            }
        }
    }
 
    bitBlt(requestedRect.topLeft(), dev, requestedRect);
 
    return true;
}

References KisPainter::bitBlt(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), KisPaintDevice::createCompositionSourceDevice(), KisPaintDevice::createRandomAccessorNG(), KisPaintDevice::defaultBounds(), KisPainter::device, KisDitherOp::dither(), DITHER_BEST, DITHER_NONE, DitherBlueNoise, KoColorSpace::ditherOp(), KisPainter::gradient, GradientRepeatAlternate, GradientRepeatForwards, GradientRepeatNone, GradientShapeBiLinear, GradientShapeConical, GradientShapeConicalSymetric, GradientShapeLinear, GradientShapePolygonal, GradientShapeRadial, GradientShapeReverseSpiral, GradientShapeSpiral, GradientShapeSquare, KoID::id(), KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, isBayerDither(), m_d, KisRandomConstAccessorNG::moveTo(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KoColorSpace::pixelSize(), precalculateShape(), KoColorSpace::profile(), KisPainter::progressUpdater, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisBaseAccessor::rawData(), KisBaseConstAccessor::rawDataConst(), KisRandomConstAccessorNG::rowStride(), KisSelection::selectedExactRect(), KisPainter::selection, toQShared(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

◆ paintGradient() [3/3]

bool KisGradientPainter::paintGradient	(	const QPointF &	gradientVectorStart,
		const QPointF &	gradientVectorEnd,
		enumGradientRepeat	repeat,
		double	antiAliasThreshold,
		bool	reverseGradient,
		qint32	startx,
		qint32	starty,
		qint32	width,
		qint32	height,
		enumDither	dither = DitherNone,
		int	ditherSteps = defaultDitherSteps )

Paint a gradient in the rect between startx, starty, width and height.

Definition at line 1142 of file kis_gradient_painter.cc.

{
    return paintGradient(gradientVectorStart,
                         gradientVectorEnd,
                         repeat,
                         antiAliasThreshold,
                         reverseGradient,
                         QRect(startx, starty, width, height),
                         dither,
                         ditherSteps);
}

References paintGradient().

◆ precalculateShape()

void KisGradientPainter::precalculateShape ( )

TODO: make this call happen asynchronously when the user does nothing

Definition at line 1108 of file kis_gradient_painter.cc.

{
    if (!m_d->processRegions.isEmpty()) return;
 
    QPainterPath path;
 
    if (selection()) {
        if (!selection()->outlineCacheValid()) {
            selection()->recalculateOutlineCache();
        }
 
        KIS_ASSERT_RECOVER_RETURN(selection()->outlineCacheValid());
        KIS_ASSERT_RECOVER_RETURN(!selection()->outlineCache().isEmpty());
 
        path = selection()->outlineCache();
    } else {
        path.addRect(device()->defaultBounds()->bounds());
    }
 
    QList<QPainterPath> splitPaths = KritaUtils::splitDisjointPaths(path);
 
    Q_FOREACH (const QPainterPath &subpath, splitPaths) {
        QRect boundingRect = subpath.boundingRect().toAlignedRect();
 
        if (boundingRect.width() < 3 || boundingRect.height() < 3) {
            boundingRect = kisGrowRect(boundingRect, 2);
        }
 
        Private::ProcessRegion r(toQShared(createPolygonShapeStrategy(subpath, boundingRect)),
                                 boundingRect);
        m_d->processRegions << r;
    }
}

References bounds, createPolygonShapeStrategy(), KisPainter::device, KIS_ASSERT_RECOVER_RETURN, kisGrowRect(), m_d, KisSelection::outlineCache(), KisSelection::recalculateOutlineCache(), KisPainter::selection, KritaUtils::splitDisjointPaths(), and toQShared().

◆ setGradientShape()

void KisGradientPainter::setGradientShape ( enumGradientShape shape )

Definition at line 1084 of file kis_gradient_painter.cc.

{
    m_d->shape = shape;
}

References m_d, and shape.

Member Data Documentation

◆ defaultDitherSteps

constexpr int KisGradientPainter::defaultDitherSteps = 2

staticconstexpr

Definition at line 60 of file kis_gradient_painter.h.

◆ m_d

const QScopedPointer<Private> KisGradientPainter::m_d

private

Definition at line 106 of file kis_gradient_painter.h.

◆ processRegions

QVector<ProcessRegion> KisGradientPainter::processRegions

Definition at line 1060 of file kis_gradient_painter.cc.

◆ shape

enumGradientShape KisGradientPainter::shape

Definition at line 1047 of file kis_gradient_painter.cc.

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

libs/image/kis_gradient_painter.cc
libs/image/kis_gradient_painter.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Attributes

Additional Inherited Members