#include <kis_suspend_projection_updates_stroke_strategy.h>

Inheritance diagram for KisSuspendProjectionUpdatesStrokeStrategy:

Classes
struct	Private

struct	SharedData

struct	SuspendUpdatesFilterInterface

Public Types
using	SharedDataSP = QSharedPointer<SharedData>

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

Public Member Functions
	KisSuspendProjectionUpdatesStrokeStrategy (KisImageWSP image, bool suspend, SharedDataSP sharedData)

	~KisSuspendProjectionUpdatesStrokeStrategy () override

Public Member Functions inherited from KisRunnableBasedStrokeStrategy
	KisRunnableBasedStrokeStrategy (const KisRunnableBasedStrokeStrategy &rhs)

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

KisRunnableStrokeJobsInterface *	runnableJobsInterface () const

	~KisRunnableBasedStrokeStrategy ()

Public Member Functions inherited from KisSimpleStrokeStrategy
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())

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 * >	createResumeJobsData (KisImageWSP image)

static SharedDataSP	createSharedData ()

static QList< KisStrokeJobData * >	createSuspendJobsData (KisImageWSP image)

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

Private Member Functions
void	cancelStrokeCallback () override

void	doStrokeCallback (KisStrokeJobData *data) override

void	initStrokeCallback () override

void	resumeStrokeCallback () override

void	suspendStrokeCallback () override

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
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 15 of file kis_suspend_projection_updates_stroke_strategy.h.

Member Typedef Documentation

◆ SharedDataSP

using KisSuspendProjectionUpdatesStrokeStrategy::SharedDataSP = QSharedPointer<SharedData>

Definition at line 26 of file kis_suspend_projection_updates_stroke_strategy.h.

Constructor & Destructor Documentation

◆ KisSuspendProjectionUpdatesStrokeStrategy()

KisSuspendProjectionUpdatesStrokeStrategy::KisSuspendProjectionUpdatesStrokeStrategy	(	KisImageWSP	image,
		bool	suspend,
		SharedDataSP	sharedData )

Here we add a dumb INIT job so that KisStrokesQueue would know that the stroke has already started or not. When the queue reaches the resume stroke and starts its execution, no Lod0 can execute anymore. So all the new Lod0 strokes should go to the end of the queue and wrapped into their own Suspend/Resume pair.

Definition at line 426 of file kis_suspend_projection_updates_stroke_strategy.cpp.

    : KisRunnableBasedStrokeStrategy(suspend ?
                                     QLatin1String("suspend_stroke_strategy") :
                                     QLatin1String("resume_stroke_strategy")),
      m_d(new Private)
{
    m_d->image = image;
    m_d->suspend = suspend;
    m_d->sharedData = sharedData;
 
    enableJob(JOB_INIT, true);
 
    enableJob(JOB_DOSTROKE, true);
    enableJob(JOB_CANCEL, true);
 
    enableJob(JOB_SUSPEND, true, KisStrokeJobData::BARRIER);
    enableJob(JOB_RESUME, true, KisStrokeJobData::BARRIER);
 
    setNeedsExplicitCancel(true);
    setClearsRedoOnStart(false);
}

References KisStrokeJobData::BARRIER, KisSimpleStrokeStrategy::enableJob(), KisSimpleStrokeStrategy::JOB_CANCEL, KisSimpleStrokeStrategy::JOB_DOSTROKE, KisSimpleStrokeStrategy::JOB_INIT, KisSimpleStrokeStrategy::JOB_RESUME, KisSimpleStrokeStrategy::JOB_SUSPEND, m_d, KisStrokeStrategy::setClearsRedoOnStart(), and KisStrokeStrategy::setNeedsExplicitCancel().

◆ ~KisSuspendProjectionUpdatesStrokeStrategy()

KisSuspendProjectionUpdatesStrokeStrategy::~KisSuspendProjectionUpdatesStrokeStrategy ( )

override

Definition at line 455 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    qDeleteAll(m_d->executedCommands);
}

References m_d.

Member Function Documentation

◆ cancelStrokeCallback()

void KisSuspendProjectionUpdatesStrokeStrategy::cancelStrokeCallback ( )

overrideprivatevirtual

We shouldn't Q_EMIT any ad-hoc updates when cancelling the stroke. It generates weird temporary holes on the canvas, making the user feel awful, thinking his image got corrupted. We will just Q_EMIT a common refreshGraphAsync() that will do all the work in a beautiful way

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 571 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    KisImageSP image = m_d->image.toStrongRef();
    if (!image) {
        return;
    }
 
    for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
        (*it)->undo();
    }
 
    m_d->tryFetchUsedUpdatesFilter(image);
 
    if (m_d->haveDisabledGUILodSync) {
        image->signalRouter()->emitRequestLodPlanesSyncBlocked(false);
    }
 
    if (!m_d->suspend) {
        // FIXME: optimize
        image->refreshGraphAsync();
    }
}

References KisImageSignalRouter::emitRequestLodPlanesSyncBlocked(), m_d, KisImage::refreshGraphAsync(), and KisImage::signalRouter().

◆ createResumeJobsData()

QList< KisStrokeJobData * > KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData ( KisImageWSP image )

static

Definition at line 532 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    return QList<KisStrokeJobData*>();
}

◆ createSharedData()

KisSuspendProjectionUpdatesStrokeStrategy::SharedDataSP KisSuspendProjectionUpdatesStrokeStrategy::createSharedData ( )

static

Definition at line 537 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    return toQShared(new SharedData());
}

References toQShared().

◆ createSuspendJobsData()

QList< KisStrokeJobData * > KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData ( KisImageWSP image )

static

Definition at line 527 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    return QList<KisStrokeJobData*>();
}

◆ doStrokeCallback()

void KisSuspendProjectionUpdatesStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overrideprivatevirtual

When the Lod0 stroke is being recalculated in the background we should block all the updates it issues to avoid user distraction. The result of the final stroke should be shown to the user in the very end when everything is fully ready. Ideally the use should not notice that the image has changed :)

(Don't mix this process with suspend/resume capabilities of a single stroke. That is a different system!)

The process of the Lod0 regeneration consists of the following:

1) Suspend stroke executes. It sets a special updates filter on the image. The filter blocks all the updates and saves them in an internal structure to be emitted in the future.

2) Lod0 strokes are being recalculated. All their updates are blocked and saved in the filter.

3) Resume stroke starts:

3.1) First it disables emitting of sigImageUpdated() so the gui
     will not get any update notifications.

3.2) Then it enables updates themselves.

3.3) Initiates all the updates that were requested by the Lod0
     stroke. The node graph is regenerated, but the GUI does
     not get this change.

3.4) Special barrier job waits for all the updates to finish
     and, when they are done, enables GUI notifications again.

3.5) In a multithreaded way emits the GUI notifications for the
     entire image. Multithreaded way is used to conform the
     double-stage update principle of KisCanvas2.

Reimplemented from KisRunnableBasedStrokeStrategy.

Definition at line 514 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    KisRunnableStrokeJobDataBase *runnable = dynamic_cast<KisRunnableStrokeJobDataBase*>(data);
    if (runnable) {
        runnable->run();
 
        if (Private::UndoableData *undoable = dynamic_cast<Private::UndoableData*>(data)) {
            Private::StrokeJobCommand *command =  undoable->m_command.release();
            m_d->executedCommands.append(command);
        }
    }
}

References m_d, and KisRunnable::run().

◆ initStrokeCallback()

void KisSuspendProjectionUpdatesStrokeStrategy::initStrokeCallback ( )

overrideprivatevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 460 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    QVector<KisRunnableStrokeJobDataBase*> jobs;
 
    if (m_d->suspend) {
        jobs << new Private::UndoableData(new Private::SuspendUpdatesCommand(m_d.data()));
    } else {
        jobs << new Private::UndoableData(new Private::ResumeAndIssueGraphUpdatesCommand(m_d.data()));
        jobs << new Private::BlockUILodSync(true, this);
        jobs << new Private::UndoableData(new Private::StartBatchUIUpdatesCommand(this));
        jobs << new Private::UndoableData(new Private::EndBatchUIUpdatesCommand(this));
        jobs << new Private::BlockUILodSync(false, this);
    }
 
    runnableJobsInterface()->addRunnableJobs(jobs);
}

References KisRunnableStrokeJobsInterface::addRunnableJobs(), m_d, and KisRunnableBasedStrokeStrategy::runnableJobsInterface().

◆ resumeStrokeCallback()

void KisSuspendProjectionUpdatesStrokeStrategy::resumeStrokeCallback ( )

overrideprivatevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 623 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    QVector<KisRunnableStrokeJobDataBase*> jobs;
 
    Q_FOREACH (Private::StrokeJobCommand *command, m_d->executedCommands) {
        jobs << new Private::UndoableData(command);
    }
    m_d->executedCommands.clear();
 
    runnableJobsInterface()->addRunnableJobs(jobs);
}

References KisRunnableStrokeJobsInterface::addRunnableJobs(), m_d, and KisRunnableBasedStrokeStrategy::runnableJobsInterface().

◆ suspendStrokeCallback()

void KisSuspendProjectionUpdatesStrokeStrategy::suspendStrokeCallback ( )

overrideprivatevirtual

The resume stroke can be suspended even when all its jobs are completed. In such a case, we should just ensure that all the internal state is reset to default.

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 601 of file kis_suspend_projection_updates_stroke_strategy.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->suspend ||
                                 !m_d->sanityResumingFinished ||
                                 (m_d->sanityResumingFinished &&
                                  m_d->usedFilters.isEmpty() &&
                                  m_d->accumulatedDirtyRects.isEmpty()));
 
    for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
        (*it)->undo();
    }
 
    // reset all the issued updates
    m_d->updatesEpoch++;
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, and m_d.

Member Data Documentation

◆ m_d

const QScopedPointer<Private> KisSuspendProjectionUpdatesStrokeStrategy::m_d

private

Definition at line 46 of file kis_suspend_projection_updates_stroke_strategy.h.

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

libs/image/kis_suspend_projection_updates_stroke_strategy.h
libs/image/kis_suspend_projection_updates_stroke_strategy.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SharedDataSP

Constructor & Destructor Documentation

◆ KisSuspendProjectionUpdatesStrokeStrategy()

◆ ~KisSuspendProjectionUpdatesStrokeStrategy()

Member Function Documentation

◆ cancelStrokeCallback()

◆ createResumeJobsData()

◆ createSharedData()

◆ createSuspendJobsData()

◆ doStrokeCallback()

◆ initStrokeCallback()

◆ resumeStrokeCallback()

◆ suspendStrokeCallback()

Member Data Documentation

◆ m_d