#include <kis_regenerate_frame_stroke_strategy.h>

Inheritance diagram for KisRegenerateFrameStrokeStrategy:

Classes
struct	Private

Public Types
enum	Type { EXTERNAL_FRAME , CURRENT_FRAME }

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

Public Member Functions
void	cancelStrokeCallback () override

KisStrokeStrategy *	createLodClone (int levelOfDetail) override

void	doStrokeCallback (KisStrokeJobData *data) override

void	finishStrokeCallback () override

void	initStrokeCallback () override

	KisRegenerateFrameStrokeStrategy (int frameId, const KisRegion &dirtyRegion, bool isCancellable, KisImageAnimationInterface *interface, KisLockFrameGenerationLock &&frameGenerationLock)

	KisRegenerateFrameStrokeStrategy (KisImageAnimationInterface *interface)

void	resumeStrokeCallback () override

void	suspendStrokeCallback () override

	~KisRegenerateFrameStrokeStrategy () override

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

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

Public Member Functions inherited from KisStrokeStrategy
qreal	balancingRatioOverride () const

bool	canForgetAboutMe () const

bool	clearsRedoOnStart () const

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 Public Member Functions inherited from KisSimpleStrokeStrategy
static QLatin1String	jobTypeToString (JobType type)

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 20 of file kis_regenerate_frame_stroke_strategy.h.

Member Enumeration Documentation

◆ Type

enum KisRegenerateFrameStrokeStrategy::Type

Enumerator
EXTERNAL_FRAME
CURRENT_FRAME

Definition at line 23 of file kis_regenerate_frame_stroke_strategy.h.

              {
        EXTERNAL_FRAME,
        CURRENT_FRAME
    };

Constructor & Destructor Documentation

◆ KisRegenerateFrameStrokeStrategy() [1/2]

KisRegenerateFrameStrokeStrategy::KisRegenerateFrameStrokeStrategy	(	int	frameId,
		const KisRegion &	dirtyRegion,
		bool	isCancellable,
		KisImageAnimationInterface *	interface,
		KisLockFrameGenerationLock &&	frameGenerationLock )

Constructs a strategy that refreshes an external frame in the background without ending/cancelling any running actions

Definition at line 72 of file kis_regenerate_frame_stroke_strategy.cpp.

    : KisSimpleStrokeStrategy(QLatin1String("regenerate_external_frame_stroke")),
      m_d(new Private)
{
    m_d->type = EXTERNAL_FRAME;
 
    m_d->frameId = frameId;
    m_d->dirtyRegion = dirtyRegion;
    m_d->interface = interface;
    m_d->frameGenerationLock = std::move(frameGenerationLock);
 
    enableJob(JOB_INIT);
    enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
    enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
 
    enableJob(JOB_DOSTROKE);
 
    enableJob(JOB_SUSPEND);
    enableJob(JOB_RESUME);
 
    setRequestsOtherStrokesToEnd(false);
    setClearsRedoOnStart(false);
    setCanForgetAboutMe(isCancellable);
}

References KisStrokeJobData::BARRIER, KisSimpleStrokeStrategy::enableJob(), EXTERNAL_FRAME, KisSimpleStrokeStrategy::JOB_CANCEL, KisSimpleStrokeStrategy::JOB_DOSTROKE, KisSimpleStrokeStrategy::JOB_FINISH, KisSimpleStrokeStrategy::JOB_INIT, KisSimpleStrokeStrategy::JOB_RESUME, KisSimpleStrokeStrategy::JOB_SUSPEND, m_d, KisStrokeStrategy::setCanForgetAboutMe(), KisStrokeStrategy::setClearsRedoOnStart(), and KisStrokeStrategy::setRequestsOtherStrokesToEnd().

◆ KisRegenerateFrameStrokeStrategy() [2/2]

KisRegenerateFrameStrokeStrategy::KisRegenerateFrameStrokeStrategy ( KisImageAnimationInterface * interface )

Regenerates current frame without affecting the frames cache. Used for redrawing the image after switching frames.

NOTE: in contrast to the other c-tor, refreshing current frame does end all the running stroke, because it is not a background action, but a distinct user action.

Definition at line 101 of file kis_regenerate_frame_stroke_strategy.cpp.

    : KisSimpleStrokeStrategy(QLatin1String("regenerate_current_frame_stroke"), kundo2_i18n("Render Animation")),
      m_d(new Private)
{
    m_d->type = CURRENT_FRAME;
 
    m_d->frameId = 0;
    m_d->dirtyRegion = KisRegion();
    m_d->interface = interface;
 
    enableJob(JOB_INIT);
    enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER);
    enableJob(JOB_CANCEL, true, KisStrokeJobData::BARRIER);
 
    enableJob(JOB_SUSPEND);
    enableJob(JOB_RESUME);
 
    // switching frames is a distinct user action, so it should
    // cancel the playback or any action easily
    setRequestsOtherStrokesToEnd(true);
    setClearsRedoOnStart(false);
}

References KisStrokeJobData::BARRIER, CURRENT_FRAME, KisSimpleStrokeStrategy::enableJob(), KisSimpleStrokeStrategy::JOB_CANCEL, KisSimpleStrokeStrategy::JOB_FINISH, KisSimpleStrokeStrategy::JOB_INIT, KisSimpleStrokeStrategy::JOB_RESUME, KisSimpleStrokeStrategy::JOB_SUSPEND, m_d, KisStrokeStrategy::setClearsRedoOnStart(), and KisStrokeStrategy::setRequestsOtherStrokesToEnd().

◆ ~KisRegenerateFrameStrokeStrategy()

KisRegenerateFrameStrokeStrategy::~KisRegenerateFrameStrokeStrategy ( )

override

Definition at line 124 of file kis_regenerate_frame_stroke_strategy.cpp.

125{

126}

Member Function Documentation

◆ cancelStrokeCallback()

void KisRegenerateFrameStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 185 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    KisImageSP image = m_d->interface->image().toStrongRef();
    if (!image) {
        return;
    }
    if (m_d->type == EXTERNAL_FRAME) {
        m_d->interface->notifyFrameCancelled();
        m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
        image->enableUIUpdates();
        m_d->restoreUpdatesFilter();
    } else if (m_d->type == CURRENT_FRAME) {
        m_d->interface->blockFrameInvalidation(false);
    }
}

References CURRENT_FRAME, KisImage::enableUIUpdates(), EXTERNAL_FRAME, and m_d.

◆ createJobsData()

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

static

Definition at line 244 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    using KritaUtils::splitRectIntoPatches;
    using KritaUtils::optimalPatchSize;
    KisImageSP image = _image;
 
    const QRect cropRect = image->bounds();
    QVector<QRect> rects = splitRectIntoPatches(image->bounds(), optimalPatchSize());
    QList<KisStrokeJobData*> jobsData;
 
    Q_FOREACH (const QRect &rc, rects) {
        jobsData << new Private::Data(image->root(), rc, cropRect);
    }
 
    return jobsData;
}

References KisImage::bounds(), KritaUtils::optimalPatchSize(), KisNodeFacade::root, and KritaUtils::splitRectIntoPatches().

◆ createLodClone()

KisStrokeStrategy * KisRegenerateFrameStrokeStrategy::createLodClone ( int levelOfDetail )

overridevirtual

We need to regenerate animation frames on LodN level only if we are processing current frame. Return dummy stroke otherwise

Reimplemented from KisStrokeStrategy.

Definition at line 201 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    Q_UNUSED(levelOfDetail);
 
    return m_d->type == CURRENT_FRAME ?
        new KisRegenerateFrameStrokeStrategy(m_d->interface) :
        new KisSimpleStrokeStrategy(QLatin1String("dumb-lodn-KisRegenerateFrameStrokeStrategy"));
}

References CURRENT_FRAME, KisRegenerateFrameStrokeStrategy(), KisSimpleStrokeStrategy::KisSimpleStrokeStrategy(), and m_d.

◆ doStrokeCallback()

void KisRegenerateFrameStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 150 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    Private::Data *d = dynamic_cast<Private::Data*>(data);
    KIS_ASSERT(d);
    KIS_ASSERT(!m_d->dirtyRegion.isEmpty());
    KIS_ASSERT(m_d->type == EXTERNAL_FRAME);
 
    const bool skipNonRenderableNodes = m_d->type == EXTERNAL_FRAME;
    KisBaseRectsWalkerSP walker = new KisFullRefreshWalker(d->cropRect,
                                                           skipNonRenderableNodes ? KisFullRefreshWalker::SkipNonRenderableNodes : KisFullRefreshWalker::None);
    walker->collectRects(d->root, d->rect);
 
    KisAsyncMerger merger;
    merger.startMerge(*walker);
}

References KisBaseRectsWalker::collectRects(), EXTERNAL_FRAME, KIS_ASSERT, m_d, KisBaseRectsWalker::None, KisBaseRectsWalker::SkipNonRenderableNodes, and KisAsyncMerger::startMerge().

◆ finishStrokeCallback()

void KisRegenerateFrameStrokeStrategy::finishStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 166 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    KisImageSP image = m_d->interface->image().toStrongRef();
    if (!image) {
        return;
    }
 
 
    if (m_d->type == EXTERNAL_FRAME) {
        m_d->interface->notifyFrameReady();
        m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
        image->enableUIUpdates();
        m_d->restoreUpdatesFilter();
    } else if (m_d->type == CURRENT_FRAME) {
        m_d->interface->notifyFrameRegenerated();
        m_d->interface->blockFrameInvalidation(false);
    }
}

References CURRENT_FRAME, KisImage::enableUIUpdates(), EXTERNAL_FRAME, and m_d.

◆ initStrokeCallback()

void KisRegenerateFrameStrokeStrategy::initStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 128 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    KisImageSP image = m_d->interface->image().toStrongRef();
    if (!image) {
        return;
    }
    if (m_d->type == EXTERNAL_FRAME) {
        if (!image->animationInterface()->hasAnimation()) {
            warnKrita << "KisRegenerateFrameStrokeStrategy::initStrokeCallback(): WARNING: trying to"
                      << "regenerate an external frame on a non-animated image, that will cause"
                      << "a useless consumption of memory";
        }
 
        m_d->saveAndResetUpdatesFilter();
        image->disableUIUpdates();
        m_d->interface->saveAndResetCurrentTime(m_d->frameId, &m_d->previousFrameId);
    } else if (m_d->type == CURRENT_FRAME) {
        m_d->interface->blockFrameInvalidation(true);
        m_d->interface->updatesFacade()->refreshGraphAsync(KisNodeSP(), KisProjectionUpdateFlag::DontInvalidateFrames);
    }
}

References KisImage::animationInterface(), CURRENT_FRAME, KisImage::disableUIUpdates(), DontInvalidateFrames, EXTERNAL_FRAME, KisImageAnimationInterface::hasAnimation(), m_d, and warnKrita.

◆ resumeStrokeCallback()

void KisRegenerateFrameStrokeStrategy::resumeStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 229 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    KisImageSP image = m_d->interface->image().toStrongRef();
    if (!image) {
        return;
    }
    if (m_d->type == EXTERNAL_FRAME) {
        m_d->saveAndResetUpdatesFilter();
        image->disableUIUpdates();
        m_d->interface->saveAndResetCurrentTime(m_d->frameId, &m_d->previousFrameId);
    } else if (m_d->type == CURRENT_FRAME) {
        m_d->interface->blockFrameInvalidation(true);
    }
}

References CURRENT_FRAME, KisImage::disableUIUpdates(), EXTERNAL_FRAME, and m_d.

◆ suspendStrokeCallback()

void KisRegenerateFrameStrokeStrategy::suspendStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 214 of file kis_regenerate_frame_stroke_strategy.cpp.

{
    KisImageSP image = m_d->interface->image().toStrongRef();
    if (!image) {
        return;
    }
    if (m_d->type == EXTERNAL_FRAME) {
        m_d->interface->restoreCurrentTime(&m_d->previousFrameId);
        image->enableUIUpdates();
        m_d->restoreUpdatesFilter();
    } else if (m_d->type == CURRENT_FRAME) {
        m_d->interface->blockFrameInvalidation(false);
    }
}

References CURRENT_FRAME, KisImage::enableUIUpdates(), EXTERNAL_FRAME, and m_d.

Member Data Documentation

◆ m_d

const QScopedPointer<Private> KisRegenerateFrameStrokeStrategy::m_d

private

Definition at line 65 of file kis_regenerate_frame_stroke_strategy.h.

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

libs/image/kis_regenerate_frame_stroke_strategy.h
libs/image/kis_regenerate_frame_stroke_strategy.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Type

Constructor & Destructor Documentation

◆ KisRegenerateFrameStrokeStrategy() [1/2]

◆ KisRegenerateFrameStrokeStrategy() [2/2]

◆ ~KisRegenerateFrameStrokeStrategy()

Member Function Documentation

◆ cancelStrokeCallback()

◆ createJobsData()

◆ createLodClone()

◆ doStrokeCallback()

◆ finishStrokeCallback()

◆ initStrokeCallback()

◆ resumeStrokeCallback()

◆ suspendStrokeCallback()

Member Data Documentation

◆ m_d