#include <kis_painter.h>

Inheritance diagram for KisPainter:

Public Types
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
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)

Static Public Member Functions
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
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

Protected Member Functions
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
template<bool useOldSrcData>
void	bitBltImpl (qint32 dstX, qint32 dstY, const KisPaintDeviceSP srcDev, qint32 srcX, qint32 srcY, qint32 srcWidth, qint32 srcHeight)

void	compositeOnePixel (quint8 *dst, const KoColor &color)

float	frac (float value)

float	invertFrac (float value)

	KisPainter (const KisPainter &)

KisPainter &	operator= (const KisPainter &)

Private Attributes
Private *const	d

Detailed Description

KisPainter contains the graphics primitives necessary to draw on a KisPaintDevice. This is the same kind of abstraction as used in Qt itself, where you have QPainter and QPaintDevice.

However, KisPainter works on a tiled image and supports different color models, and that's a lot more complicated.

KisPainter supports transactions that can group various paint operations in one undoable step.

For more complex operations, you might want to have a look at the subclasses of KisPainter: KisConvolutionPainter, KisFillPainter and KisGradientPainter

KisPainter sets a number of default values, like COMPOSITE_OVER for compositeop, OPACITY_OPAQUE for opacity and no selection for selection.

Definition at line 65 of file kis_painter.h.

Member Enumeration Documentation

◆ FillStyle

enum KisPainter::FillStyle

This enum contains the styles with which we can fill things like polygons and ellipses.

Enumerator
FillStyleNone
FillStyleForegroundColor
FillStyleBackgroundColor
FillStylePattern
FillStyleGenerator

Definition at line 718 of file kis_painter.h.

                   {
        FillStyleNone,
        FillStyleForegroundColor,
        FillStyleBackgroundColor,
        FillStylePattern,
        FillStyleGenerator
    };

◆ StrokeStyle

enum KisPainter::StrokeStyle

The style of the brush stroke around polygons and so.

Enumerator
StrokeStyleNone
StrokeStyleBrush

Definition at line 745 of file kis_painter.h.

                     {
        StrokeStyleNone,
        StrokeStyleBrush
    };

Constructor & Destructor Documentation

◆ KisPainter() [1/4]

KisPainter::KisPainter ( )

Construct painter without a device.

Definition at line 61 of file kis_painter.cc.

    : d(new Private(this))
{
    init();
}

References init().

◆ KisPainter() [2/4]

KisPainter::KisPainter ( KisPaintDeviceSP device )

Construct a painter, and begin painting on the device.

Definition at line 67 of file kis_painter.cc.

    : d(new Private(this, device->colorSpace()))
{
    init();
    Q_ASSERT(device);
    begin(device);
}

References begin(), device, and init().

◆ KisPainter() [3/4]

KisPainter::KisPainter	(	KisPaintDeviceSP	device,
		KisSelectionSP	selection )

Construct a painter, and begin painting on the device. All actions will be masked by the given selection.

Definition at line 75 of file kis_painter.cc.

    : d(new Private(this, device->colorSpace()))
{
    init();
    Q_ASSERT(device);
    begin(device);
    d->selection = selection;
}

References begin(), d, device, init(), and selection.

◆ ~KisPainter()

KisPainter::~KisPainter ( )

virtual

Definition at line 92 of file kis_painter.cc.

{
    // TODO: Maybe, don't be that strict?
    // deleteTransaction();
    end();
 
    delete d->paintOp;
    delete d->maskPainter;
    delete d->fillPainter;
    delete d;
}

References d, and end().

◆ KisPainter() [4/4]

KisPainter::KisPainter ( const KisPainter & )

private

Member Function Documentation

◆ addDirtyRect()

void KisPainter::addDirtyRect ( const QRect & r )

Add r to the current set of dirty rects

Definition at line 409 of file kis_painter.cc.

{
    QRect r = rc.normalized();
    if (r.isValid()) {
        d->dirtyRects.append(rc);
    }
}

References d.

◆ addDirtyRects()

void KisPainter::addDirtyRects ( const QVector< QRect > & rects )

Add rects to the current set of dirty rects

Definition at line 417 of file kis_painter.cc.

{
    d->dirtyRects.reserve(d->dirtyRects.size() + rects.size());
 
    Q_FOREACH (const QRect &rc, rects) {
        const QRect r = rc.normalized();
        if (r.isValid()) {
            d->dirtyRects.append(rc);
        }
    }
}

References d.

◆ antiAliasPolygonFill()

bool KisPainter::antiAliasPolygonFill ( )

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

◆ applyDevice()

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

◆ applyDeviceWithSelection()

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

◆ backgroundColor()

const KoColor & KisPainter::backgroundColor ( ) const

Returns the current background color.

◆ begin() [1/2]

void KisPainter::begin ( KisPaintDeviceSP device )

Start painting on the specified device. Not undoable.

Definition at line 291 of file kis_painter.cc.

{
    begin(device, d->selection);
}

References begin(), d, and device.

◆ begin() [2/2]

void KisPainter::begin	(	KisPaintDeviceSP	device,
		KisSelectionSP	selection )

Start painting on the specified paint device. All actions will be masked by the given selection.

Definition at line 296 of file kis_painter.cc.

{
    if (!device) return;
    d->selection = selection;
    Q_ASSERT(device->colorSpace());
 
    end();
 
    d->device = device;
    d->colorSpace = device->colorSpace();
    d->compositeOpId = COMPOSITE_OVER;
    d->cachedCompositeOp = nullptr;
    d->pixelSize = device->pixelSize();
}

References KisPaintDevice::colorSpace(), COMPOSITE_OVER, d, device, end(), KisPaintDevice::pixelSize(), and selection.

◆ beginTransaction()

void KisPainter::beginTransaction	(	const KUndo2MagicString &	transactionName = KUndo2MagicString(),
		int	timedID = -1 )

Begin an undoable paint operation.

Definition at line 318 of file kis_painter.cc.

{
    Q_ASSERT_X(!d->transaction, "KisPainter::beginTransaction()",
               "You asked for a new transaction while still having "
               "another one. Please finish the first one with "
               "end/deleteTransaction() first");
 
    d->transaction = new KisTransaction(transactionName, d->device);
    Q_CHECK_PTR(d->transaction);
    d->transaction->undoCommand()->setTimedID(timedID);
}

References d.

◆ bitBlt() [1/2]

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

Convenience method that uses QPoint and QRect.

Parameters

pos	the destination coordinate, it replaces `dstX` and `dstY`.
srcDev	the source device.
srcRect	the rectangle describing the area to blast from `srcDev` into the current paint device. `srcRect` replaces `srcX`, `srcY`, `srcWidth` and `srcHeight`.

Definition at line 831 of file kis_painter.cc.

{
    bitBlt(pos.x(), pos.y(), srcDev, srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height());
}

References bitBlt().

◆ bitBlt() [2/2]

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

Blast a region of srcWidth

Parameters

srcWidth	and srcHeight
srcHeight	from
srcDev	onto the current paint device.
srcX	and
srcY	set the x and y positions of the origin top-left corner,
dstX	and
dstY	those of the destination. Any pixel read outside the limits of
srcDev	will return the default pixel, this is a property of KisPaintDevice.
dstX	the destination x-coordinate
dstY	the destination y-coordinate
srcDev	the source device
srcX	the source x-coordinate
srcY	the source y-coordinate
srcWidth	the width of the region to be manipulated
srcHeight	the height of the region to be manipulated

Definition at line 822 of file kis_painter.cc.

{
    bitBltImpl<false>(dstX, dstY, srcDev, srcX, srcY, srcWidth, srcHeight);
}

◆ bitBltImpl()

template<bool useOldSrcData>

void KisPainter::bitBltImpl	(	qint32	dstX,
		qint32	dstY,
		const KisPaintDeviceSP	srcDev,
		qint32	srcX,
		qint32	srcY,
		qint32	srcWidth,
		qint32	srcHeight )

private

An optimization, which crops the source rect by the bounds of the source device when it is possible

Definition at line 658 of file kis_painter.cc.

{
    /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
    initializing they perform some dummy passes with those parameters, and it must not crash */
    if (srcWidth == 0 || srcHeight == 0) return;
    if (srcDev.isNull()) return;
    if (d->device.isNull()) return;
 
    QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
 
    if (d->compositeOpId == COMPOSITE_COPY) {
        if(!d->selection && d->isOpacityUnit &&
           srcX == dstX && srcY == dstY &&
           d->device->fastBitBltPossible(srcDev) &&
           (!srcDev->defaultBounds()->wrapAroundMode() ||
            srcDev->defaultBounds()->imageBorderRect().contains(srcRect))) {
 
            if(useOldSrcData) {
                d->device->fastBitBltOldData(srcDev, srcRect);
            } else {
                d->device->fastBitBlt(srcDev, srcRect);
            }
 
            addDirtyRect(srcRect);
            return;
        }
    }
    else {
        if (d->tryReduceSourceRect(srcDev, &srcRect,
                                   &srcX, &srcY,
                                   &srcWidth, &srcHeight,
                                   &dstX, &dstY)) return;
    }
 
    qint32 dstY_ = dstY;
    qint32 srcY_ = srcY;
    qint32 rowsRemaining = srcHeight;
 
    const KoCompositeOp *compositeOp = d->compositeOp(srcDev->colorSpace());
 
    // Read below
    KisRandomConstAccessorSP srcIt = srcDev->createRandomConstAccessorNG();
    KisRandomAccessorSP dstIt = d->device->createRandomAccessorNG();
 
    /* Here be a huge block of verbose code that does roughly the same than
    the other bit blit operations. This one is longer than the rest in an effort to
    optimize speed and memory use */
    if (d->selection) {
        KisPaintDeviceSP selectionProjection(d->selection->projection());
        KisRandomConstAccessorSP maskIt = selectionProjection->createRandomConstAccessorNG();
 
        while (rowsRemaining > 0) {
 
            qint32 dstX_ = dstX;
            qint32 srcX_ = srcX;
            qint32 columnsRemaining = srcWidth;
            qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY_);
            qint32 numContiguousSrcRows = srcIt->numContiguousRows(srcY_);
            qint32 numContiguousSelRows = maskIt->numContiguousRows(dstY_);
 
            qint32 rows = qMin(numContiguousDstRows, numContiguousSrcRows);
            rows = qMin(rows, numContiguousSelRows);
            rows = qMin(rows, rowsRemaining);
 
            while (columnsRemaining > 0) {
 
                qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX_);
                qint32 numContiguousSrcColumns = srcIt->numContiguousColumns(srcX_);
                qint32 numContiguousSelColumns = maskIt->numContiguousColumns(dstX_);
 
                qint32 columns = qMin(numContiguousDstColumns, numContiguousSrcColumns);
                columns = qMin(columns, numContiguousSelColumns);
                columns = qMin(columns, columnsRemaining);
 
                qint32 srcRowStride = srcIt->rowStride(srcX_, srcY_);
                srcIt->moveTo(srcX_, srcY_);
 
                qint32 dstRowStride = dstIt->rowStride(dstX_, dstY_);
                dstIt->moveTo(dstX_, dstY_);
 
                qint32 maskRowStride = maskIt->rowStride(dstX_, dstY_);
                maskIt->moveTo(dstX_, dstY_);
 
                d->paramInfo.dstRowStart   = dstIt->rawData();
                d->paramInfo.dstRowStride  = dstRowStride;
                // if we don't use the oldRawData, we need to access the rawData of the source device.
                d->paramInfo.srcRowStart   = useOldSrcData ? srcIt->oldRawData() : static_cast<KisRandomAccessor2*>(srcIt.data())->rawData();
                d->paramInfo.srcRowStride  = srcRowStride;
                d->paramInfo.maskRowStart  = static_cast<KisRandomAccessor2*>(maskIt.data())->rawData();
                d->paramInfo.maskRowStride = maskRowStride;
                d->paramInfo.rows          = rows;
                d->paramInfo.cols          = columns;
                d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
 
                srcX_ += columns;
                dstX_ += columns;
                columnsRemaining -= columns;
            }
 
            srcY_ += rows;
            dstY_ += rows;
            rowsRemaining -= rows;
        }
    }
    else {
 
        while (rowsRemaining > 0) {
 
            qint32 dstX_ = dstX;
            qint32 srcX_ = srcX;
            qint32 columnsRemaining = srcWidth;
            qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY_);
            qint32 numContiguousSrcRows = srcIt->numContiguousRows(srcY_);
 
            qint32 rows = qMin(numContiguousDstRows, numContiguousSrcRows);
            rows = qMin(rows, rowsRemaining);
 
            while (columnsRemaining > 0) {
 
                qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX_);
                qint32 numContiguousSrcColumns = srcIt->numContiguousColumns(srcX_);
 
                qint32 columns = qMin(numContiguousDstColumns, numContiguousSrcColumns);
                columns = qMin(columns, columnsRemaining);
 
                qint32 srcRowStride = srcIt->rowStride(srcX_, srcY_);
                srcIt->moveTo(srcX_, srcY_);
 
                qint32 dstRowStride = dstIt->rowStride(dstX_, dstY_);
                dstIt->moveTo(dstX_, dstY_);
 
                d->paramInfo.dstRowStart   = dstIt->rawData();
                d->paramInfo.dstRowStride  = dstRowStride;
                // if we don't use the oldRawData, we need to access the rawData of the source device.
                d->paramInfo.srcRowStart   = useOldSrcData ? srcIt->oldRawData() : static_cast<KisRandomAccessor2*>(srcIt.data())->rawData();
                d->paramInfo.srcRowStride  = srcRowStride;
                d->paramInfo.maskRowStart  = 0;
                d->paramInfo.maskRowStride = 0;
                d->paramInfo.rows          = rows;
                d->paramInfo.cols          = columns;
                d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
 
                srcX_ += columns;
                dstX_ += columns;
                columnsRemaining -= columns;
            }
 
            srcY_ += rows;
            dstY_ += rows;
            rowsRemaining -= rows;
        }
    }
 
    addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
 
}

References addDirtyRect(), KisPaintDevice::colorSpace(), COMPOSITE_COPY, compositeOp(), KisPaintDevice::createRandomConstAccessorNG(), d, KisSharedPtr< T >::data(), KisPaintDevice::defaultBounds(), KisDefaultBoundsBase::imageBorderRect(), KisSharedPtr< T >::isNull(), KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KisBaseConstAccessor::oldRawData(), KisBaseAccessor::rawData(), KisRandomConstAccessorNG::rowStride(), and KisDefaultBoundsBase::wrapAroundMode().

◆ bitBltOldData() [1/2]

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

Convenience method that uses QPoint and QRect.

Parameters

pos	the destination coordinate, it replaces `dstX` and `dstY`.
srcDev	the source device.
srcRect	the rectangle describing the area to blast from
srcDev	into the current paint device. `srcRect` replaces `srcX`, `srcY`, `srcWidth` and `srcHeight`.

Definition at line 845 of file kis_painter.cc.

{
    bitBltOldData(pos.x(), pos.y(), srcDev, srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height());
}

References bitBltOldData().

◆ bitBltOldData() [2/2]

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

The same as bitBlt() but reads data from oldData() part of the device

Parameters

dstX	the destination x-coordinate
dstY	the destination y-coordinate
srcDev	the source device
srcX	the source x-coordinate
srcY	the source y-coordinate
srcWidth	the width of the region to be manipulated
srcHeight	the height of the region to be manipulated

Definition at line 836 of file kis_painter.cc.

{
    bitBltImpl<true>(dstX, dstY, srcDev, srcX, srcY, srcWidth, srcHeight);
}

◆ bitBltWithFixedSelection() [1/2]

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

Blasts a

Parameters

selection	of srcWidth
srcWidth	and srcHeight
srcHeight	of
srcDev	on the current paint device. There is parameters to control where the area begins in each distinct device, explained below.
selection	can be used as a mask to shape
srcDev	to something interesting in the same step it is rendered to the current paint device.
selection	's colorspace must be alpha8 (the colorspace for selections/transparency), the rectangle formed by
selX

param selY ,

Parameters

srcWidth	and
srcHeight	must not go beyond its limits, and they must be different from zero.
selection	and KisPainter's selection (the user selection) are fused together through the composite operation COMPOSITE_MULT. Any pixel read outside the limits of
srcDev	will return the default pixel, this is a property of KisPaintDevice.
dstX	the destination x-coordinate
dstY	the destination y-coordinate
srcDev	the source device
selection	the custom selection to apply on the source device
selX	the selection x-coordinate
selY	the selection y-coordinate
srcX	the source x-coordinate
srcY	the source y-coordinate
srcWidth	the width of the region to be manipulated
srcHeight	the height of the region to be manipulated

An optimization, which crops the source rect by the bounds of the source device when it is possible

Definition at line 510 of file kis_painter.cc.

{
    // TODO: get selX and selY working as intended
 
    /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
    initializing they perform some dummy passes with those parameters, and it must not crash */
    if (srcWidth == 0 || srcHeight == 0) return;
    if (srcDev.isNull()) return;
    if (d->device.isNull()) return;
 
    // Check that selection has an alpha colorspace, crash if false
    Q_ASSERT(selection->colorSpace() == KoColorSpaceRegistry::instance()->alpha8());
 
    const KoCompositeOp *compositeOp = d->compositeOp(srcDev->colorSpace());
 
    QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
 
    // save selection offset in case tryReduceSourceRect() will change rects
    const int xSelectionOffset = selX - srcX;
    const int ySelectionOffset = selY - srcY;
 
    if (d->tryReduceSourceRect(srcDev, &srcRect,
                               &srcX, &srcY,
                               &srcWidth, &srcHeight,
                               &dstX, &dstY)) return;
 
    const QRect selRect = QRect(srcX + xSelectionOffset,
                                srcY + ySelectionOffset,
                                srcWidth, srcHeight);
 
    /* Trying to read outside a KisFixedPaintDevice is inherently wrong and shouldn't be done,
    so crash if someone attempts to do this. Don't resize YET as it would obfuscate the mistake. */
    KIS_SAFE_ASSERT_RECOVER_RETURN(selection->bounds().contains(selRect));
    Q_UNUSED(selRect); // only used by the above Q_ASSERT
 
 
    /* Create an intermediate byte array to hold information before it is written
    to the current paint device (d->device) */
    quint8* dstBytes = 0;
    try {
        dstBytes = new quint8[srcWidth * srcHeight * d->device->pixelSize()];
    } catch (const std::bad_alloc&) {
        warnKrita << "KisPainter::bitBltWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "dst bytes";
        return;
    }
 
    d->device->readBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
    // Copy the relevant bytes of raw data from srcDev
    quint8* srcBytes = 0;
    try {
        srcBytes = new quint8[srcWidth * srcHeight * srcDev->pixelSize()];
    } catch (const std::bad_alloc&) {
        warnKrita << "KisPainter::bitBltWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "src bytes";
        return;
    }
 
    srcDev->readBytes(srcBytes, srcX, srcY, srcWidth, srcHeight);
 
    const QRect selBounds = selection->bounds();
    const quint8 *selRowStart = selection->data() +
        (selBounds.width() * (selRect.y() - selBounds.top()) + (selRect.x() - selBounds.left())) * selection->pixelSize();
 
    /*
     * This checks whether there is nothing selected.
     */
    if (!d->selection) {
        /* As there's nothing selected, blit to dstBytes (intermediary bit array),
          ignoring d->selection (the user selection)*/
        d->paramInfo.dstRowStart   = dstBytes;
        d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
        d->paramInfo.srcRowStart   = srcBytes;
        d->paramInfo.srcRowStride  = srcWidth * srcDev->pixelSize();
        d->paramInfo.maskRowStart  = selRowStart;
        d->paramInfo.maskRowStride = selBounds.width() * selection->pixelSize();
        d->paramInfo.rows          = srcHeight;
        d->paramInfo.cols          = srcWidth;
        d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
    }
    else {
        /* Read the user selection (d->selection) bytes into an array, ready
        to merge in the next block*/
        quint32 totalBytes = srcWidth * srcHeight * selection->pixelSize();
        quint8* mergedSelectionBytes = 0;
        try {
            mergedSelectionBytes = new quint8[ totalBytes ];
        } catch (const std::bad_alloc&) {
            warnKrita << "KisPainter::bitBltWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "total bytes";
            return;
        }
 
        d->selection->projection()->readBytes(mergedSelectionBytes, dstX, dstY, srcWidth, srcHeight);
 
        KoCompositeOp::ParameterInfo multiplyParamInfo;
        multiplyParamInfo.opacity = 1.0f;
        multiplyParamInfo.flow = 1.0f;
 
        // Merge selections here by multiplying them - compositeOP(COMPOSITE_MULT)
        multiplyParamInfo.dstRowStart   = mergedSelectionBytes;
        multiplyParamInfo.dstRowStride  = srcWidth * selection->pixelSize();
        multiplyParamInfo.srcRowStart   = selRowStart;
        multiplyParamInfo.srcRowStride  = selBounds.width() * selection->pixelSize();
        multiplyParamInfo.maskRowStart  = 0;
        multiplyParamInfo.maskRowStride = 0;
        multiplyParamInfo.rows          = srcHeight;
        multiplyParamInfo.cols          = srcWidth;
        KoColorSpaceRegistry::instance()->alpha8()->compositeOp(COMPOSITE_MULT)->composite(multiplyParamInfo);
 
        // Blit to dstBytes (intermediary bit array)
        d->paramInfo.dstRowStart   = dstBytes;
        d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
        d->paramInfo.srcRowStart   = srcBytes;
        d->paramInfo.srcRowStride  = srcWidth * srcDev->pixelSize();
        d->paramInfo.maskRowStart  = mergedSelectionBytes;
        d->paramInfo.maskRowStride = srcWidth * selection->pixelSize();
        d->paramInfo.rows          = srcHeight;
        d->paramInfo.cols          = srcWidth;
        d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
        delete[] mergedSelectionBytes;
    }
 
    d->device->writeBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
    delete[] dstBytes;
    delete[] srcBytes;
 
    addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
}

◆ bitBltWithFixedSelection() [2/2]

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

Convenience method that assumes selX, selY, srcX and srcY are equal to 0. Best used when selection and the desired area of srcDev have exactly the same dimensions and are specially made for each other.

Parameters

dstX	the destination x-coordinate
dstY	the destination y-coordinate
srcDev	the source device
selection	the custom selection to apply on the source device
srcWidth	the width of the region to be manipulated
srcHeight	the height of the region to be manipulated

Definition at line 649 of file kis_painter.cc.

{
    bitBltWithFixedSelection(dstX, dstY, srcDev, selection, 0, 0, 0, 0, srcWidth, srcHeight);
}

References bitBltWithFixedSelection(), and selection.

◆ blendAverageOpacity()

qreal KisPainter::blendAverageOpacity	(	qreal	opacity,
		qreal	averageOpacity )

static

Calculate average opacity value after painting a single dab with opacity

Definition at line 2698 of file kis_painter.cc.

{
    const float exponent = 0.1;
 
    return averageOpacity < opacity ?
        opacity :
        exponent * opacity + (1.0 - exponent) * (averageOpacity);
}

◆ bltFixed() [1/3]

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

Convenience method that uses QPoint and QRect.

Parameters

pos	the destination coordinate, it replaces `dstX` and `dstY`.
srcDev	the source device.
srcRect	the rectangle describing the area to blast from `srcDev` into the current paint device.
srcRect	replaces `srcX`, `srcY`, `srcWidth` and `srcHeight`.

Definition at line 1022 of file kis_painter.cc.

{
    bltFixed(pos.x(), pos.y(), srcDev, srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height());
}

References bltFixed().

◆ bltFixed() [2/3]

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

Render the area rc from srcDevices on the destination device. If rc doesn't cross the device's rect, then the device is not rendered at all.

Definition at line 138 of file kis_painter_blt_multi_fixed.cpp.

{
    const KoColorSpace *srcColorSpace = 0;
    QList<KisRenderedDab> devices;
    QRect rc = applyRect;
 
    if (d->selection) {
        rc &= d->selection->selectedRect();
    }
 
    QRect totalDevicesRect;
 
    Q_FOREACH (const KisRenderedDab &dab, allSrcDevices) {
        if (rc.intersects(dab.realBounds())) {
            devices.append(dab);
            totalDevicesRect |= dab.realBounds();
        }
 
        if (!srcColorSpace) {
            srcColorSpace = dab.device->colorSpace();
        } else {
            KIS_SAFE_ASSERT_RECOVER_RETURN(*srcColorSpace == *dab.device->colorSpace());
        }
    }
 
    rc &= totalDevicesRect;
 
    if (devices.isEmpty() || rc.isEmpty()) return;
 
    KoCompositeOp::ParameterInfo localParamInfo = d->paramInfo;
    KisRandomAccessorSP dstIt = d->device->createRandomAccessorNG();
    KisRandomConstAccessorSP maskIt = d->selection ? d->selection->projection()->createRandomConstAccessorNG() : 0;
 
    if (maskIt) {
        Q_FOREACH (const KisRenderedDab &dab, devices) {
            d->applyDeviceWithSelection(rc, dab, dstIt, maskIt, srcColorSpace, localParamInfo);
        }
    } else {
        Q_FOREACH (const KisRenderedDab &dab, devices) {
            d->applyDevice(rc, dab, dstIt, srcColorSpace, localParamInfo);
        }
    }
 
 
#if 0
    // the code above does basically the same thing as this one,
    // but more efficiently :)
 
    Q_FOREACH (KisFixedPaintDeviceSP dev, devices) {
        const QRect copyRect = dev->bounds() & rc;
        if (copyRect.isEmpty()) continue;
 
        bltFixed(copyRect.topLeft(), dev, copyRect);
    }
#endif
}

References bltFixed(), KisFixedPaintDevice::bounds(), KisFixedPaintDevice::colorSpace(), d, KisRenderedDab::device, KIS_SAFE_ASSERT_RECOVER_RETURN, and KisRenderedDab::realBounds().

◆ bltFixed() [3/3]

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

Blast a region of srcWidth srcWidth and srcHeight srcHeight from srcDev onto the current paint device. srcX and srcY set the x and y positions of the origin top-left corner, dstX and dstY those of the destination. srcDev is a KisFixedPaintDevice : this means that srcDev must have the same colorspace as the destination device.

Parameters

dstX	the destination x-coordinate
dstY	the destination y-coordinate
srcDev	the source device
srcX	the source x-coordinate
srcY	the source y-coordinate
srcWidth	the width of the region to be manipulated
srcHeight	the height of the region to be manipulated

Definition at line 950 of file kis_painter.cc.

{
    /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
    initializing they perform some dummy passes with those parameters, and it must not crash */
    if (srcWidth == 0 || srcHeight == 0) return;
    if (srcDev.isNull()) return;
    if (d->device.isNull()) return;
 
    QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
    QRect srcBounds = srcDev->bounds();
 
    /* Trying to read outside a KisFixedPaintDevice is inherently wrong and shouldn't be done,
    so crash if someone attempts to do this. Don't resize as it would obfuscate the mistake. */
    KIS_SAFE_ASSERT_RECOVER_RETURN(srcBounds.contains(srcRect));
    Q_UNUSED(srcRect); // only used in above assertion
 
    const KoCompositeOp *compositeOp = d->compositeOp(srcDev->colorSpace());
 
    /* Create an intermediate byte array to hold information before it is written
    to the current paint device (aka: d->device) */
    quint8* dstBytes = 0;
    try {
         dstBytes = new quint8[srcWidth * srcHeight * d->device->pixelSize()];
    } catch (const std::bad_alloc&) {
        warnKrita << "KisPainter::bltFixed std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "total bytes";
        return;
    }
    d->device->readBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
    const quint8 *srcRowStart = srcDev->data() +
        (srcBounds.width() * (srcY - srcBounds.top()) + (srcX - srcBounds.left())) * srcDev->pixelSize();
 
    d->paramInfo.dstRowStart   = dstBytes;
    d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
    d->paramInfo.srcRowStart   = srcRowStart;
    d->paramInfo.srcRowStride  = srcBounds.width() * srcDev->pixelSize();
    d->paramInfo.maskRowStart  = 0;
    d->paramInfo.maskRowStride = 0;
    d->paramInfo.rows          = srcHeight;
    d->paramInfo.cols          = srcWidth;
 
    if (d->selection) {
        /* d->selection is a KisPaintDevice, so first a readBytes is performed to
        get the area of interest... */
        KisPaintDeviceSP selectionProjection(d->selection->projection());
        quint8* selBytes = 0;
        try {
            selBytes = new quint8[srcWidth * srcHeight * selectionProjection->pixelSize()];
        }
        catch (const std::bad_alloc&) {
            delete[] dstBytes;
            return;
        }
 
        selectionProjection->readBytes(selBytes, dstX, dstY, srcWidth, srcHeight);
        d->paramInfo.maskRowStart = selBytes;
        d->paramInfo.maskRowStride = srcWidth * selectionProjection->pixelSize();
    }
 
    // ...and then blit.
    d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
    d->device->writeBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
    delete[] d->paramInfo.maskRowStart;
    delete[] dstBytes;
 
    addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
}

References addDirtyRect(), KisFixedPaintDevice::bounds(), KisFixedPaintDevice::colorSpace(), compositeOp(), d, KisFixedPaintDevice::data(), KisSharedPtr< T >::isNull(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisFixedPaintDevice::pixelSize(), KisPaintDevice::pixelSize(), KisPaintDevice::readBytes(), and warnKrita.

◆ bltFixedWithFixedSelection() [1/2]

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

Blasts a selection of srcWidth srcWidth and srcHeight srcHeight of srcDev on the current paint device. There is parameters to control the top-left corner of the area in each respective paint device (dstX, dstY, srcX, srcY). selection can be used as a mask to shape srcDev to something interesting in the same step it is rendered to the current paint device. srcDev is a KisFixedPaintDevice : this means that srcDev must have the same colorspace as the destination device. selection 's colorspace must be alpha8 (the colorspace for selections/transparency). The rectangle formed by the respective top-left coordinates of each device and srcWidth and srcHeight must not go beyond their limits, and they must be different from zero. selection and KisPainter's selection (the user selection) are fused together through the composite operation COMPOSITE_MULT.

Parameters

dstX	the destination x-coordinate
dstY	the destination y-coordinate
srcDev	the source device
selection	the selection stored in fixed device
selX	the selection x-coordinate
selY	the selection y-coordinate
srcX	the source x-coordinate
srcY	the source y-coordinate
srcWidth	the width of the region to be manipulated
srcHeight	the height of the region to be manipulated

Definition at line 1027 of file kis_painter.cc.

{
    // TODO: get selX and selY working as intended
 
    /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
    initializing they perform some dummy passes with those parameters, and it must not crash */
    if (srcWidth == 0 || srcHeight == 0) return;
    if (srcDev.isNull()) return;
    if (d->device.isNull()) return;
 
     // Check that selection has an alpha colorspace, crash if false
    Q_ASSERT(selection->colorSpace() == KoColorSpaceRegistry::instance()->alpha8());
 
    const KoCompositeOp *compositeOp = d->compositeOp(srcDev->colorSpace());
 
    QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
    QRect selRect = QRect(selX, selY, srcWidth, srcHeight);
 
    QRect srcBounds = srcDev->bounds();
    QRect selBounds = selection->bounds();
 
    /* Trying to read outside a KisFixedPaintDevice is inherently wrong and shouldn't be done,
    so crash if someone attempts to do this. Don't resize as it would obfuscate the mistake. */
    KIS_ASSERT(srcBounds.contains(srcRect));
    Q_UNUSED(srcRect); // only used in above assertion
    KIS_ASSERT(selBounds.contains(selRect));
    Q_UNUSED(selRect); // only used in above assertion
 
    /* Create an intermediate byte array to hold information before it is written
    to the current paint device (aka: d->device) */
    quint8* dstBytes = 0;
    try {
        dstBytes = new quint8[srcWidth * srcHeight * d->device->pixelSize()];
    } catch (const std::bad_alloc&) {
        warnKrita << "KisPainter::bltFixedWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "total bytes";
        return;
    }
    d->device->readBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
    const quint8 *srcRowStart = srcDev->data() +
        (srcBounds.width() * (srcY - srcBounds.top()) + (srcX - srcBounds.left())) * srcDev->pixelSize();
    const quint8 *selRowStart = selection->data() +
        (selBounds.width() * (selY - selBounds.top()) + (selX - selBounds.left())) * selection->pixelSize();
 
    if (!d->selection) {
        /* As there's nothing selected, blit to dstBytes (intermediary bit array),
          ignoring d->selection (the user selection)*/
        d->paramInfo.dstRowStart   = dstBytes;
        d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
        d->paramInfo.srcRowStart   = srcRowStart;
        d->paramInfo.srcRowStride  = srcBounds.width() * srcDev->pixelSize();
        d->paramInfo.maskRowStart  = selRowStart;
        d->paramInfo.maskRowStride = selBounds.width() * selection->pixelSize();
        d->paramInfo.rows          = srcHeight;
        d->paramInfo.cols          = srcWidth;
        d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
    }
    else {
        /* Read the user selection (d->selection) bytes into an array, ready
        to merge in the next block*/
        quint32 totalBytes = srcWidth * srcHeight * selection->pixelSize();
        quint8 * mergedSelectionBytes = 0;
        try {
            mergedSelectionBytes = new quint8[ totalBytes ];
        } catch (const std::bad_alloc&) {
            warnKrita << "KisPainter::bltFixedWithFixedSelection std::bad_alloc for " << totalBytes << "total bytes";
            delete[] dstBytes;
            return;
        }
        d->selection->projection()->readBytes(mergedSelectionBytes, dstX, dstY, srcWidth, srcHeight);
 
        KoCompositeOp::ParameterInfo multiplyParamInfo;
        multiplyParamInfo.opacity = 1.0f;
        multiplyParamInfo.flow = 1.0f;
 
        // Merge selections here by multiplying them - compositeOp(COMPOSITE_MULT)
        multiplyParamInfo.dstRowStart   = mergedSelectionBytes;
        multiplyParamInfo.dstRowStride  = srcWidth * selection->pixelSize();
        multiplyParamInfo.srcRowStart   = selRowStart;
        multiplyParamInfo.srcRowStride  = selBounds.width() * selection->pixelSize();
        multiplyParamInfo.maskRowStart  = 0;
        multiplyParamInfo.maskRowStride = 0;
        multiplyParamInfo.rows          = srcHeight;
        multiplyParamInfo.cols          = srcWidth;
        KoColorSpaceRegistry::instance()->alpha8()->compositeOp(COMPOSITE_MULT)->composite(multiplyParamInfo);
 
        // Blit to dstBytes (intermediary bit array)
        d->paramInfo.dstRowStart   = dstBytes;
        d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
        d->paramInfo.srcRowStart   = srcRowStart;
        d->paramInfo.srcRowStride  = srcBounds.width() * srcDev->pixelSize();
        d->paramInfo.maskRowStart  = mergedSelectionBytes;
        d->paramInfo.maskRowStride = srcWidth * selection->pixelSize();
        d->paramInfo.rows          = srcHeight;
        d->paramInfo.cols          = srcWidth;
        d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
 
        delete[] mergedSelectionBytes;
    }
 
    d->device->writeBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
    delete[] dstBytes;
 
    addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
}

◆ bltFixedWithFixedSelection() [2/2]

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

Convenience method that assumes selX, selY, srcX and srcY are equal to 0. Best used when selection and srcDev have exactly the same dimensions and are specially made for each other.

Parameters

dstX	the destination x-coordinate
dstY	the destination y-coordinate
srcDev	the source device
selection	the custom selection to apply on the source device
srcWidth	the width of the region to be manipulated
srcHeight	the height of the region to be manipulated

Definition at line 1139 of file kis_painter.cc.

{
    bltFixedWithFixedSelection(dstX, dstY, srcDev, selection, selection->bounds().x(), selection->bounds().y(), srcDev->bounds().x(), srcDev->bounds().y(), srcWidth, srcHeight);
}

References bltFixedWithFixedSelection(), KisFixedPaintDevice::bounds(), selection, KisSelection::x(), and KisSelection::y().

◆ calculateAllMirroredPoints() [1/2]

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

Calculate the list of the mirrored point pairs according to the current mirroring configuration.

Definition at line 3150 of file kis_painter.cc.

{
    return d->calculateMirroredObjects(pair);
}

References d.

◆ calculateAllMirroredPoints() [2/2]

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

Calculate the list of the mirrored points according to the current mirroring configuration.

Definition at line 3145 of file kis_painter.cc.

{
    return d->calculateMirroredObjects(pos);
}

References d.

◆ calculateAllMirroredRects()

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

Calculate the list of the mirrored rects that will be painted on the the canvas when calling renderMirrorMask() at al

Definition at line 3140 of file kis_painter.cc.

{
    return d->calculateMirroredObjects(rc);
}

References d.

◆ calculateMirroredObjects()

template<class T >

QVector< T > KisPainter::calculateMirroredObjects ( const T & object )

◆ channelFlags()

QBitArray KisPainter::channelFlags ( )

Returns: the channel flags

Definition at line 2587 of file kis_painter.cc.

{
    return d->paramInfo.channelFlags;
}

References d.

◆ checkDeviceHasTransparency()

bool KisPainter::checkDeviceHasTransparency ( KisPaintDeviceSP dev )

static

Definition at line 268 of file kis_painter.cc.

{
    const QRect deviceBounds = dev->exactBounds();
    const QRect imageBounds = dev->defaultBounds()->bounds();
 
    if (deviceBounds.isEmpty() ||
        (deviceBounds & imageBounds) != imageBounds) {
 
        return true;
    }
 
    const KoColorSpace *cs = dev->colorSpace();
    KisSequentialConstIterator it(dev, deviceBounds);
 
    while(it.nextPixel()) {
        if (cs->opacityU8(it.rawDataConst()) != OPACITY_OPAQUE_U8) {
            return true;
        }
    }
 
    return false;
}

References KisDefaultBoundsBase::bounds(), KisPaintDevice::colorSpace(), KisPaintDevice::defaultBounds(), KisPaintDevice::exactBounds(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), OPACITY_OPAQUE_U8, KoColorSpace::opacityU8(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

◆ compositeOnePixel()

void KisPainter::compositeOnePixel	(	quint8 *	dst,
		const KoColor &	color )

inlineprivate

Definition at line 1636 of file kis_painter.cc.

{
    d->paramInfo.dstRowStart = dst;
    d->paramInfo.dstRowStride = 0;
    d->paramInfo.srcRowStart = color.data();
    d->paramInfo.srcRowStride = 0;
    d->paramInfo.maskRowStart = 0;
    d->paramInfo.maskRowStride = 0;
    d->paramInfo.rows = 1;
    d->paramInfo.cols = 1;
 
    d->colorSpace->bitBlt(color.colorSpace(), d->paramInfo, d->compositeOp(color.colorSpace()),
                          d->renderingIntent,
                          d->conversionFlags);
}

References KoColor::colorSpace(), d, and KoColor::data().

◆ compositeOp()

const KoCompositeOp * KisPainter::compositeOp ( const KoColorSpace * srcCS )

◆ compositeOpId()

QString KisPainter::compositeOpId ( )

Returns the current composite op Id.

◆ convertToAlphaAsAlpha()

KisPaintDeviceSP KisPainter::convertToAlphaAsAlpha ( KisPaintDeviceSP src )

static

Definition at line 202 of file kis_painter.cc.

{
    const KoColorSpace *srcCS = src->colorSpace();
    const QRect processRect = src->extent();
    KisPaintDeviceSP dst(new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8()));
 
    if (processRect.isEmpty()) return dst;
 
    KisSequentialConstIterator srcIt(src, processRect);
    KisSequentialIterator dstIt(dst, processRect);
 
    while (srcIt.nextPixel() && dstIt.nextPixel()) {
        const quint8 *srcPtr = srcIt.rawDataConst();
        quint8 *alpha8Ptr = dstIt.rawData();
 
        const quint8 white = srcCS->intensity8(srcPtr);
        const quint8 alpha = srcCS->opacityU8(srcPtr);
 
        *alpha8Ptr = KoColorSpaceMaths<quint8>::multiply(alpha, KoColorSpaceMathsTraits<quint8>::unitValue - white);
    }
 
    return dst;
}

References KoColorSpaceRegistry::instance(), KoColorSpace::intensity8(), KoColorSpaceMaths< _T, _Tdst >::multiply(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::opacityU8(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

◆ convertToAlphaAsGray()

KisPaintDeviceSP KisPainter::convertToAlphaAsGray ( KisPaintDeviceSP src )

static

Definition at line 226 of file kis_painter.cc.

{
    const KoColorSpace *srcCS = src->colorSpace();
    const QRect processRect = src->extent();
    KisPaintDeviceSP dst(new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8()));
 
    if (processRect.isEmpty()) return dst;
 
    KisSequentialConstIterator srcIt(src, processRect);
    KisSequentialIterator dstIt(dst, processRect);
 
    while (srcIt.nextPixel() && dstIt.nextPixel()) {
        const quint8 *srcPtr = srcIt.rawDataConst();
        quint8 *alpha8Ptr = dstIt.rawData();
 
        *alpha8Ptr = srcCS->intensity8(srcPtr);
    }
 
    return dst;
}

References KoColorSpaceRegistry::instance(), KoColorSpace::intensity8(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

◆ convertToAlphaAsPureAlpha()

KisPaintDeviceSP KisPainter::convertToAlphaAsPureAlpha ( KisPaintDeviceSP src )

static

creates a paint device with only alpha values from src

Definition at line 247 of file kis_painter.cc.

{
    const KoColorSpace *srcCS = src->colorSpace();
    const QRect processRect = src->extent();
    KisPaintDeviceSP dst(new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8()));
 
    if (processRect.isEmpty()) return dst;
 
    KisSequentialConstIterator srcIt(src, processRect);
    KisSequentialIterator dstIt(dst, processRect);
 
    while (srcIt.nextPixel() && dstIt.nextPixel()) {
        const quint8 *srcPtr = srcIt.rawDataConst();
        quint8 *alpha8Ptr = dstIt.rawData();
 
        *alpha8Ptr = srcCS->opacityU8(srcPtr);
    }
 
    return dst;
}

References KoColorSpaceRegistry::instance(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::opacityU8(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

◆ copyAreaOptimized() [1/2]

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

static

Definition at line 153 of file kis_painter.cc.

{
    copyAreaOptimizedImpl<false>(dstPt, src, dst, srcRect);
}

◆ copyAreaOptimized() [2/2]

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

static

Definition at line 169 of file kis_painter.cc.

{
    if (!selection) {
        copyAreaOptimized(dstPt, src, dst, originalSrcRect);
        return;
    }
 
    const QRect selectionRect = selection->selectedRect();
    const QRect srcRect = originalSrcRect & selectionRect;
    const QPoint dstOffset = srcRect.topLeft() - originalSrcRect.topLeft();
    const QRect dstRect = QRect(dstPt + dstOffset, srcRect.size());
 
    const bool srcEmpty = (src->extent() & srcRect).isEmpty();
    const bool dstEmpty = (dst->extent() & dstRect).isEmpty();
 
    if (!srcEmpty || !dstEmpty) {
        //if (srcEmpty) {
        // doesn't support dstRect
        // dst->clearSelection(selection);
        // } else */
        {
            KisPainter gc(dst);
            gc.setSelection(selection);
            gc.setCompositeOpId(COMPOSITE_COPY);
            gc.bitBlt(dstRect.topLeft(), src, srcRect);
        }
    }
}

References bitBlt(), COMPOSITE_COPY, copyAreaOptimized(), KisPaintDevice::extent(), KisSelection::selectedRect(), selection, setCompositeOpId(), and setSelection().

◆ copyAreaOptimizedOldData()

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

static

Definition at line 161 of file kis_painter.cc.

{
    copyAreaOptimizedImpl<true>(dstPt, src, dst, srcRect);
}

◆ copyMirrorInformationFrom()

void KisPainter::copyMirrorInformationFrom ( const KisPainter * other )

Definition at line 2809 of file kis_painter.cc.

{
    d->axesCenter = other->d->axesCenter;
    d->mirrorHorizontally = other->d->mirrorHorizontally;
    d->mirrorVertically = other->d->mirrorVertically;
}

References d.

◆ deleteTransaction()

void KisPainter::deleteTransaction ( )

Finish the transaction and delete it's undo information. NOTE: Be careful, because all the previous transactions will become non-undoable after execution of this method.

Definition at line 372 of file kis_painter.cc.

{
    if (!d->transaction) return;
 
    delete d->transaction;
    d->transaction = 0;
}

References d.

◆ device() [1/2]

KisPaintDeviceSP KisPainter::device ( )

◆ device() [2/2]

const KisPaintDeviceSP KisPainter::device ( ) const

Returns the current paint device.

◆ drawDDALine()

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

paints an unstroked, aliased one-pixel line using the DDA algorithm from specified start position to the specified end position.

Definition at line 1740 of file kis_painter.cc.

{
    int x = qFloor(start.x());
    int y = qFloor(start.y());
 
    int x2 = qFloor(end.x());
    int y2 = qFloor(end.y());
    // Width and height of the line
    int xd = x2 - x;
    int yd = y2 - y;
 
    float m = 0;
    bool lockAxis = true;
 
    if (xd == 0) {
        m = 2.0;
    } else if ( yd != 0) {
        lockAxis = false;
        m = (float)yd / (float)xd;
    }
 
    float fx = x;
    float fy = y;
    int inc;
 
    KisRandomAccessorSP accessor = d->device->createRandomAccessorNG();
    KisRandomConstAccessorSP selectionAccessor;
    if (d->selection) {
        selectionAccessor = d->selection->projection()->createRandomConstAccessorNG();
    }
 
 
    accessor->moveTo(x, y);
    if (selectionAccessor) selectionAccessor->moveTo(x,y);
 
    if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
        compositeOnePixel(accessor->rawData(), d->paintColor);
    }
 
    if (fabs(m) > 1.0f) {
        inc = (yd > 0) ? 1 : -1;
        m = (lockAxis)? 0 : 1.0f / m;
        m *= inc;
        while (y != y2) {
            y = y + inc;
            fx = fx + m;
            x = qRound(fx);
 
            accessor->moveTo(x, y);
            if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), d->paintColor);
            }
        }
    } else {
        inc = (xd > 0) ? 1 : -1;
        m *= inc;
        while (x != x2) {
            x = x + inc;
            fy = fy + m;
            y = qRound(fy);
 
            accessor->moveTo(x, y);
            if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), d->paintColor);
            }
        }
    }
}

References compositeOnePixel(), d, KisRandomConstAccessorNG::moveTo(), KisBaseConstAccessor::oldRawData(), KisBaseAccessor::rawData(), and SELECTION_THRESHOLD.

◆ drawLine() [1/2]

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

paint an unstroked one-pixel wide line from specified start position to the specified end position.

Definition at line 1735 of file kis_painter.cc.

{
    drawThickLine(start, end, 1, 1);
}

References drawThickLine().

◆ drawLine() [2/2]

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

paint an unstroked line with thickness from specified start position to the specified end position. Scanline algorithm is used.

Definition at line 1653 of file kis_painter.cc.

                                                                                              {
    int x1 = qFloor(start.x());
    int y1 = qFloor(start.y());
    int x2 = qFloor(end.x());
    int y2 = qFloor(end.y());
 
    if ((x2 == x1 ) && (y2 == y1)) return;
 
    int dstX = x2-x1;
    int dstY = y2-y1;
 
    qreal uniC = dstX*y1 - dstY*x1;
    qreal projectionDenominator = 1.0 / (pow((double)dstX, 2) + pow((double)dstY, 2));
 
    qreal subPixel;
    if (qAbs(dstX) > qAbs(dstY)){
        subPixel = start.x() - x1;
    }else{
        subPixel = start.y() - y1;
    }
 
    qreal halfWidth = width * 0.5 + subPixel;
    int W_ = qRound(halfWidth) + 1;
 
    // save the state
    int X1_ = x1;
    int Y1_ = y1;
    int X2_ = x2;
    int Y2_ = y2;
 
    if (x2<x1) std::swap(x1,x2);
    if (y2<y1) std::swap(y1,y2);
 
    qreal denominator = sqrt(pow((double)dstY,2) + pow((double)dstX,2));
    if (denominator == 0.0) {
        denominator = 1.0;
    }
    denominator = 1.0/denominator;
 
    qreal projection,scanX,scanY,AA_;
    KisRandomAccessorSP accessor = d->device->createRandomAccessorNG();
    KisRandomConstAccessorSP selectionAccessor;
    if (d->selection) {
        selectionAccessor = d->selection->projection()->createRandomConstAccessorNG();
    }
 
    for (int y = y1-W_; y < y2+W_ ; y++){
        for (int x = x1-W_; x < x2+W_; x++){
 
            projection = ( (x-X1_)* dstX + (y-Y1_)*dstY ) * projectionDenominator;
            scanX = X1_ + projection * dstX;
            scanY = Y1_ + projection * dstY;
 
            if (((scanX < x1) || (scanX > x2)) || ((scanY < y1) || (scanY > y2))) {
                AA_ = qMin( sqrt( pow((double)x - X1_, 2) + pow((double)y - Y1_, 2) ),
                            sqrt( pow((double)x - X2_, 2) + pow((double)y - Y2_, 2) ));
            }else{
                AA_ = qAbs(dstY*x - dstX*y + uniC) * denominator;
            }
 
            if (AA_>halfWidth) {
                continue;
            }
 
            accessor->moveTo(x, y);
            if (selectionAccessor) selectionAccessor->moveTo(x,y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                KoColor mycolor = d->paintColor;
 
                if (antialias && AA_ > halfWidth - 1.0) {
                    mycolor.colorSpace()->multiplyAlpha(mycolor.data(), (1.0 - (AA_ - (halfWidth - 1.0))) * 256, 1);
                }
 
                compositeOnePixel(accessor->rawData(), mycolor);
            }
        }
    }
}

References KoColor::colorSpace(), compositeOnePixel(), d, KoColor::data(), KisRandomConstAccessorNG::moveTo(), KoColorSpace::multiplyAlpha(), KisBaseConstAccessor::oldRawData(), KisBaseAccessor::rawData(), and SELECTION_THRESHOLD.

◆ drawPainterPath() [1/2]

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

Definition at line 1558 of file kis_painter.cc.

{
    drawPainterPath(path, pen, QRect());
}

References drawPainterPath().

◆ drawPainterPath() [2/2]

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

Draw the path using the Pen

if requestedRect is null, the entire path is painted

Definition at line 1563 of file kis_painter.cc.

{
    QPen pen(_pen);
    pen.setColor(Qt::white);
 
    if (!d->fillPainter) {
        d->polygon = d->device->createCompositionSourceDevice();
        d->fillPainter = new KisFillPainter(d->polygon);
    } else {
        d->polygon->clear();
    }
 
    Q_CHECK_PTR(d->polygon);
 
    QRectF boundingRect = path.boundingRect();
    QRect fillRect = boundingRect.toAlignedRect();
 
    // take width of the pen into account
    int penWidth = qRound(pen.widthF());
    fillRect.adjust(-penWidth, -penWidth, penWidth, penWidth);
 
    // Expand the rectangle to allow for anti-aliasing.
    fillRect.adjust(-1, -1, 1, 1);
 
    if (!requestedRect.isNull()) {
        fillRect &= requestedRect;
    }
 
    d->fillPainter->fillRect(fillRect, paintColor(), OPACITY_OPAQUE_U8);
 
    if (d->polygonMaskImage.isNull() || (d->maskPainter == 0)) {
        d->polygonMaskImage = QImage(d->maskImageWidth, d->maskImageHeight, QImage::Format_ARGB32_Premultiplied);
        d->maskPainter = new QPainter(&d->polygonMaskImage);
        d->maskPainter->setRenderHint(QPainter::Antialiasing, antiAliasPolygonFill());
    }
 
    // Break the mask up into chunks so we don't have to allocate a potentially very large QImage.
    const QColor black(Qt::black);
    QPen oldPen = d->maskPainter->pen();
    d->maskPainter->setPen(pen);
 
    for (qint32 x = fillRect.x(); x < fillRect.x() + fillRect.width(); x += d->maskImageWidth) {
        for (qint32 y = fillRect.y(); y < fillRect.y() + fillRect.height(); y += d->maskImageHeight) {
 
            d->polygonMaskImage.fill(black.rgb());
            d->maskPainter->translate(-x, -y);
            d->maskPainter->drawPath(path);
            d->maskPainter->translate(x, y);
 
            qint32 rectWidth = qMin(fillRect.x() + fillRect.width() - x, d->maskImageWidth);
            qint32 rectHeight = qMin(fillRect.y() + fillRect.height() - y, d->maskImageHeight);
 
            KisHLineIteratorSP lineIt = d->polygon->createHLineIteratorNG(x, y, rectWidth);
 
            quint8 tmp;
            for (int row = y; row < y + rectHeight; row++) {
                QRgb* line = reinterpret_cast<QRgb*>(d->polygonMaskImage.scanLine(row - y));
                do {
                    tmp = qRed(line[lineIt->x() - x]);
                    d->polygon->colorSpace()->applyAlphaU8Mask(lineIt->rawData(), &tmp, 1);
                } while (lineIt->nextPixel());
                lineIt->nextRow();
            }
 
        }
    }
 
    d->maskPainter->setPen(oldPen);
    QRect r = d->polygon->extent();
 
    bitBlt(r.x(), r.y(), d->polygon, r.x(), r.y(), r.width(), r.height());
}

References antiAliasPolygonFill, bitBlt(), d, OPACITY_OPAQUE_U8, and paintColor.

◆ drawThickLine()

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

Paint an unstroked wide line from the specified start to the specified end position with width varying from start at the start to end at the end.

XXX: the width should be set in doubles, not integers.

Definition at line 2168 of file kis_painter.cc.

{
 
    KisRandomAccessorSP accessor = d->device->createRandomAccessorNG();
    KisRandomConstAccessorSP selectionAccessor;
    if (d->selection) {
        selectionAccessor = d->selection->projection()->createRandomConstAccessorNG();
    }
 
    const KoColorSpace *cs = d->device->colorSpace();
 
    KoColor c1(d->paintColor);
    KoColor c2(d->paintColor);
    KoColor c3(d->paintColor);
    KoColor col1(c1);
    KoColor col2(c1);
 
    float grada, gradb, dxa, dxb, dya, dyb, fraca, fracb,
    xfa, yfa, xfb, yfb, b1a, b2a, b1b, b2b, dstX, dstY;
    int x, y, ix1, ix2, iy1, iy2;
 
    int x0a, y0a, x1a, y1a, x0b, y0b, x1b, y1b;
    int tp0, tn0, tp1, tn1;
 
    int horizontal = 0;
    float opacity = 1.0;
 
    tp0 = startWidth / 2;
    tn0 = startWidth / 2;
    if (startWidth % 2 == 0) // even width startWidth
        tn0--;
 
    tp1 = endWidth / 2;
    tn1 = endWidth / 2;
    if (endWidth % 2 == 0) // even width endWidth
        tn1--;
 
    int x0 = qRound(start.x());
    int y0 = qRound(start.y());
    int x1 = qRound(end.x());
    int y1 = qRound(end.y());
 
    dstX = x1 - x0; // run of general line
    dstY = y1 - y0; // rise of general line
 
    if (dstY < 0) dstY = -dstY;
    if (dstX < 0) dstX = -dstX;
 
    if (dstX > dstY) { // horizontalish
        horizontal = 1;
        x0a = x0;   y0a = y0 - tn0;
        x0b = x0;   y0b = y0 + tp0;
        x1a = x1;   y1a = y1 - tn1;
        x1b = x1;   y1b = y1 + tp1;
    } else {
        x0a = x0 - tn0;   y0a = y0;
        x0b = x0 + tp0;   y0b = y0;
        x1a = x1 - tn1;   y1a = y1;
        x1b = x1 + tp1;   y1b = y1;
    }
 
    if (horizontal) { // draw endpoints
        for (int i = y0a; i <= y0b; i++) {
 
            accessor->moveTo(x0, i);
            if (selectionAccessor) selectionAccessor->moveTo(x0, i);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), c1);
            }
        }
        for (int i = y1a; i <= y1b; i++) {
 
            accessor->moveTo(x1, i);
            if (selectionAccessor) selectionAccessor->moveTo(x1, i);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), c1);
            }
        }
 
    } else {
        for (int i = x0a; i <= x0b; i++) {
 
            accessor->moveTo(i, y0);
            if (selectionAccessor) selectionAccessor->moveTo(i, y0);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), c1);
            }
        }
        for (int i = x1a; i <= x1b; i++) {
            accessor->moveTo(i, y1);
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), c1);
            }
        }
    }
 
    //antialias endpoints
    if (x1 != x0 && y1 != y0) {
        if (horizontal) {
 
            accessor->moveTo(x0a, y0a - 1);
            if (selectionAccessor) selectionAccessor->moveTo(x0a, y0a - 1);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                qreal alpha = cs->opacityF(accessor->rawData());
                opacity = .25 * c1.opacityF() + (1 - .25) * alpha;
                col1.setOpacity(opacity);
                compositeOnePixel(accessor->rawData(), col1);
            }
 
            accessor->moveTo(x1b, y1b + 1);
            if (selectionAccessor) selectionAccessor->moveTo(x1b, y1b + 1);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                qreal alpha = cs->opacityF(accessor->rawData());
                opacity = .25 * c2.opacityF() + (1 - .25) * alpha;
                col1.setOpacity(opacity);
                compositeOnePixel(accessor->rawData(), col1);
            }
 
        } else {
 
            accessor->moveTo(x0a - 1, y0a);
            if (selectionAccessor) selectionAccessor->moveTo(x0a - 1, y0a);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                qreal alpha = cs->opacityF(accessor->rawData());
                opacity = .25 * c1.opacityF() + (1 - .25) * alpha;
                col1.setOpacity(opacity);
                compositeOnePixel(accessor->rawData(), col1);
            }
 
            accessor->moveTo(x1b + 1, y1b);
            if (selectionAccessor) selectionAccessor->moveTo(x1b + 1, y1b);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                qreal alpha = cs->opacityF(accessor->rawData());
                opacity = .25 * c2.opacityF() + (1 - .25) * alpha;
                col1.setOpacity(opacity);
                compositeOnePixel(accessor->rawData(), col1);
            }
        }
    }
 
    dxa = x1a - x0a; // run of a
    dya = y1a - y0a; // rise of a
    dxb = x1b - x0b; // run of b
    dyb = y1b - y0b; // rise of b
 
    if (horizontal) { // horizontal-ish lines
        if (x1 < x0) {
            int xt, yt, wt;
            KoColor tmp;
            xt = x1a;     x1a = x0a;    x0a = xt;
            yt = y1a;     y1a = y0a;    y0a = yt;
            xt = x1b;     x1b = x0b;    x0b = xt;
            yt = y1b;     y1b = y0b;    y0b = yt;
            xt = x1;      x1 = x0;      x0 = xt;
            yt = y1;      y1 = y0;      y0 = yt;
 
            tmp = c1; c1 = c2; c2 = tmp;
            wt = startWidth;      startWidth = endWidth;      endWidth = wt;
        }
 
        grada = dya / dxa;
        gradb = dyb / dxb;
 
        ix1 = x0;   iy1 = y0;
        ix2 = x1;   iy2 = y1;
 
        yfa = y0a + grada;
        yfb = y0b + gradb;
 
        for (x = ix1 + 1; x <= ix2 - 1; x++) {
            fraca = yfa - qFloor(yfa);
            b1a = 1 - fraca;
            b2a = fraca;
 
            fracb = yfb - qFloor(yfb);
            b1b = 1 - fracb;
            b2b = fracb;
 
            // color first pixel of bottom line
            opacity = ((x - ix1) / dstX) * c2.opacityF() + (1 - (x - ix1) / dstX) * c1.opacityF();
            c3.setOpacity(opacity);
 
            accessor->moveTo(x, qFloor(yfa));
            if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfa));
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                qreal alpha = cs->opacityF(accessor->rawData());
                opacity = b1a * c3.opacityF() + (1 - b1a) * alpha;
                col1.setOpacity(opacity);
                compositeOnePixel(accessor->rawData(), col1);
            }
 
            // color first pixel of top line
            if (!(startWidth == 1 && endWidth == 1)) {
                accessor->moveTo(x, qFloor(yfb));
                if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfb));
 
                if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                    qreal alpha = cs->opacityF(accessor->rawData());
                    opacity = b1b * c3.opacityF() + (1 - b1b) * alpha;
                    col1.setOpacity(opacity);
                    compositeOnePixel(accessor->rawData(), col1);
                }
            }
 
            // color second pixel of bottom line
            if (grada != 0 && grada != 1) { // if not flat or exact diagonal
 
                accessor->moveTo(x, qFloor(yfa) + 1);
                if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfa) + 1);
 
                if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                    qreal alpha = cs->opacityF(accessor->rawData());
                    opacity = b2a * c3.opacityF() + (1 - b2a)  * alpha;
                    col2.setOpacity(opacity);
                    compositeOnePixel(accessor->rawData(), col2);
                }
 
            }
 
            // color second pixel of top line
            if (gradb != 0 && gradb != 1 && !(startWidth == 1 && endWidth == 1)) {
 
                accessor->moveTo(x, qFloor(yfb) + 1);
                if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfb) + 1);
 
                if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                    qreal alpha = cs->opacityF(accessor->rawData());
                    opacity = b2b * c3.opacityF() + (1 - b2b) * alpha;
                    col2.setOpacity(opacity);
                    compositeOnePixel(accessor->rawData(), col2);
                }
 
            }
 
            // fill remaining pixels
            if (!(startWidth == 1 && endWidth == 1)) {
                if (yfa < yfb)
                    for (int i = qFloor(yfa) + 1; i <= qFloor(yfb); i++) {
 
                        accessor->moveTo(x, i);
                        if (selectionAccessor) selectionAccessor->moveTo(x, i);
 
                        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                            compositeOnePixel(accessor->rawData(), c3);
                        }
                    }
                else
                    for (int i = qFloor(yfa) + 1; i >= qFloor(yfb); i--) {
 
                        accessor->moveTo(x, i);
                        if (selectionAccessor) selectionAccessor->moveTo(x, i);
 
                        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                            compositeOnePixel(accessor->rawData(), c3);
                        }
                    }
 
            }
 
            yfa += grada;
            yfb += gradb;
        }
    } else { // vertical-ish lines
        if (y1 < y0) {
            int xt, yt, wt;
            xt = x1a;     x1a = x0a;    x0a = xt;
            yt = y1a;     y1a = y0a;    y0a = yt;
            xt = x1b;     x1b = x0b;    x0b = xt;
            yt = y1b;     y1b = y0b;    y0b = yt;
            xt = x1;      x1 = x0;      x0 = xt;
            yt = y1;      y1 = y0;      y0 = yt;
 
            KoColor tmp;
            tmp = c1; c1 = c2; c2 = tmp;
            wt = startWidth;      startWidth = endWidth;      endWidth = wt;
        }
 
        grada = dxa / dya;
        gradb = dxb / dyb;
 
        ix1 = x0;   iy1 = y0;
        ix2 = x1;   iy2 = y1;
 
        xfa = x0a + grada;
        xfb = x0b + gradb;
 
        for (y = iy1 + 1; y <= iy2 - 1; y++) {
            fraca = xfa - qFloor(xfa);
            b1a = 1 - fraca;
            b2a = fraca;
 
            fracb = xfb - qFloor(xfb);
            b1b = 1 - fracb;
            b2b = fracb;
 
            // color first pixel of left line
            opacity = ((y - iy1) / dstY) * c2.opacityF() + (1 - (y - iy1) / dstY) * c1.opacityF();
            c3.setOpacity(opacity);
 
            accessor->moveTo(qFloor(xfa), y);
            if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfa), y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                qreal alpha = cs->opacityF(accessor->rawData());
                opacity = b1a * c3.opacityF() + (1 - b1a) * alpha;
                col1.setOpacity(opacity);
                compositeOnePixel(accessor->rawData(), col1);
            }
 
            // color first pixel of right line
            if (!(startWidth == 1 && endWidth == 1)) {
 
                accessor->moveTo(qFloor(xfb), y);
                if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfb), y);
 
                if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                    qreal alpha = cs->opacityF(accessor->rawData());
                    opacity = b1b * c3.opacityF() + (1 - b1b)  * alpha;
                    col1.setOpacity(opacity);
                    compositeOnePixel(accessor->rawData(), col1);
                }
            }
 
            // color second pixel of left line
            if (grada != 0 && grada != 1) { // if not flat or exact diagonal
 
                accessor->moveTo(qFloor(xfa) + 1, y);
                if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfa) + 1, y);
 
                if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                    qreal alpha = cs->opacityF(accessor->rawData());
                    opacity = b2a * c3.opacityF() + (1 - b2a) * alpha;
                    col2.setOpacity(opacity);
                    compositeOnePixel(accessor->rawData(), col2);
                }
 
            }
 
            // color second pixel of right line
            if (gradb != 0 && gradb != 1 && !(startWidth == 1 && endWidth == 1)) {
 
                accessor->moveTo(qFloor(xfb) + 1, y);
                if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfb) + 1, y);
 
                if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                    qreal alpha = cs->opacityF(accessor->rawData());
                    opacity = b2b * c3.opacityF() + (1 - b2b) * alpha;
                    col2.setOpacity(opacity);
                    compositeOnePixel(accessor->rawData(), col2);
                }
            }
 
            // fill remaining pixels between current xfa,xfb
            if (!(startWidth == 1 && endWidth == 1)) {
                if (xfa < xfb)
                    for (int i = qFloor(xfa) + 1; i <= qFloor(xfb); i++) {
 
                        accessor->moveTo(i, y);
                        if (selectionAccessor) selectionAccessor->moveTo(i, y);
 
                        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                            compositeOnePixel(accessor->rawData(), c3);
                        }
                    }
                else
                    for (int i = qFloor(xfb); i <= qFloor(xfa) + 1; i++) {
 
                        accessor->moveTo(i, y);
                        if (selectionAccessor) selectionAccessor->moveTo(i, y);
 
                        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                            compositeOnePixel(accessor->rawData(), c3);
                        }
                    }
            }
 
            xfa += grada;
            xfb += gradb;
        }
    }
 
}

References compositeOnePixel(), d, KisRandomConstAccessorNG::moveTo(), KisBaseConstAccessor::oldRawData(), KoColor::opacityF(), KoColorSpace::opacityF(), KisBaseAccessor::rawData(), SELECTION_THRESHOLD, and KoColor::setOpacity().

◆ drawWobblyLine()

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

Paint an unstroked, wobbly one-pixel wide line from the specified start to the specified end position.

Definition at line 1813 of file kis_painter.cc.

{
    KoColor mycolor(d->paintColor);
 
    int x1 = qFloor(start.x());
    int y1 = qFloor(start.y());
    int x2 = qFloor(end.x());
    int y2 = qFloor(end.y());
 
    KisRandomAccessorSP accessor = d->device->createRandomAccessorNG();
    KisRandomConstAccessorSP selectionAccessor;
    if (d->selection) {
        selectionAccessor = d->selection->projection()->createRandomConstAccessorNG();
    }
 
    // Width and height of the line
    int xd = (x2 - x1);
    int yd = (y2 - y1);
 
    int x;
    int y;
    float fx = (x = x1);
    float fy = (y = y1);
    float m = (float)yd / (float)xd;
    int inc;
 
    if (fabs(m) > 1) {
        inc = (yd > 0) ? 1 : -1;
        m = 1.0f / m;
        m *= inc;
        while (y != y2) {
            fx = fx + m;
            y = y + inc;
            x = qRound(fx);
 
            float br1 = qFloor(fx + 1) - fx;
            float br2 = fx - qFloor(fx);
 
            accessor->moveTo(x, y);
            if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                mycolor.setOpacity((quint8)(255*br1));
                compositeOnePixel(accessor->rawData(), mycolor);
            }
 
            accessor->moveTo(x + 1, y);
            if (selectionAccessor) selectionAccessor->moveTo(x + 1, y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                mycolor.setOpacity((quint8)(255*br2));
                compositeOnePixel(accessor->rawData(), mycolor);
            }
        }
    } else {
        inc = (xd > 0) ? 1 : -1;
        m *= inc;
        while (x != x2) {
            fy = fy + m;
            x = x + inc;
            y = qRound(fy);
 
            float br1 = qFloor(fy + 1) - fy;
            float br2 = fy - qFloor(fy);
 
            accessor->moveTo(x, y);
            if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                mycolor.setOpacity((quint8)(255*br1));
                compositeOnePixel(accessor->rawData(), mycolor);
            }
 
            accessor->moveTo(x, y + 1);
            if (selectionAccessor) selectionAccessor->moveTo(x, y + 1);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                mycolor.setOpacity((quint8)(255*br2));
                compositeOnePixel(accessor->rawData(), mycolor);
            }
        }
    }
 
}

References compositeOnePixel(), d, KisRandomConstAccessorNG::moveTo(), KisBaseConstAccessor::oldRawData(), KisBaseAccessor::rawData(), SELECTION_THRESHOLD, and KoColor::setOpacity().

◆ drawWuLine()

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

Paint an unstroked, anti-aliased one-pixel wide line from the specified start to the specified end position using the Wu algorithm

Definition at line 1898 of file kis_painter.cc.

{
    KoColor lineColor(d->paintColor);
 
    int x1 = qFloor(start.x());
    int y1 = qFloor(start.y());
    int x2 = qFloor(end.x());
    int y2 = qFloor(end.y());
 
    KisRandomAccessorSP accessor = d->device->createRandomAccessorNG();
    KisRandomConstAccessorSP selectionAccessor;
    if (d->selection) {
        selectionAccessor = d->selection->projection()->createRandomConstAccessorNG();
    }
 
    float grad, xd, yd;
    float xgap, ygap, xend, yend, yf, xf;
    float brightness1, brightness2;
 
    int ix1, ix2, iy1, iy2;
    quint8 c1, c2;
 
    // gradient of line
    xd = (x2 - x1);
    yd = (y2 - y1);
 
    if (yd == 0) {
        /* Horizontal line */
        int incr = (x1 < x2) ? 1 : -1;
        ix1 = x1;
        ix2 = x2;
        iy1 = y1;
        while (ix1 != ix2) {
            ix1 = ix1 + incr;
 
            accessor->moveTo(ix1, iy1);
            if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), lineColor);
            }
        }
        return;
    }
 
    if (xd == 0) {
        /* Vertical line */
        int incr = (y1 < y2) ? 1 : -1;
        iy1 = y1;
        iy2 = y2;
        ix1 = x1;
        while (iy1 != iy2) {
            iy1 = iy1 + incr;
 
            accessor->moveTo(ix1, iy1);
            if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                compositeOnePixel(accessor->rawData(), lineColor);
            }
        }
        return;
    }
 
    if (fabs(xd) > fabs(yd)) {
        // horizontal line
        // line have to be paint from left to right
        if (x1 > x2) {
            std::swap(x1, x2);
            std::swap(y1, y2);
            xd = (x2 - x1);
            yd = (y2 - y1);
        }
        grad = yd / xd;
        // nearest X,Y integer coordinates
        xend = x1;
        yend = y1 + grad * (xend - x1);
 
        xgap = invertFrac(x1 + 0.5f);
 
        ix1 = x1;
        iy1 = qFloor(yend);
 
        // calc the intensity of the other end point pixel pair.
        brightness1 = invertFrac(yend) * xgap;
        brightness2 =       frac(yend) * xgap;
 
        c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
        c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
        accessor->moveTo(ix1, iy1);
        if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c1);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        accessor->moveTo(ix1, iy1 + 1);
        if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1 + 1);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c2);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        // calc first Y-intersection for main loop
        yf = yend + grad;
 
        xend = x2;
        yend = y2 + grad * (xend - x2);
 
        xgap = invertFrac(x2 - 0.5f);
 
        ix2 = x2;
        iy2 = qFloor(yend);
 
        brightness1 = invertFrac(yend) * xgap;
        brightness2 =    frac(yend) * xgap;
 
        c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
        c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
        accessor->moveTo(ix2, iy2);
        if (selectionAccessor) selectionAccessor->moveTo(ix2, iy2);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c1);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        accessor->moveTo(ix2, iy2 + 1);
        if (selectionAccessor) selectionAccessor->moveTo(ix2, iy2 + 1);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c2);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        // main loop
        for (int x = ix1 + 1; x <= ix2 - 1; x++) {
            brightness1 = invertFrac(yf);
            brightness2 =    frac(yf);
            c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
            c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
            accessor->moveTo(x, qFloor(yf));
            if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yf));
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                lineColor.setOpacity(c1);
                compositeOnePixel(accessor->rawData(), lineColor);
            }
 
            accessor->moveTo(x, qFloor(yf) + 1);
            if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yf) + 1);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                lineColor.setOpacity(c2);
                compositeOnePixel(accessor->rawData(), lineColor);
            }
 
            yf = yf + grad;
        }
    } else {
        //vertical
        // line have to be painted from left to right
        if (y1 > y2) {
            std::swap(x1, x2);
            std::swap(y1, y2);
            xd = (x2 - x1);
            yd = (y2 - y1);
        }
 
        grad = xd / yd;
 
        // nearest X,Y integer coordinates
        yend = y1;
        xend = x1 + grad * (yend - y1);
 
        ygap = y1;
 
        ix1 = qFloor(xend);
        iy1 = y1;
 
        // calc the intensity of the other end point pixel pair.
        brightness1 = invertFrac(xend) * ygap;
        brightness2 =       frac(xend) * ygap;
 
        c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
        c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
        accessor->moveTo(ix1, iy1);
        if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c1);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        accessor->moveTo(x1 + 1, y1);
        if (selectionAccessor) selectionAccessor->moveTo(x1 + 1, y1);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c2);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        // calc first Y-intersection for main loop
        xf = xend + grad;
 
        yend = y2;
        xend = x2 + grad * (yend - y2);
 
        ygap = invertFrac(y2 - 0.5f);
 
        ix2 = qFloor(xend);
        iy2 = y2;
 
        brightness1 = invertFrac(xend) * ygap;
        brightness2 =    frac(xend) * ygap;
 
        c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
        c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
        accessor->moveTo(ix2, iy2);
        if (selectionAccessor) selectionAccessor->moveTo(ix2, iy2);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c1);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        accessor->moveTo(ix2 + 1, iy2);
        if (selectionAccessor) selectionAccessor->moveTo(ix2 + 1, iy2);
 
        if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
            lineColor.setOpacity(c2);
            compositeOnePixel(accessor->rawData(), lineColor);
        }
 
        // main loop
        for (int y = iy1 + 1; y <= iy2 - 1; y++) {
            brightness1 = invertFrac(xf);
            brightness2 =    frac(xf);
            c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
            c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
            accessor->moveTo(qFloor(xf), y);
            if (selectionAccessor) selectionAccessor->moveTo(qFloor(xf), y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                lineColor.setOpacity(c1);
                compositeOnePixel(accessor->rawData(), lineColor);
            }
 
            accessor->moveTo(qFloor(xf) + 1, y);
            if (selectionAccessor) selectionAccessor->moveTo(qFloor(xf) + 1, y);
 
            if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                lineColor.setOpacity(c2);
                compositeOnePixel(accessor->rawData(), lineColor);
            }
 
            xf = xf + grad;
        }
    }//end-of-else
 
}

References compositeOnePixel(), d, frac(), invertFrac(), KisRandomConstAccessorNG::moveTo(), KisBaseConstAccessor::oldRawData(), OPACITY_OPAQUE_U8, KisBaseAccessor::rawData(), SELECTION_THRESHOLD, and KoColor::setOpacity().

◆ end()

void KisPainter::end ( )

Finish painting on the current device

Definition at line 311 of file kis_painter.cc.

{
    Q_ASSERT_X(!d->transaction, "KisPainter::end()",
               "end() was called for the painter having a transaction. "
               "Please use end/deleteTransaction() instead");
}

References d.

◆ endAndTakeTransaction()

KUndo2Command * KisPainter::endAndTakeTransaction ( )

Finishes a transaction and returns a pointer to its undo command

Definition at line 360 of file kis_painter.cc.

{
    Q_ASSERT_X(d->transaction, "KisPainter::endTransaction()",
               "No transaction is in progress");
 
    KUndo2Command *transactionData = d->transaction->endAndTake();
    delete d->transaction;
    d->transaction = 0;
 
    return transactionData;
}

References d.

◆ endTransaction() [1/2]

void KisPainter::endTransaction ( KisPostExecutionUndoAdapter * undoAdapter )

Finish transaction and load it to a special adapter for strokes

Definition at line 350 of file kis_painter.cc.

{
    Q_ASSERT_X(d->transaction, "KisPainter::endTransaction()",
               "No transaction is in progress");
 
    d->transaction->commit(undoAdapter);
    delete d->transaction;
    d->transaction = 0;
}

References d.

◆ endTransaction() [2/2]

void KisPainter::endTransaction ( KisUndoAdapter * undoAdapter )

Finish the undoable paint operation.

Definition at line 340 of file kis_painter.cc.

{
    Q_ASSERT_X(d->transaction, "KisPainter::endTransaction()",
               "No transaction is in progress");
 
    d->transaction->commit(undoAdapter);
    delete d->transaction;
    d->transaction = 0;
}

References d.

◆ fill()

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

fills a region of width width and height height of the current paint device with the color color. x and y set the x and y positions of the origin top-left corner.

Parameters

x	the destination x-coordinate
y	the destination y-coordinate
width	the width of the region to be manipulated
height	the height of the region to be manipulated
color	the color the area is filled with

Definition at line 851 of file kis_painter.cc.

{
    /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
     * initializing they perform some dummy passes with those parameters, and it must not crash */
    if(width == 0 || height == 0 || d->device.isNull())
        return;
 
    KoColor srcColor(color, d->device->compositionSourceColorSpace());
    const KoCompositeOp *compositeOp = d->compositeOp(srcColor.colorSpace());
 
    qint32  dstY          = y;
    qint32  rowsRemaining = height;
 
    KisRandomAccessorSP dstIt = d->device->createRandomAccessorNG();
 
    if(d->selection) {
        KisPaintDeviceSP selectionProjection(d->selection->projection());
        KisRandomConstAccessorSP maskIt = selectionProjection->createRandomConstAccessorNG();
 
        while(rowsRemaining > 0) {
 
            qint32 dstX                 = x;
            qint32 columnsRemaining     = width;
            qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY);
            qint32 numContiguousSelRows = maskIt->numContiguousRows(dstY);
            qint32 rows = qMin(numContiguousDstRows, numContiguousSelRows);
            rows = qMin(rows, rowsRemaining);
 
            while (columnsRemaining > 0) {
 
                qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX);
                qint32 numContiguousSelColumns = maskIt->numContiguousColumns(dstX);
 
                qint32 columns = qMin(numContiguousDstColumns, numContiguousSelColumns);
                columns = qMin(columns, columnsRemaining);
 
                qint32 dstRowStride = dstIt->rowStride(dstX, dstY);
                dstIt->moveTo(dstX, dstY);
                qint32 maskRowStride = maskIt->rowStride(dstX, dstY);
 
                maskIt->moveTo(dstX, dstY);
 
                d->paramInfo.dstRowStart   = dstIt->rawData();
                d->paramInfo.dstRowStride  = dstRowStride;
                d->paramInfo.srcRowStart   = srcColor.data();
                d->paramInfo.srcRowStride  = 0; // srcRowStride is set to zero to use the compositeOp with only a single color pixel
                d->paramInfo.maskRowStart  = maskIt->oldRawData();
                d->paramInfo.maskRowStride = maskRowStride;
                d->paramInfo.rows          = rows;
                d->paramInfo.cols          = columns;
                d->colorSpace->bitBlt(srcColor.colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
 
                dstX             += columns;
                columnsRemaining -= columns;
            }
 
            dstY          += rows;
            rowsRemaining -= rows;
        }
    }
    else {
 
        while(rowsRemaining > 0) {
 
            qint32 dstX                 = x;
            qint32 columnsRemaining     = width;
            qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY);
            qint32 rows                 = qMin(numContiguousDstRows, rowsRemaining);
 
            while(columnsRemaining > 0) {
 
                qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX);
                qint32 columns                 = qMin(numContiguousDstColumns, columnsRemaining);
                qint32 dstRowStride            = dstIt->rowStride(dstX, dstY);
                dstIt->moveTo(dstX, dstY);
 
                d->paramInfo.dstRowStart   = dstIt->rawData();
                d->paramInfo.dstRowStride  = dstRowStride;
                d->paramInfo.srcRowStart   = srcColor.data();
                d->paramInfo.srcRowStride  = 0; // srcRowStride is set to zero to use the compositeOp with only a single color pixel
                d->paramInfo.maskRowStart  = 0;
                d->paramInfo.maskRowStride = 0;
                d->paramInfo.rows          = rows;
                d->paramInfo.cols          = columns;
                d->colorSpace->bitBlt(srcColor.colorSpace(), d->paramInfo, compositeOp, d->renderingIntent, d->conversionFlags);
 
                dstX             += columns;
                columnsRemaining -= columns;
            }
 
            dstY          += rows;
            rowsRemaining -= rows;
        }
    }
 
    addDirtyRect(QRect(x, y, width, height));
}

References addDirtyRect(), KoColor::colorSpace(), compositeOp(), KisPaintDevice::createRandomConstAccessorNG(), d, KoColor::data(), KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KisBaseConstAccessor::oldRawData(), KisBaseAccessor::rawData(), and KisRandomConstAccessorNG::rowStride().

◆ fillPainterPath() [1/2]

void KisPainter::fillPainterPath ( const QPainterPath & path )

Fills the area enclosed by the given QPainterPath Convenience method for fillPainterPath(path, rect)

Definition at line 1427 of file kis_painter.cc.

{
    fillPainterPath(path, QRect());
}

References fillPainterPath().

◆ fillPainterPath() [2/2]

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

Fills the portion of an area enclosed by the given QPainterPath

Parameters

path	the portion of the path to fill
requestedRect	the rectangle containing the area

Definition at line 1432 of file kis_painter.cc.

{
    if (d->mirrorHorizontally || d->mirrorVertically) {
        KisLodTransform lod(d->device);
        QPointF effectiveAxesCenter = lod.map(d->axesCenter);
 
        QTransform C1 = QTransform::fromTranslate(-effectiveAxesCenter.x(), -effectiveAxesCenter.y());
        QTransform C2 = QTransform::fromTranslate(effectiveAxesCenter.x(), effectiveAxesCenter.y());
 
        QTransform t;
        QPainterPath newPath;
        QRect newRect;
 
        if (d->mirrorHorizontally) {
            t = C1 * QTransform::fromScale(-1,1) * C2;
            newPath = t.map(path);
            newRect = t.mapRect(requestedRect);
            d->fillPainterPathImpl(newPath, newRect);
        }
 
        if (d->mirrorVertically) {
            t = C1 * QTransform::fromScale(1,-1) * C2;
            newPath = t.map(path);
            newRect = t.mapRect(requestedRect);
            d->fillPainterPathImpl(newPath, newRect);
        }
 
        if (d->mirrorHorizontally && d->mirrorVertically) {
            t = C1 * QTransform::fromScale(-1,-1) * C2;
            newPath = t.map(path);
            newRect = t.mapRect(requestedRect);
            d->fillPainterPathImpl(newPath, newRect);
        }
    }
 
    d->fillPainterPathImpl(path, requestedRect);
}

References d, and KisLodTransform::map().

◆ fillPainterPathImpl()

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

◆ fillPolygon()

void KisPainter::fillPolygon	(	const vQPointF &	points,
		FillStyle	fillStyle )

protected

Fill the polygon defined by points with the fillStyle.

Definition at line 1327 of file kis_painter.cc.

{
    if (points.count() < 3) {
        return;
    }
 
    if (fillStyle == FillStyleNone) {
        return;
    }
 
    QPainterPath polygonPath;
 
    polygonPath.moveTo(points.at(0));
 
    for (int pointIndex = 1; pointIndex < points.count(); pointIndex++) {
        polygonPath.lineTo(points.at(pointIndex));
    }
 
    polygonPath.closeSubpath();
 
    d->fillStyle = fillStyle;
    fillPainterPath(polygonPath);
}

References d, fillPainterPath(), fillStyle, and FillStyleNone.

◆ fillStyle()

FillStyle KisPainter::fillStyle ( ) const

Returns the current fill style.

◆ flow()

qreal KisPainter::flow ( ) const

Definition at line 2682 of file kis_painter.cc.

{
    return d->paramInfo.flow;
}

References d.

◆ frac()

float KisPainter::frac ( float value )

inlineprivate

Definition at line 874 of file kis_painter.h.

                            {
        float tmp = 0;
        return modff(value , &tmp);
    }

References value().

◆ generator()

const KisFilterConfigurationSP KisPainter::generator ( ) const

Returns: the current generator configuration

◆ getBezierCurvePoints()

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

Fill the given vector points with the points needed to draw the Bezier curve between pos1 and pos2 using control points control1 and control2, excluding the final pos2.

Definition at line 1226 of file kis_painter.cc.

{
    ::getBezierCurvePoints(toKisVector2D(pos1), toKisVector2D(control1), toKisVector2D(control2), toKisVector2D(pos2), points);
}

References getBezierCurvePoints(), and toKisVector2D().

◆ gradient()

const KoAbstractGradientSP KisPainter::gradient ( ) const

◆ hasDirtyRegion()

bool KisPainter::hasDirtyRegion ( ) const

Returns: true if the painter has some rects marked as dirty

See also: takeDirtyRegion(), addDirtyRect()

Definition at line 3075 of file kis_painter.cc.

{
    return !d->dirtyRects.isEmpty();
}

References d.

◆ hasHorizontalMirroring()

bool KisPainter::hasHorizontalMirroring ( ) const

Indicates if horizontal mirroring mode is activated

Definition at line 2821 of file kis_painter.cc.

{
    return d->mirrorHorizontally;
}

References d.

◆ hasMirroring()

bool KisPainter::hasMirroring ( ) const

Returns whether the mirroring methods will do any work when called

Definition at line 2816 of file kis_painter.cc.

{
    return d->mirrorHorizontally || d->mirrorVertically;
}

References d.

◆ hasVerticalMirroring()

bool KisPainter::hasVerticalMirroring ( ) const

Indicates if vertical mirroring mode is activated

Definition at line 2826 of file kis_painter.cc.

{
    return d->mirrorVertically;
}

References d.

◆ init()

void KisPainter::init ( )

protected

Initialize, set everything to '0' or defaults.

Definition at line 84 of file kis_painter.cc.

{
    d->paramInfo = KoCompositeOp::ParameterInfo();
    d->renderingIntent = KoColorConversionTransformation::internalRenderingIntent();
    d->conversionFlags = KoColorConversionTransformation::internalConversionFlags();
    d->patternTransform = QTransform();
}

References d, KoColorConversionTransformation::internalConversionFlags(), and KoColorConversionTransformation::internalRenderingIntent().

◆ invertFrac()

float KisPainter::invertFrac ( float value )

inlineprivate

Definition at line 879 of file kis_painter.h.

                                  {
        float tmp = 0;
        return 1.0f - modff(value , &tmp);
    }

References value().

◆ isOpacityUnit()

bool KisPainter::isOpacityUnit ( ) const

◆ mirrorDab()

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

Mirror dab in the requested direction around the center point defined in the painter. The dab's offset is adjusted automatically.

Definition at line 3088 of file kis_painter.cc.

{
    KisLodTransform t(d->device);
    QPointF effectiveAxesCenter = t.map(d->axesCenter);
 
    KritaUtils::mirrorDab(direction, effectiveAxesCenter, dab, skipMirrorPixels);
}

References d, KisLodTransform::map(), and KritaUtils::mirrorDab().

◆ mirrorRect()

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

Mirror rc in the requested direction around the center point defined in the painter.

Definition at line 3080 of file kis_painter.cc.

{
    KisLodTransform t(d->device);
    QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
    KritaUtils::mirrorRect(direction, effectiveAxesCenter, rc);
}

References d, KisLodTransform::map(), and KritaUtils::mirrorRect().

◆ opacityF()

qreal KisPainter::opacityF ( ) const

Returns the opacity that is used in painting.

Definition at line 2719 of file kis_painter.cc.

{
    return d->paramInfo.opacity;
}

References d.

◆ operator=()

KisPainter & KisPainter::operator= ( const KisPainter & )

private

◆ paintAt()

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

Draw a spot at pos using the currently set paint op, brush and color

Definition at line 1319 of file kis_painter.cc.

{
    if (d->paintOp && d->paintOp->canPaint()) {
        d->paintOp->paintAt(pi, savedDist);
    }
}

References d.

◆ paintBezierCurve()

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

Draw a Bezier curve between pi1 and pi2 using control points control1 and control2. If savedDist is less than zero, the brush is painted at pos1 before being painted along the curve using the spacing setting.

Returns: the drag distance, that is the remains of the distance between pi1 and pi2 not covered because the currently set brush has a spacing greater than that distance.

Definition at line 1235 of file kis_painter.cc.

{   
    if (d->paintOp && d->paintOp->canPaint()) {
        d->paintOp->paintBezierCurve(pi1, control1, control2, pi2, currentDistance);
    }
}

References d.

◆ paintColor()

const KoColor & KisPainter::paintColor ( ) const

Returns the color that will be used to paint with.

◆ paintEllipse() [1/2]

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

Paint the ellipse that fills the given rectangle.

Parameters

x	x coordinate of the top-left corner
y	y coordinate of the top-left corner
w	the rectangle width
h	the rectangle height

Definition at line 1311 of file kis_painter.cc.

{
    paintEllipse(QRectF(x, y, w, h));
}

References paintEllipse().

◆ paintEllipse() [2/2]

void KisPainter::paintEllipse ( const QRectF & rect )

Paint the ellipse that fills the given rectangle.

Parameters

rect	the rectangle containing the ellipse to paint.

Definition at line 1269 of file kis_painter.cc.

{
    QRectF r = rect.normalized(); // normalize before checking as negative width and height are empty too
    if (r.isEmpty()) return;
 
    // See http://www.whizkidtech.redprince.net/bezier/circle/ for explanation.
    // kappa = (4/3*(sqrt(2)-1))
    const qreal kappa = 0.5522847498;
    const qreal lx = (r.width() / 2) * kappa;
    const qreal ly = (r.height() / 2) * kappa;
 
    QPointF center = r.center();
 
    QPointF p0(r.left(), center.y());
    QPointF p1(r.left(), center.y() - ly);
    QPointF p2(center.x() - lx, r.top());
    QPointF p3(center.x(), r.top());
 
    vQPointF points;
 
    getBezierCurvePoints(p0, p1, p2, p3, points);
 
    QPointF p4(center.x() + lx, r.top());
    QPointF p5(r.right(), center.y() - ly);
    QPointF p6(r.right(), center.y());
 
    getBezierCurvePoints(p3, p4, p5, p6, points);
 
    QPointF p7(r.right(), center.y() + ly);
    QPointF p8(center.x() + lx, r.bottom());
    QPointF p9(center.x(), r.bottom());
 
    getBezierCurvePoints(p6, p7, p8, p9, points);
 
    QPointF p10(center.x() - lx, r.bottom());
    QPointF p11(r.left(), center.y() + ly);
 
    getBezierCurvePoints(p9, p10, p11, p0, points);
 
    paintPolygon(points);
}

References getBezierCurvePoints(), p0, p1, p2, p3, and paintPolygon().

◆ paintLine()

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

Draw a line between pos1 and pos2 using the currently set brush and color. If savedDist is less than zero, the brush is painted at pos1 before being painted along the line using the spacing setting.

Returns: the drag distance, that is the remains of the distance between p1 and p2 not covered because the currently set brush has a spacing greater than that distance.

Definition at line 1151 of file kis_painter.cc.

{   
    if (d->device && d->paintOp && d->paintOp->canPaint()) {
        d->paintOp->paintLine(pi1, pi2, currentDistance);
    }
}

References d.

◆ paintOp()

KisPaintOp * KisPainter::paintOp ( ) const

Return the active paintop (which is created based on the specified preset and will be deleted as soon as the KisPainter instance dies).

◆ paintPainterPath()

void KisPainter::paintPainterPath ( const QPainterPath & path )

Stroke the given QPainterPath.

Definition at line 1380 of file kis_painter.cc.

{
    if (d->fillStyle != FillStyleNone) {
        fillPainterPath(path);
    }
 
    if (d->strokeStyle == StrokeStyleNone) return;
 
    QPointF lastPoint, nextPoint;
    int elementCount = path.elementCount();
    KisDistanceInformation saveDist;
 
    KisRandomSourceSP rnd = new KisRandomSource();
    KisPerStrokeRandomSourceSP strokeRnd = new KisPerStrokeRandomSource();
 
    auto point = [rnd, strokeRnd] (const QPointF &pt) {
        KisPaintInformation pi(pt);
        pi.setRandomSource(rnd);
        pi.setPerStrokeRandomSource(strokeRnd);
        return pi;
    };
 
    for (int i = 0; i < elementCount; i++) {
        QPainterPath::Element element = path.elementAt(i);
        switch (element.type) {
        case QPainterPath::MoveToElement:
            lastPoint = QPointF(element.x, element.y);
            break;
        case QPainterPath::LineToElement:
            nextPoint = QPointF(element.x, element.y);
            paintLine(point(lastPoint), point(nextPoint), &saveDist);
            lastPoint = nextPoint;
            break;
        case QPainterPath::CurveToElement:
            nextPoint = QPointF(path.elementAt(i + 2).x, path.elementAt(i + 2).y);
            paintBezierCurve(point(lastPoint),
                             QPointF(path.elementAt(i).x, path.elementAt(i).y),
                             QPointF(path.elementAt(i + 1).x, path.elementAt(i + 1).y),
                             point(nextPoint), &saveDist);
            lastPoint = nextPoint;
            break;
        default:
            continue;
        }
    }
}

References d, fillPainterPath(), FillStyleNone, paintBezierCurve(), paintLine(), KisPaintInformation::setPerStrokeRandomSource(), KisPaintInformation::setRandomSource(), and StrokeStyleNone.

◆ paintPolygon()

void KisPainter::paintPolygon ( const vQPointF & points )

Paint the polygon with the points given in points. It automatically closes the polygon by drawing the line from the last point to the first.

Definition at line 1351 of file kis_painter.cc.

{
    if (d->fillStyle != FillStyleNone) {
        fillPolygon(points, d->fillStyle);
    }
 
    if (d->strokeStyle != StrokeStyleNone) {
        if (points.count() > 1) {
            KisDistanceInformation distance(points[0],
                                            KisAlgebra2D::directionBetweenPoints(points[0], points[1], 0.0));
 
            KisRandomSourceSP rnd = new KisRandomSource();
            KisPerStrokeRandomSourceSP strokeRnd = new KisPerStrokeRandomSource();
 
            auto point = [rnd, strokeRnd] (const QPointF &pt) {
                KisPaintInformation pi(pt);
                pi.setRandomSource(rnd);
                pi.setPerStrokeRandomSource(strokeRnd);
                return pi;
            };
 
            for (int i = 0; i < points.count() - 1; i++) {
                paintLine(point(points[i]), point(points[i + 1]), &distance);
            }
            paintLine(point(points[points.count() - 1]), point(points[0]), &distance);
        }
    }
}

References d, KisAlgebra2D::directionBetweenPoints(), distance(), fillPolygon(), FillStyleNone, paintLine(), KisPaintInformation::setPerStrokeRandomSource(), KisPaintInformation::setRandomSource(), and StrokeStyleNone.

◆ paintPolyline()

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

Paint a line that connects the dots in points

Definition at line 1161 of file kis_painter.cc.

{
    if (d->fillStyle != FillStyleNone) {
        fillPolygon(points, d->fillStyle);
    }
 
    if (d->strokeStyle == StrokeStyleNone) return;
 
    if (index >= points.count())
        return;
 
    if (numPoints < 0)
        numPoints = points.count();
 
    if (index + numPoints > points.count())
        numPoints = points.count() - index;
 
    if (numPoints > 1) {
        KisRandomSourceSP rnd = new KisRandomSource();
        KisPerStrokeRandomSourceSP strokeRnd = new KisPerStrokeRandomSource();
 
        auto point = [rnd, strokeRnd] (const QPointF &pt) {
            KisPaintInformation pi(pt);
            pi.setRandomSource(rnd);
            pi.setPerStrokeRandomSource(strokeRnd);
            return pi;
        };
 
        KisDistanceInformation saveDist(points[0],
                KisAlgebra2D::directionBetweenPoints(points[0], points[1], 0.0));
        for (int i = index; i < index + numPoints - 1; i++) {
            paintLine(point(points[i]), point(points[i + 1]), &saveDist);
        }
    }
 
}

References d, KisAlgebra2D::directionBetweenPoints(), fillPolygon(), FillStyleNone, paintLine(), KisPaintInformation::setPerStrokeRandomSource(), KisPaintInformation::setRandomSource(), and StrokeStyleNone.

◆ paintRect() [1/2]

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

Paint a rectangle.

Parameters

x	x coordinate of the top-left corner
y	y coordinate of the top-left corner
w	the rectangle width
h	the rectangle height

Definition at line 1261 of file kis_painter.cc.

{
    paintRect(QRectF(x, y, w, h));
}

References paintRect().

◆ paintRect() [2/2]

void KisPainter::paintRect ( const QRectF & rect )

Paint a rectangle.

Parameters

rect	the rectangle to paint.

Definition at line 1247 of file kis_painter.cc.

{
    QRectF normalizedRect = rect.normalized();
 
    vQPointF points;
 
    points.push_back(normalizedRect.topLeft());
    points.push_back(normalizedRect.bottomLeft());
    points.push_back(normalizedRect.bottomRight());
    points.push_back(normalizedRect.topRight());
 
    paintPolygon(points);
}

References paintPolygon().

◆ pattern()

const KoPatternSP KisPainter::pattern ( ) const

Returns the currently set pattern.

◆ patternTransform()

QTransform KisPainter::patternTransform ( )

get the current transform on the pattern.

◆ preset()

KisPaintOpPresetSP KisPainter::preset ( ) const

Return the paintop preset.

Definition at line 2792 of file kis_painter.cc.

{
    return d->paintOpPreset;
}

References d.

◆ Private() [1/2]

KisPainter::Private ( KisPainter * _q )

inline

Definition at line 22 of file kis_painter_p.h.

22: q(_q) {}

KisPainter::q

KisPainter * q

Definition kis_painter_p.h:26

◆ Private() [2/2]

KisPainter::Private	(	KisPainter *	_q,
		const KoColorSpace *	cs )

inline

Definition at line 23 of file kis_painter_p.h.

24 : q(_q), paintColor(cs), backgroundColor(cs) {}

KisPainter::backgroundColor

KoColor backgroundColor

Definition kis_painter_p.h:36

◆ progressUpdater()

KoUpdater * KisPainter::progressUpdater ( )

protected

◆ putTransaction()

void KisPainter::putTransaction ( KisTransaction * transaction )

continue a transaction started somewhere else

Definition at line 380 of file kis_painter.cc.

{
    Q_ASSERT_X(!d->transaction, "KisPainter::putTransaction()",
               "You asked for a new transaction while still having "
               "another one. Please finish the first one with "
               "end/deleteTransaction() first");
 
    d->transaction = transaction;
}

References d, and transaction.

◆ renderDabWithMirroringNonIncremental()

void KisPainter::renderDabWithMirroringNonIncremental	(	QRect	rc,
		KisPaintDeviceSP	dab )

A complex method that re-renders a dab on an rc area. The rc area and all the dedicated mirroring areas are cleared before the painting, so this method should be used by paintops which do not update the canvas incrementally, but instead regenerate some internal cache dab with the COMPOSITE_COPY op.

See also: KisExperimentPaintOp

If there are no cross-intersections, we can use a fast path and do no cycling recompositing

Definition at line 3019 of file kis_painter.cc.

{
    QVector<QRect> rects;
 
    int x = rc.topLeft().x();
    int y = rc.topLeft().y();
 
    KisLodTransform t(d->device);
    QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
    int mirrorX = -((x+rc.width()) - effectiveAxesCenter.x()) + effectiveAxesCenter.x();
    int mirrorY = -((y+rc.height()) - effectiveAxesCenter.y()) + effectiveAxesCenter.y();
 
    rects << rc;
 
    if (d->mirrorHorizontally && d->mirrorVertically){
        rects << QRect(mirrorX, y, rc.width(), rc.height());
        rects << QRect(mirrorX, mirrorY, rc.width(), rc.height());
        rects << QRect(x, mirrorY, rc.width(), rc.height());
    } else if (d->mirrorHorizontally) {
        rects << QRect(mirrorX, y, rc.width(), rc.height());
    } else if (d->mirrorVertically) {
        rects << QRect(x, mirrorY, rc.width(), rc.height());
    }
 
    Q_FOREACH (const QRect &rc, rects) {
        d->device->clear(rc);
    }
 
    QRect resultRect = dab->extent() | rc;
    bool intersects = false;
 
    for (int i = 1; i < rects.size(); i++) {
        if (rects[i].intersects(resultRect)) {
            intersects = true;
            break;
        }
    }
 
    if (!intersects) {
        rects.resize(1);
    }
 
    Q_FOREACH (const QRect &rc, rects) {
        bitBlt(rc.topLeft(), dab, rc);
    }
 
    Q_FOREACH (const QRect &rc, rects) {
        renderMirrorMask(rc, dab);
    }
}

References bitBlt(), d, KisPaintDevice::extent(), KisLodTransform::map(), and renderMirrorMask().

◆ renderMirrorMask() [1/4]

void KisPainter::renderMirrorMask	(	QRect	rc,
		KisFixedPaintDeviceSP	dab )

First you need to setup the painter with setMirrorInformation, then these set of methods provide way to render the devices mirrored according the axesCenter vertically or horizontally or both.

Parameters

rc	rectangle area covered by dab
dab	this device will be mirrored in-place, it means that it will be changed

Definition at line 2925 of file kis_painter.cc.

{
    int x = rc.topLeft().x();
    int y = rc.topLeft().y();
 
    KisLodTransform t(d->device);
    QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
    int mirrorX = -((x+rc.width()) - effectiveAxesCenter.x()) + effectiveAxesCenter.x();
    int mirrorY = -((y+rc.height()) - effectiveAxesCenter.y()) + effectiveAxesCenter.y();
 
    if (d->mirrorHorizontally && d->mirrorVertically){
        dab->mirror(true, false);
        bltFixed(mirrorX, y, dab, 0,0,rc.width(),rc.height());
        dab->mirror(false,true);
        bltFixed(mirrorX, mirrorY, dab, 0,0,rc.width(),rc.height());
        dab->mirror(true, false);
        bltFixed(x, mirrorY, dab, 0,0,rc.width(),rc.height());
 
    }
    else if (d->mirrorHorizontally){
        dab->mirror(true, false);
        bltFixed(mirrorX, y, dab, 0,0,rc.width(),rc.height());
    }
    else if (d->mirrorVertically){
        dab->mirror(false, true);
        bltFixed(x, mirrorY, dab, 0,0,rc.width(),rc.height());
    }
 
}

References bltFixed(), d, KisLodTransform::map(), and KisFixedPaintDevice::mirror().

◆ renderMirrorMask() [2/4]

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

Definition at line 2956 of file kis_painter.cc.

{
    int x = rc.topLeft().x();
    int y = rc.topLeft().y();
 
    KisLodTransform t(d->device);
    QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
    int mirrorX = -((x+rc.width()) - effectiveAxesCenter.x()) + effectiveAxesCenter.x();
    int mirrorY = -((y+rc.height()) - effectiveAxesCenter.y()) + effectiveAxesCenter.y();
 
    if (d->mirrorHorizontally && d->mirrorVertically){
        dab->mirror(true, false);
        mask->mirror(true, false);
        bltFixedWithFixedSelection(mirrorX,y, dab, mask, rc.width() ,rc.height() );
 
        dab->mirror(false,true);
        mask->mirror(false, true);
        bltFixedWithFixedSelection(mirrorX,mirrorY, dab, mask, rc.width() ,rc.height() );
 
        dab->mirror(true, false);
        mask->mirror(true, false);
        bltFixedWithFixedSelection(x,mirrorY, dab, mask, rc.width() ,rc.height() );
 
    }else if (d->mirrorHorizontally){
        dab->mirror(true, false);
        mask->mirror(true, false);
        bltFixedWithFixedSelection(mirrorX,y, dab, mask, rc.width() ,rc.height() );
 
    }else if (d->mirrorVertically){
        dab->mirror(false, true);
        mask->mirror(false, true);
        bltFixedWithFixedSelection(x,mirrorY, dab, mask, rc.width() ,rc.height() );
    }
 
}

References bltFixedWithFixedSelection(), d, KisLodTransform::map(), and KisFixedPaintDevice::mirror().

◆ renderMirrorMask() [3/4]

void KisPainter::renderMirrorMask	(	QRect	rc,
		KisPaintDeviceSP	dab )

Definition at line 2994 of file kis_painter.cc.

                                                               {
    if (d->mirrorHorizontally || d->mirrorVertically){
        KisFixedPaintDeviceSP mirrorDab(new KisFixedPaintDevice(dab->colorSpace()));
        QRect dabRc( QPoint(0,0), QSize(rc.width(),rc.height()) );
        mirrorDab->setRect(dabRc);
        mirrorDab->lazyGrowBufferWithoutInitialization();
 
        dab->readBytes(mirrorDab->data(),rc);
 
        renderMirrorMask( QRect(rc.topLeft(),dabRc.size()), mirrorDab);
    }
}

References KisPaintDevice::colorSpace(), d, mirrorDab(), KisPaintDevice::readBytes(), and renderMirrorMask().

◆ renderMirrorMask() [4/4]

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

Definition at line 3007 of file kis_painter.cc.

{
    if (d->mirrorHorizontally || d->mirrorVertically){
        KisFixedPaintDeviceSP mirrorDab(new KisFixedPaintDevice(dab->colorSpace()));
        QRect dabRc( QPoint(0,0), QSize(rc.width(),rc.height()) );
        mirrorDab->setRect(dabRc);
        mirrorDab->lazyGrowBufferWithoutInitialization();
        dab->readBytes(mirrorDab->data(),QRect(QPoint(sx,sy),rc.size()));
        renderMirrorMask(rc, mirrorDab, mask);
    }
}

References KisPaintDevice::colorSpace(), d, mirrorDab(), KisPaintDevice::readBytes(), and renderMirrorMask().

◆ renderMirrorMaskSafe() [1/3]

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

Convenience method for renderMirrorMask(), allows to choose whether we need to preserve out dab or do the transformations in-place.

Parameters

rc	rectangle area covered by dab
dab	the device to render
mask	mask to use for rendering
preserveDab	states whether a temporary device should be created to do the transformations

Definition at line 2892 of file kis_painter.cc.

{
    if (!d->mirrorHorizontally && !d->mirrorVertically) return;
 
    KisFixedPaintDeviceSP dabToProcess = dab;
    if (preserveDab) {
        dabToProcess = new KisFixedPaintDevice(*dab);
    }
    renderMirrorMask(rc, dabToProcess);
}

References d, and renderMirrorMask().

◆ renderMirrorMaskSafe() [2/3]

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

Definition at line 2903 of file kis_painter.cc.

{
    if (!d->mirrorHorizontally && !d->mirrorVertically) return;
 
    KisFixedPaintDeviceSP dabToProcess = dab;
    if (preserveDab) {
        dabToProcess = new KisFixedPaintDevice(*dab);
    }
    renderMirrorMask(rc, dabToProcess, mask);
}

References d, and renderMirrorMask().

◆ renderMirrorMaskSafe() [3/3]

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

Convenience method for renderMirrorMask(), allows to choose whether we need to preserve our fixed mask or do the transformations in-place.

Parameters

rc	rectangular area covered by dab
dab	the device to render
sx	x coordinate of the top left corner of the area
sy	y coordinate of the top left corner of the area
mask	mask to use for rendering
preserveMask	states whether a temporary device should be created to do the transformations

Definition at line 2914 of file kis_painter.cc.

{
    if (!d->mirrorHorizontally && !d->mirrorVertically) return;
 
    KisFixedPaintDeviceSP maskToProcess = mask;
    if (preserveMask) {
        maskToProcess = new KisFixedPaintDevice(*mask);
    }
    renderMirrorMask(rc, dab, sx, sy, maskToProcess);
}

References d, and renderMirrorMask().

◆ revertTransaction()

void KisPainter::revertTransaction ( )

Cancel all the changes made by the painter.

Definition at line 330 of file kis_painter.cc.

{
    Q_ASSERT_X(d->transaction, "KisPainter::revertTransaction()",
               "No transaction is in progress");
 
    d->transaction->revert();
    delete d->transaction;
    d->transaction = 0;
}

References d.

◆ runnableStrokeJobsInterface()

KisRunnableStrokeJobsInterface * KisPainter::runnableStrokeJobsInterface ( ) const

Get the interface for running asynchronous jobs. It is used by paintops mostly.

◆ selection()

KisSelectionSP KisPainter::selection ( )

Returns: the selection set on this painter.

◆ setAntiAliasPolygonFill()

void KisPainter::setAntiAliasPolygonFill ( bool antiAliasPolygonFill )

Set whether a polygon's filled area should be anti-aliased or not. The default is true.

Definition at line 2658 of file kis_painter.cc.

{
    d->antiAliasPolygonFill = antiAliasPolygonFill;
}

References antiAliasPolygonFill, and d.

◆ setAverageOpacity()

void KisPainter::setAverageOpacity ( qreal averageOpacity )

Sets average opacity, that is used to make ALPHA_DARKEN painting look correct

Definition at line 2693 of file kis_painter.cc.

{
    d->paramInfo.setOpacityAndAverage(d->paramInfo.opacity, averageOpacity);
}

References d.

◆ setBackgroundColor()

void KisPainter::setBackgroundColor ( const KoColor & color )

Set the current background color, and convert it to the color space of the current paint device.

Definition at line 2615 of file kis_painter.cc.

{
    d->backgroundColor = color;
    if (d->device) {
        d->backgroundColor.convertTo(d->device->compositionSourceColorSpace());
    }
}

References d.

◆ setChannelFlags()

void KisPainter::setChannelFlags ( QBitArray channelFlags )

Set the channelflags: a bit array where true means that the channel corresponding in position with the bit will be read by the operation, and false means that it will not be affected.

An empty channelFlags parameter means that all channels are affected.

Parameters

channelFlags the bit array that masks the source channels; only the channels where the corresponding bit is true it will be composited onto the destination device.

Definition at line 2575 of file kis_painter.cc.

{
    // Q_ASSERT(channelFlags.isEmpty() || quint32(channelFlags.size()) == d->colorSpace->channelCount());
    // Now, if all bits in the channelflags are true, pass an empty channel flags bitarray
    // because otherwise the compositeops cannot optimize.
    d->paramInfo.channelFlags = channelFlags;
 
    if (!channelFlags.isEmpty() && channelFlags == QBitArray(channelFlags.size(), true)) {
        d->paramInfo.channelFlags = QBitArray();
    }
}

References channelFlags(), and d.

◆ setColorConversionFlags()

void KisPainter::setColorConversionFlags ( KoColorConversionTransformation::ConversionFlags conversionFlags )

set the conversion flags in case pixels need to be converted before painting

Definition at line 2870 of file kis_painter.cc.

{
    d->conversionFlags = conversionFlags;
}

References conversionFlags, and d.

◆ setCompositeOpId() [1/2]

void KisPainter::setCompositeOpId ( const KoCompositeOp * op )

Set the composite op ID for this painter Only kept for convenience, it will just call ::setCompositeOpId(QString) with op->Id().

Definition at line 2735 of file kis_painter.cc.

{
    setCompositeOpId(op->id());
}

References KoCompositeOp::id, and setCompositeOpId().

◆ setCompositeOpId() [2/2]

void KisPainter::setCompositeOpId ( const QString & op )

Set the composite op for this painter by string.

Definition at line 2745 of file kis_painter.cc.

{
    if (op != d->compositeOpId) {
        d->compositeOpId = op;
        d->cachedCompositeOp = nullptr;
    }
}

References d.

◆ setFillStyle()

void KisPainter::setFillStyle ( FillStyle fillStyle )

Set the current style with which to fill.

Definition at line 2638 of file kis_painter.cc.

{
    d->fillStyle = fillStyle;
}

References d, and fillStyle.

◆ setFlow()

void KisPainter::setFlow ( qreal flow )

Definition at line 2677 of file kis_painter.cc.

{
    d->paramInfo.flow = flow;
}

References d, and flow().

◆ setGenerator()

void KisPainter::setGenerator ( KisFilterConfigurationSP generator )

Set the current generator (a generator can be used to fill an area.

Definition at line 2628 of file kis_painter.cc.

{
    d->generator = generator;
}

References d, and generator.

◆ setGradient()

void KisPainter::setGradient ( const KoAbstractGradientSP gradient )

Definition at line 2768 of file kis_painter.cc.

{
    d->gradient = gradient;
}

References d, and gradient.

◆ setMaskImageSize()

void KisPainter::setMaskImageSize	(	qint32	width,
		qint32	height )

Set the size of the tile in fillPainterPath, useful when optimizing the use of fillPainterPath e.g. Spray paintop uses more small tiles, although selections uses bigger tiles. QImage::fill is quite expensive so with smaller images you can save instructions Default and maximum size is 256x256 image

Definition at line 2831 of file kis_painter.cc.

{
 
    d->maskImageWidth = qBound(1, width, 256);
    d->maskImageHeight = qBound(1, height, 256);
    d->fillPainter = 0;
    d->polygonMaskImage = QImage();
}

References d.

◆ setMirrorInformation()

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

Definition at line 2802 of file kis_painter.cc.

{
    d->axesCenter = axesCenter;
    d->mirrorHorizontally = mirrorHorizontally;
    d->mirrorVertically = mirrorVertically;
}

References axesCenter, d, mirrorHorizontally, and mirrorVertically.

◆ setOpacityF()

void KisPainter::setOpacityF ( qreal opacity )

Definition at line 2713 of file kis_painter.cc.

{
    d->isOpacityUnit = qFuzzyCompare(opacity, OPACITY_OPAQUE_F);
    d->paramInfo.opacity = opacity;
}

References d, OPACITY_OPAQUE_F, and qFuzzyCompare().

◆ setOpacityToUnit()

void KisPainter::setOpacityToUnit ( )

Definition at line 2729 of file kis_painter.cc.

{
    d->isOpacityUnit = true;
    d->paramInfo.opacity = OPACITY_OPAQUE_F;
}

References d, and OPACITY_OPAQUE_F.

◆ setOpacityU8()

void KisPainter::setOpacityU8 ( quint8 opacity )

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

Definition at line 2707 of file kis_painter.cc.

{
    d->isOpacityUnit = opacity == OPACITY_OPAQUE_U8;
    d->paramInfo.opacity = float(opacity) / 255.0f;
}

References d, and OPACITY_OPAQUE_U8.

◆ setOpacityUpdateAverage()

void KisPainter::setOpacityUpdateAverage ( qreal opacity )

Sets the opacity of the painting and recalculates the mean opacity of the stroke. This mean value is used to make ALPHA_DARKEN painting look correct

Definition at line 2687 of file kis_painter.cc.

{
    d->isOpacityUnit = qFuzzyCompare(opacity, OPACITY_OPAQUE_F);
    d->paramInfo.updateOpacityAndAverage(opacity);
}

References d, OPACITY_OPAQUE_F, and qFuzzyCompare().

◆ setPaintColor()

void KisPainter::setPaintColor ( const KoColor & color )

Set the color that will be used to paint with, and convert it to the color space of the current paint device.

Definition at line 2602 of file kis_painter.cc.

{
    d->paintColor = color;
    if (d->device) {
        d->paintColor.convertTo(d->device->compositionSourceColorSpace());
    }
}

References d.

◆ setPaintOpPreset()

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

Set the paintop preset to use. If image is given, the paintop will be created using this image as parameter. Some paintops really want to know about the image they work for, e.g. the clone paintop.

Definition at line 2778 of file kis_painter.cc.

{
    d->paintOpPreset = preset;
    KisPaintOp *paintop = KisPaintOpRegistry::instance()->paintOp(preset, this, node, image);
    Q_ASSERT(paintop);
    if (paintop) {
        delete d->paintOp;
        d->paintOp = paintop;
    }
    else {
        warnKrita << "Could not create paintop for preset " << preset->name();
    }
}

References d, KisPaintOpRegistry::instance(), KisPaintOpRegistry::paintOp(), preset(), and warnKrita.

◆ setPattern()

void KisPainter::setPattern ( const KoPatternSP pattern )

Set the current pattern.

Definition at line 2592 of file kis_painter.cc.

{
    d->pattern = pattern;
}

References d, and pattern.

◆ setPatternTransform()

void KisPainter::setPatternTransform ( QTransform transform )

Set the transform on the pattern.

Definition at line 2648 of file kis_painter.cc.

{
    d->patternTransform = transform;
}

References d.

◆ setProgress()

void KisPainter::setProgress ( KoUpdater * progressUpdater )

If set, the painter action is cancelable, if the action supports that.

Definition at line 2561 of file kis_painter.cc.

{
    d->progressUpdater = progressUpdater;
}

References d, and progressUpdater.

◆ setRenderingIntent()

void KisPainter::setRenderingIntent ( KoColorConversionTransformation::Intent intent )

set the rendering intent in case pixels need to be converted before painting

Definition at line 2865 of file kis_painter.cc.

{
    d->renderingIntent = intent;
}

References d.

◆ setRunnableStrokeJobsInterface()

void KisPainter::setRunnableStrokeJobsInterface ( KisRunnableStrokeJobsInterface * interface )

Set interface for running asynchronous jobs by paintops.

NOTE: the painter does not own the interface device. It is the responsibility of the caller to ensure that the interface object is alive during the lifetime of the painter.

Definition at line 2875 of file kis_painter.cc.

{
    d->runnableStrokeJobsInterface = interface;
}

References d.

◆ setSelection()

void KisPainter::setSelection ( KisSelectionSP selection )

Reset the selection to the given selection. All painter actions will be masked by the specified selection.

Definition at line 2753 of file kis_painter.cc.

{
    d->selection = selection;
}

References d, and selection.

◆ setStrokeStyle()

void KisPainter::setStrokeStyle ( KisPainter::StrokeStyle strokeStyle )

Set the current brush stroke style.

Definition at line 2668 of file kis_painter.cc.

{
    d->strokeStyle = strokeStyle;
}

References d, and strokeStyle.

◆ strokeStyle()

StrokeStyle KisPainter::strokeStyle ( ) const

Returns the current brush stroke style.

◆ takeDirtyRegion()

QVector< QRect > KisPainter::takeDirtyRegion ( )

The methods in this class do not tell the paintdevice to update, but they calculate the dirty area. This method returns this dirty area and resets it.

Definition at line 401 of file kis_painter.cc.

{
    QVector<QRect> vrect = d->dirtyRects;
    d->dirtyRects.clear();
    return vrect;
}

References d.

◆ takeTransaction()

KisTransaction * KisPainter::takeTransaction ( )

take transaction out of the reach of KisPainter

Definition at line 390 of file kis_painter.cc.

{
    Q_ASSERT_X(d->transaction, "KisPainter::takeTransaction()",
               "No transaction is in progress");
    KisTransaction *temp = d->transaction;
    d->transaction = 0;
    return temp;
}

References d.

◆ tryReduceSourceRect()

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

Member Data Documentation

◆ antiAliasPolygonFill

bool KisPainter::antiAliasPolygonFill {true}

Definition at line 42 of file kis_painter_p.h.

42{true};

◆ axesCenter

QPointF KisPainter::axesCenter

Definition at line 59 of file kis_painter_p.h.

◆ backgroundColor

const KoColor & KisPainter::backgroundColor

Definition at line 36 of file kis_painter_p.h.

◆ cachedCompositeOp

const KoCompositeOp* KisPainter::cachedCompositeOp {nullptr}

Definition at line 49 of file kis_painter_p.h.

49{nullptr};

◆ cachedSourceColorSpace

const KoColorSpace* KisPainter::cachedSourceColorSpace {nullptr}

Definition at line 48 of file kis_painter_p.h.

48{nullptr};

◆ colorSpace

const KoColorSpace* KisPainter::colorSpace {nullptr}

Definition at line 46 of file kis_painter_p.h.

46{nullptr};

◆ compositeOpId

QString KisPainter::compositeOpId

Definition at line 50 of file kis_painter_p.h.

◆ conversionFlags

KoColorConversionTransformation::ConversionFlags KisPainter::conversionFlags {KoColorConversionTransformation::Empty}

Definition at line 65 of file kis_painter_p.h.

65{KoColorConversionTransformation::Empty};

KoColorConversionTransformation::Empty

@ Empty

Definition KoColorConversionTransformation.h:41

◆ customColor

KoColor KisPainter::customColor

Definition at line 37 of file kis_painter_p.h.

◆ d

Private* const KisPainter::d

private

Definition at line 899 of file kis_painter.h.

◆ device

KisPaintDeviceSP KisPainter::device

Definition at line 28 of file kis_painter_p.h.

◆ dirtyRects

QVector<QRect> KisPainter::dirtyRects

Definition at line 33 of file kis_painter_p.h.

◆ duplicateOffset

QPointF KisPainter::duplicateOffset

Definition at line 44 of file kis_painter_p.h.

◆ fakeRunnableStrokeJobsInterface

QScopedPointer<KisRunnableStrokeJobsInterface> KisPainter::fakeRunnableStrokeJobsInterface

Definition at line 67 of file kis_painter_p.h.

◆ fillPainter

KisFillPainter* KisPainter::fillPainter {nullptr}

Definition at line 55 of file kis_painter_p.h.

55{nullptr};

◆ fillStyle

KisPainter::FillStyle KisPainter::fillStyle {FillStyleNone}

Definition at line 40 of file kis_painter_p.h.

40{FillStyleNone};

◆ generator

const KisFilterConfigurationSP KisPainter::generator

Definition at line 38 of file kis_painter_p.h.

◆ gradient

const KoAbstractGradientSP KisPainter::gradient

Definition at line 51 of file kis_painter_p.h.

◆ isOpacityUnit

bool KisPainter::isOpacityUnit {true}

Definition at line 62 of file kis_painter_p.h.

62{true}; // TODO: move into ParameterInfo

◆ maskImageHeight

qint32 KisPainter::maskImageHeight {255}

Definition at line 58 of file kis_painter_p.h.

58{255};

◆ maskImageWidth

qint32 KisPainter::maskImageWidth {255}

Definition at line 57 of file kis_painter_p.h.

57{255};

◆ maskPainter

QPainter* KisPainter::maskPainter {nullptr}

Definition at line 54 of file kis_painter_p.h.

54{nullptr};

◆ mirrorHorizontally

bool KisPainter::mirrorHorizontally {false}

Definition at line 60 of file kis_painter_p.h.

60{false};

◆ mirrorVertically

bool KisPainter::mirrorVertically {false}

Definition at line 61 of file kis_painter_p.h.

61{false};

◆ paintColor

const KoColor & KisPainter::paintColor

Definition at line 35 of file kis_painter_p.h.

◆ paintOp

KisPaintOp * KisPainter::paintOp {nullptr}

Definition at line 34 of file kis_painter_p.h.

34{nullptr};

◆ paintOpPreset

KisPaintOpPresetSP KisPainter::paintOpPreset

Definition at line 52 of file kis_painter_p.h.

◆ paramInfo

KoCompositeOp::ParameterInfo KisPainter::paramInfo

Definition at line 63 of file kis_painter_p.h.

◆ pattern

const KoPatternSP KisPainter::pattern

Definition at line 43 of file kis_painter_p.h.

◆ patternTransform

QTransform KisPainter::patternTransform

Definition at line 68 of file kis_painter_p.h.

◆ pixelSize

quint32 KisPainter::pixelSize {0}

Definition at line 45 of file kis_painter_p.h.

45{0};

◆ polygon

KisPaintDeviceSP KisPainter::polygon

Definition at line 56 of file kis_painter_p.h.

◆ polygonMaskImage

QImage KisPainter::polygonMaskImage

Definition at line 53 of file kis_painter_p.h.

◆ profile

KoColorProfile* KisPainter::profile {nullptr}

Definition at line 47 of file kis_painter_p.h.

47{nullptr};

◆ progressUpdater

KoUpdater * KisPainter::progressUpdater {nullptr}

Definition at line 31 of file kis_painter_p.h.

31{nullptr};

◆ q

KisPainter* KisPainter::q {nullptr}

Definition at line 26 of file kis_painter_p.h.

26{nullptr};

◆ renderingIntent

KoColorConversionTransformation::Intent KisPainter::renderingIntent {KoColorConversionTransformation::IntentPerceptual}

Definition at line 64 of file kis_painter_p.h.

64{KoColorConversionTransformation::IntentPerceptual};

KoColorConversionTransformation::IntentPerceptual

@ IntentPerceptual

Definition KoColorConversionTransformation.h:31

◆ runnableStrokeJobsInterface

KisRunnableStrokeJobsInterface * KisPainter::runnableStrokeJobsInterface {nullptr}

Definition at line 66 of file kis_painter_p.h.

66{nullptr};

◆ selection

KisSelectionSP KisPainter::selection

Definition at line 29 of file kis_painter_p.h.

◆ sourceLayer

KisPaintLayer* KisPainter::sourceLayer {nullptr}

Definition at line 39 of file kis_painter_p.h.

39{nullptr};

◆ strokeStyle

KisPainter::StrokeStyle KisPainter::strokeStyle {StrokeStyleBrush}

Definition at line 41 of file kis_painter_p.h.

41{StrokeStyleBrush};

◆ transaction

KisTransaction* KisPainter::transaction {nullptr}

Definition at line 30 of file kis_painter_p.h.

30{nullptr};

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

libs/image/kis_painter.h
libs/image/kis_painter_p.h
libs/image/kis_painter.cc
libs/image/kis_painter_blt_multi_fixed.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ FillStyle

◆ StrokeStyle

Constructor & Destructor Documentation

◆ KisPainter() [1/4]

◆ KisPainter() [2/4]

◆ KisPainter() [3/4]

◆ ~KisPainter()

◆ KisPainter() [4/4]

Member Function Documentation

◆ addDirtyRect()

◆ addDirtyRects()

◆ antiAliasPolygonFill()

◆ applyDevice()

◆ applyDeviceWithSelection()

◆ backgroundColor()

◆ begin() [1/2]

◆ begin() [2/2]

◆ beginTransaction()

◆ bitBlt() [1/2]

◆ bitBlt() [2/2]

◆ bitBltImpl()

◆ bitBltOldData() [1/2]

◆ bitBltOldData() [2/2]

◆ bitBltWithFixedSelection() [1/2]

◆ bitBltWithFixedSelection() [2/2]

◆ blendAverageOpacity()

◆ bltFixed() [1/3]

◆ bltFixed() [2/3]

◆ bltFixed() [3/3]

◆ bltFixedWithFixedSelection() [1/2]

◆ bltFixedWithFixedSelection() [2/2]

◆ calculateAllMirroredPoints() [1/2]

◆ calculateAllMirroredPoints() [2/2]

◆ calculateAllMirroredRects()

◆ calculateMirroredObjects()

◆ channelFlags()

◆ checkDeviceHasTransparency()

◆ compositeOnePixel()

◆ compositeOp()

◆ compositeOpId()

◆ convertToAlphaAsAlpha()

◆ convertToAlphaAsGray()

◆ convertToAlphaAsPureAlpha()

◆ copyAreaOptimized() [1/2]

◆ copyAreaOptimized() [2/2]

◆ copyAreaOptimizedOldData()

◆ copyMirrorInformationFrom()

◆ deleteTransaction()

◆ device() [1/2]

◆ device() [2/2]

◆ drawDDALine()

◆ drawLine() [1/2]

◆ drawLine() [2/2]

◆ drawPainterPath() [1/2]

◆ drawPainterPath() [2/2]

◆ drawThickLine()

◆ drawWobblyLine()

◆ drawWuLine()

◆ end()

◆ endAndTakeTransaction()

◆ endTransaction() [1/2]

◆ endTransaction() [2/2]

◆ fill()

◆ fillPainterPath() [1/2]

◆ fillPainterPath() [2/2]

◆ fillPainterPathImpl()

◆ fillPolygon()

◆ fillStyle()

◆ flow()

◆ frac()

◆ generator()