#include <kis_paint_device.h>

Inheritance diagram for KisPaintDevice:

Classes
struct	LodDataStruct

struct	MemoryReleaseObject

struct	Private

Signals
void	colorSpaceChanged (const KoColorSpace *colorspace)

void	profileChanged (const KoColorProfile *profile)

Public Member Functions
bool	burnKeyframe ()

bool	burnKeyframe (int frameID)
	burnKeyframe

QRect	calculateExactBounds (bool nonDefaultOnly) const

quint32	channelCount () const

virtual void	clear ()

void	clear (const QRect &rc)

void	clearSelection (KisSelectionSP selection)

const KoColorSpace *	colorSpace () const

virtual const KoColorSpace *	compositionSourceColorSpace () const

void	convertFromQImage (const QImage &image, const KoColorProfile *profile, qint32 offsetX=0, qint32 offsetY=0)

void	convertTo (const KoColorSpace dstColorSpace, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags(), KUndo2Command parentCommand=nullptr, KoUpdater *progressUpdater=nullptr)

QImage	convertToQImage (const KoColorProfile *dstProfile, const QRect &rc, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags()) const

QImage	convertToQImage (const KoColorProfile *dstProfile, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags()) const

QImage	convertToQImage (const KoColorProfile *dstProfile, qint32 x, qint32 y, qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags()) const

KUndo2Command *	createChangeInterstrokeDataCommand (KisInterstrokeDataSP data)
	set interstroke data to the device

KisPaintDeviceSP	createCompositionSourceDevice () const

KisPaintDeviceSP	createCompositionSourceDevice (KisPaintDeviceSP cloneSource) const

KisPaintDeviceSP	createCompositionSourceDevice (KisPaintDeviceSP cloneSource, const QRect roughRect) const

KisFixedPaintDeviceSP	createCompositionSourceDeviceFixed () const

KisHLineConstIteratorSP	createHLineConstIteratorNG (qint32 x, qint32 y, qint32 w) const

KisHLineIteratorSP	createHLineIteratorNG (qint32 x, qint32 y, qint32 w)

KisRasterKeyframeChannel *	createKeyframeChannel (const KoID &id)

LodDataStruct *	createLodDataStruct (int lod)

KisRandomAccessorSP	createRandomAccessorNG ()

KisRandomConstAccessorSP	createRandomConstAccessorNG () const

KisRandomSubAccessorSP	createRandomSubAccessor () const

KisRepeatHLineConstIteratorSP	createRepeatHLineConstIterator (qint32 x, qint32 y, qint32 w, const QRect &_dataWidth) const

KisRepeatVLineConstIteratorSP	createRepeatVLineConstIterator (qint32 x, qint32 y, qint32 h, const QRect &_dataWidth) const

QImage	createThumbnail (qint32 maxw, qint32 maxh, qreal oversample=1, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags())

QImage	createThumbnail (qint32 maxw, qint32 maxh, QRect rect, qreal oversample=1, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags())

QImage	createThumbnail (qint32 maxw, qint32 maxh, Qt::AspectRatioMode aspectRatioMode, qreal oversample=1, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags())

KisPaintDeviceSP	createThumbnailDevice (qint32 w, qint32 h, QRect rect=QRect(), QRect outputRect=QRect()) const

KisPaintDeviceSP	createThumbnailDeviceOversampled (qint32 w, qint32 h, qreal oversample, QRect rect=QRect(), QRect outputRect=QRect()) const

KisVLineConstIteratorSP	createVLineConstIteratorNG (qint32 x, qint32 y, qint32 h) const

KisVLineIteratorSP	createVLineIteratorNG (qint32 x, qint32 y, qint32 h)

void	crop (const QRect &r)
	Convenience method for the above.

void	crop (qint32 x, qint32 y, qint32 w, qint32 h)

KisDataManagerSP	dataManager () const

KisDefaultBoundsBaseSP	defaultBounds () const

KoColor	defaultPixel () const

void	estimateMemoryStats (qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const

QRect	exactBounds () const

QRect	exactBoundsAmortized () const

QRect	extent () const

void	extent (qint32 &x, qint32 &y, qint32 &w, qint32 &h) const
	Convenience method for the above.

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

void	fill (qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel)

KisPaintDeviceFramesInterface *	framesInterface ()

void	generateLodCloneDevice (KisPaintDeviceSP dst, const QRect &originalRect, int lod)

KisInterstrokeDataSP	interstrokeData () const

KisRasterKeyframeChannel *	keyframeChannel () const

	KisPaintDevice (const KisPaintDevice &rhs, KritaUtils::DeviceCopyMode copyMode=KritaUtils::CopySnapshot, KisNode *newParentNode=0)

	KisPaintDevice (const KoColorSpace *colorSpace, const QString &name=QString())

	KisPaintDevice (KisNodeWSP parent, const KoColorSpace *colorSpace, KisDefaultBoundsBaseSP defaultBounds=KisDefaultBoundsBaseSP(), const QString &name=QString())

void	makeCloneFrom (KisPaintDeviceSP src, const QRect &rect)

void	makeCloneFromRough (KisPaintDeviceSP src, const QRect &minimalRect)

void	makeFullCopyFrom (const KisPaintDevice &rhs, KritaUtils::DeviceCopyMode copyMode=KritaUtils::CopySnapshot, KisNode *newParentNode=0)

virtual void	moveTo (const QPoint &pt)

void	moveTo (qint32 x, qint32 y)

QRect	nonDefaultPixelArea () const

QPoint	offset () const

KoColor	pixel (const QPoint &pos) const

bool	pixel (qint32 x, qint32 y, KoColor *kc) const

bool	pixel (qint32 x, qint32 y, QColor *c) const

quint32	pixelSize () const

void	prepareClone (KisPaintDeviceSP src)

void	purgeDefaultPixels ()

bool	read (QIODevice *stream)

void	readBytes (quint8 *data, const QRect &rect) const

void	readBytes (quint8 *data, qint32 x, qint32 y, qint32 w, qint32 h) const

QVector< quint8 * >	readPlanarBytes (qint32 x, qint32 y, qint32 w, qint32 h) const

KisRegion	region () const

KisRegion	regionExact () const

KisRegion	regionForLodSyncing () const

KUndo2Command *	reincarnateWithDetachedHistory (bool copyContent)

void	requestTimeSwitch (int time)

int	sequenceNumber () const

void	setDataManager (KisDataManagerSP data, const KoColorSpace *colorSpace=0)

void	setDefaultBounds (KisDefaultBoundsBaseSP bounds)

void	setDefaultPixel (const KoColor &defPixel)

void	setDirty ()

void	setDirty (const KisRegion &region)

void	setDirty (const QRect &rc)

void	setDirty (const QVector< QRect > &rects)

void	setParentNode (KisNodeWSP parent)

bool	setPixel (qint32 x, qint32 y, const KoColor &kc)
	Convenience method for the above.

bool	setPixel (qint32 x, qint32 y, const QColor &c)

bool	setProfile (const KoColorProfile profile, KUndo2Command parentCommand)

void	setProjectionDevice (bool value)

void	setSupportsWraparoundMode (bool value)

void	setX (qint32 x)

void	setY (qint32 y)

bool	supportsWraproundMode () const

void	testingFetchLodDevice (KisPaintDeviceSP targetDevice)

void	updateLodDataStruct (LodDataStruct *dst, const QRect &srcRect)

void	uploadLodDataStruct (LodDataStruct *dst)

bool	write (KisPaintDeviceWriter &store)

void	writeBytes (const quint8 *data, const QRect &rect)

void	writeBytes (const quint8 *data, qint32 x, qint32 y, qint32 w, qint32 h)

void	writePlanarBytes (QVector< quint8 * > planes, qint32 x, qint32 y, qint32 w, qint32 h)

qint32	x () const

qint32	y () const

	~KisPaintDevice () override

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static MemoryReleaseObject *	createMemoryReleaseObject ()

Protected Member Functions
void	fastBitBlt (KisPaintDeviceSP src, const QRect &rect)

void	fastBitBltOldData (KisPaintDeviceSP src, const QRect &rect)

bool	fastBitBltPossible (KisPaintDeviceSP src)

void	fastBitBltRough (KisPaintDeviceSP src, const QRect &rect)

void	fastBitBltRoughOldData (KisPaintDeviceSP src, const QRect &rect)

	KisPaintDevice (KisDataManagerSP explicitDataManager, KisPaintDeviceSP src, const QString &name=QString())

KisNodeWSP	parentNode () const

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Private Member Functions
QVector< qint32 >	channelSizes () const

void	emitColorSpaceChanged ()

void	emitProfileChanged ()

void	init (const KoColorSpace *colorSpace, KisDefaultBoundsBaseSP defaultBounds, KisNodeWSP parent, const QString &name)

KisPaintDevice &	operator= (const KisPaintDevice &)

Private Attributes
Private *const	m_d

Friends
class	DataReaderThread

class	KisPaintDeviceFramesInterface

class	KisPaintDeviceTest

class	KisPainter

class	KisSelectionTest

class	PaintDeviceCache

Detailed Description

A paint device contains the actual pixel data and offers methods to read and write pixels. A paint device has an integer x, y position (it is not positioned on the image with sub-pixel accuracy). A KisPaintDevice doesn't have any fixed size, the size changes dynamically when pixels are accessed by an iterator.

Definition at line 65 of file kis_paint_device.h.

Constructor & Destructor Documentation

◆ KisPaintDevice() [1/4]

KisPaintDevice::KisPaintDevice	(	const KoColorSpace *	colorSpace,
		const QString &	name = QString() )

explicit

Create a new paint device with the specified colorspace.

Parameters

colorSpace	the colorspace of this paint device
name	for debugging purposes

Definition at line 1043 of file kis_paint_device.cc.

    : QObject(0)
    , m_d(new Private(this))
{
    init(colorSpace, new KisDefaultBounds(), 0, name);
}

References colorSpace(), and init().

◆ KisPaintDevice() [2/4]

KisPaintDevice::KisPaintDevice	(	KisNodeWSP	parent,
		const KoColorSpace *	colorSpace,
		KisDefaultBoundsBaseSP	defaultBounds = KisDefaultBoundsBaseSP(),
		const QString &	name = QString() )

Create a new paint device with the specified colorspace. The parent node will be notified of changes to this paint device.

Parameters

parent	the node that contains this paint device
colorSpace	the colorspace of this paint device
defaultBounds	boundaries of the device in case it is empty
name	for debugging purposes

Definition at line 1050 of file kis_paint_device.cc.

    : QObject(0)
    , m_d(new Private(this))
{
    init(colorSpace, defaultBounds, parent, name);
}

References colorSpace(), defaultBounds(), and init().

◆ KisPaintDevice() [3/4]

KisPaintDevice::KisPaintDevice	(	const KisPaintDevice &	rhs,
		KritaUtils::DeviceCopyMode	copyMode = KritaUtils::CopySnapshot,
		KisNode *	newParentNode = 0 )

Creates a copy of this device.

If copyMode is CopySnapshot, the newly created device clones the current frame of rhs only (default and efficient behavior). If copyFrames is CopyAllFrames, the new device is a deep copy of the source with all the frames included.

Definition at line 1082 of file kis_paint_device.cc.

    : QObject()
    , KisShared()
    , m_d(new Private(this))
{
    if (this != &rhs) {
        makeFullCopyFrom(rhs, copyMode, newParentNode);
    }
}

References makeFullCopyFrom().

◆ ~KisPaintDevice()

KisPaintDevice::~KisPaintDevice ( )

override

Definition at line 1112 of file kis_paint_device.cc.

{
    delete m_d;
}

References m_d.

◆ KisPaintDevice() [4/4]

KisPaintDevice::KisPaintDevice	(	KisDataManagerSP	explicitDataManager,
		KisPaintDeviceSP	src,
		const QString &	name = QString() )

protected

A special constructor for usage in KisPixelSelection. It allows two paint devices to share a data manager.

Parameters

explicitDataManager	data manager to use inside paint device
src	source paint device to copy parameters from
name	for debugging purposes

Member Function Documentation

◆ burnKeyframe() [1/2]

bool KisPaintDevice::burnKeyframe ( )

Definition at line 2209 of file kis_paint_device.cc.

{
    if (m_d->framesInterface) {
        return burnKeyframe(m_d->framesInterface->currentFrameId());
    }
    return true;
}

References burnKeyframe(), KisPaintDevice::Private::framesInterface, and m_d.

◆ burnKeyframe() [2/2]

bool KisPaintDevice::burnKeyframe ( int frameID )

burnKeyframe

Take a frame from the keyframe channel, Copy the contents onto the "base" frame, and completely remove the keyframe channel.

Should be useful for copy+paste operations where we shouldn't expect keyframe data to persist.

Parameterless version simply gets the current frameID.

Parameters

frameID – frameID (from the framesInterface, not the time) to burn to device.

Returns: success

Definition at line 2188 of file kis_paint_device.cc.

{
    KIS_ASSERT_RECOVER_RETURN_VALUE(m_d->framesInterface.data()->frames().contains(frameID), false);
 
    // Preserve keyframe data from frameID...
    KisPaintDeviceSP holder = new KisPaintDevice(m_d->colorSpace());
    m_d->framesInterface->writeFrameToDevice(frameID, holder);
 
    // Remove all keyframes..
    QSet<int> times = m_d->contentChannel->allKeyframeTimes();
    Q_FOREACH( const int& time, times ) {
        m_d->contentChannel->removeKeyframe(time);
    }
 
    // TODO: Eventually rewrite this to completely remove contentChannel.
    //          For now, importing it as frame 0 will be close enough.
    m_d->contentChannel->importFrame(0, holder, nullptr);
 
    return true;
}

References KisPaintDevice::Private::colorSpace(), KisPaintDevice::Private::contentChannel, KisPaintDevice::Private::framesInterface, KIS_ASSERT_RECOVER_RETURN_VALUE, KisPaintDevice(), and m_d.

◆ calculateExactBounds()

QRect KisPaintDevice::calculateExactBounds ( bool nonDefaultOnly ) const

Calculates exact bounds of the device. Used internally by a transparent caching system. The solution is very slow because it does a linear scanline search. So the complexity is n*n at worst.

See also: exactBounds(), nonDefaultPixelArea()

We will calculate exact bounds only outside of the image bounds, and that'll be nondefault area only.

Definition at line 1435 of file kis_paint_device.cc.

{
    QRect startRect = extent();
    QRect endRect;
 
    quint8 defaultOpacity = defaultPixel().opacityU8();
    if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
        if (!nonDefaultOnly) {
            endRect = defaultBounds()->bounds();
            nonDefaultOnly = true;
 
        } else {
            startRect = region().boundingRect();
        }
    }
 
    if (nonDefaultOnly) {
        const KoColor defaultPixel = this->defaultPixel();
        Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
        endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
    } else {
        Impl::CheckFullyTransparent compareOp(m_d->colorSpace());
        endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
    }
 
    return endRect;
}

References KisRegion::boundingRect(), KisDefaultBoundsBase::bounds(), Impl::calculateExactBoundsImpl(), KisPaintDevice::Private::colorSpace(), KoColor::data(), defaultBounds(), defaultPixel(), extent(), m_d, OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), pixelSize(), and region().

◆ channelCount()

quint32 KisPaintDevice::channelCount ( ) const

Return the number of channels a pixel takes

Definition at line 2030 of file kis_paint_device.cc.

{
    quint32 _channelCount = m_d->colorSpace()->channelCount();
    Q_ASSERT(_channelCount > 0);
    return _channelCount;
}

References KoColorSpace::channelCount(), KisPaintDevice::Private::colorSpace(), and m_d.

◆ channelSizes()

QVector< qint32 > KisPaintDevice::channelSizes ( ) const

private

Return a vector with in order the size in bytes of the channels in the colorspace of this paint device.

Definition at line 2122 of file kis_paint_device.cc.

{
    QVector<qint32> sizes;
    QList<KoChannelInfo*> channels = colorSpace()->channels();
    std::sort(channels.begin(), channels.end());
 
    Q_FOREACH (KoChannelInfo * channelInfo, channels) {
        sizes.append(channelInfo->size());
    }
    return sizes;
}

References KoColorSpace::channels, colorSpace(), and KoChannelInfo::size().

◆ clear() [1/2]

void KisPaintDevice::clear ( )

virtual

Complete erase the current paint device. Its size will become 0. This does not take the selection into account.

Reimplemented in KisPixelSelection.

Definition at line 1523 of file kis_paint_device.cc.

{
    m_d->dataManager()->clear();
    m_d->cache()->invalidate();
}

References KisPaintDevice::Private::cache(), KisDataManager::clear(), KisPaintDevice::Private::dataManager(), KisPaintDeviceCache::invalidate(), and m_d.

◆ clear() [2/2]

void KisPaintDevice::clear ( const QRect & rc )

Clear the given rectangle to transparent black. The paint device will expand to contain the given rect.

Definition at line 1529 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->clear(rc);
}

References KisPaintDevice::Private::KisPaintDeviceStrategy::clear(), KisPaintDevice::Private::currentStrategy(), and m_d.

◆ clearSelection()

void KisPaintDevice::clearSelection ( KisSelectionSP selection )

Clear the selected pixels from the paint device

Definition at line 1875 of file kis_paint_device.cc.

{
    const KoColorSpace *colorSpace = m_d->colorSpace();
    const QRect r = selection->selectedExactRect();
 
    if (r.isValid()) {
 
        {
            KisHLineIteratorSP devIt = createHLineIteratorNG(r.x(), r.y(), r.width());
            KisHLineConstIteratorSP selectionIt = selection->projection()->createHLineConstIteratorNG(r.x(), r.y(), r.width());
 
            const KoColor defaultPixel = this->defaultPixel();
            bool transparentDefault = (defaultPixel.opacityU8() == OPACITY_TRANSPARENT_U8);
            for (qint32 y = 0; y < r.height(); y++) {
 
                do {
                    // XXX: Optimize by using stretches
                    colorSpace->applyInverseAlphaU8Mask(devIt->rawData(), selectionIt->rawDataConst(), 1);
                    if (transparentDefault && colorSpace->opacityU8(devIt->rawData()) == OPACITY_TRANSPARENT_U8) {
                        memcpy(devIt->rawData(), defaultPixel.data(), colorSpace->pixelSize());
                    }
                } while (devIt->nextPixel() && selectionIt->nextPixel());
                devIt->nextRow();
                selectionIt->nextRow();
            }
        }
 
        // purge() must be executed **after** all iterators have been destroyed!
        m_d->dataManager()->purge(r.translated(-m_d->x(), -m_d->y()));
 
        setDirty(r);
    }
}

References KoColorSpace::applyInverseAlphaU8Mask(), KisPaintDevice::Private::colorSpace(), colorSpace(), createHLineConstIteratorNG(), createHLineIteratorNG(), KoColor::data(), KisPaintDevice::Private::dataManager(), defaultPixel(), m_d, KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), KoColorSpace::opacityU8(), KoColorSpace::pixelSize(), KisSelection::projection(), KisDataManager::purge(), KisBaseConstAccessor::rawDataConst(), KisSelection::selectedExactRect(), setDirty(), KisPaintDevice::Private::x(), KisPaintDevice::Private::y(), and y().

◆ colorSpace()

const KoColorSpace * KisPaintDevice::colorSpace ( ) const

Returns: the colorspace of the pixels in this paint device

Definition at line 2075 of file kis_paint_device.cc.

{
    Q_ASSERT(m_d->colorSpace() != 0);
    return m_d->colorSpace();
}

References KisPaintDevice::Private::colorSpace(), and m_d.

◆ colorSpaceChanged

void KisPaintDevice::colorSpaceChanged ( const KoColorSpace * colorspace )

signal

◆ compositionSourceColorSpace()

const KoColorSpace * KisPaintDevice::compositionSourceColorSpace ( ) const

virtual

This is a lowlevel method for the principle used in createCompositionSourceDevice(). In most of the cases the paint device creation methods should be used instead of this function.

See also: createCompositionSourceDevice(); createCompositionSourceDeviceFixed()

Reimplemented in KisPixelSelection.

Definition at line 2117 of file kis_paint_device.cc.

{
    return colorSpace();
}

References colorSpace().

◆ convertFromQImage()

void KisPaintDevice::convertFromQImage	(	const QImage &	image,
		const KoColorProfile *	profile,
		qint32	offsetX = 0,
		qint32	offsetY = 0 )

Fill this paint device with the data from image; starting at (offsetX, offsetY)

Parameters

image	the image
profile	name of the RGB profile to interpret the image as. 0 is interpreted as sRGB
offsetX	x offset
offsetY	y offset

Definition at line 1595 of file kis_paint_device.cc.

{
    QImage image = _image;
 
    if (image.format() != QImage::Format_ARGB32) {
        image.convertTo(QImage::Format_ARGB32);
    }
    // Don't convert if not no profile is given and both paint dev and qimage are rgba.
    if (!profile && colorSpace()->id() == "RGBA") {
        writeBytes(image.constBits(), offsetX, offsetY, image.width(), image.height());
    } else {
        try {
            quint8 * dstData = new quint8[image.width() * image.height() * pixelSize()];
            KoColorSpaceRegistry::instance()
            ->colorSpace(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), profile)
            ->convertPixelsTo(image.constBits(), dstData, colorSpace(), image.width() * image.height(),
                              KoColorConversionTransformation::internalRenderingIntent(),
                              KoColorConversionTransformation::internalConversionFlags());
 
            writeBytes(dstData, offsetX, offsetY, image.width(), image.height());
            delete[] dstData;
        } catch (const std::bad_alloc&) {
            warnKrita << "KisPaintDevice::convertFromQImage: Could not allocate" << image.width() * image.height() * pixelSize() << "bytes";
            return;
        }
    }
    m_d->cache()->invalidate();
}

References KisPaintDevice::Private::cache(), colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpace::convertPixelsTo(), KoID::id(), KoColorSpaceRegistry::instance(), Integer8BitsColorDepthID, KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisPaintDeviceCache::invalidate(), m_d, pixelSize(), RGBAColorModelID, warnKrita, and writeBytes().

◆ convertTo()

void KisPaintDevice::convertTo	(	const KoColorSpace *	dstColorSpace,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags(),
		KUndo2Command *	parentCommand = nullptr,
		KoUpdater *	progressUpdater = nullptr )

Converts the paint device to a different colorspace

Definition at line 1571 of file kis_paint_device.cc.

{
    m_d->convertColorSpace(dstColorSpace, renderingIntent, conversionFlags, parentCommand, progressUpdater);
}

References KisPaintDevice::Private::convertColorSpace(), and m_d.

◆ convertToQImage() [1/3]

QImage KisPaintDevice::convertToQImage	(	const KoColorProfile *	dstProfile,
		const QRect &	rc,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags() ) const

Overridden method for convenience

Definition at line 1641 of file kis_paint_device.cc.

{
    return convertToQImage(dstProfile,
                           rc.x(), rc.y(), rc.width(), rc.height(),
                           renderingIntent, conversionFlags);
}

References convertToQImage().

◆ convertToQImage() [2/3]

QImage KisPaintDevice::convertToQImage	(	const KoColorProfile *	dstProfile,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags() ) const

Create an RGBA QImage from a rectangle in the paint device. The rectangle is defined by the parent image's bounds.

Parameters

dstProfile	RGB profile to use in conversion. May be 0, in which case it's up to the color strategy to choose a profile (most like sRGB).
renderingIntent	Rendering intent
conversionFlags	Conversion flags

Definition at line 1625 of file kis_paint_device.cc.

{
    qint32 x1;
    qint32 y1;
    qint32 w;
    qint32 h;
 
    QRect rc = exactBounds();
    x1 = rc.x();
    y1 = rc.y();
    w = rc.width();
    h = rc.height();
 
    return convertToQImage(dstProfile, x1, y1, w, h, renderingIntent, conversionFlags);
}

References convertToQImage(), and exactBounds().

◆ convertToQImage() [3/3]

QImage KisPaintDevice::convertToQImage	(	const KoColorProfile *	dstProfile,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags() ) const

Create an RGBA QImage from a rectangle in the paint device.

Parameters

dstProfile	RGB profile to use in conversion. May be 0, in which case it's up to the color strategy to choose a profile (most like sRGB).
x	Left coordinate of the rectangle
y	Top coordinate of the rectangle
w	Width of the rectangle in pixels
h	Height of the rectangle in pixels
renderingIntent	Rendering intent
conversionFlags	Conversion flags

Definition at line 1651 of file kis_paint_device.cc.

{
 
    if (w < 0)
        return QImage();
 
    if (h < 0)
        return QImage();
 
    quint8 *data = 0;
    try {
        data = new quint8 [w * h * pixelSize()];
    } catch (const std::bad_alloc&) {
        warnKrita << "KisPaintDevice::convertToQImage std::bad_alloc for " << w << " * " << h << " * " << pixelSize();
        //delete[] data; // data is not allocated, so don't free it
        return QImage();
    }
    Q_CHECK_PTR(data);
 
    // XXX: Is this really faster than converting line by line and building the QImage directly?
    //      This copies potentially a lot of data.
    readBytes(data, x1, y1, w, h);
    QImage image = colorSpace()->convertToQImage(data, w, h, dstProfile, renderingIntent, conversionFlags);
    delete[] data;
 
    return image;
}

References colorSpace(), KoColorSpace::convertToQImage(), pixelSize(), readBytes(), and warnKrita.

◆ createChangeInterstrokeDataCommand()

KUndo2Command * KisPaintDevice::createChangeInterstrokeDataCommand ( KisInterstrokeDataSP data )

set interstroke data to the device

Interstroke data is managed by KisTransaction, don't call this method manually unless you really know what you are doing.

See also: interstrokeData()

Definition at line 2042 of file kis_paint_device.cc.

{
    return m_d->createChangeInterstrokeDataCommand(data);
}

References KisPaintDevice::Private::createChangeInterstrokeDataCommand(), and m_d.

◆ createCompositionSourceDevice() [1/3]

KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice ( ) const

There is quite a common technique in Krita. It is used in cases, when we want to paint something over a paint device using the composition, opacity or selection. E.g. painting a dab in a paint op, filling the selection in the Fill Tool. Such work is usually done in the following way:

1) Create a paint device

2) Fill it with the desired color or data

3) Create a KisPainter and set all the properties of the transaction: selection, compositeOp, opacity and etc.

4) Paint a newly created paint device over the destination device.

The following two methods (createCompositionSourceDevice() or createCompositionSourceDeviceFixed())should be used for the accomplishing the step 1). The point is that the desired color space of the temporary device may not coincide with the color space of the destination. That is the case, for example, for the alpha8() colorspace used in the selections. So for such devices the temporary target would have a different (grayscale) color space.

So there are two rules of thumb:

1) If you need a temporary device which you are going to fill with some data and then paint over the paint device, create it with either createCompositionSourceDevice() or createCompositionSourceDeviceFixed().

2) Do not expect that the color spaces of the destination and the temporary device would coincide. If you need to copy a single pixel from one device to another, you can use KisCrossDeviceColorSampler class, that will handle all the necessary conversions for you.

See also: createCompositionSourceDeviceFixed(); compositionSourceColorSpace(); KisCrossDeviceColorSampler; KisCrossDeviceColorSamplerInt

Definition at line 2081 of file kis_paint_device.cc.

{
    KisPaintDeviceSP device = new KisPaintDevice(compositionSourceColorSpace());
    device->setDefaultBounds(defaultBounds());
    device->setSupportsWraparoundMode(supportsWraproundMode());
    return device;
}

References compositionSourceColorSpace(), defaultBounds(), KisPaintDevice(), setDefaultBounds(), setSupportsWraparoundMode(), and supportsWraproundMode().

◆ createCompositionSourceDevice() [2/3]

KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice ( KisPaintDeviceSP cloneSource ) const

The same as createCompositionSourceDevice(), but initializes the newly created device with the content of cloneSource

See also: createCompositionSourceDevice()

Definition at line 2089 of file kis_paint_device.cc.

{
    KisPaintDeviceSP clone = new KisPaintDevice(*cloneSource);
    clone->setDefaultBounds(defaultBounds());
    clone->setSupportsWraparoundMode(supportsWraproundMode());
    clone->convertTo(compositionSourceColorSpace(),
                     KoColorConversionTransformation::internalRenderingIntent(),
                     KoColorConversionTransformation::internalConversionFlags());
    return clone;
}

References compositionSourceColorSpace(), convertTo(), defaultBounds(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisPaintDevice(), setDefaultBounds(), setSupportsWraparoundMode(), and supportsWraproundMode().

◆ createCompositionSourceDevice() [3/3]

KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice	(	KisPaintDeviceSP	cloneSource,
		const QRect	roughRect ) const

The same as createCompositionSourceDevice(), but initializes the newly created device with the rough roughRect of cloneSource.

"Rough rect" means that it may copy a bit more than requested. It is expected that the caller will not use the area outside roughRect.

See also: createCompositionSourceDevice()

Definition at line 2100 of file kis_paint_device.cc.

{
    KisPaintDeviceSP clone = new KisPaintDevice(colorSpace());
    clone->setDefaultBounds(defaultBounds());
    clone->setSupportsWraparoundMode(supportsWraproundMode());
    clone->makeCloneFromRough(cloneSource, roughRect);
    clone->convertTo(compositionSourceColorSpace(),
                     KoColorConversionTransformation::internalRenderingIntent(),
                     KoColorConversionTransformation::internalConversionFlags());
    return clone;
}

References colorSpace(), compositionSourceColorSpace(), convertTo(), defaultBounds(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisPaintDevice(), makeCloneFromRough(), setDefaultBounds(), setSupportsWraparoundMode(), and supportsWraproundMode().

◆ createCompositionSourceDeviceFixed()

KisFixedPaintDeviceSP KisPaintDevice::createCompositionSourceDeviceFixed ( ) const

This is a convenience method for createCompositionSourceDevice()

See also: createCompositionSourceDevice()

Definition at line 2112 of file kis_paint_device.cc.

{
    return new KisFixedPaintDevice(compositionSourceColorSpace());
}

References compositionSourceColorSpace().

◆ createHLineConstIteratorNG()

KisHLineConstIteratorSP KisPaintDevice::createHLineConstIteratorNG	(	qint32	x,
		qint32	y,
		qint32	w ) const

Definition at line 1832 of file kis_paint_device.cc.

{
    return m_d->currentStrategy()->createHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
}

References KisPaintDevice::Private::KisPaintDeviceStrategy::createHLineConstIteratorNG(), KisPaintDevice::Private::currentStrategy(), KisSharedPtr< T >::data(), KisPaintDevice::Private::dataManager(), m_d, KisPaintDevice::Private::x(), x(), KisPaintDevice::Private::y(), and y().

◆ createHLineIteratorNG()

KisHLineIteratorSP KisPaintDevice::createHLineIteratorNG	(	qint32	x,
		qint32	y,
		qint32	w )

Definition at line 1826 of file kis_paint_device.cc.

{
    m_d->cache()->invalidate();
    return m_d->currentStrategy()->createHLineIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
}

References KisPaintDevice::Private::cache(), KisPaintDevice::Private::KisPaintDeviceStrategy::createHLineIteratorNG(), KisPaintDevice::Private::currentStrategy(), KisSharedPtr< T >::data(), KisPaintDevice::Private::dataManager(), KisPaintDeviceCache::invalidate(), m_d, KisPaintDevice::Private::x(), x(), KisPaintDevice::Private::y(), and y().

◆ createKeyframeChannel()

KisRasterKeyframeChannel * KisPaintDevice::createKeyframeChannel ( const KoID & id )

Create a keyframe channel for the content on this device.

Parameters

id	identifier for the channel

Returns: keyframe channel or 0 if there is not one

Definition at line 2047 of file kis_paint_device.cc.

{
    Q_ASSERT(!m_d->framesInterface);
    m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
 
    Q_ASSERT(!m_d->contentChannel);
    if (m_d->parent.isValid()) {
        m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, this, new KisDefaultBoundsNodeWrapper(m_d->parent)));
    } else {
        //fallback when paint device is isolated / does not belong to a node.
        m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, this, m_d->defaultBounds));
    }
 
    // Raster channels always have at least one frame (representing a static image)
    KUndo2Command tempParentCommand;
    m_d->contentChannel->addKeyframe(0);
 
    return m_d->contentChannel.data();
}

References KisPaintDevice::Private::contentChannel, KisPaintDevice::Private::defaultBounds, KisPaintDevice::Private::framesInterface, KisWeakSharedPtr< T >::isValid(), KisPaintDeviceFramesInterface, m_d, and KisPaintDevice::Private::parent.

◆ createLodDataStruct()

KisPaintDevice::LodDataStruct * KisPaintDevice::createLodDataStruct ( int lod )

Definition at line 2153 of file kis_paint_device.cc.

{
    return m_d->createLodDataStruct(lod);
}

References KisPaintDevice::Private::createLodDataStruct(), and m_d.

◆ createMemoryReleaseObject()

KisPaintDevice::MemoryReleaseObject * KisPaintDevice::createMemoryReleaseObject ( )

static

Definition at line 2139 of file kis_paint_device.cc.

{
    return new MemoryReleaseObject();
}

◆ createRandomAccessorNG()

KisRandomAccessorSP KisPaintDevice::createRandomAccessorNG ( )

Definition at line 1858 of file kis_paint_device.cc.

{
    m_d->cache()->invalidate();
    return m_d->currentStrategy()->createRandomAccessorNG();
}

References KisPaintDevice::Private::cache(), KisPaintDevice::Private::KisPaintDeviceStrategy::createRandomAccessorNG(), KisPaintDevice::Private::currentStrategy(), KisPaintDeviceCache::invalidate(), and m_d.

◆ createRandomConstAccessorNG()

KisRandomConstAccessorSP KisPaintDevice::createRandomConstAccessorNG ( ) const

Definition at line 1864 of file kis_paint_device.cc.

{
    return m_d->currentStrategy()->createRandomConstAccessorNG();
}

References KisPaintDevice::Private::KisPaintDeviceStrategy::createRandomConstAccessorNG(), KisPaintDevice::Private::currentStrategy(), and m_d.

◆ createRandomSubAccessor()

KisRandomSubAccessorSP KisPaintDevice::createRandomSubAccessor ( ) const

This function create a random accessor which can easily access to sub pixel values.

Definition at line 1869 of file kis_paint_device.cc.

{
    KisPaintDevice* pd = const_cast<KisPaintDevice*>(this);
    return new KisRandomSubAccessor(pd);
}

◆ createRepeatHLineConstIterator()

KisRepeatHLineConstIteratorSP KisPaintDevice::createRepeatHLineConstIterator	(	qint32	x,
		qint32	y,
		qint32	w,
		const QRect &	_dataWidth ) const

Create an iterator that will "artificially" extend the paint device with the value of the border when trying to access values outside the range of data.

Parameters

x	x of top left corner
y	y of top left corner
w	width of the border
_dataWidth	indicates the rectangle that truly contains data

Definition at line 1848 of file kis_paint_device.cc.

{
    return new KisRepeatHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
}

References KisPaintDevice::Private::cacheInvalidator(), KisSharedPtr< T >::data(), KisPaintDevice::Private::dataManager(), m_d, KisPaintDevice::Private::x(), x(), KisPaintDevice::Private::y(), and y().

◆ createRepeatVLineConstIterator()

KisRepeatVLineConstIteratorSP KisPaintDevice::createRepeatVLineConstIterator	(	qint32	x,
		qint32	y,
		qint32	h,
		const QRect &	_dataWidth ) const

Create an iterator that will "artificially" extend the paint device with the value of the border when trying to access values outside the range of data.

Parameters

x	x of top left corner
y	y of top left corner
h	height of the border
_dataWidth	indicates the rectangle that truly contains data

Definition at line 1853 of file kis_paint_device.cc.

{
    return new KisRepeatVLineConstIteratorNG(m_d->dataManager().data(), x, y, h, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
}

References KisPaintDevice::Private::cacheInvalidator(), KisSharedPtr< T >::data(), KisPaintDevice::Private::dataManager(), m_d, KisPaintDevice::Private::x(), x(), KisPaintDevice::Private::y(), and y().

◆ createThumbnail() [1/3]

QImage KisPaintDevice::createThumbnail	(	qint32	maxw,
		qint32	maxh,
		qreal	oversample = 1,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags() )

Cached version of createThumbnail(qint32 maxw, qint32 maxh, const KisSelection *selection, QRect rect)

Definition at line 1808 of file kis_paint_device.cc.

{
    QSize size = fixThumbnailSize(QSize(w, h));
 
    return m_d->cache()->createThumbnail(size.width(), size.height(), oversample, renderingIntent, conversionFlags);
}

References KisPaintDevice::Private::cache(), KisPaintDeviceCache::createThumbnail(), fixThumbnailSize(), m_d, and oversample.

◆ createThumbnail() [2/3]

QImage KisPaintDevice::createThumbnail	(	qint32	maxw,
		qint32	maxh,
		QRect	rect,
		qreal	oversample = 1,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags() )

Creates a thumbnail of the paint device, retaining the aspect ratio. The width and height of the returned QImage won't exceed maxw and maxw, but they may be smaller. The colors are not corrected for display!

Parameters

maxw	maximum width
maxh	maximum height
rect	only this rect will be used for the thumbnail
oversample	ratio used for antialiasing
renderingIntent	Rendering intent
conversionFlags	Conversion flags

Definition at line 1799 of file kis_paint_device.cc.

{
    QSize size = fixThumbnailSize(QSize(w, h));
 
    KisPaintDeviceSP dev = createThumbnailDeviceOversampled(size.width(), size.height(), oversample, rect);
    QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags);
    return thumbnail;
}

References convertToQImage(), createThumbnailDeviceOversampled(), fixThumbnailSize(), KoColorSpaceRegistry::instance(), and oversample.

◆ createThumbnail() [3/3]

QImage KisPaintDevice::createThumbnail	(	qint32	maxw,
		qint32	maxh,
		Qt::AspectRatioMode	aspectRatioMode,
		qreal	oversample = 1,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags() )

Cached version of createThumbnail that also adjusts aspect ratio of the thumbnail to fit the extents of the paint device.

Definition at line 1815 of file kis_paint_device.cc.

{
    const QRect deviceExtent = exactBounds();
    const QSize thumbnailSize = deviceExtent.size().scaled(maxw, maxh, aspectRatioMode);
    return createThumbnail(thumbnailSize.width(), thumbnailSize.height(),
                           oversample, renderingIntent, conversionFlags);
}

References createThumbnail(), exactBounds(), and oversample.

◆ createThumbnailDevice()

KisPaintDeviceSP KisPaintDevice::createThumbnailDevice	(	qint32	w,
		qint32	h,
		QRect	rect = QRect(),
		QRect	outputRect = QRect() ) const

Creates a paint device thumbnail of the paint device, retaining the aspect ratio. The width and height of the returned device won't exceed maxw and maxw, but they may be smaller.

Parameters

w	maximum width
h	maximum height
rect	only this rect will be used for the thumbnail
outputRect	output rectangle

Definition at line 1724 of file kis_paint_device.cc.

{
    QSize thumbnailSize(w, h);
 
    QRect imageRect = rect.isValid() ? rect : extent();
 
    if ((thumbnailSize.width() > imageRect.width()) || (thumbnailSize.height() > imageRect.height())) {
        thumbnailSize.scale(imageRect.size(), Qt::KeepAspectRatio);
    }
 
    thumbnailSize = fixThumbnailSize(thumbnailSize);
 
    //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
    if (imageRect.isEmpty() || thumbnailSize.isEmpty()) {
        return new KisPaintDevice(colorSpace());
    }
 
    int srcWidth, srcHeight;
    int srcX0, srcY0;
    imageRect.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight);
 
    if (!outputRect.isValid()) {
        outputRect = QRect(0, 0, w, h);
    }
 
    KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                 thumbnailSize.width(), thumbnailSize.height(), outputRect);
 
    return thumbnail;
}

References colorSpace(), createThumbnailDeviceInternal(), extent(), fixThumbnailSize(), and KisPaintDevice().

◆ createThumbnailDeviceOversampled()

KisPaintDeviceSP KisPaintDevice::createThumbnailDeviceOversampled	(	qint32	w,
		qint32	h,
		qreal	oversample,
		QRect	rect = QRect(),
		QRect	outputRect = QRect() ) const

Definition at line 1755 of file kis_paint_device.cc.

{
    QSize thumbnailSize(w, h);
    qreal oversampleAdjusted = qMax(oversample, 1.);
    QSize thumbnailOversampledSize = oversampleAdjusted * thumbnailSize;
 
    QRect outputRect;
    QRect imageRect = rect.isValid() ? rect : extent();
 
    qint32 hstart = thumbnailOversampledSize.height();
 
    if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
        thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
    }
 
    thumbnailOversampledSize = fixThumbnailSize(thumbnailOversampledSize);
 
    //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
    if (imageRect.isEmpty() || thumbnailSize.isEmpty() || thumbnailOversampledSize.isEmpty()) {
        return new KisPaintDevice(colorSpace());
    }
 
    oversampleAdjusted *= (hstart > 0) ? ((qreal)thumbnailOversampledSize.height() / hstart) : 1.; //readjusting oversample ratio, given that we had to adjust thumbnail size
 
    outputRect = QRect(0, 0, thumbnailOversampledSize.width(), thumbnailOversampledSize.height());
 
    if (outputTileRect.isValid()) {
        //compensating output rectangle for oversampling
        outputTileRect = QRect(oversampleAdjusted * outputTileRect.topLeft(), oversampleAdjusted * outputTileRect.bottomRight());
        outputRect = outputRect.intersected(outputTileRect);
    }
 
    KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                 thumbnailOversampledSize.width(), thumbnailOversampledSize.height(), outputRect);
 
    if (oversample != 1. && oversampleAdjusted != 1.) {
        KoDummyUpdaterHolder updaterHolder;
        KisTransformWorker worker(thumbnail, 1 / oversampleAdjusted, 1 / oversampleAdjusted, 0.0, 0.0, 0.0, 0.0, 0.0,
                                  updaterHolder.updater(), KisFilterStrategyRegistry::instance()->value("Bilinear"));
        worker.run();
    }
    return thumbnail;
}

References colorSpace(), createThumbnailDeviceInternal(), extent(), fixThumbnailSize(), KisFilterStrategyRegistry::instance(), KisPaintDevice(), oversample, KisTransformWorker::run(), KoDummyUpdaterHolder::updater(), and KoGenericRegistry< T >::value().

◆ createVLineConstIteratorNG()

KisVLineConstIteratorSP KisPaintDevice::createVLineConstIteratorNG	(	qint32	x,
		qint32	y,
		qint32	h ) const

Definition at line 1843 of file kis_paint_device.cc.

{
    return m_d->currentStrategy()->createVLineConstIteratorNG(x, y, w);
}

References KisPaintDevice::Private::KisPaintDeviceStrategy::createVLineConstIteratorNG(), KisPaintDevice::Private::currentStrategy(), m_d, x(), and y().

◆ createVLineIteratorNG()

KisVLineIteratorSP KisPaintDevice::createVLineIteratorNG	(	qint32	x,
		qint32	y,
		qint32	h )

Definition at line 1837 of file kis_paint_device.cc.

{
    m_d->cache()->invalidate();
    return m_d->currentStrategy()->createVLineIteratorNG(x, y, w);
}

References KisPaintDevice::Private::cache(), KisPaintDevice::Private::KisPaintDeviceStrategy::createVLineIteratorNG(), KisPaintDevice::Private::currentStrategy(), KisPaintDeviceCache::invalidate(), m_d, x(), and y().

◆ crop() [1/2]

void KisPaintDevice::crop ( const QRect & r )

Convenience method for the above.

Definition at line 1498 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->crop(rect);
}

References KisPaintDevice::Private::KisPaintDeviceStrategy::crop(), KisPaintDevice::Private::currentStrategy(), and m_d.

◆ crop() [2/2]

void KisPaintDevice::crop	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h )

Cut the paint device down to the specified rect. If the crop area is bigger than the paint device, nothing will happen.

Definition at line 1492 of file kis_paint_device.cc.

{
    crop(QRect(x, y, w, h));
}

References crop(), x(), and y().

◆ dataManager()

KisDataManagerSP KisPaintDevice::dataManager ( ) const

Returns: the internal datamanager that keeps the pixels.

Definition at line 1590 of file kis_paint_device.cc.

{
    return m_d->dataManager();
}

References KisPaintDevice::Private::dataManager(), and m_d.

◆ defaultBounds()

KisDefaultBoundsBaseSP KisPaintDevice::defaultBounds ( ) const

the default bounds rect of the paint device

Definition at line 1212 of file kis_paint_device.cc.

{
    return m_d->defaultBounds;
}

References KisPaintDevice::Private::defaultBounds, and m_d.

◆ defaultPixel()

KoColor KisPaintDevice::defaultPixel ( ) const

Get a pointer to the default pixel. If the frame parameter is given, get the default pixel of specified frame. Otherwise use currently active frame.

Definition at line 1518 of file kis_paint_device.cc.

{
    return KoColor(m_d->dataManager()->defaultPixel(), colorSpace());
}

References colorSpace(), KisPaintDevice::Private::dataManager(), KisDataManager::defaultPixel(), and m_d.

◆ emitColorSpaceChanged()

void KisPaintDevice::emitColorSpaceChanged ( )

private

Definition at line 1561 of file kis_paint_device.cc.

{
    Q_EMIT colorSpaceChanged(m_d->colorSpace());
}

References KisPaintDevice::Private::colorSpace(), colorSpaceChanged(), and m_d.

◆ emitProfileChanged()

void KisPaintDevice::emitProfileChanged ( )

private

Definition at line 1566 of file kis_paint_device.cc.

{
    Q_EMIT profileChanged(m_d->colorSpace()->profile());
}

References KisPaintDevice::Private::colorSpace(), m_d, KoColorSpace::profile(), and profileChanged().

◆ estimateMemoryStats()

void KisPaintDevice::estimateMemoryStats	(	qint64 &	imageData,
		qint64 &	temporaryData,
		qint64 &	lodData ) const

Definition at line 1189 of file kis_paint_device.cc.

{
    m_d->estimateMemoryStats(imageData, temporaryData, lodData);
}

References KisPaintDevice::Private::estimateMemoryStats(), and m_d.

◆ exactBounds()

QRect KisPaintDevice::exactBounds ( ) const

Get the exact bounds of this paint device. The real solution is very slow because it does a linear scanline search, but it uses caching, so calling to this function without changing the device is quite cheap.

exactBounds follows these rules:

if default pixel is transparent, then exact bounds of actual pixel data are returned
if default pixel is not transparent, then the union (defaultBounds()->bounds() | nonDefaultPixelArea()) is returned

See also: calculateExactBounds()

Definition at line 1277 of file kis_paint_device.cc.

{
    return m_d->cache()->exactBounds();
}

References KisPaintDevice::Private::cache(), KisPaintDeviceCache::exactBounds(), and m_d.

◆ exactBoundsAmortized()

QRect KisPaintDevice::exactBoundsAmortized ( ) const

Relaxed version of the exactBounds() that can be used in tight loops. If the exact bounds value is present in the paint device cache, returns this value. If the cache is invalidated, returns extent() and tries to recalculate the exact bounds not faster than once in 1000 ms.

Definition at line 1282 of file kis_paint_device.cc.

{
    return m_d->cache()->exactBoundsAmortized();
}

References KisPaintDevice::Private::cache(), KisPaintDeviceCache::exactBoundsAmortized(), and m_d.

◆ extent() [1/2]

QRect KisPaintDevice::extent ( ) const

Retrieve the bounds of the paint device. The size is not exact, but may be larger if the underlying datamanager works that way. For instance, the tiled datamanager keeps the extent to the nearest multiple of 64.

If default pixel is not transparent, then the actual extent rect is united with the defaultBounds()->bounds() value (the size of the image, usually).

Definition at line 1262 of file kis_paint_device.cc.

{
    return m_d->currentStrategy()->extent();
}

References KisPaintDevice::Private::currentStrategy(), KisPaintDevice::Private::KisPaintDeviceStrategy::extent(), and m_d.

◆ extent() [2/2]

void KisPaintDevice::extent	(	qint32 &	x,
		qint32 &	y,
		qint32 &	w,
		qint32 &	h ) const

Convenience method for the above.

Definition at line 1253 of file kis_paint_device.cc.

{
    QRect rc = extent();
    x = rc.x();
    y = rc.y();
    w = rc.width();
    h = rc.height();
}

References extent(), x(), and y().

◆ fastBitBlt()

void KisPaintDevice::fastBitBlt	(	KisPaintDeviceSP	src,
		const QRect &	rect )

protected

Clones rect from another paint device. The cloned area will be shared between both paint devices as much as possible using copy-on-write. Parts of the rect that cannot be shared (cross tiles) are deep-copied,

See also: fastBitBltPossible; fastBitBltRough

Definition at line 1972 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->fastBitBlt(src, rect);
}

References KisPaintDevice::Private::currentStrategy(), KisPaintDevice::Private::KisPaintDeviceStrategy::fastBitBlt(), and m_d.

◆ fastBitBltOldData()

void KisPaintDevice::fastBitBltOldData	(	KisPaintDeviceSP	src,
		const QRect &	rect )

protected

The same as fastBitBlt() but reads old data

Definition at line 1977 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->fastBitBltOldData(src, rect);
}

References KisPaintDevice::Private::currentStrategy(), KisPaintDevice::Private::KisPaintDeviceStrategy::fastBitBltOldData(), and m_d.

◆ fastBitBltPossible()

bool KisPaintDevice::fastBitBltPossible ( KisPaintDeviceSP src )

protected

Checks whether a src paint device can be used as source of fast bitBlt operation. The result of the check may depend on whether color spaces coincide, whether there is any shift of tiles between the devices and etc.

WARNING: This check must be done before performing any fast bitBlt operation!

See also: fastBitBlt; fastBitBltRough

Definition at line 1967 of file kis_paint_device.cc.

{
    return m_d->fastBitBltPossible(src);
}

References KisPaintDevice::Private::fastBitBltPossible(), and m_d.

◆ fastBitBltRough()

void KisPaintDevice::fastBitBltRough	(	KisPaintDeviceSP	src,
		const QRect &	rect )

protected

Clones rect from another paint device in a rough and fast way. All the tiles touched by rect will be shared, between both devices, that means it will copy a bigger area than was requested. This method is supposed to be used for bitBlt'ing into temporary paint devices.

See also: fastBitBltPossible; fastBitBlt

Definition at line 1982 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->fastBitBltRough(src, rect);
}

References KisPaintDevice::Private::currentStrategy(), KisPaintDevice::Private::KisPaintDeviceStrategy::fastBitBltRough(), and m_d.

◆ fastBitBltRoughOldData()

void KisPaintDevice::fastBitBltRoughOldData	(	KisPaintDeviceSP	src,
		const QRect &	rect )

protected

The same as fastBitBltRough() but reads old data

Definition at line 1987 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->fastBitBltRoughOldData(src, rect);
}

References KisPaintDevice::Private::currentStrategy(), KisPaintDevice::Private::KisPaintDeviceStrategy::fastBitBltRoughOldData(), and m_d.

◆ fill() [1/2]

void KisPaintDevice::fill	(	const QRect &	rc,
		const KoColor &	color )

Fill the given rectangle with the given pixel. The paint device will expand to contain the given rect.

Definition at line 1534 of file kis_paint_device.cc.

{
    KIS_ASSERT_RECOVER_RETURN(*color.colorSpace() == *colorSpace());
    m_d->currentStrategy()->fill(rc, color.data());
}

References colorSpace(), KoColor::colorSpace(), KisPaintDevice::Private::currentStrategy(), KoColor::data(), KisPaintDevice::Private::KisPaintDeviceStrategy::fill(), KIS_ASSERT_RECOVER_RETURN, and m_d.

◆ fill() [2/2]

void KisPaintDevice::fill	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		const quint8 *	fillPixel )

Overloaded function. For legacy purposes only. Please use fill(const QRect & rc, const KoColor &color) instead

Definition at line 1540 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->fill(QRect(x, y, w, h), fillPixel);
}

References KisPaintDevice::Private::currentStrategy(), KisPaintDevice::Private::KisPaintDeviceStrategy::fill(), m_d, x(), and y().

◆ framesInterface()

KisPaintDeviceFramesInterface * KisPaintDevice::framesInterface ( )

An interface to modify/load/save frames stored inside this device

Definition at line 2183 of file kis_paint_device.cc.

{
    return m_d->framesInterface.data();
}

References KisPaintDevice::Private::framesInterface, and m_d.

◆ generateLodCloneDevice()

void KisPaintDevice::generateLodCloneDevice	(	KisPaintDeviceSP	dst,
		const QRect &	originalRect,
		int	lod )

Definition at line 2168 of file kis_paint_device.cc.

{
    m_d->generateLodCloneDevice(dst, originalRect, lod);
}

References KisPaintDevice::Private::generateLodCloneDevice(), and m_d.

◆ init()

void KisPaintDevice::init	(	const KoColorSpace *	colorSpace,
		KisDefaultBoundsBaseSP	defaultBounds,
		KisNodeWSP	parent,
		const QString &	name )

private

Definition at line 1057 of file kis_paint_device.cc.

{
    Q_ASSERT(colorSpace);
    setObjectName(name);
 
    // temporary def. bounds object for the initialization phase only
    m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
    if (!defaultBounds) {
        // Reuse transitionalDefaultBounds here. Change if you change
        // semantics of transitionalDefaultBounds
        defaultBounds = m_d->transitionalDefaultBounds;
    }
 
    KoColor color = KoColor::createTransparent(colorSpace);
    m_d->init(colorSpace, color.data());
 
    Q_ASSERT(m_d->colorSpace());
 
    setDefaultBounds(defaultBounds);
    setParentNode(parent);
}

References KisPaintDevice::Private::colorSpace(), colorSpace(), KoColor::createTransparent(), KoColor::data(), KisPaintDevice::Private::defaultBounds, defaultBounds(), KisPaintDevice::Private::init(), m_d, setDefaultBounds(), setParentNode(), and KisPaintDevice::Private::transitionalDefaultBounds.

◆ interstrokeData()

KisInterstrokeDataSP KisPaintDevice::interstrokeData ( ) const

Returns: interstroke data that is attached to the paint device.

This data is managed by KisTransaction and can be used by brushes to store some data that can be shared between the strokes. For example, information about drying of the pigment.

The interstroke data is stored in a per-frame manner, that is, there is a separate per-stroke data for each frame.

Definition at line 2037 of file kis_paint_device.cc.

{
    return m_d->interstrokeData();
}

References KisPaintDevice::Private::interstrokeData(), and m_d.

◆ keyframeChannel()

KisRasterKeyframeChannel * KisPaintDevice::keyframeChannel ( ) const

Definition at line 2067 of file kis_paint_device.cc.

{
    if (m_d->contentChannel) {
        return m_d->contentChannel.data();
    }
    return 0;
}

References KisPaintDevice::Private::contentChannel, and m_d.

◆ makeCloneFrom()

void KisPaintDevice::makeCloneFrom	(	KisPaintDeviceSP	src,
		const QRect &	rect )

Make this device to become a clone of src. It will have the same x,y shifts, colorspace and will share pixels inside rect. After calling this function: (this->extent() >= this->exactBounds() == rect).

Rule of thumb:

"Use makeCloneFrom() or makeCloneFromRough() if and only if you are the only owner of the destination paint device and you are 100% sure no other thread has access to it"

Definition at line 1127 of file kis_paint_device.cc.

{
    prepareClone(src);
 
    // we guarantee that *this is totally empty, so copy pixels that
    // are areally present on the source image only
    const QRect optimizedRect = rect & src->extent();
 
    fastBitBlt(src, optimizedRect);
}

References fastBitBlt(), and prepareClone().

◆ makeCloneFromRough()

void KisPaintDevice::makeCloneFromRough	(	KisPaintDeviceSP	src,
		const QRect &	minimalRect )

Make this device to become a clone of src. It will have the same x,y shifts, colorspace and will share pixels inside rect. Be careful, this function will copy at least rect of pixels. Actual copy area will be a bigger - it will be aligned by tiles borders. So after calling this function: (this->extent() == this->exactBounds() >= rect).

Rule of thumb:

"Use makeCloneFrom() or makeCloneFromRough() if and only if you are the only owner of the destination paint device and you are 100% sure no other thread has access to it"

Definition at line 1138 of file kis_paint_device.cc.

{
    prepareClone(src);
 
    // we guarantee that *this is totally empty, so copy pixels that
    // are areally present on the source image only
    const QRect optimizedRect = minimalRect & src->extent();
 
    fastBitBltRough(src, optimizedRect);
}

References fastBitBltRough(), and prepareClone().

◆ makeFullCopyFrom()

void KisPaintDevice::makeFullCopyFrom	(	const KisPaintDevice &	rhs,
		KritaUtils::DeviceCopyMode	copyMode = KritaUtils::CopySnapshot,
		KisNode *	newParentNode = 0 )

Definition at line 1092 of file kis_paint_device.cc.

{
    // temporary def. bounds object for the initialization phase only
    m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
    // copy data objects with or without frames
    m_d->cloneAllDataObjects(rhs.m_d, copyMode == KritaUtils::CopyAllFrames);
 
    if (copyMode == KritaUtils::CopyAllFrames && rhs.m_d->framesInterface) {
        KIS_ASSERT_RECOVER_RETURN(rhs.m_d->framesInterface);
        KIS_ASSERT_RECOVER_RETURN(rhs.m_d->contentChannel);
        m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
        m_d->contentChannel.reset(new KisRasterKeyframeChannel(*rhs.m_d->contentChannel.data(), this));
    }
 
    m_d->supportsWrapAroundMode = rhs.m_d->supportsWrapAroundMode;
    setDefaultBounds(rhs.m_d->defaultBounds);
    setParentNode(newParentNode);
}

References KisPaintDevice::Private::cloneAllDataObjects(), KisPaintDevice::Private::contentChannel, KritaUtils::CopyAllFrames, KisPaintDevice::Private::defaultBounds, KisPaintDevice::Private::framesInterface, KIS_ASSERT_RECOVER_RETURN, KisPaintDeviceFramesInterface, m_d, setDefaultBounds(), setParentNode(), KisPaintDevice::Private::supportsWrapAroundMode, and KisPaintDevice::Private::transitionalDefaultBounds.

◆ moveTo() [1/2]

void KisPaintDevice::moveTo ( const QPoint & pt )

virtual

Convenience method for the above.

Reimplemented in KisPixelSelection, and KisPixelSelection.

Definition at line 1217 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->move(pt);
    m_d->cache()->invalidate();
}

References KisPaintDevice::Private::cache(), KisPaintDevice::Private::currentStrategy(), KisPaintDeviceCache::invalidate(), m_d, and KisPaintDevice::Private::KisPaintDeviceStrategy::move().

◆ moveTo() [2/2]

void KisPaintDevice::moveTo	(	qint32	x,
		qint32	y )

Moves the device to these new coordinates (no incremental move)

Definition at line 1228 of file kis_paint_device.cc.

{
    moveTo(QPoint(x, y));
}

References moveTo(), x(), and y().

◆ nonDefaultPixelArea()

QRect KisPaintDevice::nonDefaultPixelArea ( ) const

Returns exact rectangle of the paint device that contains non-default pixels. For paint devices with fully transparent default pixel is equivalent to exactBounds().

nonDefaultPixelArea() follows these rules:

if default pixel is transparent, then exact bounds of actual pixel data are returned. The same as exactBounds()
if default pixel is not transparent, then calculates the rectangle of non-default pixels. May be smaller or greater than image bounds

See also: calculateExactBounds()

Definition at line 1272 of file kis_paint_device.cc.

{
    return m_d->cache()->nonDefaultPixelArea();
}

References KisPaintDevice::Private::cache(), m_d, and KisPaintDeviceCache::nonDefaultPixelArea().

◆ offset()

QPoint KisPaintDevice::offset ( ) const

Return an X,Y offset of the device in a convenient form

Definition at line 1223 of file kis_paint_device.cc.

{
    return QPoint(x(), y());
}

References x(), and y().

◆ operator=()

KisPaintDevice & KisPaintDevice::operator= ( const KisPaintDevice & )

private

◆ parentNode()

KisNodeWSP KisPaintDevice::parentNode ( ) const

protected

Definition at line 1201 of file kis_paint_device.cc.

{
    return m_d->parent;
}

References m_d, and KisPaintDevice::Private::parent.

◆ pixel() [1/3]

KoColor KisPaintDevice::pixel ( const QPoint & pos ) const

Return pixel value in a form of KoColor. Please don't use this method for iteration, it is highly inefficient. Use iterators instead.

Definition at line 1936 of file kis_paint_device.cc.

{
    KisHLineConstIteratorSP iter = createHLineConstIteratorNG(pos.x(), pos.y(), 1);
    return KoColor(iter->rawDataConst(), m_d->colorSpace());
}

References KisPaintDevice::Private::colorSpace(), createHLineConstIteratorNG(), m_d, and KisBaseConstAccessor::rawDataConst().

◆ pixel() [2/3]

bool KisPaintDevice::pixel	(	qint32	x,
		qint32	y,
		KoColor *	kc ) const

Fill kc with the values found at x and y. This method differs from the above in using KoColor, which can be of any colorspace

The color values will be transformed from the profile of this paint device to the display profile.

Returns: true if the operation was successful.

Definition at line 1923 of file kis_paint_device.cc.

{
    KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
    const quint8 *pix = iter->rawDataConst();
 
    if (!pix) return false;
 
    kc->setColor(pix, m_d->colorSpace());
 
    return true;
}

References KisPaintDevice::Private::colorSpace(), createHLineConstIteratorNG(), m_d, KisBaseConstAccessor::rawDataConst(), KoColor::setColor(), x(), and y().

◆ pixel() [3/3]

bool KisPaintDevice::pixel	(	qint32	x,
		qint32	y,
		QColor *	c ) const

Fill c and opacity with the values found at x and y.

The color values will be transformed from the profile of this paint device to the display profile.

Returns: true if the operation was successful.

Definition at line 1909 of file kis_paint_device.cc.

{
    KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
    const quint8 *pix = iter->rawDataConst();
 
    if (!pix) return false;
 
    colorSpace()->toQColor(pix, c);
 
    return true;
}

References colorSpace(), createHLineConstIteratorNG(), KisBaseConstAccessor::rawDataConst(), KoColorSpace::toQColor(), x(), and y().

◆ pixelSize()

quint32 KisPaintDevice::pixelSize ( ) const

Return the number of bytes a pixel takes.

Definition at line 2023 of file kis_paint_device.cc.

{
    quint32 _pixelSize = m_d->colorSpace()->pixelSize();
    Q_ASSERT(_pixelSize > 0);
    return _pixelSize;
}

References KisPaintDevice::Private::colorSpace(), m_d, and KoColorSpace::pixelSize().

◆ prepareClone()

void KisPaintDevice::prepareClone ( KisPaintDeviceSP src )

Prepares the device for fastBitBlt operation. It clears the device, switches x,y shifts and colorspace if needed. After this call fastBitBltPossible will return true. May be used for initialization of temporary devices.

Definition at line 1122 of file kis_paint_device.cc.

{
    m_d->prepareClone(src);
}

References m_d, and KisPaintDevice::Private::prepareClone().

◆ profileChanged

void KisPaintDevice::profileChanged ( const KoColorProfile * profile )

signal

◆ purgeDefaultPixels()

void KisPaintDevice::purgeDefaultPixels ( )

Frees the memory occupied by the pixels containing default values. The extents() and exactBounds() of the paint device will probably also shrink

Definition at line 1503 of file kis_paint_device.cc.

{
    KisDataManagerSP dm = m_d->dataManager();
    dm->purge(dm->extent());
}

References KisPaintDevice::Private::dataManager(), KisDataManager::extent(), m_d, and KisDataManager::purge().

◆ read()

bool KisPaintDevice::read ( QIODevice * stream )

Fill this paint device with the pixels from the specified file store.

Definition at line 1551 of file kis_paint_device.cc.

{
    bool retval;
 
    retval = m_d->dataManager()->read(stream);
    m_d->cache()->invalidate();
 
    return retval;
}

References KisPaintDevice::Private::cache(), KisPaintDevice::Private::dataManager(), KisPaintDeviceCache::invalidate(), m_d, and KisDataManager::read().

◆ readBytes() [1/2]

void KisPaintDevice::readBytes	(	quint8 *	data,
		const QRect &	rect ) const

Read the bytes representing the rectangle rect into data. If data is not big enough, Krita will gladly overwrite the rest of your precious memory.

Since this is a copy, you need to make sure you have enough memory.

Reading from areas not previously initialized will read the default pixel value into data but not initialize that region.

Parameters

data	The address of the memory to receive the bytes read
rect	The rectangle in the paint device to read from

Definition at line 1997 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->readBytes(data, rect);
}

References KisPaintDevice::Private::currentStrategy(), m_d, and KisPaintDevice::Private::KisPaintDeviceStrategy::readBytes().

◆ readBytes() [2/2]

void KisPaintDevice::readBytes	(	quint8 *	data,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h ) const

Read the bytes representing the rectangle described by x, y, w, h into data. If data is not big enough, Krita will gladly overwrite the rest of your precious memory.

Since this is a copy, you need to make sure you have enough memory.

Reading from areas not previously initialized will read the default pixel value into data but not initialize that region.

Definition at line 1992 of file kis_paint_device.cc.

{
    readBytes(data, QRect(x, y, w, h));
}

References readBytes(), x(), and y().

◆ readPlanarBytes()

QVector< quint8 * > KisPaintDevice::readPlanarBytes	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h ) const

Copy the bytes in the paint device into a vector of arrays of bytes, where the number of arrays is the number of channels in the paint device. If the specified area is larger than the paint device's extent, the default pixel will be read.

Definition at line 2012 of file kis_paint_device.cc.

{
    return m_d->currentStrategy()->readPlanarBytes(x, y, w, h);
}

References KisPaintDevice::Private::currentStrategy(), m_d, KisPaintDevice::Private::KisPaintDeviceStrategy::readPlanarBytes(), x(), and y().

◆ region()

KisRegion KisPaintDevice::region ( ) const

Returns a rough approximation of region covered by device. For tiled data manager, it region will consist of a number of rects each corresponding to a tile.

Definition at line 1267 of file kis_paint_device.cc.

{
    return m_d->currentStrategy()->region();
}

References KisPaintDevice::Private::currentStrategy(), m_d, and KisPaintDevice::Private::KisPaintDeviceStrategy::region().

◆ regionExact()

KisRegion KisPaintDevice::regionExact ( ) const

The slow version of region() that searches for exact bounds of each rectangle in the region

Definition at line 1468 of file kis_paint_device.cc.

{
    QVector<QRect> sourceRects = region().rects();
    QVector<QRect> resultRects;
 
    const KoColor defaultPixel = this->defaultPixel();
    Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
 
    Q_FOREACH (const QRect &rc1, sourceRects) {
        const int patchSize = 64;
        QVector<QRect> smallerRects = KritaUtils::splitRectIntoPatches(rc1, QSize(patchSize, patchSize));
        Q_FOREACH (const QRect &rc2, smallerRects) {
 
            const QRect result =
                Impl::calculateExactBoundsImpl(this, rc2, QRect(), compareOp);
 
            if (!result.isEmpty()) {
                resultRects << result;
            }
        }
    }
    return KisRegion(std::move(resultRects));
}

References Impl::calculateExactBoundsImpl(), KoColor::data(), defaultPixel(), pixelSize(), KisRegion::rects(), region(), and KritaUtils::splitRectIntoPatches().

◆ regionForLodSyncing()

KisRegion KisPaintDevice::regionForLodSyncing ( ) const

Definition at line 2148 of file kis_paint_device.cc.

{
    return m_d->regionForLodSyncing();
}

References m_d, and KisPaintDevice::Private::regionForLodSyncing().

◆ reincarnateWithDetachedHistory()

KUndo2Command * KisPaintDevice::reincarnateWithDetachedHistory ( bool copyContent )

Converts a paint device into a "new" paint device, that has unconnected history. That is, after reincarnation, the device's life starts a new page. No history. No memories.

When the device is fed up with the new life, it can reincarnate back to its previous life by undoing the command returned by reincarnateWithDetachedHistory(). The old undo will continue working as if nothing has happened.

NOTE: reincarnation affects only the current lod plane and/or current frame. All other frames are kept unaffected.

Parameters

copyContent decides if the device should take its current content to the new life

Returns: undo command for execution and undoing of the reincarnation

Definition at line 1585 of file kis_paint_device.cc.

{
    return m_d->reincarnateWithDetachedHistory(copyContent);
}

References m_d, and KisPaintDevice::Private::reincarnateWithDetachedHistory().

◆ requestTimeSwitch()

void KisPaintDevice::requestTimeSwitch ( int time )

Called by KisTransactionData when it thinks current time should be changed. And the requests is forwarded to the image if needed.

Definition at line 1177 of file kis_paint_device.cc.

{
    if (m_d->parent.isValid()) {
        m_d->parent->requestTimeSwitch(time);
    }
}

References KisWeakSharedPtr< T >::isValid(), m_d, KisPaintDevice::Private::parent, and KisNode::requestTimeSwitch().

◆ sequenceNumber()

int KisPaintDevice::sequenceNumber ( ) const

Returns: a sequence number corresponding to the current paint device state. Every time the paint device is changed, the sequence number is increased

Definition at line 1184 of file kis_paint_device.cc.

{
    return m_d->cache()->sequenceNumber();
}

References KisPaintDevice::Private::cache(), m_d, and KisPaintDeviceCache::sequenceNumber().

◆ setDataManager()

void KisPaintDevice::setDataManager	(	KisDataManagerSP	data,
		const KoColorSpace *	colorSpace = 0 )

Replace the pixel data, color strategy, and profile.

◆ setDefaultBounds()

void KisPaintDevice::setDefaultBounds ( KisDefaultBoundsBaseSP bounds )

set the default bounds for the paint device when the default pixel is not completely transparent

Definition at line 1206 of file kis_paint_device.cc.

{
    m_d->defaultBounds = defaultBounds;
    m_d->cache()->invalidate();
}

References KisPaintDevice::Private::cache(), KisPaintDevice::Private::defaultBounds, defaultBounds(), KisPaintDeviceCache::invalidate(), and m_d.

◆ setDefaultPixel()

void KisPaintDevice::setDefaultPixel ( const KoColor & defPixel )

Sets the default pixel. New data will be initialised with this pixel. The pixel is copied: the caller still owns the pointer and needs to delete it to avoid memory leaks. If frame ID is given, set default pixel for that frame. Otherwise use active frame.

Definition at line 1509 of file kis_paint_device.cc.

{
    KoColor color(defPixel);
    color.convertTo(colorSpace());
 
    m_d->dataManager()->setDefaultPixel(color.data());
    m_d->cache()->invalidate();
}

References KisPaintDevice::Private::cache(), colorSpace(), KoColor::convertTo(), KoColor::data(), KisPaintDevice::Private::dataManager(), KisPaintDeviceCache::invalidate(), m_d, and KisDataManager::setDefaultPixel().

◆ setDirty() [1/4]

void KisPaintDevice::setDirty ( )

Set the parent layer completely dirty, if this paint device has as parent layer.

Definition at line 1149 of file kis_paint_device.cc.

{
    m_d->cache()->invalidate();
    if (m_d->parent.isValid())
        m_d->parent->setDirty();
}

References KisPaintDevice::Private::cache(), KisPaintDeviceCache::invalidate(), KisWeakSharedPtr< T >::isValid(), m_d, KisPaintDevice::Private::parent, and KisNode::setDirty().

◆ setDirty() [2/4]

void KisPaintDevice::setDirty ( const KisRegion & region )

Definition at line 1163 of file kis_paint_device.cc.

{
    m_d->cache()->invalidate();
    if (m_d->parent.isValid())
        m_d->parent->setDirty(region);
}

References KisPaintDevice::Private::cache(), KisPaintDeviceCache::invalidate(), KisWeakSharedPtr< T >::isValid(), m_d, KisPaintDevice::Private::parent, region(), and KisNode::setDirty().

◆ setDirty() [3/4]

void KisPaintDevice::setDirty ( const QRect & rc )

Add the specified rect to the parent layer's set of dirty rects (if there is a parent layer)

Definition at line 1156 of file kis_paint_device.cc.

{
    m_d->cache()->invalidate();
    if (m_d->parent.isValid())
        m_d->parent->setDirty(rc);
}

References KisPaintDevice::Private::cache(), KisPaintDeviceCache::invalidate(), KisWeakSharedPtr< T >::isValid(), m_d, KisPaintDevice::Private::parent, and KisNode::setDirty().

◆ setDirty() [4/4]

void KisPaintDevice::setDirty ( const QVector< QRect > & rects )

Definition at line 1170 of file kis_paint_device.cc.

{
    m_d->cache()->invalidate();
    if (m_d->parent.isValid())
        m_d->parent->setDirty(rects);
}

References KisPaintDevice::Private::cache(), KisPaintDeviceCache::invalidate(), KisWeakSharedPtr< T >::isValid(), m_d, KisPaintDevice::Private::parent, and KisNode::setDirty().

◆ setParentNode()

void KisPaintDevice::setParentNode ( KisNodeWSP parent )

set the parent node of the paint device

Definition at line 1194 of file kis_paint_device.cc.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->parent || !parent);
    m_d->parent = parent;
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, and KisPaintDevice::Private::parent.

◆ setPixel() [1/2]

bool KisPaintDevice::setPixel	(	qint32	x,
		qint32	y,
		const KoColor &	kc )

Convenience method for the above.

Definition at line 1951 of file kis_paint_device.cc.

{
    const quint8 * pix;
    KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
    if (kc.colorSpace() != m_d->colorSpace()) {
        KoColor kc2(kc, m_d->colorSpace());
        pix = kc2.data();
        memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
    } else {
        pix = kc.data();
        memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
    }
    m_d->cache()->invalidate();
    return true;
}

References KisPaintDevice::Private::cache(), KisPaintDevice::Private::colorSpace(), KoColor::colorSpace(), createHLineIteratorNG(), KoColor::data(), KisPaintDeviceCache::invalidate(), m_d, KoColorSpace::pixelSize(), x(), and y().

◆ setPixel() [2/2]

bool KisPaintDevice::setPixel	(	qint32	x,
		qint32	y,
		const QColor &	c )

Set the specified pixel to the specified color. Note that this bypasses KisPainter. the PaintDevice is here used as an equivalent to QImage, not QPixmap. This means that this is not undoable; also, there is no compositing with an existing value at this location.

The color values will be transformed from the display profile to the paint device profile.

Note that this will use 8-bit values and may cause a significant degradation when used on 16-bit or hdr quality images.

Returns: true if the operation was successful

Definition at line 1942 of file kis_paint_device.cc.

{
    KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
 
    colorSpace()->fromQColor(c, iter->rawData());
    m_d->cache()->invalidate();
    return true;
}

References KisPaintDevice::Private::cache(), colorSpace(), createHLineIteratorNG(), KoColorSpace::fromQColor(), KisPaintDeviceCache::invalidate(), m_d, x(), and y().

◆ setProfile()

bool KisPaintDevice::setProfile	(	const KoColorProfile *	profile,
		KUndo2Command *	parentCommand )

Changes the profile of the colorspace of this paint device to the given profile. If the given profile is 0, nothing happens.

Definition at line 1580 of file kis_paint_device.cc.

{
    return m_d->assignProfile(profile, parentCommand);
}

References KisPaintDevice::Private::assignProfile(), and m_d.

◆ setProjectionDevice()

void KisPaintDevice::setProjectionDevice ( bool value )

Definition at line 1117 of file kis_paint_device.cc.

{
    m_d->isProjectionDevice = value;
}

References KisPaintDevice::Private::isProjectionDevice, m_d, and value().

◆ setSupportsWraparoundMode()

void KisPaintDevice::setSupportsWraparoundMode ( bool value )

Definition at line 2173 of file kis_paint_device.cc.

{
    m_d->supportsWrapAroundMode = value;
}

References m_d, KisPaintDevice::Private::supportsWrapAroundMode, and value().

◆ setX()

void KisPaintDevice::setX ( qint32 x )

set the X offset of the paint device

Definition at line 1233 of file kis_paint_device.cc.

{
    moveTo(QPoint(x, m_d->y()));
}

References m_d, moveTo(), x(), and KisPaintDevice::Private::y().

◆ setY()

void KisPaintDevice::setY ( qint32 y )

set the Y offset of the paint device

Definition at line 1238 of file kis_paint_device.cc.

{
    moveTo(QPoint(m_d->x(), y));
}

References m_d, moveTo(), KisPaintDevice::Private::x(), and y().

◆ supportsWraproundMode()

bool KisPaintDevice::supportsWraproundMode ( ) const

Definition at line 2178 of file kis_paint_device.cc.

{
    return m_d->supportsWrapAroundMode;
}

References m_d, and KisPaintDevice::Private::supportsWrapAroundMode.

◆ testingFetchLodDevice()

void KisPaintDevice::testingFetchLodDevice ( KisPaintDeviceSP targetDevice )

Definition at line 2350 of file kis_paint_device.cc.

{
    m_d->testingFetchLodDevice(targetDevice);
}

References m_d, and KisPaintDevice::Private::testingFetchLodDevice().

◆ updateLodDataStruct()

void KisPaintDevice::updateLodDataStruct	(	LodDataStruct *	dst,
		const QRect &	srcRect )

Definition at line 2158 of file kis_paint_device.cc.

{
    m_d->updateLodDataStruct(dst, srcRect);
}

References m_d, and KisPaintDevice::Private::updateLodDataStruct().

◆ uploadLodDataStruct()

void KisPaintDevice::uploadLodDataStruct ( LodDataStruct * dst )

Definition at line 2163 of file kis_paint_device.cc.

{
    m_d->uploadLodDataStruct(dst);
}

References m_d, and KisPaintDevice::Private::uploadLodDataStruct().

◆ write()

bool KisPaintDevice::write ( KisPaintDeviceWriter & store )

Write the pixels of this paint device into the specified file store.

Definition at line 1546 of file kis_paint_device.cc.

{
    return m_d->dataManager()->write(store);
}

References KisPaintDevice::Private::dataManager(), m_d, and KisDataManager::write().

◆ writeBytes() [1/2]

void KisPaintDevice::writeBytes	(	const quint8 *	data,
		const QRect &	rect )

Copy the bytes in data into the rectangle rect. If the data is too small or uninitialized, Krita will happily read parts of memory you never wanted to be read.

If the data is written to areas of the paint device not previously initialized, the paint device will grow.

Parameters

data	The address of the memory to write bytes from
rect	The rectangle in the paint device to write to

Definition at line 2007 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->writeBytes(data, rect);
}

References KisPaintDevice::Private::currentStrategy(), m_d, and KisPaintDevice::Private::KisPaintDeviceStrategy::writeBytes().

◆ writeBytes() [2/2]

void KisPaintDevice::writeBytes	(	const quint8 *	data,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h )

Copy the bytes in data into the rect specified by x, y, w, h. If the data is too small or uninitialized, Krita will happily read parts of memory you never wanted to be read.

If the data is written to areas of the paint device not previously initialized, the paint device will grow.

Definition at line 2002 of file kis_paint_device.cc.

{
    writeBytes(data, QRect(x, y, w, h));
}

References writeBytes(), x(), and y().

◆ writePlanarBytes()

void KisPaintDevice::writePlanarBytes	(	QVector< quint8 * >	planes,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h )

Write the data in the separate arrays to the channels. If there are less vectors than channels, the remaining channels will not be copied. If any of the arrays points to 0, the channel in that location will not be touched. If the specified area is larger than the paint device, the paint device will be extended. There are no guards: if the area covers more pixels than there are bytes in the arrays, krita will happily fill your paint device with areas of memory you never wanted to be read. Krita may also crash.

XXX: what about undo?

Definition at line 2017 of file kis_paint_device.cc.

{
    m_d->currentStrategy()->writePlanarBytes(planes, x, y, w, h);
}

References KisPaintDevice::Private::currentStrategy(), m_d, KisPaintDevice::Private::KisPaintDeviceStrategy::writePlanarBytes(), x(), and y().

◆ x()

qint32 KisPaintDevice::x ( ) const

The X offset of the paint device

Definition at line 1243 of file kis_paint_device.cc.

{
    return m_d->x();
}

References m_d, and KisPaintDevice::Private::x().

◆ y()

qint32 KisPaintDevice::y ( ) const

The Y offset of the paint device

Definition at line 1248 of file kis_paint_device.cc.

{
    return m_d->y();
}

References m_d, and KisPaintDevice::Private::y().

Friends And Related Symbol Documentation

◆ DataReaderThread

friend class DataReaderThread

friend

Definition at line 355 of file kis_paint_device.h.

◆ KisPaintDeviceFramesInterface

friend class KisPaintDeviceFramesInterface

friend

Definition at line 952 of file kis_paint_device.h.

◆ KisPaintDeviceTest

friend class KisPaintDeviceTest

friend

Definition at line 354 of file kis_paint_device.h.

◆ KisPainter

friend class KisPainter

friend

Definition at line 940 of file kis_paint_device.h.

◆ KisSelectionTest

friend class KisSelectionTest

friend

Definition at line 955 of file kis_paint_device.h.

◆ PaintDeviceCache

friend class PaintDeviceCache

friend

Definition at line 896 of file kis_paint_device.h.

Member Data Documentation

◆ m_d

Private* const KisPaintDevice::m_d

private

Definition at line 960 of file kis_paint_device.h.

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

libs/image/kis_paint_device.h
libs/image/kis_paint_device.cc

Classes

Signals

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ KisPaintDevice() [1/4]

◆ KisPaintDevice() [2/4]

◆ KisPaintDevice() [3/4]

◆ ~KisPaintDevice()

◆ KisPaintDevice() [4/4]

Member Function Documentation

◆ burnKeyframe() [1/2]

◆ burnKeyframe() [2/2]

◆ calculateExactBounds()

◆ channelCount()

◆ channelSizes()

◆ clear() [1/2]

◆ clear() [2/2]

◆ clearSelection()

◆ colorSpace()

◆ colorSpaceChanged

◆ compositionSourceColorSpace()

◆ convertFromQImage()

◆ convertTo()

◆ convertToQImage() [1/3]

◆ convertToQImage() [2/3]

◆ convertToQImage() [3/3]

◆ createChangeInterstrokeDataCommand()

◆ createCompositionSourceDevice() [1/3]

◆ createCompositionSourceDevice() [2/3]

◆ createCompositionSourceDevice() [3/3]

◆ createCompositionSourceDeviceFixed()

◆ createHLineConstIteratorNG()

◆ createHLineIteratorNG()

◆ createKeyframeChannel()

◆ createLodDataStruct()

◆ createMemoryReleaseObject()

◆ createRandomAccessorNG()

◆ createRandomConstAccessorNG()

◆ createRandomSubAccessor()

◆ createRepeatHLineConstIterator()

◆ createRepeatVLineConstIterator()

◆ createThumbnail() [1/3]

◆ createThumbnail() [2/3]

◆ createThumbnail() [3/3]

◆ createThumbnailDevice()

◆ createThumbnailDeviceOversampled()

◆ createVLineConstIteratorNG()

◆ createVLineIteratorNG()

◆ crop() [1/2]

◆ crop() [2/2]

◆ dataManager()

◆ defaultBounds()

◆ defaultPixel()

◆ emitColorSpaceChanged()

◆ emitProfileChanged()

◆ estimateMemoryStats()

◆ exactBounds()

◆ exactBoundsAmortized()

◆ extent() [1/2]

◆ extent() [2/2]

◆ fastBitBlt()

◆ fastBitBltOldData()

◆ fastBitBltPossible()

◆ fastBitBltRough()

◆ fastBitBltRoughOldData()

◆ fill() [1/2]

◆ fill() [2/2]

◆ framesInterface()

◆ generateLodCloneDevice()

◆ init()

◆ interstrokeData()

◆ keyframeChannel()

◆ makeCloneFrom()

◆ makeCloneFromRough()