KisFilterStrokeStrategy Class Reference

#include <kis_filter_stroke_strategy.h>

Inheritance diagram for KisFilterStrokeStrategy:

Classes
struct	ExternalCancelUpdatesStorage
class	FilterJobData
class	IdleBarrierData
struct	Private

Public Types
using	ExternalCancelUpdatesStorageSP = QSharedPointer<ExternalCancelUpdatesStorage>
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
	KisFilterStrokeStrategy (const KisFilterStrokeStrategy &rhs, int levelOfDetail)
	KisFilterStrokeStrategy (KisFilterSP filter, KisFilterConfigurationSP filterConfig, KisResourcesSnapshotSP resources)
	KisFilterStrokeStrategy (KisFilterSP filter, KisFilterConfigurationSP filterConfig, KisResourcesSnapshotSP resources, ExternalCancelUpdatesStorageSP externalCancelUpdatesStorage)
	~KisFilterStrokeStrategy () override
Public Member Functions inherited from KisStrokeStrategyUndoCommandBased
void	cancelStrokeCallback () override
void	doStrokeCallback (KisStrokeJobData *data) override
void	finishStrokeCallback () override
void	initStrokeCallback () override
	KisStrokeStrategyUndoCommandBased (const KUndo2MagicString &name, bool undo, KisStrokeUndoFacade *undoFacade, KUndo2CommandSP initCommand=KUndo2CommandSP(0), KUndo2CommandSP finishCommand=KUndo2CommandSP(0))
void	setCommandExtraData (KUndo2CommandExtraData *data)
void	setMacroId (int value)
void	setSupportsWrapAroundMode (bool value)
void	setUsedWhileUndoRedo (bool value)
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
	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
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 ()

Private Attributes
Private *const	m_d

Additional Inherited Members
Static Public Member Functions inherited from KisSimpleStrokeStrategy
static QLatin1String	jobTypeToString (JobType type)
Protected Member Functions inherited from KisStrokeStrategyUndoCommandBased
void	cancelStrokeCallbackImpl (QVector< KisStrokeJobData * > &mutatedJobs)
void	executeCommand (KUndo2CommandSP command, bool undo)
	KisStrokeStrategyUndoCommandBased (const KisStrokeStrategyUndoCommandBased &rhs)
void	notifyCommandDone (KUndo2CommandSP command, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)
virtual void	postProcessToplevelCommand (KUndo2Command *command)
	Applies some modifications (e.g. assigning extra data) to the toplevel command.
void	runAndSaveCommand (KUndo2CommandSP command, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)
KisStrokeUndoFacade *	undoFacade () const
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_filter_stroke_strategy.h.

Member Typedef Documentation

ExternalCancelUpdatesStorageSP

using KisFilterStrokeStrategy::ExternalCancelUpdatesStorageSP = QSharedPointer<ExternalCancelUpdatesStorage>

Definition at line 77 of file kis_filter_stroke_strategy.h.

Constructor & Destructor Documentation

KisFilterStrokeStrategy() [1/3]

KisFilterStrokeStrategy::KisFilterStrokeStrategy	(	KisFilterSP	filter,
		KisFilterConfigurationSP	filterConfig,
		KisResourcesSnapshotSP	resources )

Definition at line 132 of file kis_filter_stroke_strategy.cpp.

    : KisFilterStrokeStrategy(filter, filterConfig, resources, toQShared(new ExternalCancelUpdatesStorage()))
{
    // by default, cancellation updates are disabled, so we should enable them
    m_d->cancelledUpdates->shouldIssueCancellationUpdates.ref();
}

References KisFilterStrokeStrategy::Private::cancelledUpdates, and m_d.

KisFilterStrokeStrategy() [2/3]

KisFilterStrokeStrategy::KisFilterStrokeStrategy	(	KisFilterSP	filter,
		KisFilterConfigurationSP	filterConfig,
		KisResourcesSnapshotSP	resources,
		ExternalCancelUpdatesStorageSP	externalCancelUpdatesStorage )

Definition at line 139 of file kis_filter_stroke_strategy.cpp.

    : KisStrokeStrategyUndoCommandBased(kundo2_i18nc("Filter as an effect", "Filter \"%1\"", filter->name()),
                                        false,
                                        resources->image().data())
    , m_d(new Private())
{
    m_d->filter = filter;
    m_d->filterConfig = filterConfig;
    m_d->node = resources->currentNode();
    m_d->targetDevice = resources->currentNode()->paintDevice();
    m_d->activeSelection = resources->activeSelection();
    m_d->image = resources->image();
    m_d->updatesFacade = resources->image().data();
    m_d->levelOfDetail = 0;
    m_d->cancelledUpdates = externalCancelUpdatesStorage;
 
    setNeedsExplicitCancel(true);
    setSupportsWrapAroundMode(true);
    enableJob(KisSimpleStrokeStrategy::JOB_INIT);
    enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
    enableJob(KisSimpleStrokeStrategy::JOB_CANCEL);
    enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
}

References KisResourcesSnapshot::activeSelection(), KisFilterStrokeStrategy::Private::activeSelection, KisFilterStrokeStrategy::Private::cancelledUpdates, KisResourcesSnapshot::currentNode(), KisSharedPtr< T >::data(), KisSimpleStrokeStrategy::enableJob(), KisFilterStrokeStrategy::Private::filter, KisFilterStrokeStrategy::Private::filterConfig, KisResourcesSnapshot::image(), KisFilterStrokeStrategy::Private::image, KisSimpleStrokeStrategy::JOB_CANCEL, KisSimpleStrokeStrategy::JOB_DOSTROKE, KisSimpleStrokeStrategy::JOB_FINISH, KisSimpleStrokeStrategy::JOB_INIT, KisFilterStrokeStrategy::Private::levelOfDetail, m_d, KisFilterStrokeStrategy::Private::node, KisBaseNode::paintDevice(), KisStrokeStrategy::setNeedsExplicitCancel(), KisStrokeStrategyUndoCommandBased::setSupportsWrapAroundMode(), KisFilterStrokeStrategy::Private::targetDevice, and KisFilterStrokeStrategy::Private::updatesFacade.

KisFilterStrokeStrategy() [3/3]

KisFilterStrokeStrategy::KisFilterStrokeStrategy	(	const KisFilterStrokeStrategy &	rhs,
		int	levelOfDetail )

Definition at line 166 of file kis_filter_stroke_strategy.cpp.

    : KisStrokeStrategyUndoCommandBased(rhs)
    , m_d(new Private(*rhs.m_d))
{
    m_d->levelOfDetail = levelOfDetail;
}

References KisFilterStrokeStrategy::Private::levelOfDetail, and m_d.

~KisFilterStrokeStrategy()

KisFilterStrokeStrategy::~KisFilterStrokeStrategy ( )

override

Definition at line 173 of file kis_filter_stroke_strategy.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

cancelStrokeCallback()

void KisFilterStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 327 of file kis_filter_stroke_strategy.cpp.

{
    using namespace KritaUtils;
 
    const bool shouldIssueCancellationUpdates = m_d->cancelledUpdates->shouldIssueCancellationUpdates;
 
    QVector<KisStrokeJobData *> jobs;
 
    jobs << new Data(toQShared(new KisDisableDirtyRequestsCommand(m_d->updatesFacade, KisDisableDirtyRequestsCommand::INITIALIZING)));
    KisStrokeStrategyUndoCommandBased::cancelStrokeCallbackImpl(jobs);
    jobs << new Data(toQShared(new KisDisableDirtyRequestsCommand(m_d->updatesFacade, KisDisableDirtyRequestsCommand::FINALIZING)));
 
    if (shouldIssueCancellationUpdates) {
        addJobSequential(jobs, [this] () {
            QRect updateRect =
                m_d->cancelledUpdates->updateRect |
                m_d->nextExternalUpdateRect;
 
            if (m_d->levelOfDetail <= 0) {
                updateRect |= m_d->cancelledUpdates->cancelledLod0UpdateRect;
            }
 
            if (!updateRect.isEmpty()) {
                m_d->node->setDirty(updateRect);
            }
        });
    } else if (!m_d->nextExternalUpdateRect.isEmpty()) {
 
        KisLodTransform t(m_d->levelOfDetail);
        m_d->cancelledUpdates->updateRect = t.mapInverted(m_d->nextExternalUpdateRect);
 
        if (!m_d->hasBeenLodCloned && m_d->levelOfDetail <= 0) {
            m_d->cancelledUpdates->cancelledLod0UpdateRect = m_d->nextExternalUpdateRect;
        }
    }
 
    addMutatedJobs(jobs);
}

References KritaUtils::addJobSequential(), KisStrokeStrategy::addMutatedJobs(), KisFilterStrokeStrategy::Private::cancelledUpdates, KisStrokeStrategyUndoCommandBased::cancelStrokeCallbackImpl(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisFilterStrokeStrategy::Private::hasBeenLodCloned, KisCommandUtils::FlipFlopCommand::INITIALIZING, KisFilterStrokeStrategy::Private::levelOfDetail, m_d, KisLodTransformBase::mapInverted(), KisFilterStrokeStrategy::Private::nextExternalUpdateRect, toQShared(), and KisFilterStrokeStrategy::Private::updatesFacade.

createLodClone()

KisStrokeStrategy * KisFilterStrokeStrategy::createLodClone ( int levelOfDetail )

overridevirtual

Reimplemented from KisStrokeStrategy.

Definition at line 371 of file kis_filter_stroke_strategy.cpp.

{
    if (!m_d->filter->supportsLevelOfDetail(m_d->filterConfig.data(), levelOfDetail)) return 0;
    if (!m_d->node->supportsLodPainting()) return 0;
 
    KisFilterStrokeStrategy *clone = new KisFilterStrokeStrategy(*this, levelOfDetail);
    m_d->hasBeenLodCloned = true;
    return clone;
}

References KisSharedPtr< T >::data(), KisFilterStrokeStrategy::Private::filter, KisFilterStrokeStrategy::Private::filterConfig, KisFilterStrokeStrategy::Private::hasBeenLodCloned, KisFilterStrokeStrategy(), m_d, KisFilterStrokeStrategy::Private::node, KisFilter::supportsLevelOfDetail(), and KisBaseNode::supportsLodPainting().

doStrokeCallback()

void KisFilterStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overridevirtual

Save the last update to be able to restore the original state on the cancellation (even when the cancellation step is explicitly prohibited)

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 195 of file kis_filter_stroke_strategy.cpp.

{
    FilterJobData *filterFrameData = dynamic_cast<FilterJobData*>(data);
    KisRunnableStrokeJobData *jobData = dynamic_cast<KisRunnableStrokeJobData*>(data);
 
    // Populate list of jobs for filter application...
    if (filterFrameData) {
 
        QVector<KisRunnableStrokeJobData*> jobs;
 
        QSharedPointer<SubTaskSharedData> shared( new SubTaskSharedData(m_d->image, m_d->node, m_d->levelOfDetail,
                                                                        m_d->activeSelection, m_d->filter, m_d->filterConfig, filterFrameData) );
        QSharedPointer<KisProcessingVisitor::ProgressHelper> progress( new KisProcessingVisitor::ProgressHelper(m_d->node) );
        addJobSequential(jobs, [this, shared, progress](){
            // Switch time if necessary..
            if (shared->shouldSwitchTime()) {
                runAndSaveCommand( toQShared( new KisLayerUtils::SwitchFrameCommand(shared->image(), shared->frameTime(), false, shared->storage()) )
                                   , KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
            }
 
            // Copy snapshot of targetDevice for filter processing..
            shared->filterDevice = new KisPaintDevice(*shared->targetDevice());
 
            // Update all necessary rect data based on contents of frame..
            shared->filterDeviceBounds = shared->filterDevice->exactBounds();
 
            if (shared->filter()->needsTransparentPixels(shared->filterConfig().data(), shared->targetDevice()->colorSpace())) {
                shared->filterDeviceBounds |= shared->targetDevice()->defaultBounds()->bounds();
            }
 
            shared->processRect = shared->filter()->changedRect(shared->filterDeviceBounds, shared->filterConfig(), shared->levelOfDetail());
            shared->processRect &= shared->targetDevice()->defaultBounds()->bounds();
 
            //If we're dealing with some kind of transparency mask, we will create a compositionSourceDevice instead.
            //  Carry over from commit ca810f85 ...
            if (shared->selection() ||
                    (shared->targetDevice()->colorSpace() != shared->targetDevice()->compositionSourceColorSpace() &&
                    *shared->targetDevice()->colorSpace() != *shared->targetDevice()->compositionSourceColorSpace())) {
 
                shared->filterDevice = shared->targetDevice()->createCompositionSourceDevice(shared->targetDevice());
 
                if (shared->selection()) {
                    shared->filterDeviceBounds &= shared->selection()->selectedRect();
                }
            }
 
            // Filter device needs a transaction to prevent grid-patch artifacts from multithreaded read/write.
            shared->filterDeviceTransaction.reset(new KisTransaction(shared->filterDevice));
 
 
            // Actually process the device
 
            QVector<KisRunnableStrokeJobData*> processJobs;
 
            if (shared->filter()->supportsThreading()) {
                // Split stroke into patches...
                QSize size = KritaUtils::optimalPatchSize();
                QVector<QRect> patches = KritaUtils::splitRectIntoPatches(shared->processRect, size);
 
                Q_FOREACH (const QRect &patch, patches) {
                    if (!patch.isEmpty()) {
                        addJobConcurrent(processJobs, [patch, shared, progress](){
                            shared->filter()->processImpl(shared->filterDevice, patch,
                                                          shared->filterConfig().data(),
                                                          progress->updater());
                        });
                    }
                }
            } else {
                if (!shared->processRect.isEmpty()) {
                    addJobSequential(processJobs, [shared, progress](){
                        shared->filter()->processImpl(shared->filterDevice, shared->processRect,
                                                      shared->filterConfig().data(),
                                                      progress->updater());
                    });
                }
            }
 
            runnableJobsInterface()->addRunnableJobs(processJobs);
 
        });
 
        addJobSequential(jobs, [this, shared](){
            // We will first apply the transaction to the temporary filterDevice
            runAndSaveCommand(toQShared(shared->filterDeviceTransaction->endAndTake()), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
            shared->filterDeviceTransaction.reset();
 
            if (!shared->filterDeviceBounds.intersects(
                    shared->filter()->neededRect(shared->processRect, shared->filterConfig().data(), shared->levelOfDetail()))) {
                return;
            }
 
            // Make a transaction, change the target device, and "end" transaction.
            // Should be useful for undoing later.
            QScopedPointer<KisTransaction> workingTransaction( new KisTransaction(shared->targetDevice()) );
            KisPainter::copyAreaOptimized(shared->processRect.topLeft(), shared->filterDevice, shared->targetDevice(), shared->processRect, shared->selection());
            runAndSaveCommand( toQShared(workingTransaction->endAndTake()), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE );
 
            if (shared->shouldRedraw()) {
                QRect extraUpdateRect;
                qSwap(extraUpdateRect, m_d->nextExternalUpdateRect);
 
                shared->node()->setDirty(shared->processRect | extraUpdateRect);
 
                m_d->nextExternalUpdateRect = shared->processRect;
            }
        });
 
        addJobSequential(jobs, [this, shared](){
            shared->image()->animationInterface()->invalidateFrame(shared->frameTime(), shared->node());
            if (shared->shouldSwitchTime()) {
                runAndSaveCommand( toQShared( new KisLayerUtils::SwitchFrameCommand(shared->image(), shared->frameTime(), true, shared->storage()) )
                                   , KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
            }
        });
 
        runnableJobsInterface()->addRunnableJobs(jobs);
 
    } else if (dynamic_cast<IdleBarrierData*>(data)) {
        /* noop, just delete that */
    } else if (jobData) {
        jobData->run();
    } else {
        KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
    }
}

References KisFilterStrokeStrategy::Private::activeSelection, KritaUtils::addJobConcurrent(), KritaUtils::addJobSequential(), KisRunnableStrokeJobsInterface::addRunnableJobs(), KisStrokeJobData::BARRIER, KisPainter::copyAreaOptimized(), KisStrokeStrategyUndoCommandBased::doStrokeCallback(), KisStrokeJobData::EXCLUSIVE, KisFilterStrokeStrategy::Private::filter, KisFilterStrokeStrategy::Private::filterConfig, KisFilterStrokeStrategy::Private::image, KisFilterStrokeStrategy::Private::levelOfDetail, m_d, KisFilterStrokeStrategy::Private::nextExternalUpdateRect, KisFilterStrokeStrategy::Private::node, KisStrokeJobData::NORMAL, KritaUtils::optimalPatchSize(), KisRunnableStrokeJobData::run(), KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisRunnableBasedStrokeStrategy::runnableJobsInterface(), KritaUtils::splitRectIntoPatches(), and toQShared().

finishStrokeCallback()

void KisFilterStrokeStrategy::finishStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 366 of file kis_filter_stroke_strategy.cpp.

{
    KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
}

References KisStrokeStrategyUndoCommandBased::finishStrokeCallback().

initStrokeCallback()

void KisFilterStrokeStrategy::initStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 178 of file kis_filter_stroke_strategy.cpp.

{
    KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
    qSwap(m_d->nextExternalUpdateRect, m_d->cancelledUpdates->updateRect);
    KisLodTransform t(m_d->levelOfDetail);
    m_d->nextExternalUpdateRect = t.map(m_d->nextExternalUpdateRect);
 
    KUndo2Command *autoKeyframeCommand =
        KisAutoKey::tryAutoCreateDuplicatedFrame(m_d->node->paintDevice(),
                                                 KisAutoKey::SupportsLod);
    if (autoKeyframeCommand) {
        runAndSaveCommand(toQShared(autoKeyframeCommand), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
    }
}

References KisStrokeJobData::BARRIER, KisFilterStrokeStrategy::Private::cancelledUpdates, KisStrokeStrategyUndoCommandBased::initStrokeCallback(), KisFilterStrokeStrategy::Private::levelOfDetail, m_d, KisLodTransform::map(), KisFilterStrokeStrategy::Private::nextExternalUpdateRect, KisFilterStrokeStrategy::Private::node, KisStrokeJobData::NORMAL, KisBaseNode::paintDevice(), KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisAutoKey::SupportsLod, toQShared(), and KisAutoKey::tryAutoCreateDuplicatedFrame().

Member Data Documentation

m_d

Private* const KisFilterStrokeStrategy::m_d

private

Definition at line 102 of file kis_filter_stroke_strategy.h.

---

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

• libs/ui/tool/strokes/kis_filter_stroke_strategy.h
• libs/ui/tool/strokes/kis_filter_stroke_strategy.cpp