#include <kis_strokes_queue.h>

Inheritance diagram for KisStrokesQueue:

Classes
class	LodNUndoStrokesFacade

Public Member Functions
void	addJob (KisStrokeId id, KisStrokeJobData *data)

void	addMutatedJobs (KisStrokeId id, const QVector< KisStrokeJobData * > list) final override

qreal	balancingRatioOverride () const

void	cancelForgettableStrokes ()

bool	cancelStroke (KisStrokeId id)

std::pair< StrokesQueueIterator, StrokesQueueIterator >	currentLodRange ()

KUndo2MagicString	currentStrokeName () const

void	debugDumpAllStrokes ()

void	endStroke (KisStrokeId id)

void	explicitRegenerateLevelOfDetail ()

StrokesQueueIterator	findNewLod0Pos ()

StrokesQueueIterator	findNewLodNPos (KisStrokeSP lodN)

void	forceResetLodAndCloseCurrentLodRange ()

bool	hasOpenedStrokes () const

bool	hasUnfinishedStrokes () const

bool	isEmpty () const

	KisStrokesQueue ()

void	loadStroke (KisStrokeSP stroke)

KisPostExecutionUndoAdapter *	lodNPostExecutionUndoAdapter () const

KisLodPreferences	lodPreferences () const override

bool	needsExclusiveAccess () const

void	notifyUFOChangedImage ()

	Private (KisStrokesQueue *_q)

void	processQueue (KisUpdaterContext &updaterContext, bool externalJobsPending)

void	setLod0ToNStrokeStrategyFactory (const KisLodSyncStrokeStrategyFactory &factory)

void	setLodPreferences (const KisLodPreferences &value)

void	setPostSyncLod0GUIPlaneRequestForResumeCallback (const std::function< void()> &callback)

void	setPurgeRedoStateCallback (const std::function< void()> &callback)

void	setSuspendResumeUpdatesStrokeStrategyFactory (const KisSuspendResumeStrategyPairFactory &factory)

bool	shouldWrapInSuspendUpdatesStroke ()

qint32	sizeMetric () const

void	startLod0ToNStroke (int levelOfDetail, bool forgettable)

KisStrokeId	startStroke (KisStrokeStrategy *strokeStrategy)

void	switchDesiredLevelOfDetail (bool forced)

bool	tryCancelCurrentStrokeAsync ()

void	tryClearUndoOnStrokeCompletion (KisStrokeSP finishingStroke)

UndoResult	tryUndoLastStrokeAsync ()

bool	wrapAroundModeSupported () const

	~KisStrokesQueue ()

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

Public Member Functions inherited from KisStrokesQueueMutatedJobInterface
virtual	~KisStrokesQueueMutatedJobInterface ()

Public Attributes
qreal	balancingRatioOverride

bool	currentStrokeLoaded

int	desiredLevelOfDetail

KisLodSyncStrokeStrategyFactory	lod0ToNStrokeStrategyFactory

bool	lodNNeedsSynchronization

KisPostExecutionUndoAdapter	lodNPostExecutionUndoAdapter

LodNUndoStrokesFacade	lodNStrokesFacade

KisSurrogateUndoStore	lodNUndoStore

KisLodPreferences	lodPreferences

QMutex	mutex

bool	needsExclusiveAccess

int	nextDesiredLevelOfDetail

int	openedStrokesCounter

std::function< void()>	postSyncLod0GUIPlaneRequestForResume

std::function< void()>	purgeRedoStateCallback

KisStrokesQueue *	q

StrokesQueue	strokesQueue

KisSuspendResumeStrategyPairFactory	suspendResumeUpdatesStrokeStrategyFactory

bool	wrapAroundModeSupported

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Private Member Functions
bool	checkBarrierProperty (bool hasMergeJobs, bool hasStrokeJobs, bool externalJobsPending)

bool	checkExclusiveProperty (bool hasMergeJobs, bool hasStrokeJobs)

bool	checkLevelOfDetailProperty (int runningLevelOfDetail)

bool	checkSequentialProperty (KisUpdaterContextSnapshotEx snapshot, bool externalJobsPending)

bool	checkStrokeState (bool hasStrokeJobsRunning, int runningLevelOfDetail)

bool	processOneJob (KisUpdaterContext &updaterContext, bool externalJobsPending)

KisStrokeId	startLodNUndoStroke (KisStrokeStrategy *strokeStrategy)

Private Attributes
Private *const	m_d

Detailed Description

Definition at line 62 of file kis_strokes_queue.cpp.

Constructor & Destructor Documentation

◆ KisStrokesQueue()

KisStrokesQueue::KisStrokesQueue ( )

Definition at line 114 of file kis_strokes_queue.cpp.

  : m_d(new Private(this))
{
}

◆ ~KisStrokesQueue()

KisStrokesQueue::~KisStrokesQueue ( )

Definition at line 119 of file kis_strokes_queue.cpp.

{
    Q_FOREACH (KisStrokeSP stroke, m_d->strokesQueue) {
        stroke->cancelStroke();
    }
 
    delete m_d;
}

References m_d.

Member Function Documentation

◆ addJob()

void KisStrokesQueue::addJob	(	KisStrokeId	id,
		KisStrokeJobData *	data )

Definition at line 342 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    KisStrokeSP stroke = id.toStrongRef();
    KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
 
    KisStrokeSP buddy = stroke->lodBuddy();
    if (buddy) {
        KisStrokeJobData *clonedData =
            data->createLodClone(buddy->worksOnLevelOfDetail());
        KIS_ASSERT_RECOVER_RETURN(clonedData);
 
        buddy->addJob(clonedData);
    }
 
    stroke->addJob(data);
}

References KisStrokeJobData::createLodClone(), KIS_ASSERT_RECOVER_RETURN, KIS_SAFE_ASSERT_RECOVER_RETURN, and m_d.

◆ addMutatedJobs()

void KisStrokesQueue::addMutatedJobs	(	KisStrokeId	id,
		const QVector< KisStrokeJobData * >	list )

finaloverridevirtual

Implements KisStrokesQueueMutatedJobInterface.

Definition at line 361 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    KisStrokeSP stroke = id.toStrongRef();
    KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
 
    stroke->addMutatedJobs(list);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, and m_d.

◆ balancingRatioOverride()

qreal KisStrokesQueue::balancingRatioOverride ( ) const

◆ cancelForgettableStrokes()

void KisStrokesQueue::cancelForgettableStrokes ( )

◆ cancelStroke()

bool KisStrokesQueue::cancelStroke ( KisStrokeId id )

Definition at line 386 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    KisStrokeSP stroke = id.toStrongRef();
    if(stroke) {
        stroke->cancelStroke();
        m_d->openedStrokesCounter--;
 
        KisStrokeSP buddy = stroke->lodBuddy();
        if (buddy) {
            buddy->cancelStroke();
        }
    }
    return bool(stroke);
}

References m_d.

◆ checkBarrierProperty()

bool KisStrokesQueue::checkBarrierProperty	(	bool	hasMergeJobs,
		bool	hasStrokeJobs,
		bool	externalJobsPending )

private

◆ checkExclusiveProperty()

bool KisStrokesQueue::checkExclusiveProperty	(	bool	hasMergeJobs,
		bool	hasStrokeJobs )

private

Definition at line 867 of file kis_strokes_queue.cpp.

{
    Q_UNUSED(hasStrokeJobs);
 
    if(!m_d->strokesQueue.head()->isExclusive()) return true;
    return hasMergeJobs == 0;
}

References m_d.

◆ checkLevelOfDetailProperty()

bool KisStrokesQueue::checkLevelOfDetailProperty ( int runningLevelOfDetail )

private

Definition at line 914 of file kis_strokes_queue.cpp.

{
    KisStrokeSP stroke = m_d->strokesQueue.head();
 
    return runningLevelOfDetail < 0 ||
        stroke->nextJobLevelOfDetail() == runningLevelOfDetail;
}

References m_d.

◆ checkSequentialProperty()

bool KisStrokesQueue::checkSequentialProperty	(	KisUpdaterContextSnapshotEx	snapshot,
		bool	externalJobsPending )

private

Definition at line 876 of file kis_strokes_queue.cpp.

{
    KisStrokeSP stroke = m_d->strokesQueue.head();
 
    if (snapshot & HasSequentialJob ||
        snapshot & HasBarrierJob) {
        return false;
    }
 
    KisStrokeJobData::Sequentiality nextSequentiality =
        stroke->nextJobSequentiality();
 
    if (nextSequentiality == KisStrokeJobData::UNIQUELY_CONCURRENT &&
        snapshot & HasUniquelyConcurrentJob) {
 
        return false;
    }
 
    if (nextSequentiality == KisStrokeJobData::SEQUENTIAL &&
        (snapshot & HasUniquelyConcurrentJob ||
         snapshot & HasConcurrentJob)) {
 
        return false;
    }
 
    if (nextSequentiality == KisStrokeJobData::BARRIER &&
        (snapshot & HasUniquelyConcurrentJob ||
         snapshot & HasConcurrentJob ||
         snapshot & HasMergeJob ||
         externalJobsPending)) {
 
        return false;
    }
 
    return true;
}

References KisStrokeJobData::BARRIER, HasBarrierJob, HasConcurrentJob, HasMergeJob, HasSequentialJob, HasUniquelyConcurrentJob, m_d, KisStrokeJobData::SEQUENTIAL, and KisStrokeJobData::UNIQUELY_CONCURRENT.

◆ checkStrokeState()

bool KisStrokesQueue::checkStrokeState	(	bool	hasStrokeJobsRunning,
		int	runningLevelOfDetail )

private

We cannot start/continue a stroke if its LOD differs from the one that is running on CPU

The stroke may be cancelled very fast. In this case it will end up in the state:

!stroke->isInitialized() && stroke->isEnded() && !stroke->hasJobs()

This means that !isInitialised() doesn't imply there are any jobs present.

It might happen that the stroke got initialized, but its job was not started due to some other reasons like exclusivity. Therefore the stroke might end up in loaded, but uninitialized state.

If the stroke has no initialization phase, then it can arrive here unloaded.

If the Lod0 stroke has been cancelled without even being started, it means that the GUI still has LodN tiles active, so we should reread the data from the image to switch GUI tiles into Lod0 mode.

Definition at line 788 of file kis_strokes_queue.cpp.

{
    KisStrokeSP stroke = m_d->strokesQueue.head();
    bool result = false;
 
    bool hasLodCompatibility = checkLevelOfDetailProperty(runningLevelOfDetail);
    bool hasJobs = stroke->hasJobs();
 
    if(!stroke->isInitialized() && hasJobs && hasLodCompatibility) {
        if (!m_d->currentStrokeLoaded) {
            m_d->loadStroke(stroke);
        }
 
        result = true;
    }
    else if(hasJobs && hasLodCompatibility) {
        if (!m_d->currentStrokeLoaded) {
            m_d->loadStroke(stroke);
        }
 
        result = true;
    }
    else if(stroke->isEnded() && !hasJobs && !hasStrokeJobsRunning) {
        m_d->tryClearUndoOnStrokeCompletion(stroke);
 
        const bool needsSyncLod0PlaneToGUI =
                stroke->type() == KisStroke::LOD0 &&
                stroke->isCancelled();
 
        if (needsSyncLod0PlaneToGUI &&
            m_d->postSyncLod0GUIPlaneRequestForResume) {
            m_d->postSyncLod0GUIPlaneRequestForResume();
        }
 
        m_d->strokesQueue.dequeue(); // deleted by shared pointer
        m_d->needsExclusiveAccess = false;
        m_d->wrapAroundModeSupported = false;
        m_d->balancingRatioOverride = -1.0;
        m_d->currentStrokeLoaded = false;
 
        m_d->switchDesiredLevelOfDetail(false);
 
        if(!m_d->strokesQueue.isEmpty()) {
            result = checkStrokeState(false, runningLevelOfDetail);
        }
    }
 
    return result;
}

References checkLevelOfDetailProperty(), checkStrokeState(), KisStroke::LOD0, and m_d.

◆ currentLodRange()

std::pair< StrokesQueueIterator, StrokesQueueIterator > KisStrokesQueue::currentLodRange ( )

◆ currentStrokeName()

KUndo2MagicString KisStrokesQueue::currentStrokeName ( ) const

Definition at line 728 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
    if(m_d->strokesQueue.isEmpty()) return KUndo2MagicString();
 
    return m_d->strokesQueue.head()->name();
}

References m_d.

◆ debugDumpAllStrokes()

void KisStrokesQueue::debugDumpAllStrokes ( )

Definition at line 692 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    qDebug() <<"===";
    Q_FOREACH (KisStrokeSP stroke, m_d->strokesQueue) {
        qDebug() << ppVar(stroke->name()) << ppVar(stroke->type()) << ppVar(stroke->numJobs()) << ppVar(stroke->isInitialized()) << ppVar(stroke->isCancelled());
    }
    qDebug() <<"===";
}

References m_d, and ppVar.

◆ endStroke()

void KisStrokesQueue::endStroke ( KisStrokeId id )

Definition at line 371 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    KisStrokeSP stroke = id.toStrongRef();
    KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
    stroke->endStroke();
    m_d->openedStrokesCounter--;
 
    KisStrokeSP buddy = stroke->lodBuddy();
    if (buddy) {
        buddy->endStroke();
    }
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, and m_d.

◆ explicitRegenerateLevelOfDetail()

void KisStrokesQueue::explicitRegenerateLevelOfDetail ( )

Definition at line 679 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
    m_d->switchDesiredLevelOfDetail(true);
}

References m_d.

◆ findNewLod0Pos()

StrokesQueueIterator KisStrokesQueue::findNewLod0Pos ( )

◆ findNewLodNPos()

StrokesQueueIterator KisStrokesQueue::findNewLodNPos ( KisStrokeSP lodN )

◆ forceResetLodAndCloseCurrentLodRange()

void KisStrokesQueue::forceResetLodAndCloseCurrentLodRange ( )

◆ hasOpenedStrokes()

bool KisStrokesQueue::hasOpenedStrokes ( ) const

Definition at line 736 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
    return m_d->openedStrokesCounter;
}

References m_d.

◆ hasUnfinishedStrokes()

bool KisStrokesQueue::hasUnfinishedStrokes ( ) const

◆ isEmpty()

bool KisStrokesQueue::isEmpty ( ) const

Definition at line 643 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
    return m_d->strokesQueue.isEmpty();
}

References m_d.

◆ loadStroke()

void KisStrokesQueue::loadStroke ( KisStrokeSP stroke )

◆ lodNPostExecutionUndoAdapter()

KisPostExecutionUndoAdapter * KisStrokesQueue::lodNPostExecutionUndoAdapter ( ) const

◆ lodPreferences()

KisLodPreferences KisStrokesQueue::lodPreferences ( ) const

overridevirtual

Implements KisStrokesQueueMutatedJobInterface.

◆ needsExclusiveAccess()

bool KisStrokesQueue::needsExclusiveAccess ( ) const

◆ notifyUFOChangedImage()

void KisStrokesQueue::notifyUFOChangedImage ( )

Notifies the queue, that someone else (neither strokes nor the queue itself have changed the image. It means that the caches should be regenerated

Definition at line 685 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    m_d->forceResetLodAndCloseCurrentLodRange();
}

References m_d.

◆ Private()

KisStrokesQueue::Private ( KisStrokesQueue * _q )

inline

Definition at line 63 of file kis_strokes_queue.cpp.

        : q(_q),
          openedStrokesCounter(0),
          needsExclusiveAccess(false),
          wrapAroundModeSupported(false),
          balancingRatioOverride(-1.0),
          currentStrokeLoaded(false),
          lodNNeedsSynchronization(true),
          desiredLevelOfDetail(0),
          nextDesiredLevelOfDetail(0),
          lodNStrokesFacade(_q),
          lodNPostExecutionUndoAdapter(&lodNUndoStore, &lodNStrokesFacade) {}

◆ processOneJob()

bool KisStrokesQueue::processOneJob	(	KisUpdaterContext &	updaterContext,
		bool	externalJobsPending )

private

Definition at line 742 of file kis_strokes_queue.cpp.

{
    if(m_d->strokesQueue.isEmpty()) return false;
    bool result = false;
 
    const int levelOfDetail = updaterContext.currentLevelOfDetail();
 
    const KisUpdaterContextSnapshotEx snapshot = updaterContext.getContextSnapshotEx();
 
    const bool hasStrokeJobs = !(snapshot == ContextEmpty ||
                                 snapshot == HasMergeJob);
    const bool hasMergeJobs = snapshot & HasMergeJob;
 
    if(checkStrokeState(hasStrokeJobs, levelOfDetail) &&
       checkExclusiveProperty(hasMergeJobs, hasStrokeJobs) &&
       checkSequentialProperty(snapshot, externalJobsPending)) {
 
        KisStrokeSP stroke = m_d->strokesQueue.head();
        updaterContext.addStrokeJob(stroke->popOneJob());
        result = true;
    }
 
    return result;
}

References KisUpdaterContext::addStrokeJob(), checkExclusiveProperty(), checkSequentialProperty(), checkStrokeState(), ContextEmpty, KisUpdaterContext::currentLevelOfDetail(), KisUpdaterContext::getContextSnapshotEx(), HasMergeJob, and m_d.

◆ processQueue()

void KisStrokesQueue::processQueue	(	KisUpdaterContext &	updaterContext,
		bool	externalJobsPending )

Definition at line 589 of file kis_strokes_queue.cpp.

{
    updaterContext.lock();
    m_d->mutex.lock();
 
    while(updaterContext.hasSpareThread() &&
          processOneJob(updaterContext,
                        externalJobsPending));
 
    m_d->mutex.unlock();
    updaterContext.unlock();
}

References KisUpdaterContext::hasSpareThread(), KisUpdaterContext::lock(), m_d, processOneJob(), and KisUpdaterContext::unlock().

◆ setLod0ToNStrokeStrategyFactory()

void KisStrokesQueue::setLod0ToNStrokeStrategyFactory ( const KisLodSyncStrokeStrategyFactory & factory )

Definition at line 703 of file kis_strokes_queue.cpp.

{
    m_d->lod0ToNStrokeStrategyFactory = factory;
}

References m_d.

◆ setLodPreferences()

void KisStrokesQueue::setLodPreferences ( const KisLodPreferences & value )

Definition at line 629 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    m_d->lodPreferences = value;
 
    if (m_d->lodPreferences.desiredLevelOfDetail() != m_d->nextDesiredLevelOfDetail ||
            (m_d->lodPreferences.lodPreferred() && m_d->lodNNeedsSynchronization)) {
 
        m_d->nextDesiredLevelOfDetail = m_d->lodPreferences.desiredLevelOfDetail();
        m_d->switchDesiredLevelOfDetail(false);
    }
}

References m_d, and value().

◆ setPostSyncLod0GUIPlaneRequestForResumeCallback()

void KisStrokesQueue::setPostSyncLod0GUIPlaneRequestForResumeCallback ( const std::function< void()> & callback )

Definition at line 718 of file kis_strokes_queue.cpp.

{
    m_d->postSyncLod0GUIPlaneRequestForResume = callback;
}

References m_d.

◆ setPurgeRedoStateCallback()

void KisStrokesQueue::setPurgeRedoStateCallback ( const std::function< void()> & callback )

Definition at line 713 of file kis_strokes_queue.cpp.

{
    m_d->purgeRedoStateCallback = callback;
}

References m_d.

◆ setSuspendResumeUpdatesStrokeStrategyFactory()

void KisStrokesQueue::setSuspendResumeUpdatesStrokeStrategyFactory ( const KisSuspendResumeStrategyPairFactory & factory )

Definition at line 708 of file kis_strokes_queue.cpp.

{
    m_d->suspendResumeUpdatesStrokeStrategyFactory = factory;
}

References m_d.

◆ shouldWrapInSuspendUpdatesStroke()

bool KisStrokesQueue::shouldWrapInSuspendUpdatesStroke ( )

◆ sizeMetric()

qint32 KisStrokesQueue::sizeMetric ( ) const

Definition at line 649 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
    if(m_d->strokesQueue.isEmpty()) return 0;
 
    // just a rough approximation
    return qMax(1, m_d->strokesQueue.head()->numJobs()) * m_d->strokesQueue.size();
}

References m_d.

◆ startLod0ToNStroke()

void KisStrokesQueue::startLod0ToNStroke	(	int	levelOfDetail,
		bool	forgettable )

◆ startLodNUndoStroke()

KisStrokeId KisStrokesQueue::startLodNUndoStroke ( KisStrokeStrategy * strokeStrategy )

private

Definition at line 264 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->lodNNeedsSynchronization);
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->desiredLevelOfDetail > 0);
 
    KisStrokeSP buddy(new KisStroke(strokeStrategy, KisStroke::LODN, m_d->desiredLevelOfDetail));
    strokeStrategy->setMutatedJobsInterface(this, buddy);
    m_d->strokesQueue.insert(m_d->findNewLodNPos(buddy), buddy);
 
    KisStrokeId id(buddy);
    m_d->openedStrokesCounter++;
 
    return id;
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, KisStroke::LODN, m_d, and KisStrokeStrategy::setMutatedJobsInterface().

◆ startStroke()

KisStrokeId KisStrokesQueue::startStroke ( KisStrokeStrategy * strokeStrategy )

Definition at line 281 of file kis_strokes_queue.cpp.

{
    QMutexLocker locker(&m_d->mutex);
 
    KisStrokeSP stroke;
    KisStrokeStrategy* lodBuddyStrategy;
 
    // we should let forgettable strokes to queue up
    if (!strokeStrategy->canForgetAboutMe()) {
        m_d->cancelForgettableStrokes();
    }
 
    if (m_d->desiredLevelOfDetail &&
        (m_d->lodPreferences.lodPreferred() || strokeStrategy->forceLodModeIfPossible()) &&
        (lodBuddyStrategy =
         strokeStrategy->createLodClone(m_d->desiredLevelOfDetail))) {
 
        if (m_d->lodNNeedsSynchronization) {
            m_d->startLod0ToNStroke(m_d->desiredLevelOfDetail, false);
        }
 
        stroke = KisStrokeSP(new KisStroke(strokeStrategy, KisStroke::LOD0, 0));
 
        KisStrokeSP buddy(new KisStroke(lodBuddyStrategy, KisStroke::LODN, m_d->desiredLevelOfDetail));
        lodBuddyStrategy->setMutatedJobsInterface(this, buddy);
        stroke->setLodBuddy(buddy);
        m_d->strokesQueue.insert(m_d->findNewLodNPos(buddy), buddy);
 
        if (m_d->shouldWrapInSuspendUpdatesStroke()) {
 
            KisSuspendResumePair suspendPair;
            KisSuspendResumePair resumePair;
            std::tie(suspendPair, resumePair) = m_d->suspendResumeUpdatesStrokeStrategyFactory();
 
            StrokesQueueIterator it = m_d->findNewLod0Pos();
 
            it = executeStrokePair(resumePair, m_d->strokesQueue, it, KisStroke::RESUME, 0, this);
            it = m_d->strokesQueue.insert(it, stroke);
            it = executeStrokePair(suspendPair, m_d->strokesQueue, it, KisStroke::SUSPEND, 0, this);
 
        } else {
            m_d->strokesQueue.insert(m_d->findNewLod0Pos(), stroke);
        }
 
    } else {
        stroke = KisStrokeSP(new KisStroke(strokeStrategy, KisStroke::LEGACY, 0));
        m_d->strokesQueue.enqueue(stroke);
    }
 
    KisStrokeId id(stroke);
    strokeStrategy->setMutatedJobsInterface(this, id);
 
    m_d->openedStrokesCounter++;
 
    if (stroke->type() == KisStroke::LEGACY) {
        m_d->lodNNeedsSynchronization = true;
    }
 
    return id;
}

References KisStrokeStrategy::canForgetAboutMe(), KisStrokeStrategy::createLodClone(), executeStrokePair(), KisStrokeStrategy::forceLodModeIfPossible(), KisStroke::LEGACY, KisStroke::LOD0, KisStroke::LODN, m_d, KisStroke::RESUME, KisStrokeStrategy::setMutatedJobsInterface(), and KisStroke::SUSPEND.

◆ switchDesiredLevelOfDetail()

void KisStrokesQueue::switchDesiredLevelOfDetail ( bool forced )

◆ tryCancelCurrentStrokeAsync()

bool KisStrokesQueue::tryCancelCurrentStrokeAsync ( )

We cancel only ended strokes. This is done to avoid handling dangling pointers problem (KisStrokeId). The owner of a stroke will cancel the stroke itself if needed.

1) We can cancel only cancellable strokes 2) We can only cancel a continuous set of strokes

Basically, a non-cancellable stroke adds a barrier wall into the strokes queue, preventing cancellation of any strokes that we added into the queue earlier.

If the buddy has already finished, we cannot undo it because it doesn't store any undo data. Therefore we just regenerate the LOD caches.

NOTE: We do not touch the openedStrokesCounter here since we work with closed id's only here

Definition at line 414 of file kis_strokes_queue.cpp.

{
    bool anythingCanceled = false;
 
    QMutexLocker locker(&m_d->mutex);
 
    if (!m_d->strokesQueue.isEmpty() &&
        !m_d->hasUnfinishedStrokes()) {
 
        const auto lastNonCancellableStrokeIt =
            std::find_if_not(std::make_reverse_iterator(m_d->strokesQueue.end()),
                             std::make_reverse_iterator(m_d->strokesQueue.begin()),
                             std::mem_fn(&KisStroke::isAsynchronouslyCancellable));
 
        bool needsLodNSynchronization = false;
 
        for (auto it = lastNonCancellableStrokeIt.base(); it != m_d->strokesQueue.end(); it++) {
            KisStrokeSP currentStroke = *it;
            KIS_ASSERT_RECOVER_NOOP(currentStroke->isEnded());
            KIS_ASSERT_RECOVER_NOOP(currentStroke->isAsynchronouslyCancellable());
 
            currentStroke->cancelStroke();
            anythingCanceled = true;
 
            // we shouldn't cancel buddies...
            if (currentStroke->type() == KisStroke::LOD0) {
                needsLodNSynchronization = true;
            }
 
        }
 
        if (needsLodNSynchronization) {
            m_d->forceResetLodAndCloseCurrentLodRange();
        }
    }
 
    return anythingCanceled;
}

References KisStroke::isAsynchronouslyCancellable(), KIS_ASSERT_RECOVER_NOOP, KisStroke::LOD0, and m_d.

◆ tryClearUndoOnStrokeCompletion()

void KisStrokesQueue::tryClearUndoOnStrokeCompletion ( KisStrokeSP finishingStroke )

◆ tryUndoLastStrokeAsync()

UndoResult KisStrokesQueue::tryUndoLastStrokeAsync ( )

Definition at line 476 of file kis_strokes_queue.cpp.

{
    UndoResult result = UNDO_FAIL;
 
    QMutexLocker locker(&m_d->mutex);
 
    KisStrokeSP lastStroke;
    KisStrokeSP lastBuddy;
    bool buddyFound = false;
 
    for (auto it = std::make_reverse_iterator(m_d->strokesQueue.constEnd());
         it != std::make_reverse_iterator(m_d->strokesQueue.constBegin());
         ++it) {
 
        if ((*it)->type() == KisStroke::LEGACY) {
            break;
        }
 
        if (!lastStroke && (*it)->type() == KisStroke::LOD0 && !(*it)->isCancelled()) {
            lastStroke = *it;
            lastBuddy = lastStroke->lodBuddy();
 
            KIS_SAFE_ASSERT_RECOVER(lastBuddy) {
                lastStroke.clear();
                lastBuddy.clear();
                break;
            }
        }
 
        KIS_SAFE_ASSERT_RECOVER(!lastStroke || *it == lastBuddy || (*it)->type() != KisStroke::LODN) {
            lastStroke.clear();
            lastBuddy.clear();
            break;
        }
 
        if (lastStroke && *it == lastBuddy) {
            KIS_SAFE_ASSERT_RECOVER(lastBuddy->type() == KisStroke::LODN) {
                lastStroke.clear();
                lastBuddy.clear();
                break;
            }
            buddyFound = true;
            break;
        }
    }
 
    if (!lastStroke) return UNDO_FAIL;
    if (!lastStroke->isEnded()) return UNDO_FAIL;
    if (lastStroke->isCancelled()) return UNDO_FAIL;
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(!buddyFound ||
                                 lastStroke->isCancelled() == lastBuddy->isCancelled());
    KIS_SAFE_ASSERT_RECOVER_NOOP(lastBuddy->isEnded());
 
    if (!lastStroke->canCancel()) {
        return UNDO_WAIT;
    }
    lastStroke->cancelStroke();
 
    if (buddyFound && lastBuddy->canCancel()) {
        lastBuddy->cancelStroke();
    } else {
        // TODO: assert that checks that there is no other lodn strokes
        locker.unlock();
        m_d->lodNUndoStore.undo();
        m_d->lodNUndoStore.purgeRedoState();
        locker.relock();
    }
 
    result = UNDO_OK;
 
    return result;
}

References KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_NOOP, KisStroke::LEGACY, KisStroke::LOD0, KisStroke::LODN, m_d, UNDO_FAIL, UNDO_OK, and UNDO_WAIT.

◆ wrapAroundModeSupported()

bool KisStrokesQueue::wrapAroundModeSupported ( ) const

Member Data Documentation

◆ balancingRatioOverride

qreal KisStrokesQueue::balancingRatioOverride

Definition at line 81 of file kis_strokes_queue.cpp.

◆ currentStrokeLoaded

bool KisStrokesQueue::currentStrokeLoaded

Definition at line 82 of file kis_strokes_queue.cpp.

◆ desiredLevelOfDetail

int KisStrokesQueue::desiredLevelOfDetail

Definition at line 85 of file kis_strokes_queue.cpp.

◆ lod0ToNStrokeStrategyFactory

KisLodSyncStrokeStrategyFactory KisStrokesQueue::lod0ToNStrokeStrategyFactory

Definition at line 88 of file kis_strokes_queue.cpp.

◆ lodNNeedsSynchronization

bool KisStrokesQueue::lodNNeedsSynchronization

Definition at line 84 of file kis_strokes_queue.cpp.

◆ lodNPostExecutionUndoAdapter

KisPostExecutionUndoAdapter * KisStrokesQueue::lodNPostExecutionUndoAdapter

Definition at line 94 of file kis_strokes_queue.cpp.

◆ lodNStrokesFacade

LodNUndoStrokesFacade KisStrokesQueue::lodNStrokesFacade

Definition at line 93 of file kis_strokes_queue.cpp.

◆ lodNUndoStore

KisSurrogateUndoStore KisStrokesQueue::lodNUndoStore

Definition at line 92 of file kis_strokes_queue.cpp.

◆ lodPreferences

KisLodPreferences KisStrokesQueue::lodPreferences

The desired level of detail might have not been activated due to multi-stage activation process

Definition at line 95 of file kis_strokes_queue.cpp.

◆ m_d

Private* const KisStrokesQueue::m_d

private

Definition at line 93 of file kis_strokes_queue.h.

◆ mutex

QMutex KisStrokesQueue::mutex

Definition at line 87 of file kis_strokes_queue.cpp.

◆ needsExclusiveAccess

bool KisStrokesQueue::needsExclusiveAccess

Definition at line 79 of file kis_strokes_queue.cpp.

◆ nextDesiredLevelOfDetail

int KisStrokesQueue::nextDesiredLevelOfDetail

Definition at line 86 of file kis_strokes_queue.cpp.

◆ openedStrokesCounter

int KisStrokesQueue::openedStrokesCounter

Definition at line 78 of file kis_strokes_queue.cpp.

◆ postSyncLod0GUIPlaneRequestForResume

std::function<void()> KisStrokesQueue::postSyncLod0GUIPlaneRequestForResume

Definition at line 91 of file kis_strokes_queue.cpp.

◆ purgeRedoStateCallback

std::function<void()> KisStrokesQueue::purgeRedoStateCallback

Definition at line 90 of file kis_strokes_queue.cpp.

◆ q

KisStrokesQueue* KisStrokesQueue::q

Definition at line 76 of file kis_strokes_queue.cpp.

◆ strokesQueue

StrokesQueue KisStrokesQueue::strokesQueue

Definition at line 77 of file kis_strokes_queue.cpp.

◆ suspendResumeUpdatesStrokeStrategyFactory

KisSuspendResumeStrategyPairFactory KisStrokesQueue::suspendResumeUpdatesStrokeStrategyFactory

Definition at line 89 of file kis_strokes_queue.cpp.

◆ wrapAroundModeSupported

bool KisStrokesQueue::wrapAroundModeSupported

Definition at line 80 of file kis_strokes_queue.cpp.

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

libs/image/kis_strokes_queue.cpp
libs/image/kis_strokes_queue.h

Classes

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisStrokesQueue()

◆ ~KisStrokesQueue()

Member Function Documentation

◆ addJob()

◆ addMutatedJobs()

◆ balancingRatioOverride()

◆ cancelForgettableStrokes()

◆ cancelStroke()

◆ checkBarrierProperty()

◆ checkExclusiveProperty()

◆ checkLevelOfDetailProperty()

◆ checkSequentialProperty()

◆ checkStrokeState()

◆ currentLodRange()

◆ currentStrokeName()

◆ debugDumpAllStrokes()

◆ endStroke()

◆ explicitRegenerateLevelOfDetail()

◆ findNewLod0Pos()

◆ findNewLodNPos()

◆ forceResetLodAndCloseCurrentLodRange()

◆ hasOpenedStrokes()

◆ hasUnfinishedStrokes()

◆ isEmpty()

◆ loadStroke()

◆ lodNPostExecutionUndoAdapter()

◆ lodPreferences()

◆ needsExclusiveAccess()

◆ notifyUFOChangedImage()

◆ Private()

◆ processOneJob()

◆ processQueue()

◆ setLod0ToNStrokeStrategyFactory()

◆ setLodPreferences()

◆ setPostSyncLod0GUIPlaneRequestForResumeCallback()

◆ setPurgeRedoStateCallback()

◆ setSuspendResumeUpdatesStrokeStrategyFactory()

◆ shouldWrapInSuspendUpdatesStroke()

◆ sizeMetric()

◆ startLod0ToNStroke()

◆ startLodNUndoStroke()

◆ startStroke()

◆ switchDesiredLevelOfDetail()

◆ tryCancelCurrentStrokeAsync()

◆ tryClearUndoOnStrokeCompletion()

◆ tryUndoLastStrokeAsync()

◆ wrapAroundModeSupported()

Member Data Documentation

◆ balancingRatioOverride

◆ currentStrokeLoaded

◆ desiredLevelOfDetail

◆ lod0ToNStrokeStrategyFactory

◆ lodNNeedsSynchronization

◆ lodNPostExecutionUndoAdapter

◆ lodNStrokesFacade

◆ lodNUndoStore

◆ lodPreferences

◆ m_d

◆ mutex

◆ needsExclusiveAccess

◆ nextDesiredLevelOfDetail

◆ openedStrokesCounter

◆ postSyncLod0GUIPlaneRequestForResume

◆ purgeRedoStateCallback

◆ q

◆ strokesQueue

◆ suspendResumeUpdatesStrokeStrategyFactory

◆ wrapAroundModeSupported