#include <kis_processing_applicator.h>

Public Types
enum	ProcessingFlag { NONE = 0x0 , RECURSIVE = 0x1 , NO_UI_UPDATES = 0x2 , SUPPORTS_WRAPAROUND_MODE = 0x4 , NO_IMAGE_UPDATES = 0x8 , RECURSIVE_FRAME_TIMES = 0x10 , READ_ONLY_ACTION = 0x20 }

Public Member Functions
void	applyCommand (KUndo2Command *command, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)

void	applyVisitor (KisProcessingVisitorSP visitor, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)

void	applyVisitorAllFrames (KisProcessingVisitorSP visitor, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)

void	cancel ()

void	end ()

void	explicitlyEmitFinalSignals ()

const KisStrokeId	getStroke () const

	KisProcessingApplicator (KisImageWSP image, KisNodeList nodes=KisNodeList(), ProcessingFlags flags=NONE, KisImageSignalVector emitSignals=KisImageSignalVector(), const KUndo2MagicString &name=KUndo2MagicString(), KUndo2CommandExtraData *extraData=0, int macroId=-1)

	KisProcessingApplicator (KisImageWSP image, KisNodeSP node, ProcessingFlags flags=NONE, KisImageSignalVector emitSignals=KisImageSignalVector(), const KUndo2MagicString &name=KUndo2MagicString(), KUndo2CommandExtraData *extraData=0, int macroId=-1)

std::future< bool > &&	successfullyCompletedFuture ()

	~KisProcessingApplicator ()

Static Public Member Functions
static void	runSingleCommandStroke (KisImageSP image, KUndo2Command *cmd, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)
	runSingleCommandStroke creates a stroke and runs `cmd` in it. The text() field of `cmd` is used as a title of the stroke.

Private Member Functions
void	visitRecursively (KisNodeSP node, KisProcessingVisitorSP visitor, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)

Private Attributes
KisImageSignalVector	m_emitSignals

bool	m_finalSignalsEmitted

ProcessingFlags	m_flags

KisImageWSP	m_image

KisNodeList	m_nodes

QSharedPointer< bool >	m_sharedAllFramesToken

KisStrokeId	m_strokeId

std::future< bool >	m_successfullyCompletedFuture

Detailed Description

Definition at line 21 of file kis_processing_applicator.h.

Member Enumeration Documentation

◆ ProcessingFlag

enum KisProcessingApplicator::ProcessingFlag

Enumerator
NONE
RECURSIVE
NO_UI_UPDATES
SUPPORTS_WRAPAROUND_MODE
NO_IMAGE_UPDATES
RECURSIVE_FRAME_TIMES	you might want to have the frame times be recursive, useful for group layers. When there's a non-recursive applicator on all frames,
READ_ONLY_ACTION	Do not save undo commands into the global undo stack after the action has been completed. Also, do not emit any updates and do not invalidate any frames.

Definition at line 24 of file kis_processing_applicator.h.

                        {
        NONE = 0x0,
        RECURSIVE = 0x1,
        NO_UI_UPDATES = 0x2,
        SUPPORTS_WRAPAROUND_MODE = 0x4,
        NO_IMAGE_UPDATES = 0x8,
        RECURSIVE_FRAME_TIMES = 0x10, 
        READ_ONLY_ACTION = 0x20, 
    };

Constructor & Destructor Documentation

◆ KisProcessingApplicator() [1/2]

KisProcessingApplicator::KisProcessingApplicator	(	KisImageWSP	image,
		KisNodeSP	node,
		ProcessingFlags	flags = NONE,
		KisImageSignalVector	emitSignals = KisImageSignalVector(),
		const KUndo2MagicString &	name = KUndo2MagicString(),
		KUndo2CommandExtraData *	extraData = 0,
		int	macroId = -1 )

Definition at line 262 of file kis_processing_applicator.cpp.

    : KisProcessingApplicator(image, node ? KisNodeList { node } : KisNodeList(), flags, emitSignals, name, extraData, macroId )
{
 
}

◆ KisProcessingApplicator() [2/2]

KisProcessingApplicator::KisProcessingApplicator	(	KisImageWSP	image,
		KisNodeList	nodes = KisNodeList(),
		ProcessingFlags	flags = NONE,
		KisImageSignalVector	emitSignals = KisImageSignalVector(),
		const KUndo2MagicString &	name = KUndo2MagicString(),
		KUndo2CommandExtraData *	extraData = 0,
		int	macroId = -1 )

Definition at line 273 of file kis_processing_applicator.cpp.

    : m_image(image),
      m_nodes(nodes),
      m_flags(flags),
      m_emitSignals(emitSignals),
      m_finalSignalsEmitted(false),
      m_sharedAllFramesToken(new bool(false))
{
    StrategyWithStatusPromise *strategy =
            new StrategyWithStatusPromise(name, !flags.testFlag(READ_ONLY_ACTION) ? m_image.data() : nullptr);
 
    m_successfullyCompletedFuture = strategy->m_successfullyCompleted.get_future();
 
    if (m_flags.testFlag(SUPPORTS_WRAPAROUND_MODE)) {
        strategy->setSupportsWrapAroundMode(true);
    }
 
    if (extraData) {
        strategy->setCommandExtraData(extraData);
    }
 
    strategy->setMacroId(macroId);
 
    m_strokeId = m_image->startStroke(strategy);
    if(!m_emitSignals.isEmpty()) {
        applyCommand(new EmitImageSignalsCommand(m_image, m_emitSignals, false), KisStrokeJobData::BARRIER);
    }
 
    if(m_flags.testFlag(NO_UI_UPDATES)) {
        applyCommand(new DisableUIUpdatesCommand(m_image, false), KisStrokeJobData::BARRIER);
    }
 
    if (!m_nodes.isEmpty() && !m_flags.testFlag(READ_ONLY_ACTION)) {
        applyCommand(new UpdateCommand(m_image, m_nodes, m_flags,
                                       UpdateCommand::INITIALIZING,
                                       m_sharedAllFramesToken));
    }
}

References applyCommand(), KisStrokeJobData::BARRIER, KisWeakSharedPtr< T >::data(), KisCommandUtils::FlipFlopCommand::INITIALIZING, m_emitSignals, m_flags, m_image, m_nodes, m_sharedAllFramesToken, m_strokeId, StrategyWithStatusPromise::m_successfullyCompleted, m_successfullyCompletedFuture, NO_UI_UPDATES, READ_ONLY_ACTION, KisStrokeStrategyUndoCommandBased::setCommandExtraData(), KisStrokeStrategyUndoCommandBased::setMacroId(), KisStrokeStrategyUndoCommandBased::setSupportsWrapAroundMode(), KisImage::startStroke(), and SUPPORTS_WRAPAROUND_MODE.

◆ ~KisProcessingApplicator()

KisProcessingApplicator::~KisProcessingApplicator ( )

Definition at line 318 of file kis_processing_applicator.cpp.

319{

320}

Member Function Documentation

◆ applyCommand()

void KisProcessingApplicator::applyCommand	(	KUndo2Command *	command,
		KisStrokeJobData::Sequentiality	sequentiality = KisStrokeJobData::SEQUENTIAL,
		KisStrokeJobData::Exclusivity	exclusivity = KisStrokeJobData::NORMAL )

Definition at line 430 of file kis_processing_applicator.cpp.

{
    /*
     * One should not add commands after the final signals have been
     * emitted, only end or cancel the stroke
     */
    KIS_ASSERT_RECOVER_RETURN(!m_finalSignalsEmitted);
 
    m_image->addJob(m_strokeId,
                    new KisStrokeStrategyUndoCommandBased::Data(KUndo2CommandSP(command),
                                                                false,
                                                                sequentiality,
                                                                exclusivity));
}

References KisImage::addJob(), KIS_ASSERT_RECOVER_RETURN, m_finalSignalsEmitted, m_image, and m_strokeId.

◆ applyVisitor()

void KisProcessingApplicator::applyVisitor	(	KisProcessingVisitorSP	visitor,
		KisStrokeJobData::Sequentiality	sequentiality = KisStrokeJobData::SEQUENTIAL,
		KisStrokeJobData::Exclusivity	exclusivity = KisStrokeJobData::NORMAL )

Definition at line 333 of file kis_processing_applicator.cpp.

{
    KUndo2Command *initCommand = visitor->createInitCommand();
    if (initCommand) {
        applyCommand(initCommand,
                     KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
    }
 
    if (!m_nodes.isEmpty()) {
        Q_FOREACH(KisNodeSP node, m_nodes) {
            if(!m_flags.testFlag(RECURSIVE)) {
                applyCommand(new KisProcessingCommand(visitor, node),
                             sequentiality, exclusivity);
            }
            else {
                visitRecursively(node, visitor, sequentiality, exclusivity);
            }
        }
    }
}

References applyCommand(), KisProcessingVisitor::createInitCommand(), m_flags, m_nodes, KisStrokeJobData::NORMAL, RECURSIVE, KisStrokeJobData::SEQUENTIAL, and visitRecursively().

◆ applyVisitorAllFrames()

void KisProcessingApplicator::applyVisitorAllFrames	(	KisProcessingVisitorSP	visitor,
		KisStrokeJobData::Sequentiality	sequentiality = KisStrokeJobData::SEQUENTIAL,
		KisStrokeJobData::Exclusivity	exclusivity = KisStrokeJobData::NORMAL )

Definition at line 356 of file kis_processing_applicator.cpp.

{
    *m_sharedAllFramesToken = true;
 
    KUndo2Command *initCommand = visitor->createInitCommand();
    if (initCommand) {
        applyCommand(initCommand,
                     KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
    }
 
    KisLayerUtils::FrameJobs jobs;
 
    // TODO: implement a nonrecursive case when !m_flags.testFlag(RECURSIVE)
    //       (such case is not yet used anywhere)
    //KIS_SAFE_ASSERT_RECOVER_NOOP(m_flags.testFlag(RECURSIVE));
 
    if (!m_nodes.isEmpty()) {
 
        if (m_flags.testFlag(RECURSIVE)) {
            Q_FOREACH(KisNodeSP node, m_nodes) {
                KisLayerUtils::updateFrameJobsRecursive(&jobs, node);
            }
        } else {
            Q_FOREACH(KisNodeSP node, m_nodes) {
                KisLayerUtils::updateFrameJobsNonRecursive(&jobs, node, m_flags.testFlag(RECURSIVE_FRAME_TIMES));
            }
        }
    }
 
    if (jobs.isEmpty()) {
        applyVisitor(visitor, sequentiality, exclusivity);
        return;
    }
 
    KisLayerUtils::FrameJobs::const_iterator it = jobs.constBegin();
    KisLayerUtils::FrameJobs::const_iterator end = jobs.constEnd();
 
    KisLayerUtils::SwitchFrameCommand::SharedStorageSP switchFrameStorage(
        new KisLayerUtils::SwitchFrameCommand::SharedStorage());
 
    for (; it != end; ++it) {
        const int frame = it.key();
        const QSet<KisNodeSP> &nodes = it.value();
 
        applyCommand(new KisLayerUtils::SwitchFrameCommand(m_image, frame, false, switchFrameStorage), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
 
        foreach (KisNodeSP node, nodes) {
            applyCommand(new KisProcessingCommand(visitor, node),
                         sequentiality, exclusivity);
        }
 
        applyCommand(new KisLayerUtils::SwitchFrameCommand(m_image, frame, true, switchFrameStorage), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
    }
}

References applyCommand(), applyVisitor(), KisStrokeJobData::BARRIER, KisProcessingVisitor::createInitCommand(), end(), KisStrokeJobData::EXCLUSIVE, m_flags, m_image, m_nodes, m_sharedAllFramesToken, KisStrokeJobData::NORMAL, RECURSIVE, RECURSIVE_FRAME_TIMES, KisStrokeJobData::SEQUENTIAL, KisLayerUtils::updateFrameJobsNonRecursive(), and KisLayerUtils::updateFrameJobsRecursive().

◆ cancel()

void KisProcessingApplicator::cancel ( )

Definition at line 478 of file kis_processing_applicator.cpp.

{
    m_image->cancelStroke(m_strokeId);
}

References KisImage::cancelStroke(), m_image, and m_strokeId.

◆ end()

void KisProcessingApplicator::end ( )

Definition at line 469 of file kis_processing_applicator.cpp.

{
    if (!m_finalSignalsEmitted) {
        explicitlyEmitFinalSignals();
    }
 
    m_image->endStroke(m_strokeId);
}

References KisImage::endStroke(), explicitlyEmitFinalSignals(), m_finalSignalsEmitted, m_image, and m_strokeId.

◆ explicitlyEmitFinalSignals()

void KisProcessingApplicator::explicitlyEmitFinalSignals ( )

This method emits all the final update signals of the stroke without actually ending the stroke. This can be used for long-running strokes which are kept open to implement preview of the actions.

WARNING: you cannot add new commands/processings after the final signals has been emitted. You should either call end() or cancel().

Definition at line 447 of file kis_processing_applicator.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(!m_finalSignalsEmitted);
 
    if (!m_nodes.isEmpty() && !m_flags.testFlag(READ_ONLY_ACTION)) {
        applyCommand(new UpdateCommand(m_image, m_nodes, m_flags,
                                       UpdateCommand::FINALIZING,
                                       m_sharedAllFramesToken));
    }
 
    if(m_flags.testFlag(NO_UI_UPDATES)) {
        applyCommand(new DisableUIUpdatesCommand(m_image, true), KisStrokeJobData::BARRIER);
    }
 
    if(!m_emitSignals.isEmpty()) {
        applyCommand(new EmitImageSignalsCommand(m_image, m_emitSignals, true), KisStrokeJobData::BARRIER);
    }
 
    // simple consistency check
    m_finalSignalsEmitted = true;
}

References applyCommand(), KisStrokeJobData::BARRIER, KisCommandUtils::FlipFlopCommand::FINALIZING, KIS_ASSERT_RECOVER_RETURN, m_emitSignals, m_finalSignalsEmitted, m_flags, m_image, m_nodes, m_sharedAllFramesToken, NO_UI_UPDATES, and READ_ONLY_ACTION.

◆ getStroke()

const KisStrokeId KisProcessingApplicator::getStroke ( ) const

Returns the underlying stroke. Useful if you want to inject additional jobs in the applicator.

Definition at line 322 of file kis_processing_applicator.cpp.

{
    return m_strokeId;
}

References m_strokeId.

◆ runSingleCommandStroke()

void KisProcessingApplicator::runSingleCommandStroke	(	KisImageSP	image,
		KUndo2Command *	cmd,
		KisStrokeJobData::Sequentiality	sequentiality = KisStrokeJobData::SEQUENTIAL,
		KisStrokeJobData::Exclusivity	exclusivity = KisStrokeJobData::NORMAL )

static

runSingleCommandStroke creates a stroke and runs cmd in it. The text() field of cmd is used as a title of the stroke.

Parameters

image	the image to run the stroke on
cmd	the command to be executed
sequentiality	sequentiality property of the command being executed (see strokes documentation)
exclusivity	sequentiality property of the command being executed (see strokes documentation)

Definition at line 483 of file kis_processing_applicator.cpp.

{
    KisProcessingApplicator applicator(image, 0,
                                       KisProcessingApplicator::NONE,
                                       KisImageSignalVector(),
                                       cmd->text(),
                                       nullptr,
                                       cmd->id());
    applicator.applyCommand(cmd, sequentiality, exclusivity);
    applicator.end();
}

References applyCommand(), end(), KUndo2Command::id(), NONE, and KUndo2Command::text().

◆ successfullyCompletedFuture()

std::future< bool > && KisProcessingApplicator::successfullyCompletedFuture ( )

A future that notifies the caller when the whole processing stroke has been completed. The returned value shows if the stroke has been completed (true) or cancelled (false).

Definition at line 327 of file kis_processing_applicator.cpp.

{
    KIS_ASSERT(m_successfullyCompletedFuture.valid());
    return std::move(m_successfullyCompletedFuture);
}

References KIS_ASSERT, and m_successfullyCompletedFuture.

◆ visitRecursively()

void KisProcessingApplicator::visitRecursively	(	KisNodeSP	node,
		KisProcessingVisitorSP	visitor,
		KisStrokeJobData::Sequentiality	sequentiality,
		KisStrokeJobData::Exclusivity	exclusivity )

private

Definition at line 413 of file kis_processing_applicator.cpp.

{
    // simple tail-recursive iteration
 
    KisNodeSP prevNode = node->lastChild();
    while(prevNode) {
        visitRecursively(prevNode, visitor, sequentiality, exclusivity);
        prevNode = prevNode->prevSibling();
    }
 
    applyCommand(new KisProcessingCommand(visitor, node),
                 sequentiality, exclusivity);
}

References applyCommand(), KisNode::lastChild(), KisNode::prevSibling(), and visitRecursively().

Member Data Documentation

◆ m_emitSignals

KisImageSignalVector KisProcessingApplicator::m_emitSignals

private

Definition at line 120 of file kis_processing_applicator.h.

◆ m_finalSignalsEmitted

bool KisProcessingApplicator::m_finalSignalsEmitted

private

Definition at line 122 of file kis_processing_applicator.h.

◆ m_flags

ProcessingFlags KisProcessingApplicator::m_flags

private

Definition at line 119 of file kis_processing_applicator.h.

◆ m_image

KisImageWSP KisProcessingApplicator::m_image

private

Definition at line 117 of file kis_processing_applicator.h.

◆ m_nodes

KisNodeList KisProcessingApplicator::m_nodes

private

Definition at line 118 of file kis_processing_applicator.h.

◆ m_sharedAllFramesToken

QSharedPointer<bool> KisProcessingApplicator::m_sharedAllFramesToken

private

Definition at line 123 of file kis_processing_applicator.h.

◆ m_strokeId

KisStrokeId KisProcessingApplicator::m_strokeId

private

Definition at line 121 of file kis_processing_applicator.h.

◆ m_successfullyCompletedFuture

std::future<bool> KisProcessingApplicator::m_successfullyCompletedFuture

private

Definition at line 124 of file kis_processing_applicator.h.

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

libs/image/kis_processing_applicator.h
libs/image/kis_processing_applicator.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ProcessingFlag

Constructor & Destructor Documentation

◆ KisProcessingApplicator() [1/2]

◆ KisProcessingApplicator() [2/2]

◆ ~KisProcessingApplicator()

Member Function Documentation

◆ applyCommand()

◆ applyVisitor()

◆ applyVisitorAllFrames()

◆ cancel()

◆ end()

◆ explicitlyEmitFinalSignals()

◆ getStroke()

◆ runSingleCommandStroke()

◆ successfullyCompletedFuture()

◆ visitRecursively()

Member Data Documentation

◆ m_emitSignals

◆ m_finalSignalsEmitted

◆ m_flags

◆ m_image

◆ m_nodes

◆ m_sharedAllFramesToken

◆ m_strokeId

◆ m_successfullyCompletedFuture