KisPaintDevice::Private Struct Reference

Classes
class	DeviceChangeColorSpaceCommand
class	DeviceChangeProfileCommand
class	FrameInsertionCommand
class	KisPaintDeviceStrategy
class	KisPaintDeviceWrappedStrategy
struct	LodDataStructImpl
struct	StrategyPolicy

Public Member Functions
bool	assignProfile (const KoColorProfile *profile, KUndo2Command *parentCommand)
KisPaintDeviceCache *	cache ()
KisIteratorCompleteListener *	cacheInvalidator ()
void	cloneAllDataObjects (Private *rhs, bool copyFrames)
const KoColorSpace *	colorSpace () const
void	convertColorSpace (const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, KUndo2Command *parentCommand, KoUpdater *progressUpdater)
KUndo2Command *	createChangeInterstrokeDataCommand (KisInterstrokeDataSP value)
int	createFrame (bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
LodDataStruct *	createLodDataStruct (int lod)
int	currentFrameId () const
KisPaintDeviceStrategy *	currentStrategy ()
KisDataManagerSP	dataManager () const
void	deleteFrame (int frameID, KUndo2Command *parentCommand)
void	estimateMemoryStats (qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const
bool	fastBitBltPossible (KisPaintDeviceSP src)
QRect	frameBounds (int frameId)
KisDataManagerSP	frameDataManager (int frameId) const
KoColor	frameDefaultPixel (int frameId) const
const QList< int >	frameIds () const
QPoint	frameOffset (int frameId) const
void	generateLodCloneDevice (KisPaintDeviceSP dst, const QRect &originalRect, int lod)
int	getNextFrameId ()
void	init (const KoColorSpace *cs, const quint8 *defaultPixel)
KisInterstrokeDataSP	interstrokeData () const
void	invalidateFrameCache (int frameId)
void	prepareClone (KisPaintDeviceSP src)
	Private (KisPaintDevice *paintDevice)
bool	readFrame (QIODevice *stream, int frameId)
KisRegion	regionForLodSyncing () const
KUndo2Command *	reincarnateWithDetachedHistory (bool copyContent)
void	setFrameDefaultPixel (const KoColor &defPixel, int frameId)
void	setFrameOffset (int frameId, const QPoint &offset)
void	setX (qint32 x)
void	setY (qint32 y)
void	testingFetchLodDevice (KisPaintDeviceSP targetDevice)
void	updateLodDataManager (KisDataManager *srcDataManager, KisDataManager *dstDataManager, const QPoint &srcOffset, const QPoint &dstOffset, const QRect &originalRect, int lod)
void	updateLodDataStruct (LodDataStruct *dst, const QRect &srcRect)
void	uploadFrame (int dstFrameId, KisPaintDeviceSP srcDevice)
void	uploadFrame (int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
void	uploadFrameData (DataSP srcData, DataSP dstData)
void	uploadLodDataStruct (LodDataStruct *dst)
bool	writeFrame (KisPaintDeviceWriter &store, int frameId)
void	writeFrameToDevice (int frameId, KisPaintDeviceSP targetDevice)
qint32	x () const
qint32	y () const
	~Private ()

Public Attributes
QScopedPointer< KisPaintDeviceStrategy >	basicStrategy
QScopedPointer< KisRasterKeyframeChannel >	contentChannel
KisDefaultBoundsBaseSP	defaultBounds
QScopedPointer< KisPaintDeviceFramesInterface >	framesInterface
bool	isProjectionDevice
QMutex	m_wrappedStrategyMutex
KisNodeWSP	parent
KisPaintDevice *	q
bool	supportsWrapAroundMode
QScopedPointer< KisPaintDeviceWrappedStrategy >	wrappedStrategy

Static Public Attributes
static const KisDefaultBoundsSP	transitionalDefaultBounds = new KisDefaultBounds()

Private Types
typedef KisPaintDeviceData	Data
typedef QSharedPointer< Data >	DataSP
typedef QHash< int, DataSP >	FramesHash
typedef KisSequentialIteratorBase< ReadOnlyIteratorPolicy< StrategyPolicy >, StrategyPolicy >	InternalSequentialConstIterator
typedef KisSequentialIteratorBase< WritableIteratorPolicy< StrategyPolicy >, StrategyPolicy >	InternalSequentialIterator

Private Member Functions
QList< Data * >	allDataObjects () const
Data *	currentData () const
DataSP	currentFrameData () const
Data *	currentNonLodData () const
void	ensureLodDataPresent () const
qint64	estimateDataSize (Data *data) const
bool	fastBitBltPossibleImpl (Data *srcData)
void	prepareCloneImpl (KisPaintDeviceSP src, Data *srcData)
void	transferFromData (Data *data, KisPaintDeviceSP targetDevice)

Private Attributes
DataSP	m_data
QMutex	m_dataSwitchLock
QScopedPointer< Data >	m_externalFrameData
FramesHash	m_frames
QScopedPointer< Data >	m_lodData
int	m_nextFreeFrameId
struct Q_DECL_HIDDEN	StrategyPolicy

Friends
class	KisPaintDeviceFramesInterface

Detailed Description

Definition at line 67 of file kis_paint_device.cc.

Member Typedef Documentation

Data

typedef KisPaintDeviceData KisPaintDevice::Private::Data

private

Definition at line 230 of file kis_paint_device.cc.

DataSP

typedef QSharedPointer<Data> KisPaintDevice::Private::DataSP

private

Definition at line 231 of file kis_paint_device.cc.

FramesHash

typedef QHash<int, DataSP> KisPaintDevice::Private::FramesHash

private

Definition at line 232 of file kis_paint_device.cc.

InternalSequentialConstIterator

typedef KisSequentialIteratorBase<ReadOnlyIteratorPolicy<StrategyPolicy>, StrategyPolicy> KisPaintDevice::Private::InternalSequentialConstIterator

private

Definition at line 588 of file kis_paint_device.cc.

InternalSequentialIterator

typedef KisSequentialIteratorBase<WritableIteratorPolicy<StrategyPolicy>, StrategyPolicy> KisPaintDevice::Private::InternalSequentialIterator

private

Definition at line 589 of file kis_paint_device.cc.

Constructor & Destructor Documentation

Private()

KisPaintDevice::Private::Private

(

KisPaintDevice *

paintDevice

)

Definition at line 608 of file kis_paint_device.cc.

    : q(paintDevice),
      basicStrategy(new KisPaintDeviceStrategy(paintDevice, this)),
      isProjectionDevice(false),
      supportsWrapAroundMode(false),
      m_data(new Data(paintDevice)),
      m_nextFreeFrameId(0)
{
}

~Private()

KisPaintDevice::Private::~Private

(

)

Definition at line 618 of file kis_paint_device.cc.

{
    contentChannel.reset();
    m_frames.clear();
}

References KisPaintDevice::clear().

Member Function Documentation

allDataObjects()

QList< Data * > KisPaintDevice::Private::allDataObjects ( ) const

inlineprivate

Definition at line 568 of file kis_paint_device.cc.

    {
        QList<Data*> dataObjects;
 
        if (m_frames.isEmpty()) {
            dataObjects << m_data.data();
        }
        dataObjects << m_lodData.data();
        dataObjects << m_externalFrameData.data();
 
        Q_FOREACH (DataSP value, m_frames.values()) {
            dataObjects << value.data();
        }
 
        return dataObjects;
    }

References m_data, m_externalFrameData, m_frames, m_lodData, and value().

assignProfile()

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

Definition at line 1002 of file kis_paint_device.cc.

{
    if (!profile) return false;
 
    const KoColorSpace *dstColorSpace =
        KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
    if (!dstColorSpace) return false;
 
    KUndo2Command *mainCommand =
        parentCommand ? new DeviceChangeColorSpaceCommand(q, parentCommand) : 0;
 
 
    QList<Data*> dataObjects = allDataObjects();
    Q_FOREACH (Data *data, dataObjects) {
        if (!data) continue;
        data->assignColorSpace(dstColorSpace, mainCommand);
    }
    q->emitProfileChanged();
 
    // no undo information is provided here
    return true;
}

References KisPaintDeviceData::assignColorSpace(), KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), KisPaintDevice::emitProfileChanged(), and KoColorSpaceRegistry::instance().

cache()

KisPaintDeviceCache * KisPaintDevice::Private::cache ( )

inline

Definition at line 137 of file kis_paint_device.cc.

    {
        return currentData()->cache();
    }

References KisPaintDeviceData::cache(), and currentData().

cacheInvalidator()

KisIteratorCompleteListener * KisPaintDevice::Private::cacheInvalidator ( )

inline

Definition at line 142 of file kis_paint_device.cc.

                                                           {
        return currentData()->cacheInvalidator();
    }

References KisPaintDeviceData::cacheInvalidator(), and currentData().

cloneAllDataObjects()

void KisPaintDevice::Private::cloneAllDataObjects ( Private * rhs, bool copyFrames )

inline

Definition at line 154 of file kis_paint_device.cc.

    {
 
        m_lodData.reset();
        m_externalFrameData.reset();
 
        if (!m_frames.isEmpty()) {
            m_frames.clear();
        }
 
        if (!copyFrames) {
            if (m_data) {
                m_data->prepareClone(rhs->currentNonLodData(), true);
            } else {
                m_data = toQShared(new KisPaintDeviceData(q, rhs->currentNonLodData(), true));
            }
        } else {
            if (m_data && !rhs->m_data) {
                m_data.clear();
            } else if (!m_data && rhs->m_data) {
                m_data = toQShared(new KisPaintDeviceData(q, rhs->m_data.data(), true));
            } else if (m_data && rhs->m_data) {
                m_data->prepareClone(rhs->m_data.data(), true);
            }
 
            if (!rhs->m_frames.isEmpty()) {
                FramesHash::const_iterator it = rhs->m_frames.constBegin();
                FramesHash::const_iterator end = rhs->m_frames.constEnd();
 
                for (; it != end; ++it) {
                    DataSP data = toQShared(new KisPaintDeviceData(q, it.value().data(), true));
                    m_frames.insert(it.key(), data);
                }
            }
            m_nextFreeFrameId = rhs->m_nextFreeFrameId;
        }
 
        if (rhs->m_lodData) {
            m_lodData.reset(new KisPaintDeviceData(q, rhs->m_lodData.data(), true));
        }
    }

colorSpace()

const KoColorSpace * KisPaintDevice::Private::colorSpace ( ) const

inline

Definition at line 111 of file kis_paint_device.cc.

    {
        return currentData()->colorSpace();
    }

References KisPaintDeviceData::colorSpace(), and currentData().

convertColorSpace()

void KisPaintDevice::Private::convertColorSpace	(	const KoColorSpace *	dstColorSpace,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags,
		KUndo2Command *	parentCommand,
		KoUpdater *	progressUpdater )

Definition at line 981 of file kis_paint_device.cc.

{
    QList<Data*> dataObjects = allDataObjects();
    if (dataObjects.isEmpty()) return;
 
    KUndo2Command *mainCommand =
        parentCommand ? new DeviceChangeColorSpaceCommand(q, parentCommand) : 0;
 
    Q_FOREACH (Data *data, dataObjects) {
        if (!data) continue;
 
        data->convertDataColorSpace(dstColorSpace, renderingIntent, conversionFlags, mainCommand, progressUpdater);
    }
 
    q->emitColorSpaceChanged();
}

References KisPaintDeviceData::convertDataColorSpace(), and KisPaintDevice::emitColorSpaceChanged().

createChangeInterstrokeDataCommand()

KUndo2Command * KisPaintDevice::Private::createChangeInterstrokeDataCommand ( KisInterstrokeDataSP value )

inline

Definition at line 150 of file kis_paint_device.cc.

                                                                                         {
        return currentData()->createChangeInterstrokeDataCommand(value);
    }

createFrame()

int KisPaintDevice::Private::createFrame ( bool copy, int copySrc, const QPoint & offset, KUndo2Command * parentCommand )

inline

Here we move the contents of the paint device to the new frame and clear m_data to make the "background" for the areas where there is no frame at all.

Definition at line 284 of file kis_paint_device.cc.

    {
        DataSP data;
        bool initialFrame = false;
 
        if (m_frames.isEmpty()) {
            data = toQShared(new Data(q, m_data.data(), true));
            m_data->dataManager()->clear();
            m_data->cache()->invalidate();
            initialFrame = true;
 
        } else if (copy) {
            DataSP srcData = m_frames[copySrc];
            data = toQShared(new Data(q, srcData.data(), true));
        } else {
            DataSP srcData = m_frames.begin().value();
            data = toQShared(new Data(q, srcData.data(), false));
        }
 
        if (!initialFrame && !copy) {
            data->setX(offset.x());
            data->setY(offset.y());
        }
 
        int frameId = getNextFrameId();
 
        if (parentCommand) {
            KUndo2Command *cmd =
                new FrameInsertionCommand(&m_frames,
                                          data,
                                          frameId, true,
                                          parentCommand);
 
            cmd->redo();
        } else {
            m_frames.insert(frameId, data);
        }
 
        return frameId;
    }

References getNextFrameId(), m_data, m_frames, KisPaintDevice::offset(), q, KUndo2Command::redo(), and toQShared().

createLodDataStruct()

KisPaintDevice::LodDataStruct * KisPaintDevice::Private::createLodDataStruct

(

int

lod

)

We compare color spaces as pure pointers, because they must be exactly the same, since they come from the common source.

Definition at line 688 of file kis_paint_device.cc.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(newLod > 0);
 
    Data *srcData = currentNonLodData();
 
    Data *lodData = new Data(q, srcData, false);
    LodDataStruct *lodStruct = new LodDataStructImpl(lodData);
 
    int expectedX = KisLodTransform::coordToLodCoord(srcData->x(), newLod);
    int expectedY = KisLodTransform::coordToLodCoord(srcData->y(), newLod);
 
    if (lodData->levelOfDetail() != newLod ||
        lodData->colorSpace() != srcData->colorSpace() ||
        lodData->x() != expectedX ||
        lodData->y() != expectedY) {
 
 
        lodData->prepareClone(srcData);
 
        lodData->setLevelOfDetail(newLod);
        lodData->setX(expectedX);
        lodData->setY(expectedY);
 
        // FIXME: different kind of synchronization
    }
 
    lodData->cache()->invalidate();
 
    return lodStruct;
}

References KisPaintDeviceData::cache(), KisPaintDeviceData::colorSpace(), KisLodTransformBase::coordToLodCoord(), KisPaintDeviceCache::invalidate(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisPaintDeviceData::levelOfDetail(), KisPaintDeviceData::prepareClone(), KisPaintDeviceData::setLevelOfDetail(), KisPaintDeviceData::setX(), KisPaintDeviceData::setY(), KisPaintDeviceData::x(), and KisPaintDeviceData::y().

currentData()

Data * KisPaintDevice::Private::currentData ( ) const

inlineprivate

Definition at line 522 of file kis_paint_device.cc.

    {
        Data *data;
 
        if (defaultBounds->currentLevelOfDetail()) {
            ensureLodDataPresent();
            data = m_lodData.data();
        } else {
            data = currentNonLodData();
        }
 
        return data;
    }

References KisDefaultBoundsBase::currentLevelOfDetail(), currentNonLodData(), defaultBounds, ensureLodDataPresent(), and m_lodData.

currentFrameData()

DataSP KisPaintDevice::Private::currentFrameData ( ) const

inlineprivate

Definition at line 466 of file kis_paint_device.cc.

    {
        DataSP data;
 
        const int vFramesCount = contentChannel->keyframeCount();
 
        if (vFramesCount >= 1) {
            KisRasterKeyframeSP keyframe =  contentChannel->activeKeyframeAt<KisRasterKeyframe>(defaultBounds->currentTime());
            if (!keyframe || keyframe->frameID() < 0) {
                return m_data;
            }
 
            const int frameID = keyframe->frameID();
            KIS_ASSERT_RECOVER(m_frames.contains(frameID)) {
                return m_data;
            }
 
            data = m_frames[frameID];
        } else {
            data = m_data;
        }
 
        return data;
    }

References contentChannel, KisDefaultBoundsBase::currentTime(), defaultBounds, KIS_ASSERT_RECOVER, m_data, and m_frames.

currentFrameId()

int KisPaintDevice::Private::currentFrameId ( ) const

inline

Definition at line 207 of file kis_paint_device.cc.

    {
        KIS_ASSERT_RECOVER(contentChannel) {
            return -1;
        }
        return !defaultBounds->currentLevelOfDetail() ?
               contentChannel->activeKeyframeAt<KisRasterKeyframe>(defaultBounds->currentTime())->frameID() :
               -1;
    }

References contentChannel, KisDefaultBoundsBase::currentLevelOfDetail(), KisDefaultBoundsBase::currentTime(), defaultBounds, and KIS_ASSERT_RECOVER.

currentNonLodData()

Data * KisPaintDevice::Private::currentNonLodData ( ) const

inlineprivate

Definition at line 491 of file kis_paint_device.cc.

    {
        Data *data = m_data.data();
 
        if (contentChannel) {
            data = currentFrameData().data();
        } else if (isProjectionDevice && defaultBounds->externalFrameActive()) {
            if (!m_externalFrameData) {
                QMutexLocker l(&m_dataSwitchLock);
                if (!m_externalFrameData) {
                    m_externalFrameData.reset(new Data(q, m_data.data(), false));
                }
            }
            data = m_externalFrameData.data();
        }
 
        return data;
    }

References contentChannel, currentFrameData(), defaultBounds, KisDefaultBoundsBase::externalFrameActive(), isProjectionDevice, m_data, m_dataSwitchLock, m_externalFrameData, and q.

currentStrategy()

KisPaintDevice::Private::KisPaintDeviceStrategy * KisPaintDevice::Private::currentStrategy

(

)

Definition at line 624 of file kis_paint_device.cc.

{
    if (!supportsWrapAroundMode || !defaultBounds->wrapAroundMode()) {
        return basicStrategy.data();
    }
 
    const QRect wrapRect = defaultBounds->imageBorderRect();
 
    if (!wrappedStrategy || wrappedStrategy->wrapRect() != wrapRect) {
        QMutexLocker locker(&m_wrappedStrategyMutex);
 
        if (!wrappedStrategy) {
            wrappedStrategy.reset(new KisPaintDeviceWrappedStrategy(wrapRect, q, this));
        }  else if (wrappedStrategy->wrapRect() != wrapRect) {
            wrappedStrategy->setWrapRect(wrapRect);
        }
    }
 
    return wrappedStrategy.data();
}

References KisPaintDevice::defaultBounds(), KisDefaultBoundsBase::imageBorderRect(), and KisDefaultBoundsBase::wrapAroundMode().

dataManager()

KisDataManagerSP KisPaintDevice::Private::dataManager ( ) const

inline

Definition at line 115 of file kis_paint_device.cc.

    {
        return currentData()->dataManager();
    }

References currentData(), and KisPaintDeviceData::dataManager().

deleteFrame()

void KisPaintDevice::Private::deleteFrame ( int frameID, KUndo2Command * parentCommand )

inline

Definition at line 330 of file kis_paint_device.cc.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_frames.contains(frameID));
        DataSP deletedData = m_frames[frameID];
 
        if(parentCommand) {
            KUndo2Command *cmd =
                new FrameInsertionCommand(&m_frames,
                                          deletedData,
                                          frameID, false,
                                          parentCommand);
            cmd->redo();
        } else {
            m_frames.take(frameID);
        }
    }

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_frames, and KUndo2Command::redo().

ensureLodDataPresent()

void KisPaintDevice::Private::ensureLodDataPresent ( ) const

inlineprivate

Definition at line 510 of file kis_paint_device.cc.

    {
        if (!m_lodData) {
            Data *srcData = currentNonLodData();
 
            QMutexLocker l(&m_dataSwitchLock);
            if (!m_lodData) {
                m_lodData.reset(new Data(q, srcData, false));
            }
        }
    }

References currentNonLodData(), m_dataSwitchLock, m_lodData, and q.

estimateDataSize()

qint64 KisPaintDevice::Private::estimateDataSize ( Data * data ) const

inlineprivate

Definition at line 434 of file kis_paint_device.cc.

                                              {
        const QRect &rc = data->dataManager()->extent();
        return qint64(rc.width()) * rc.height() * data->colorSpace()->pixelSize();
    }

References KisPaintDeviceData::colorSpace(), KisPaintDeviceData::dataManager(), KisDataManager::extent(), and KoColorSpace::pixelSize().

estimateMemoryStats()

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

inline

Definition at line 441 of file kis_paint_device.cc.

                                                                                              {
        imageData = 0;
        temporaryData = 0;
        lodData = 0;
 
        if (m_data) {
            imageData += estimateDataSize(m_data.data());
        }
 
        if (m_lodData) {
            lodData += estimateDataSize(m_lodData.data());
        }
 
        if (m_externalFrameData) {
            temporaryData += estimateDataSize(m_externalFrameData.data());
        }
 
        Q_FOREACH (DataSP value, m_frames.values()) {
            imageData += estimateDataSize(value.data());
        }
    }

References estimateDataSize(), m_data, m_externalFrameData, m_frames, m_lodData, and value().

fastBitBltPossible()

bool KisPaintDevice::Private::fastBitBltPossible ( KisPaintDeviceSP src )

inline

Definition at line 202 of file kis_paint_device.cc.

    {
        return fastBitBltPossibleImpl(src->m_d->currentData());
    }

References fastBitBltPossibleImpl().

fastBitBltPossibleImpl()

bool KisPaintDevice::Private::fastBitBltPossibleImpl ( Data * srcData )

inlineprivate

Definition at line 562 of file kis_paint_device.cc.

    {
        return x() == srcData->x() && y() == srcData->y() &&
               *colorSpace() == *srcData->colorSpace();
    }

References colorSpace(), KisPaintDeviceData::colorSpace(), x(), KisPaintDeviceData::x(), y(), and KisPaintDeviceData::y().

frameBounds()

QRect KisPaintDevice::Private::frameBounds ( int frameId )

inline

Definition at line 347 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
 
        QRect extent = data->dataManager()->extent();
        extent.translate(data->x(), data->y());
 
        quint8 defaultOpacity = data->colorSpace()->opacityU8(data->dataManager()->defaultPixel());
 
        if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
            extent |= defaultBounds->bounds();
        }
 
        return extent;
    }

References KisDefaultBoundsBase::bounds(), defaultBounds, KisPaintDevice::extent(), m_frames, and OPACITY_TRANSPARENT_U8.

frameDataManager()

KisDataManagerSP KisPaintDevice::Private::frameDataManager ( int frameId ) const

inline

Definition at line 217 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
        return data->dataManager();
    }

References m_frames.

frameDefaultPixel()

KoColor KisPaintDevice::Private::frameDefaultPixel ( int frameId ) const

inline

Definition at line 406 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
        return KoColor(data->dataManager()->defaultPixel(),
                       data->colorSpace());
    }

References m_frames.

frameIds()

const QList< int > KisPaintDevice::Private::frameIds ( ) const

inline

Definition at line 377 of file kis_paint_device.cc.

    {
        return m_frames.keys();
    }

References m_frames.

frameOffset()

QPoint KisPaintDevice::Private::frameOffset ( int frameId ) const

inline

Definition at line 363 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
        return QPoint(data->x(), data->y());
    }

References m_frames.

generateLodCloneDevice()

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

Definition at line 824 of file kis_paint_device.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(fastBitBltPossible(dst));
 
    Data *srcData = currentNonLodData();
    updateLodDataManager(srcData->dataManager().data(), dst->dataManager().data(),
                         QPoint(srcData->x(), srcData->y()),
                         QPoint(dst->x(), dst->y()),
                         originalRect, lod);
}

References KisSharedPtr< T >::data(), KisPaintDevice::dataManager(), KisPaintDeviceData::dataManager(), KisPaintDevice::fastBitBltPossible(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintDevice::x(), KisPaintDeviceData::x(), KisPaintDevice::y(), and KisPaintDeviceData::y().

getNextFrameId()

int KisPaintDevice::Private::getNextFrameId ( )

inline

Definition at line 276 of file kis_paint_device.cc.

                         {
        int frameId = 0;
        while (m_frames.contains(frameId = m_nextFreeFrameId++));
        KIS_SAFE_ASSERT_RECOVER_NOOP(!m_frames.contains(frameId));
 
        return frameId;
    }

References KIS_SAFE_ASSERT_RECOVER_NOOP, m_frames, and m_nextFreeFrameId.

init()

void KisPaintDevice::Private::init	(	const KoColorSpace *	cs,
		const quint8 *	defaultPixel )

Definition at line 1032 of file kis_paint_device.cc.

{
    QList<Data*> dataObjects = allDataObjects();
    Q_FOREACH (Data *data, dataObjects) {
        if (!data) continue;
 
        KisDataManagerSP dataManager = new KisDataManager(cs->pixelSize(), defaultPixel);
        data->init(cs, dataManager);
    }
}

References KisPaintDevice::dataManager(), KisPaintDevice::defaultPixel(), KisPaintDeviceData::init(), and KoColorSpace::pixelSize().

interstrokeData()

KisInterstrokeDataSP KisPaintDevice::Private::interstrokeData ( ) const

inline

Definition at line 146 of file kis_paint_device.cc.

                                                        {
        return currentData()->interstrokeData();
    }

References currentData(), and KisPaintDeviceData::interstrokeData().

invalidateFrameCache()

void KisPaintDevice::Private::invalidateFrameCache ( int frameId )

inline

Definition at line 223 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
        return data->cache()->invalidate();
    }

References m_frames.

prepareClone()

void KisPaintDevice::Private::prepareClone ( KisPaintDeviceSP src )

inline

Definition at line 196 of file kis_paint_device.cc.

    {
        prepareCloneImpl(src, src->m_d->currentData());
        KIS_SAFE_ASSERT_RECOVER_NOOP(fastBitBltPossible(src));
    }

prepareCloneImpl()

void KisPaintDevice::Private::prepareCloneImpl ( KisPaintDeviceSP src, Data * srcData )

inlineprivate

The result of currentData() depends on the current level of detail and animation frame index. So we should first connect the device to the new default bounds object, and only after that ask currentData() to start cloning.

Default pixel must be updated after the color space of the device has been adjusted in prepareClone(). Otherwise, colorSpace() of the resulting KoColor object will be incorrect.

Definition at line 536 of file kis_paint_device.cc.

    {
        q->setDefaultBounds(src->defaultBounds());
        q->setSupportsWraparoundMode(src->supportsWraproundMode());
 
        currentData()->prepareClone(srcData);
 
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(*colorSpace() == *src->colorSpace());
        q->setDefaultPixel(KoColor(srcData->dataManager()->defaultPixel(), colorSpace()));
 
    }

References colorSpace(), currentData(), KisPaintDeviceData::dataManager(), KisDataManager::defaultPixel(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintDeviceData::prepareClone(), q, KisPaintDevice::setDefaultBounds(), KisPaintDevice::setDefaultPixel(), and KisPaintDevice::setSupportsWraparoundMode().

readFrame()

bool KisPaintDevice::Private::readFrame ( QIODevice * stream, int frameId )

inline

Definition at line 382 of file kis_paint_device.cc.

    {
        bool retval = false;
        DataSP data = m_frames[frameId];
        retval = data->dataManager()->read(stream);
        data->cache()->invalidate();
        return retval;
    }

References m_frames.

regionForLodSyncing()

KisRegion KisPaintDevice::Private::regionForLodSyncing

(

)

const

Definition at line 682 of file kis_paint_device.cc.

{
    Data *srcData = currentNonLodData();
    return srcData->dataManager()->region().translated(srcData->x(), srcData->y());
}

References KisPaintDeviceData::dataManager(), KisDataManager::region(), KisRegion::translated(), KisPaintDeviceData::x(), and KisPaintDeviceData::y().

reincarnateWithDetachedHistory()

KUndo2Command * KisPaintDevice::Private::reincarnateWithDetachedHistory

(

bool

copyContent

)

Definition at line 1025 of file kis_paint_device.cc.

{
    KUndo2Command *mainCommand = new KUndo2Command();
    currentData()->reincarnateWithDetachedHistory(copyContent, mainCommand);
    return mainCommand;
}

setFrameDefaultPixel()

void KisPaintDevice::Private::setFrameDefaultPixel ( const KoColor & defPixel, int frameId )

inline

Definition at line 397 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
        KoColor color(defPixel);
        color.convertTo(data->colorSpace());
        data->dataManager()->setDefaultPixel(color.data());
        data->cache()->invalidate();
    }

References KoColor::convertTo(), KoColor::data(), and m_frames.

setFrameOffset()

void KisPaintDevice::Private::setFrameOffset ( int frameId, const QPoint & offset )

inline

Definition at line 369 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
        data->setX(offset.x());
        data->setY(offset.y());
        data->cache()->invalidate();
    }

References m_frames, and KisPaintDevice::offset().

setX()

void KisPaintDevice::Private::setX ( qint32 x )

inline

Definition at line 128 of file kis_paint_device.cc.

    {
        currentData()->setX(x);
    }

References currentData(), KisPaintDeviceData::setX(), and x().

setY()

void KisPaintDevice::Private::setY ( qint32 y )

inline

Definition at line 132 of file kis_paint_device.cc.

    {
        currentData()->setY(y);
    }

References currentData(), KisPaintDeviceData::setY(), and y().

testingFetchLodDevice()

void KisPaintDevice::Private::testingFetchLodDevice

(

KisPaintDeviceSP

targetDevice

)

Definition at line 921 of file kis_paint_device.cc.

{
    Data *data = m_lodData.data();
    Q_ASSERT(data);
 
    transferFromData(data, targetDevice);
}

transferFromData()

void KisPaintDevice::Private::transferFromData ( Data * data, KisPaintDeviceSP targetDevice )

private

Definition at line 849 of file kis_paint_device.cc.

{
    QRect extent = data->dataManager()->extent();
    extent.translate(data->x(), data->y());
 
    targetDevice->m_d->prepareCloneImpl(q, data);
    targetDevice->m_d->currentStrategy()->fastBitBltRough(data->dataManager(), extent);
}

References currentStrategy(), KisPaintDeviceData::dataManager(), KisPaintDevice::extent(), KisDataManager::extent(), KisPaintDevice::Private::KisPaintDeviceStrategy::fastBitBltRough(), KisPaintDevice::m_d, prepareCloneImpl(), KisPaintDeviceData::x(), and KisPaintDeviceData::y().

updateLodDataManager()

void KisPaintDevice::Private::updateLodDataManager	(	KisDataManager *	srcDataManager,
		KisDataManager *	dstDataManager,
		const QPoint &	srcOffset,
		const QPoint &	dstOffset,
		const QRect &	originalRect,
		int	lod )

Definition at line 724 of file kis_paint_device.cc.

{
    if (originalRect.isEmpty()) return;
 
    const int srcStepSize = 1 << lod;
 
    KIS_ASSERT_RECOVER_RETURN(lod > 0);
 
    const QRect srcRect = KisLodTransform::alignedRect(originalRect, lod);
    const QRect dstRect = KisLodTransform::scaledRect(srcRect, lod);
    if (!srcRect.isValid() || !dstRect.isValid()) return;
 
    KIS_ASSERT_RECOVER_NOOP(srcRect.width() / srcStepSize == dstRect.width());
 
    const int pixelSize = srcDataManager->pixelSize();
 
    int rowsAccumulated = 0;
    int columnsAccumulated = 0;
 
    KoMixColorsOp *mixOp = colorSpace()->mixColorsOp();
 
    QScopedArrayPointer<quint8> blendData(new quint8[srcStepSize * srcRect.width() * pixelSize]);
    quint8 *blendDataPtr = blendData.data();
    int blendDataOffset = 0;
 
    const int srcCellSize = srcStepSize * srcStepSize;
    const int srcCellStride = srcCellSize * pixelSize;
    const int srcStepStride = srcStepSize * pixelSize;
    const int srcColumnStride = (srcStepSize - 1) * srcStepStride;
 
    InternalSequentialConstIterator srcIntIt(StrategyPolicy(currentStrategy(), srcDataManager, srcOffset.x(), srcOffset.y()), srcRect);
    InternalSequentialIterator dstIntIt(StrategyPolicy(currentStrategy(), dstDataManager, dstOffset.x(), dstOffset.y()), dstRect);
 
    int rowsRemaining = srcRect.height();
    while (rowsRemaining > 0) {
 
        int colsRemaining = srcRect.width();
        while (colsRemaining > 0 && srcIntIt.nextPixel()) {
 
            memcpy(blendDataPtr, srcIntIt.rawDataConst(), pixelSize);
            blendDataPtr += pixelSize;
            columnsAccumulated++;
 
            if (columnsAccumulated >= srcStepSize) {
                blendDataPtr += srcColumnStride;
                columnsAccumulated = 0;
            }
 
            colsRemaining--;
        }
 
        rowsAccumulated++;
 
        if (rowsAccumulated >= srcStepSize) {
 
            // blend and write the final data
            blendDataPtr = blendData.data();
 
            int colsRemaining = dstRect.width();
            while (colsRemaining > 0 && dstIntIt.nextPixel()) {
                mixOp->mixColors(blendDataPtr, srcCellSize, dstIntIt.rawData());
                blendDataPtr += srcCellStride;
 
                colsRemaining--;
            }
 
            // reset counters
            rowsAccumulated = 0;
            blendDataPtr = blendData.data();
            blendDataOffset = 0;
        } else {
            blendDataOffset += srcStepStride;
            blendDataPtr = blendData.data() + blendDataOffset;
        }
 
        rowsRemaining--;
    }
}

References KisLodTransformBase::alignedRect(), KisPaintDevice::colorSpace(), KIS_ASSERT_RECOVER_NOOP, KIS_ASSERT_RECOVER_RETURN, KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisDataManager::pixelSize(), KisPaintDevice::pixelSize(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst(), and KisLodTransformBase::scaledRect().

updateLodDataStruct()

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

Definition at line 808 of file kis_paint_device.cc.

{
    LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
    KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
    Data *lodData = dst->lodData.data();
    Data *srcData = currentNonLodData();
 
    const int lod = lodData->levelOfDetail();
 
    updateLodDataManager(srcData->dataManager().data(), lodData->dataManager().data(),
                         QPoint(srcData->x(), srcData->y()),
                         QPoint(lodData->x(), lodData->y()),
                         originalRect, lod);
}

References KisSharedPtr< T >::data(), KisPaintDeviceData::dataManager(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintDeviceData::levelOfDetail(), KisPaintDevice::Private::LodDataStructImpl::lodData, KisPaintDeviceData::x(), and KisPaintDeviceData::y().

uploadFrame() [1/2]

void KisPaintDevice::Private::uploadFrame	(	int	dstFrameId,
		KisPaintDeviceSP	srcDevice )

Definition at line 875 of file kis_paint_device.cc.

{
    DataSP dstData = m_frames[dstFrameId];
    KIS_ASSERT_RECOVER_RETURN(dstData);
 
    DataSP srcData = srcDevice->m_d->m_data;
    KIS_ASSERT_RECOVER_RETURN(srcData);
 
    uploadFrameData(srcData, dstData);
}

References KIS_ASSERT_RECOVER_RETURN, KisPaintDevice::m_d, and m_data.

uploadFrame() [2/2]

void KisPaintDevice::Private::uploadFrame	(	int	srcFrameId,
		int	dstFrameId,
		KisPaintDeviceSP	srcDevice )

Definition at line 864 of file kis_paint_device.cc.

{
    DataSP dstData = m_frames[dstFrameId];
    KIS_ASSERT_RECOVER_RETURN(dstData);
 
    DataSP srcData = srcDevice->m_d->m_frames[srcFrameId];
    KIS_ASSERT_RECOVER_RETURN(srcData);
 
    uploadFrameData(srcData, dstData);
}

References KIS_ASSERT_RECOVER_RETURN, KisPaintDevice::m_d, and m_frames.

uploadFrameData()

void KisPaintDevice::Private::uploadFrameData	(	DataSP	srcData,
		DataSP	dstData )

Definition at line 886 of file kis_paint_device.cc.

{
    if (srcData->colorSpace() != dstData->colorSpace() &&
        *srcData->colorSpace() != *dstData->colorSpace()) {
 
        KUndo2Command tempCommand;
 
        srcData = toQShared(new Data(q, srcData.data(), true));
        srcData->convertDataColorSpace(dstData->colorSpace(),
                                       KoColorConversionTransformation::internalRenderingIntent(),
                                       KoColorConversionTransformation::internalConversionFlags(),
                                       &tempCommand);
    }
 
    /* If the destination data doesn't share a default pixel value
     * with src, we should make sure that the default pixel is set
     * properly before clearing and writing contents.
     */
    const int defaultPixelcmp =
            memcmp(srcData->dataManager()->defaultPixel(),
                   dstData->dataManager()->defaultPixel(),
                   dstData->dataManager()->pixelSize());
    if (defaultPixelcmp != 0) {
        dstData->dataManager()->setDefaultPixel(srcData->dataManager()->defaultPixel());
    }
 
    dstData->dataManager()->clear();
    dstData->cache()->invalidate();
 
    const QRect rect = srcData->dataManager()->extent();
    dstData->dataManager()->bitBltRough(srcData->dataManager(), rect);
    dstData->setX(srcData->x());
    dstData->setY(srcData->y());
}

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

uploadLodDataStruct()

void KisPaintDevice::Private::uploadLodDataStruct

(

LodDataStruct *

dst

)

Definition at line 835 of file kis_paint_device.cc.

{
    LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
    KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(
        dst->lodData->levelOfDetail() == defaultBounds->currentLevelOfDetail());
 
    ensureLodDataPresent();
 
    m_lodData->prepareClone(dst->lodData.data());
    m_lodData->dataManager()->bitBltRough(dst->lodData->dataManager(), dst->lodData->dataManager()->extent());
}

References KisDefaultBoundsBase::currentLevelOfDetail(), KisPaintDevice::defaultBounds(), KIS_SAFE_ASSERT_RECOVER_RETURN, and KisPaintDevice::Private::LodDataStructImpl::lodData.

writeFrame()

bool KisPaintDevice::Private::writeFrame ( KisPaintDeviceWriter & store, int frameId )

inline

Definition at line 391 of file kis_paint_device.cc.

    {
        DataSP data = m_frames[frameId];
        return data->dataManager()->write(store);
    }

References m_frames.

writeFrameToDevice()

void KisPaintDevice::Private::writeFrameToDevice	(	int	frameId,
		KisPaintDeviceSP	targetDevice )

Definition at line 858 of file kis_paint_device.cc.

{
    DataSP data = m_frames[frameId];
    transferFromData(data.data(), targetDevice);
}

x()

qint32 KisPaintDevice::Private::x ( ) const

inline

Definition at line 120 of file kis_paint_device.cc.

    {
        return currentData()->x();
    }

References currentData(), and KisPaintDeviceData::x().

y()

qint32 KisPaintDevice::Private::y ( ) const

inline

Definition at line 124 of file kis_paint_device.cc.

    {
        return currentData()->y();
    }

References currentData(), and KisPaintDeviceData::y().

Friends And Related Symbol Documentation

KisPaintDeviceFramesInterface

friend class KisPaintDeviceFramesInterface

friend

Definition at line 592 of file kis_paint_device.cc.

Member Data Documentation

basicStrategy

QScopedPointer<KisPaintDeviceStrategy> KisPaintDevice::Private::basicStrategy

Definition at line 90 of file kis_paint_device.cc.

contentChannel

QScopedPointer<KisRasterKeyframeChannel> KisPaintDevice::Private::contentChannel

Definition at line 88 of file kis_paint_device.cc.

defaultBounds

KisDefaultBoundsBaseSP KisPaintDevice::Private::defaultBounds

Definition at line 89 of file kis_paint_device.cc.

framesInterface

QScopedPointer<KisPaintDeviceFramesInterface> KisPaintDevice::Private::framesInterface

Definition at line 94 of file kis_paint_device.cc.

isProjectionDevice

bool KisPaintDevice::Private::isProjectionDevice

Definition at line 95 of file kis_paint_device.cc.

m_data

DataSP KisPaintDevice::Private::m_data

private

Definition at line 595 of file kis_paint_device.cc.

m_dataSwitchLock

QMutex KisPaintDevice::Private::m_dataSwitchLock

mutableprivate

Definition at line 598 of file kis_paint_device.cc.

m_externalFrameData

QScopedPointer<Data> KisPaintDevice::Private::m_externalFrameData

mutableprivate

Definition at line 597 of file kis_paint_device.cc.

m_frames

FramesHash KisPaintDevice::Private::m_frames

private

Definition at line 600 of file kis_paint_device.cc.

m_lodData

QScopedPointer<Data> KisPaintDevice::Private::m_lodData

mutableprivate

Definition at line 596 of file kis_paint_device.cc.

m_nextFreeFrameId

int KisPaintDevice::Private::m_nextFreeFrameId

private

Definition at line 601 of file kis_paint_device.cc.

m_wrappedStrategyMutex

QMutex KisPaintDevice::Private::m_wrappedStrategyMutex

Definition at line 92 of file kis_paint_device.cc.

parent

KisNodeWSP KisPaintDevice::Private::parent

Definition at line 87 of file kis_paint_device.cc.

q

KisPaintDevice* KisPaintDevice::Private::q

Definition at line 86 of file kis_paint_device.cc.

StrategyPolicy

struct Q_DECL_HIDDEN KisPaintDevice::Private::StrategyPolicy

private

Definition at line 587 of file kis_paint_device.cc.

supportsWrapAroundMode

bool KisPaintDevice::Private::supportsWrapAroundMode

Definition at line 96 of file kis_paint_device.cc.

transitionalDefaultBounds

const KisDefaultBoundsSP KisPaintDevice::Private::transitionalDefaultBounds = new KisDefaultBounds()

static

Used when the paint device is loading to ensure no lod/animation interferes the process.

Definition at line 73 of file kis_paint_device.cc.

wrappedStrategy

QScopedPointer<KisPaintDeviceWrappedStrategy> KisPaintDevice::Private::wrappedStrategy

Definition at line 91 of file kis_paint_device.cc.

---

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

• libs/image/kis_paint_device.cc