#include <kis_sync_lod_cache_stroke_strategy.h>

Inheritance diagram for KisSyncLodCacheStrokeStrategy:

Classes
struct	Private

Public Member Functions
	KisSyncLodCacheStrokeStrategy (KisImageWSP image, bool forgettable)

	~KisSyncLodCacheStrokeStrategy () override

Public Member Functions inherited from KisRunnableBasedStrokeStrategy
void	doStrokeCallback (KisStrokeJobData *data) override

	KisRunnableBasedStrokeStrategy (const KisRunnableBasedStrokeStrategy &rhs)

	KisRunnableBasedStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

KisRunnableStrokeJobsInterface *	runnableJobsInterface () const

	~KisRunnableBasedStrokeStrategy ()

Public Member Functions inherited from KisSimpleStrokeStrategy
virtual void	cancelStrokeCallback ()

KisStrokeJobData *	createCancelData () override

KisStrokeJobStrategy *	createCancelStrategy () override

KisStrokeJobStrategy *	createDabStrategy () override

KisStrokeJobData *	createFinishData () override

KisStrokeJobStrategy *	createFinishStrategy () override

KisStrokeJobData *	createInitData () override

KisStrokeJobStrategy *	createInitStrategy () override

KisStrokeJobData *	createResumeData () override

KisStrokeJobStrategy *	createResumeStrategy () override

KisStrokeJobData *	createSuspendData () override

KisStrokeJobStrategy *	createSuspendStrategy () override

virtual void	finishStrokeCallback ()

	KisSimpleStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

virtual void	resumeStrokeCallback ()

virtual void	suspendStrokeCallback ()

Public Member Functions inherited from KisStrokeStrategy
qreal	balancingRatioOverride () const

bool	canForgetAboutMe () const

bool	clearsRedoOnStart () const

virtual KisStrokeStrategy *	createLodClone (int levelOfDetail)

KisLodPreferences	currentLodPreferences () const

bool	forceLodModeIfPossible () const

QString	id () const

bool	isAsynchronouslyCancellable () const

bool	isExclusive () const

	KisStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

KUndo2MagicString	name () const

bool	needsExplicitCancel () const

virtual void	notifyUserEndedStroke ()

virtual void	notifyUserStartedStroke ()

bool	requestsOtherStrokesToEnd () const

void	setForceLodModeIfPossible (bool forceLodModeIfPossible)

void	setMutatedJobsInterface (KisStrokesQueueMutatedJobInterface *mutatedJobsInterface, KisStrokeId strokeId)

bool	supportsWrapAroundMode () const

virtual void	tryCancelCurrentStrokeJobAsync ()
	tryCancelCurrentStrokeJobAsync is called by the strokes queue when the stroke is being cancelled. The stroke strategy may or may not handle this request and cancel the currently running long action.

virtual	~KisStrokeStrategy ()

Static Public Member Functions
static QList< KisStrokeJobData * >	createJobsData (KisImageWSP image)

static void	createJobsData (QVector< KisStrokeJobData * > &jobs, KisNodeSP imageRoot, KisUpdatesFacade *updatesFacade, int levelOfDetail, KisPaintDeviceList extraDevices={})

Static Public Member Functions inherited from KisSimpleStrokeStrategy
static QLatin1String	jobTypeToString (JobType type)

Private Member Functions
void	initStrokeCallback () override

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
Public Types inherited from KisSimpleStrokeStrategy
enum	JobType { JOB_INIT = 0 , JOB_CANCEL , JOB_FINISH , JOB_DOSTROKE , JOB_SUSPEND , JOB_RESUME , NJOBS }

Protected Member Functions inherited from KisSimpleStrokeStrategy
void	enableJob (JobType type, bool enable=true, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)

	KisSimpleStrokeStrategy (const KisSimpleStrokeStrategy &rhs)

Protected Member Functions inherited from KisStrokeStrategy
void	addMutatedJob (KisStrokeJobData *data)

void	addMutatedJobs (const QVector< KisStrokeJobData * > list)

	KisStrokeStrategy (const KisStrokeStrategy &rhs)

void	setAsynchronouslyCancellable (bool value)

void	setBalancingRatioOverride (qreal value)

void	setCanForgetAboutMe (bool value)

void	setClearsRedoOnStart (bool value)

void	setExclusive (bool value)

void	setNeedsExplicitCancel (bool value)

void	setRequestsOtherStrokesToEnd (bool value)

void	setSupportsWrapAroundMode (bool value)

Detailed Description

Definition at line 17 of file kis_sync_lod_cache_stroke_strategy.h.

Constructor & Destructor Documentation

◆ KisSyncLodCacheStrokeStrategy()

KisSyncLodCacheStrokeStrategy::KisSyncLodCacheStrokeStrategy	(	KisImageWSP	image,
		bool	forgettable )

We shouldn't start syncing before all the updates are done. Otherwise we might get artifacts!

Definition at line 21 of file kis_sync_lod_cache_stroke_strategy.cpp.

    : KisRunnableBasedStrokeStrategy(QLatin1String("SyncLodCacheStroke"), kundo2_i18n("Instant Preview")),
      m_d(new Private)
{
    m_d->image = image;
 
    enableJob(KisSimpleStrokeStrategy::JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
    enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 
    setRequestsOtherStrokesToEnd(false);
    setClearsRedoOnStart(false);
    setCanForgetAboutMe(forgettable);
}

References KisStrokeJobData::BARRIER, KisSimpleStrokeStrategy::enableJob(), KisStrokeJobData::EXCLUSIVE, KisSimpleStrokeStrategy::JOB_DOSTROKE, KisSimpleStrokeStrategy::JOB_INIT, m_d, KisStrokeStrategy::setCanForgetAboutMe(), KisStrokeStrategy::setClearsRedoOnStart(), and KisStrokeStrategy::setRequestsOtherStrokesToEnd().

◆ ~KisSyncLodCacheStrokeStrategy()

KisSyncLodCacheStrokeStrategy::~KisSyncLodCacheStrokeStrategy ( )

override

Definition at line 39 of file kis_sync_lod_cache_stroke_strategy.cpp.

40{

41}

Member Function Documentation

◆ createJobsData() [1/2]

QList< KisStrokeJobData * > KisSyncLodCacheStrokeStrategy::createJobsData ( KisImageWSP image )

static

Definition at line 50 of file kis_sync_lod_cache_stroke_strategy.cpp.

{
    // all the jobs are populates in the init job
    return {};
}

◆ createJobsData() [2/2]

void KisSyncLodCacheStrokeStrategy::createJobsData	(	QVector< KisStrokeJobData * > &	jobs,
		KisNodeSP	imageRoot,
		KisUpdatesFacade *	updatesFacade,
		int	levelOfDetail,
		KisPaintDeviceList	extraDevices = {} )

static

Definition at line 56 of file kis_sync_lod_cache_stroke_strategy.cpp.

{
    using KisLayerUtils::recursiveApplyNodes;
    using KritaUtils::splitRegionIntoPatches;
    using KritaUtils::optimalPatchSize;
 
    using SharedData = QHash<KisPaintDeviceSP, QSharedPointer<KisPaintDevice::LodDataStruct>>;
    using SharedDataSP = QSharedPointer<SharedData>;
 
    SharedDataSP sharedData(new SharedData());
 
    KisPaintDeviceList deviceList = extraDevices;
 
    recursiveApplyNodes(imageRoot,
        [&deviceList](KisNodeSP node) {
             deviceList << node->getLodCapableDevices();
        });
 
    KritaUtils::makeContainerUnique(deviceList);
 
    KritaUtils::addJobBarrierNoCancel(jobs, [updatesFacade] () {
        updatesFacade->blockUpdates();
    });
 
    KritaUtils::addJobBarrier(jobs, [sharedData, deviceList, levelOfDetail] () mutable {
        Q_FOREACH (KisPaintDeviceSP device, deviceList) {
            sharedData->insert(device, toQShared(device->createLodDataStruct(levelOfDetail)));
        }
    });
 
    KritaUtils::addJobSequential(jobs, [](){});
 
    Q_FOREACH (KisPaintDeviceSP device, deviceList) {
        KisRegion region = device->regionForLodSyncing();
        QVector<QRect> rects = splitRegionIntoPatches(region, optimalPatchSize());
 
        Q_FOREACH (const QRect &rc, rects) {
            KritaUtils::addJobConcurrent(jobs, [sharedData, device, rc] () mutable {
                KIS_ASSERT(sharedData->contains(device));
 
                KisPaintDevice::LodDataStruct *data = sharedData->value(device).data();
                device->updateLodDataStruct(data, rc);
            });
        }
    }
 
    KritaUtils::addJobSequential(jobs, [](){});
 
    recursiveApplyNodes(imageRoot,
        [&jobs](KisNodeSP node) {
             KritaUtils::addJobConcurrent(jobs, [node] () mutable {
                 node->syncLodCache();
             });
        });
 
    KritaUtils::addJobSequential(jobs, [sharedData] () mutable {
        auto it = sharedData->begin();
        auto end = sharedData->end();
 
        for (; it != end; ++it) {
            KisPaintDeviceSP dev = it.key();
            dev->uploadLodDataStruct(it.value().data());
        }
    });
 
    KritaUtils::addJobSequentialNoCancel(jobs, [updatesFacade] () {
        updatesFacade->unblockUpdates();
    });
}

References KritaUtils::addJobBarrier(), KritaUtils::addJobBarrierNoCancel(), KritaUtils::addJobConcurrent(), KritaUtils::addJobSequential(), KritaUtils::addJobSequentialNoCancel(), KisUpdatesFacade::blockUpdates(), KisPaintDevice::createLodDataStruct(), KisNode::getLodCapableDevices(), KIS_ASSERT, KritaUtils::makeContainerUnique(), KritaUtils::optimalPatchSize(), KisLayerUtils::recursiveApplyNodes(), KisPaintDevice::regionForLodSyncing(), KritaUtils::splitRegionIntoPatches(), KisNode::syncLodCache(), toQShared(), KisUpdatesFacade::unblockUpdates(), KisPaintDevice::updateLodDataStruct(), and KisPaintDevice::uploadLodDataStruct().

◆ initStrokeCallback()

void KisSyncLodCacheStrokeStrategy::initStrokeCallback ( )

overrideprivatevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 43 of file kis_sync_lod_cache_stroke_strategy.cpp.

{
    QVector<KisStrokeJobData *> jobs;
    createJobsData(jobs, m_d->image->root(), m_d->image.data(), m_d->image->currentLevelOfDetail());
    addMutatedJobs(jobs);
}

References KisStrokeStrategy::addMutatedJobs(), createJobsData(), and m_d.

Member Data Documentation

◆ m_d

const QScopedPointer<Private> KisSyncLodCacheStrokeStrategy::m_d

private

Definition at line 32 of file kis_sync_lod_cache_stroke_strategy.h.

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

libs/image/kis_sync_lod_cache_stroke_strategy.h
libs/image/kis_sync_lod_cache_stroke_strategy.cpp

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members