KisUpdateScheduler Class Reference

#include <kis_update_scheduler.h>

Inheritance diagram for KisUpdateScheduler:

Public Member Functions
void	addJob (KisStrokeId id, KisStrokeJobData *data) override
void	addSpontaneousJob (KisSpontaneousJob *spontaneousJob)
qreal	balancingRatio () const
void	barrierLock ()
void	blockUpdates ()
bool	cancelStroke (KisStrokeId id) override
void	continueUpdate (const QRect &rect)
int	currentLevelOfDetail () const
void	doSomeUsefulWork ()
void	endStroke (KisStrokeId id) override
void	explicitRegenerateLevelOfDetail ()
void	fullRefreshAsync (KisNodeSP root, const QRect &rc, const QRect &cropRect)
void	fullRefreshAsync (KisNodeSP root, const QVector< QRect > &rects, const QRect &cropRect, KisProjectionUpdateFlags flags)
bool	hasUpdatesRunning () const
void	immediateLockForReadOnly ()
bool	isIdle ()
	KisUpdateScheduler (KisProjectionUpdateListener *projectionUpdateListener, QObject *parent=0)
KisPostExecutionUndoAdapter *	lodNPostExecutionUndoAdapter () const
KisLodPreferences	lodPreferences () const
	Private (KisUpdateScheduler *_q, KisProjectionUpdateListener *p)
void	setLod0ToNStrokeStrategyFactory (const KisLodSyncStrokeStrategyFactory &factory)
void	setLodPreferences (const KisLodPreferences &value)
void	setPostSyncLod0GUIPlaneRequestForResumeCallback (const std::function< void()> &callback)
void	setProgressProxy (KoProgressProxy *progressProxy)
void	setPurgeRedoStateCallback (const std::function< void()> &callback)
void	setSuspendResumeUpdatesStrokeStrategyFactory (const KisSuspendResumeStrategyPairFactory &factory)
void	setThreadsLimit (int value)
void	spareThreadAppeared ()
KisStrokeId	startStroke (KisStrokeStrategy *strokeStrategy) override
int	threadsLimit () const
bool	tryBarrierLock ()
bool	tryCancelCurrentStrokeAsync ()
UndoResult	tryUndoLastStrokeAsync ()
void	unblockUpdates ()
void	unlock (bool resetLodLevels=true)
void	updateProjection (KisNodeSP node, const QRect &rc, const QRect &cropRect)
void	updateProjection (KisNodeSP node, const QVector< QRect > &rects, const QRect &cropRect, KisProjectionUpdateFlags flags)
void	waitForDone ()
bool	wrapAroundModeSupported () const
	~KisUpdateScheduler () override
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)
Public Member Functions inherited from KisStrokesFacade
virtual	~KisStrokesFacade ()

Public Attributes
qreal	defaultBalancingRatio = 1.0
bool	processingBlocked = false
KisQueuesProgressUpdater *	progressUpdater = 0
KisProjectionUpdateListener *	projectionUpdateListener
KisUpdateScheduler *	q
KisStrokesQueue	strokesQueue
KisUpdaterContext	updaterContext
KisLazyWaitCondition	updatesFinishedCondition
QAtomicInt	updatesLockCounter
KisSimpleUpdateQueue	updatesQueue
QReadWriteLock	updatesStartLock
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Protected Slots
void	updateSettings ()

Protected Member Functions
void	connectSignals ()
	KisUpdateScheduler ()
void	processQueues ()

Protected Attributes
Private *const	m_d

Private Member Functions
bool	haveUpdatesRunning ()
void	progressUpdate ()
void	tryProcessUpdatesQueue ()
void	wakeUpWaitingThreads ()

Friends
class	UpdatesBlockTester

Detailed Description

Definition at line 38 of file kis_update_scheduler.cpp.

Constructor & Destructor Documentation

KisUpdateScheduler() [1/2]

KisUpdateScheduler::KisUpdateScheduler	(	KisProjectionUpdateListener *	projectionUpdateListener,
		QObject *	parent = 0 )

Definition at line 65 of file kis_update_scheduler.cpp.

    : QObject(parent),
      m_d(new Private(this, projectionUpdateListener))
{
    updateSettings();
    connectSignals();
}

References connectSignals(), and updateSettings().

~KisUpdateScheduler()

KisUpdateScheduler::~KisUpdateScheduler ( )

override

Definition at line 78 of file kis_update_scheduler.cpp.

{
    delete m_d->progressUpdater;
    delete m_d;
}

References m_d.

KisUpdateScheduler() [2/2]

KisUpdateScheduler::KisUpdateScheduler ( )

protected

Definition at line 73 of file kis_update_scheduler.cpp.

    : m_d(new Private(this, 0))
{
}

Member Function Documentation

addJob()

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

overridevirtual

Implements KisStrokesFacade.

Definition at line 181 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.addJob(id, data);
    processQueues();
}

References m_d, and processQueues().

addSpontaneousJob()

void KisUpdateScheduler::addSpontaneousJob

(

KisSpontaneousJob *

spontaneousJob

)

Definition at line 163 of file kis_update_scheduler.cpp.

{
    m_d->updatesQueue.addSpontaneousJob(spontaneousJob);
    processQueues();
}

References m_d, and processQueues().

balancingRatio()

qreal KisUpdateScheduler::balancingRatio ( ) const

inline

Definition at line 59 of file kis_update_scheduler.cpp.

                                 {
        const qreal strokeRatioOverride = strokesQueue.balancingRatioOverride();
        return strokeRatioOverride > 0 ? strokeRatioOverride : defaultBalancingRatio;
    }

References KisStrokesQueue::balancingRatioOverride.

barrierLock()

void KisUpdateScheduler::barrierLock

(

)

Waits until the queues become empty, then blocks the processing. To unblock processing you should use unlock().

If some other thread adds jobs in parallel, then you may wait forever. If you don't want it, consider lock() instead.

See also

unlock(), lock()

Definition at line 346 of file kis_update_scheduler.cpp.

{
    do {
        m_d->processingBlocked = false;
        processQueues();
        m_d->processingBlocked = true;
        m_d->updaterContext.waitForDone();
    } while(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty());
}

References m_d, and processQueues().

blockUpdates()

void KisUpdateScheduler::blockUpdates

(

)

Blocks all the updates from execution. It doesn't affect strokes execution in any way. This type of lock is supposed to be held by the strokes themselves when they need a short access to some parts of the projection of the image.

From all the other places you should use usual lock()/unlock() methods

See also

lock(), unlock()

Definition at line 388 of file kis_update_scheduler.cpp.

{
    m_d->updatesFinishedCondition.initWaiting();
 
    m_d->updatesLockCounter.ref();
    while(haveUpdatesRunning()) {
        m_d->updatesFinishedCondition.wait();
    }
 
    m_d->updatesFinishedCondition.endWaiting();
}

References haveUpdatesRunning(), and m_d.

cancelStroke()

bool KisUpdateScheduler::cancelStroke ( KisStrokeId id )

overridevirtual

Implements KisStrokesFacade.

Definition at line 193 of file kis_update_scheduler.cpp.

{
    bool result = m_d->strokesQueue.cancelStroke(id);
    processQueues();
    return result;
}

References m_d, and processQueues().

connectSignals()

void KisUpdateScheduler::connectSignals ( )

protected

Definition at line 106 of file kis_update_scheduler.cpp.

{
    connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()),
            SLOT(updateSettings()));
}

References connect(), KisImageConfigNotifier::instance(), and updateSettings().

continueUpdate()

void KisUpdateScheduler::continueUpdate

(

const QRect &

rect

)

Definition at line 431 of file kis_update_scheduler.cpp.

{
    Q_ASSERT(m_d->projectionUpdateListener);
    m_d->projectionUpdateListener->notifyProjectionUpdated(rect);
}

References m_d.

currentLevelOfDetail()

int KisUpdateScheduler::currentLevelOfDetail

(

)

const

Definition at line 240 of file kis_update_scheduler.cpp.

{
    int levelOfDetail = m_d->updaterContext.currentLevelOfDetail();
 
    if (levelOfDetail < 0) {
        // it is safe, because is called iff updaterContext has no running jobs at all
        levelOfDetail = m_d->updatesQueue.overrideLevelOfDetail();
    }
 
    if (levelOfDetail < 0) {
        levelOfDetail = 0;
    }
 
    return levelOfDetail;
}

References m_d.

doSomeUsefulWork()

void KisUpdateScheduler::doSomeUsefulWork

(

)

Definition at line 437 of file kis_update_scheduler.cpp.

{
    m_d->updatesQueue.optimize();
}

References m_d.

endStroke()

void KisUpdateScheduler::endStroke ( KisStrokeId id )

overridevirtual

Implements KisStrokesFacade.

Definition at line 187 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.endStroke(id);
    processQueues();
}

References m_d, and processQueues().

explicitRegenerateLevelOfDetail()

void KisUpdateScheduler::explicitRegenerateLevelOfDetail

(

)

Explicitly start regeneration of LoD planes of all the devices in the image. This call should be performed when the user is idle, just to make the quality of image updates better.

Definition at line 232 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.explicitRegenerateLevelOfDetail();
 
    // \see a comment in setDesiredLevelOfDetail()
    processQueues();
}

References m_d, and processQueues().

fullRefreshAsync() [1/2]

void KisUpdateScheduler::fullRefreshAsync	(	KisNodeSP	root,
		const QRect &	rc,
		const QRect &	cropRect )

Definition at line 158 of file kis_update_scheduler.cpp.

{
    fullRefreshAsync(root, {rc}, cropRect, KisProjectionUpdateFlag::None);
}

References fullRefreshAsync(), and None.

fullRefreshAsync() [2/2]

void KisUpdateScheduler::fullRefreshAsync	(	KisNodeSP	root,
		const QVector< QRect > &	rects,
		const QRect &	cropRect,
		KisProjectionUpdateFlags	flags )

Definition at line 147 of file kis_update_scheduler.cpp.

{
    m_d->updatesQueue.addFullRefreshJob(root, rects, cropRect, currentLevelOfDetail(), flags);
    processQueues();
}

References currentLevelOfDetail(), m_d, and processQueues().

hasUpdatesRunning()

bool KisUpdateScheduler::hasUpdatesRunning

(

)

const

Definition at line 169 of file kis_update_scheduler.cpp.

{
    return !m_d->updatesQueue.isEmpty();
}

References m_d.

haveUpdatesRunning()

bool KisUpdateScheduler::haveUpdatesRunning ( )

private

Definition at line 421 of file kis_update_scheduler.cpp.

{
    QWriteLocker locker(&m_d->updatesStartLock);
 
    qint32 numMergeJobs, numStrokeJobs;
    m_d->updaterContext.getJobsSnapshot(numMergeJobs, numStrokeJobs);
 
    return numMergeJobs;
}

References m_d.

immediateLockForReadOnly()

void KisUpdateScheduler::immediateLockForReadOnly

(

)

Blocks processing of the queues. The function will wait until all the executing jobs are finished. NOTE: you may add new jobs while the block held, but they will be delayed until unlock() is called.

See also

unlock()

Definition at line 289 of file kis_update_scheduler.cpp.

{
    m_d->processingBlocked = true;
    m_d->updaterContext.waitForDone();
}

References m_d.

isIdle()

bool KisUpdateScheduler::isIdle

(

)

Tells if there are no strokes or updates are running at the moment. Internally calls to tryBarrierLock(), so it is not O(1).

Definition at line 309 of file kis_update_scheduler.cpp.

{
    bool result = false;
 
    if (tryBarrierLock()) {
        result = true;
        unlock(false);
    }
 
    return result;
}

References tryBarrierLock(), and unlock().

lodNPostExecutionUndoAdapter()

KisPostExecutionUndoAdapter * KisUpdateScheduler::lodNPostExecutionUndoAdapter

(

)

const

Definition at line 276 of file kis_update_scheduler.cpp.

{
    return m_d->strokesQueue.lodNPostExecutionUndoAdapter();
}

References m_d.

lodPreferences()

KisLodPreferences KisUpdateScheduler::lodPreferences

(

)

const

Return current lod preferences loaded in the strokes queue

Definition at line 227 of file kis_update_scheduler.cpp.

{
    return m_d->strokesQueue.lodPreferences();
}

References m_d.

Private()

KisUpdateScheduler::Private ( KisUpdateScheduler * _q, KisProjectionUpdateListener * p )

inline

Definition at line 39 of file kis_update_scheduler.cpp.

        : q(_q)
        , updaterContext(KisImageConfig(true).maxNumberOfThreads(), q)
        , projectionUpdateListener(p)
    {}

processQueues()

void KisUpdateScheduler::processQueues ( )

protected

Definition at line 356 of file kis_update_scheduler.cpp.

{
    wakeUpWaitingThreads();
 
    if(m_d->processingBlocked) return;
 
    if(m_d->strokesQueue.needsExclusiveAccess()) {
        DEBUG_BALANCING_METRICS("STROKES", "X");
        m_d->strokesQueue.processQueue(m_d->updaterContext,
                                        !m_d->updatesQueue.isEmpty());
 
        if(!m_d->strokesQueue.needsExclusiveAccess()) {
            tryProcessUpdatesQueue();
        }
    }
    else if(m_d->balancingRatio() * m_d->strokesQueue.sizeMetric() > m_d->updatesQueue.sizeMetric()) {
        DEBUG_BALANCING_METRICS("STROKES", "N");
        m_d->strokesQueue.processQueue(m_d->updaterContext,
                                        !m_d->updatesQueue.isEmpty());
        tryProcessUpdatesQueue();
    }
    else {
        DEBUG_BALANCING_METRICS("UPDATES", "N");
        tryProcessUpdatesQueue();
        m_d->strokesQueue.processQueue(m_d->updaterContext,
                                        !m_d->updatesQueue.isEmpty());
 
    }
 
    progressUpdate();
}

References DEBUG_BALANCING_METRICS, m_d, progressUpdate(), tryProcessUpdatesQueue(), and wakeUpWaitingThreads().

progressUpdate()

void KisUpdateScheduler::progressUpdate ( )

private

Definition at line 119 of file kis_update_scheduler.cpp.

{
    if (!m_d->progressUpdater) return;
 
    if(!m_d->strokesQueue.hasOpenedStrokes()) {
        QString jobName = m_d->strokesQueue.currentStrokeName().toString();
        if(jobName.isEmpty()) {
            jobName = i18n("Updating...");
        }
 
        int sizeMetric = m_d->strokesQueue.sizeMetric();
        if (!sizeMetric) {
            sizeMetric = m_d->updatesQueue.sizeMetric();
        }
 
        m_d->progressUpdater->updateProgress(sizeMetric, jobName);
    }
    else {
        m_d->progressUpdater->hide();
    }
}

References m_d.

setLod0ToNStrokeStrategyFactory()

void KisUpdateScheduler::setLod0ToNStrokeStrategyFactory

(

const KisLodSyncStrokeStrategyFactory &

factory

)

Install a factory of a stroke strategy, that will be started every time when the scheduler needs to synchronize LOD caches of all the paint devices of the image.

Definition at line 256 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.setLod0ToNStrokeStrategyFactory(factory);
}

References m_d.

setLodPreferences()

void KisUpdateScheduler::setLodPreferences

(

const KisLodPreferences &

value

)

Sets the desired level of detail preferences on which the strokes should work. Please note that this configuration will be applied starting from the next stroke. Please also note that this value is not guaranteed to coincide with the one returned by currentLevelOfDetail()

The queue might have started an internal stroke for cache synchronization. Process the queues to execute it if needed.

Definition at line 215 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.setLodPreferences(value);
 
    processQueues();
}

References m_d, processQueues(), and value().

setPostSyncLod0GUIPlaneRequestForResumeCallback()

void KisUpdateScheduler::setPostSyncLod0GUIPlaneRequestForResumeCallback

(

const std::function< void()> &

callback

)

Sets a callback that is called bu the scheduler when it thinks that Lod0 tiles in the GUI should be refetched by the GUI. Such situation happens in cases when a Lod0 stroke has been cancelled, after its LodN buddy has managed to do some manipulations on the canvas. Without this call the GUI will still contain LodN tiles active.

Definition at line 271 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.setPostSyncLod0GUIPlaneRequestForResumeCallback(callback);
}

References m_d.

setProgressProxy()

void KisUpdateScheduler::setProgressProxy

(

KoProgressProxy *

progressProxy

)

Sets the proxy that is going to be notified about the progress of processing of the queues. If you want to switch the proxy on runtime, you should do it under the lock held.

See also

lock(), unlock()

Definition at line 112 of file kis_update_scheduler.cpp.

{
    delete m_d->progressUpdater;
    m_d->progressUpdater = progressProxy ?
        new KisQueuesProgressUpdater(progressProxy, this) : 0;
}

References m_d.

setPurgeRedoStateCallback()

void KisUpdateScheduler::setPurgeRedoStateCallback

(

const std::function< void()> &

callback

)

Sets a callback that is called by the scheduler in the beginning of every stroke that declared the necessity of the redo state clearance.

Definition at line 266 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.setPurgeRedoStateCallback(callback);
}

References m_d.

setSuspendResumeUpdatesStrokeStrategyFactory()

void KisUpdateScheduler::setSuspendResumeUpdatesStrokeStrategyFactory

(

const KisSuspendResumeStrategyPairFactory &

factory

)

Install a factory of a stroke strategies, that will be started every time when the scheduler needs to postpone/resume all the updates of the LOD0 strokes.

Definition at line 261 of file kis_update_scheduler.cpp.

{
    m_d->strokesQueue.setSuspendResumeUpdatesStrokeStrategyFactory(factory);
}

References m_d.

setThreadsLimit()

void KisUpdateScheduler::setThreadsLimit

(

int

value

)

Set the number of threads used by the scheduler

Thread limit can be changed without the full-featured barrier lock, we can avoid waiting for all the jobs to complete. We should just ensure there is no more jobs in the updater context.

Definition at line 84 of file kis_update_scheduler.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->processingBlocked);
 
    immediateLockForReadOnly();
    m_d->updaterContext.lock();
    m_d->updaterContext.setThreadsLimit(value);
    m_d->updaterContext.unlock();
    unlock(false);
}

References immediateLockForReadOnly(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, unlock(), and value().

spareThreadAppeared()

void KisUpdateScheduler::spareThreadAppeared

(

)

Definition at line 442 of file kis_update_scheduler.cpp.

{
    processQueues();
}

References processQueues().

startStroke()

KisStrokeId KisUpdateScheduler::startStroke ( KisStrokeStrategy * strokeStrategy )

overridevirtual

Implements KisStrokesFacade.

Definition at line 174 of file kis_update_scheduler.cpp.

{
    KisStrokeId id  = m_d->strokesQueue.startStroke(strokeStrategy);
    processQueues();
    return id;
}

References m_d, and processQueues().

threadsLimit()

int KisUpdateScheduler::threadsLimit

(

)

const

Return the number of threads available to the scheduler

Definition at line 100 of file kis_update_scheduler.cpp.

{
    std::lock_guard<KisUpdaterContext> l(m_d->updaterContext);
    return m_d->updaterContext.threadsLimit();
}

References m_d.

tryBarrierLock()

bool KisUpdateScheduler::tryBarrierLock

(

)

Works like barrier lock, but returns false immediately if barrierLock can't be acquired.

See also

barrierLock()

Definition at line 329 of file kis_update_scheduler.cpp.

{
    if(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty()) {
        return false;
    }
 
    m_d->processingBlocked = true;
    m_d->updaterContext.waitForDone();
    if(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty()) {
        m_d->processingBlocked = false;
        processQueues();
        return false;
    }
 
    return true;
}

References m_d, and processQueues().

tryCancelCurrentStrokeAsync()

bool KisUpdateScheduler::tryCancelCurrentStrokeAsync

(

)

tryCancelCurrentStrokeAsync() checks whether there is a running stroke (which is being executed at this very moment) which is not still open by the owner (endStroke() or cancelStroke() have already been called) and cancels it.

Returns

true if some stroke has been found and cancelled

Note

This method is not part of KisStrokesFacade! It is too low level for KisImage. In KisImage it is combined with more high level requestStrokeCancellation().

Definition at line 200 of file kis_update_scheduler.cpp.

{
    return m_d->strokesQueue.tryCancelCurrentStrokeAsync();
}

References m_d.

tryProcessUpdatesQueue()

void KisUpdateScheduler::tryProcessUpdatesQueue ( )

private

Definition at line 413 of file kis_update_scheduler.cpp.

{
    QReadLocker locker(&m_d->updatesStartLock);
    if(m_d->updatesLockCounter) return;
 
    m_d->updatesQueue.processQueue(m_d->updaterContext);
}

References m_d.

tryUndoLastStrokeAsync()

UndoResult KisUpdateScheduler::tryUndoLastStrokeAsync

(

)

Definition at line 205 of file kis_update_scheduler.cpp.

{
    return m_d->strokesQueue.tryUndoLastStrokeAsync();
}

References m_d.

unblockUpdates()

void KisUpdateScheduler::unblockUpdates

(

)

Unblocks updates from execution previously locked by blockUpdates()

See also

blockUpdates()

Definition at line 400 of file kis_update_scheduler.cpp.

{
    m_d->updatesLockCounter.deref();
    processQueues();
}

References m_d, and processQueues().

unlock()

void KisUpdateScheduler::unlock

(

bool

resetLodLevels = true

)

Unblocks the process and calls processQueues()

See also

processQueues()

Legacy strokes may have changed the image while we didn't control it. Notify the queue to take it into account.

Definition at line 295 of file kis_update_scheduler.cpp.

{
    if (resetLodLevels) {
        m_d->strokesQueue.notifyUFOChangedImage();
    }
 
    m_d->processingBlocked = false;
    processQueues();
}

References m_d, and processQueues().

updateProjection() [1/2]

void KisUpdateScheduler::updateProjection	(	KisNodeSP	node,
		const QRect &	rc,
		const QRect &	cropRect )

Definition at line 153 of file kis_update_scheduler.cpp.

{
    updateProjection(node, {rc}, cropRect, KisProjectionUpdateFlag::None);
}

References None, and updateProjection().

updateProjection() [2/2]

void KisUpdateScheduler::updateProjection	(	KisNodeSP	node,
		const QVector< QRect > &	rects,
		const QRect &	cropRect,
		KisProjectionUpdateFlags	flags )

Definition at line 141 of file kis_update_scheduler.cpp.

{
    m_d->updatesQueue.addUpdateJob(node, rects, cropRect, currentLevelOfDetail(), flags);
    processQueues();
}

References currentLevelOfDetail(), m_d, and processQueues().

updateSettings

void KisUpdateScheduler::updateSettings ( )

protectedslot

Called when it is necessary to reread configuration

Definition at line 281 of file kis_update_scheduler.cpp.

{
    m_d->updatesQueue.updateSettings();
    KisImageConfig config(true);
    m_d->defaultBalancingRatio = config.schedulerBalancingRatio();
    setThreadsLimit(config.maxNumberOfThreads());
}

References m_d, KisImageConfig::maxNumberOfThreads(), KisImageConfig::schedulerBalancingRatio(), and setThreadsLimit().

waitForDone()

void KisUpdateScheduler::waitForDone

(

)

Waits until all the running jobs are finished.

If some other thread adds jobs in parallel, then you may wait forever. If you don't want it, consider lock() instead.

See also

lock()

Definition at line 321 of file kis_update_scheduler.cpp.

{
    do {
        processQueues();
        m_d->updaterContext.waitForDone();
    } while(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty());
}

References m_d, and processQueues().

wakeUpWaitingThreads()

void KisUpdateScheduler::wakeUpWaitingThreads ( )

private

Definition at line 406 of file kis_update_scheduler.cpp.

{
    if(m_d->updatesLockCounter && !haveUpdatesRunning()) {
        m_d->updatesFinishedCondition.wakeAll();
    }
}

References haveUpdatesRunning(), and m_d.

wrapAroundModeSupported()

bool KisUpdateScheduler::wrapAroundModeSupported

(

)

const

Definition at line 210 of file kis_update_scheduler.cpp.

{
    return m_d->strokesQueue.wrapAroundModeSupported();
}

References m_d.

Friends And Related Symbol Documentation

UpdatesBlockTester

friend class UpdatesBlockTester

friend

Definition at line 236 of file kis_update_scheduler.h.

Member Data Documentation

defaultBalancingRatio

qreal KisUpdateScheduler::defaultBalancingRatio = 1.0

Definition at line 51 of file kis_update_scheduler.cpp.

m_d

Private* const KisUpdateScheduler::m_d

protected

Definition at line 245 of file kis_update_scheduler.h.

processingBlocked

bool KisUpdateScheduler::processingBlocked = false

Definition at line 50 of file kis_update_scheduler.cpp.

progressUpdater

KisQueuesProgressUpdater* KisUpdateScheduler::progressUpdater = 0

Definition at line 53 of file kis_update_scheduler.cpp.

projectionUpdateListener

KisProjectionUpdateListener* KisUpdateScheduler::projectionUpdateListener

Definition at line 52 of file kis_update_scheduler.cpp.

q

KisUpdateScheduler* KisUpdateScheduler::q

Definition at line 45 of file kis_update_scheduler.cpp.

strokesQueue

KisStrokesQueue KisUpdateScheduler::strokesQueue

Definition at line 48 of file kis_update_scheduler.cpp.

updaterContext

KisUpdaterContext KisUpdateScheduler::updaterContext

Definition at line 49 of file kis_update_scheduler.cpp.

updatesFinishedCondition

KisLazyWaitCondition KisUpdateScheduler::updatesFinishedCondition

Definition at line 57 of file kis_update_scheduler.cpp.

updatesLockCounter

QAtomicInt KisUpdateScheduler::updatesLockCounter

Definition at line 55 of file kis_update_scheduler.cpp.

updatesQueue

KisSimpleUpdateQueue KisUpdateScheduler::updatesQueue

Definition at line 47 of file kis_update_scheduler.cpp.

updatesStartLock

QReadWriteLock KisUpdateScheduler::updatesStartLock

Definition at line 56 of file kis_update_scheduler.cpp.

---

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

• libs/image/kis_update_scheduler.cpp
• libs/image/kis_update_scheduler.h