#include <move_stroke_strategy.h>

Inheritance diagram for MoveStrokeStrategy:

Classes
struct	BarrierUpdateData

class	Data

class	PickLayerData

struct	Private

Signals
void	sigHandlesRectCalculated (const QRect &handlesRect)

void	sigLayersPicked (const KisNodeList &nodes)

void	sigStrokeStartedEmpty ()

Public Member Functions
void	cancelStrokeCallback () override

KisStrokeStrategy *	createLodClone (int levelOfDetail) override

void	doStrokeCallback (KisStrokeJobData *data) override

void	finishStrokeCallback () override

void	initStrokeCallback () override

	MoveStrokeStrategy (KisNodeList nodes, KisUpdatesFacade updatesFacade, KisStrokeUndoFacade undoFacade)

	MoveStrokeStrategy (KisNodeSelectionRecipe nodeSelection, KisUpdatesFacade updatesFacade, KisStrokeUndoFacade undoFacade)

	~MoveStrokeStrategy () override

Public Member Functions inherited from KisStrokeStrategyUndoCommandBased
	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 Member Functions
void	doCanvasUpdate (bool forceUpdate=false)

	MoveStrokeStrategy (const MoveStrokeStrategy &rhs, int lod)

template<typename Functor >
void	recursiveApplyNodes (KisNodeList nodes, Functor &&func)

void	setUndoEnabled (bool value)

void	setUpdatesEnabled (bool value)

void	tryPostUpdateJob (bool forceUpdate)

Private Attributes
QSet< KisNodeSP >	m_blacklistedNodes

QScopedPointer< Private >	m_d

QHash< KisNodeSP, QRect >	m_dirtyRects

QPoint	m_finalOffset

bool	m_hasPostponedJob {false}

KisNodeList	m_nodes

KisNodeSelectionRecipe	m_requestedNodeSelection

QSharedPointer< std::pair< KisNodeList, QSet< KisNodeSP > > >	m_sharedNodes

const int	m_updateInterval {30}

bool	m_updatesEnabled {true}

KisUpdatesFacade *	m_updatesFacade {nullptr}

QElapsedTimer	m_updateTimer

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

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 29 of file move_stroke_strategy.h.

Constructor & Destructor Documentation

◆ MoveStrokeStrategy() [1/3]

MoveStrokeStrategy::MoveStrokeStrategy	(	KisNodeSelectionRecipe	nodeSelection,
		KisUpdatesFacade *	updatesFacade,
		KisStrokeUndoFacade *	undoFacade )

Definition at line 212 of file move_stroke_strategy.cpp.

    : KisStrokeStrategyUndoCommandBased(kundo2_i18n("Move"), false, undoFacade),
      m_d(new Private()),
      m_requestedNodeSelection(nodeSelection),
      m_updatesFacade(updatesFacade),
      m_updatesEnabled(true)
{
    setSupportsWrapAroundMode(true);
 
    enableJob(KisSimpleStrokeStrategy::JOB_INIT, true, KisStrokeJobData::BARRIER);
}

References KisStrokeJobData::BARRIER, KisSimpleStrokeStrategy::enableJob(), KisSimpleStrokeStrategy::JOB_INIT, and KisStrokeStrategyUndoCommandBased::setSupportsWrapAroundMode().

◆ MoveStrokeStrategy() [2/3]

MoveStrokeStrategy::MoveStrokeStrategy	(	KisNodeList	nodes,
		KisUpdatesFacade *	updatesFacade,
		KisStrokeUndoFacade *	undoFacade )

Definition at line 226 of file move_stroke_strategy.cpp.

    : MoveStrokeStrategy(KisNodeSelectionRecipe(nodes), updatesFacade, undoFacade)
{
}

◆ ~MoveStrokeStrategy()

MoveStrokeStrategy::~MoveStrokeStrategy ( )

override

Definition at line 231 of file move_stroke_strategy.cpp.

232{

233}

◆ MoveStrokeStrategy() [3/3]

MoveStrokeStrategy::MoveStrokeStrategy	(	const MoveStrokeStrategy &	rhs,
		int	lod )

private

Definition at line 235 of file move_stroke_strategy.cpp.

    : QObject(),
      KisStrokeStrategyUndoCommandBased(rhs),
      m_d(new Private()),
      m_requestedNodeSelection(rhs.m_requestedNodeSelection, lod),
      m_nodes(rhs.m_nodes),
      m_blacklistedNodes(rhs.m_blacklistedNodes),
      m_updatesFacade(rhs.m_updatesFacade),
      m_finalOffset(rhs.m_finalOffset),
      m_dirtyRects(rhs.m_dirtyRects),
      m_updatesEnabled(rhs.m_updatesEnabled)
{
    KIS_SAFE_ASSERT_RECOVER_NOOP(rhs.m_d->strategy.empty());
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, and m_d.

Member Function Documentation

◆ cancelStrokeCallback()

void MoveStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Q_EMIT updates not looking onto the updatesEnabled switch, since that is the end of the stroke

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 415 of file move_stroke_strategy.cpp.

{
    if (!m_nodes.isEmpty()) {
        m_finalOffset = QPoint();
        m_hasPostponedJob = true;
 
        QVector<KisRunnableStrokeJobData*> jobs;
 
        KritaUtils::addJobBarrierExclusive(jobs, [this]() {
            Q_FOREACH (KisNodeSP node, m_nodes) {
                QRect dirtyRect;
 
                recursiveApplyNodes({node},
                    [this, &dirtyRect] (KisNodeSP node) {
                        MoveNodeStrategyBase *strategy =
                            m_d->strategy[node].get();
                        KIS_SAFE_ASSERT_RECOVER_RETURN(strategy);
 
                        dirtyRect |= strategy->cancelMove();
                    });
 
                m_dirtyRects[node] |= dirtyRect;
 
                m_updatesFacade->refreshGraphAsync(node, dirtyRect);
            }
        });
 
        runnableJobsInterface()->addRunnableJobs(jobs);
    }
 
    KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
}

References KritaUtils::addJobBarrierExclusive(), KisRunnableStrokeJobsInterface::addRunnableJobs(), MoveNodeStrategyBase::cancelMove(), KisStrokeStrategyUndoCommandBased::cancelStrokeCallback(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, m_dirtyRects, m_finalOffset, m_hasPostponedJob, m_nodes, m_updatesFacade, recursiveApplyNodes(), KisUpdatesFacade::refreshGraphAsync(), and KisRunnableBasedStrokeStrategy::runnableJobsInterface().

◆ createLodClone()

KisStrokeStrategy * MoveStrokeStrategy::createLodClone ( int levelOfDetail )

overridevirtual

Since this function is executed in the GUI thread, we cannot properly pick the layers. Therefore we should use pessimistic approach and check if there are non-lodn-capable nodes in the entire image.

Reimplemented from KisStrokeStrategy.

Definition at line 548 of file move_stroke_strategy.cpp.

{
    KisNodeList nodesToCheck;
 
    if (m_requestedNodeSelection.mode == KisNodeSelectionRecipe::SelectedLayer) {
        nodesToCheck = m_requestedNodeSelection.selectedNodes;
    } else if (!m_requestedNodeSelection.selectedNodes.isEmpty()){
        nodesToCheck.append(KisLayerUtils::findRoot(m_requestedNodeSelection.selectedNodes.first()));
    }
 
    Q_FOREACH (KisNodeSP node, nodesToCheck) {
        if (!checkSupportsLodMoves(node)) return 0;
    }
 
    MoveStrokeStrategy *clone = new MoveStrokeStrategy(*this, levelOfDetail);
    connect(clone, SIGNAL(sigHandlesRectCalculated(QRect)), this, SIGNAL(sigHandlesRectCalculated(QRect)));
    connect(clone, SIGNAL(sigStrokeStartedEmpty()), this, SIGNAL(sigStrokeStartedEmpty()));
    connect(clone, SIGNAL(sigLayersPicked(const KisNodeList&)), this, SIGNAL(sigLayersPicked(const KisNodeList&)));
    this->setUpdatesEnabled(false);
    m_sharedNodes.reset(new std::pair<KisNodeList, QSet<KisNodeSP>>());
    clone->m_sharedNodes = m_sharedNodes;
    return clone;
}

References checkSupportsLodMoves(), connect(), KisLayerUtils::findRoot(), m_requestedNodeSelection, m_sharedNodes, KisNodeSelectionRecipe::mode, MoveStrokeStrategy(), KisNodeSelectionRecipe::SelectedLayer, KisNodeSelectionRecipe::selectedNodes, setUpdatesEnabled(), sigHandlesRectCalculated(), sigLayersPicked(), and sigStrokeStartedEmpty().

◆ doCanvasUpdate()

void MoveStrokeStrategy::doCanvasUpdate ( bool forceUpdate = false )

private

Definition at line 498 of file move_stroke_strategy.cpp.

{
    if (!forceUpdate &&
            (m_updateTimer.elapsed() < m_updateInterval ||
             m_updatesFacade->hasUpdatesRunning())) {
 
        return;
    }
 
    if (!m_hasPostponedJob) return;
 
    Q_FOREACH (KisNodeSP node, m_nodes) {
        QRect dirtyRect;
 
        recursiveApplyNodes({node},
            [this, &dirtyRect] (KisNodeSP node) {
                MoveNodeStrategyBase *strategy =
                    m_d->strategy[node].get();
                KIS_SAFE_ASSERT_RECOVER_RETURN(strategy);
 
                dirtyRect |= strategy->moveNode(m_finalOffset);
            });
 
        m_dirtyRects[node] |= dirtyRect;
 
        if (m_updatesEnabled) {
            m_updatesFacade->refreshGraphAsync(node, dirtyRect);
        }
    }
 
    m_hasPostponedJob = false;
    m_updateTimer.restart();
}

References KisUpdatesFacade::hasUpdatesRunning(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, m_dirtyRects, m_finalOffset, m_hasPostponedJob, m_nodes, m_updateInterval, m_updatesEnabled, m_updatesFacade, m_updateTimer, MoveNodeStrategyBase::moveNode(), recursiveApplyNodes(), and KisUpdatesFacade::refreshGraphAsync().

◆ doStrokeCallback()

void MoveStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overridevirtual

NOTE: we do not care about threading here, because all our jobs are declared sequential

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 463 of file move_stroke_strategy.cpp.

{
    if (PickLayerData *pickData = dynamic_cast<PickLayerData*>(data)) {
        KisNodeSelectionRecipe clone = m_requestedNodeSelection;
        clone.pickPoint = pickData->pos;
        Q_EMIT sigLayersPicked(clone.selectNodesToProcess());
        return;
    }
 
    Data *d = dynamic_cast<Data*>(data);
 
    if (!m_nodes.isEmpty() && d) {
        m_finalOffset = d->offset;
        m_hasPostponedJob = true;
        tryPostUpdateJob(false);
 
    } else if (BarrierUpdateData *barrierData =
               dynamic_cast<BarrierUpdateData*>(data)) {
 
        doCanvasUpdate(barrierData->forceUpdate);
 
    } else if (KisAsynchronousStrokeUpdateHelper::UpdateData *updateData =
               dynamic_cast<KisAsynchronousStrokeUpdateHelper::UpdateData*>(data)) {
 
        tryPostUpdateJob(updateData->forceUpdate);
 
    } else {
        KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
    }
}

References doCanvasUpdate(), KisStrokeStrategyUndoCommandBased::doStrokeCallback(), m_finalOffset, m_hasPostponedJob, m_nodes, m_requestedNodeSelection, KisNodeSelectionRecipe::pickPoint, KisNodeSelectionRecipe::selectNodesToProcess(), sigLayersPicked(), and tryPostUpdateJob().

◆ finishStrokeCallback()

void MoveStrokeStrategy::finishStrokeCallback ( )

overridevirtual

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 387 of file move_stroke_strategy.cpp.

{
    Q_FOREACH (KisNodeSP node, m_nodes) {
        KUndo2Command *updateCommand =
            new KisUpdateCommand(node, m_dirtyRects[node], m_updatesFacade, true);
 
        recursiveApplyNodes({node}, [this, updateCommand](KisNodeSP node) {
            KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->strategy.find(node) != m_d->strategy.end());
 
            MoveNodeStrategyBase *strategy = m_d->strategy[node].get();
 
            strategy->finishMove(updateCommand);
        });
 
        notifyCommandDone(KUndo2CommandSP(updateCommand),
                          KisStrokeJobData::SEQUENTIAL,
                          KisStrokeJobData::EXCLUSIVE);
    }
 
    if (!m_updatesEnabled) {
        Q_FOREACH (KisNodeSP node, m_nodes) {
            m_updatesFacade->refreshGraphAsync(node, m_dirtyRects[node]);
        }
    }
 
    KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
}

References KisStrokeJobData::EXCLUSIVE, MoveNodeStrategyBase::finishMove(), KisStrokeStrategyUndoCommandBased::finishStrokeCallback(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, m_dirtyRects, m_nodes, m_updatesEnabled, m_updatesFacade, KisStrokeStrategyUndoCommandBased::notifyCommandDone(), recursiveApplyNodes(), KisUpdatesFacade::refreshGraphAsync(), and KisStrokeJobData::SEQUENTIAL.

◆ initStrokeCallback()

void MoveStrokeStrategy::initStrokeCallback ( )

overridevirtual

Our LodN might have already prepared the list of nodes for us, so we should reuse it to avoid different nodes to be moved in LodN and Lod0 modes.

We shouldn't try to transform standalone fully empty filter masks. That just doesn't make sense.

Collect handles rect

Since the mask is contained in m_nodes, we are explicitly asked to transform it by the user, we should show all the non- default pixels it has (since that is exactly what we are transforming)

Create strategies and start the transactions when necessary

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 250 of file move_stroke_strategy.cpp.

{
    if (m_updatesEnabled) {
        m_nodes = m_requestedNodeSelection.selectNodesToProcess();
 
        if (!m_nodes.isEmpty()) {
            m_nodes = KisLayerUtils::sortAndFilterMergeableInternalNodes(m_nodes, true);
        }
 
        KritaUtils::filterContainer<KisNodeList>(m_nodes, [this](KisNodeSP node) {
            const bool isEmptyFilterMask = node->inherits("KisFilterMask") && node->paintDevice()
                && node->paintDevice()->nonDefaultPixelArea().isEmpty();
 
            // TODO: check isolation
            return !isEmptyFilterMask &&
                !KisLayerUtils::checkIsCloneOf(node, m_nodes) &&
                node->isEditable(true);
        });
        Q_FOREACH(KisNodeSP subtree, m_nodes) {
            KisLayerUtils::recursiveApplyNodes(
                        subtree,
                        [this](KisNodeSP node) {
                if (KisLayerUtils::checkIsCloneOf(node, m_nodes) ||
                        !node->isEditable(false) ||
                        (dynamic_cast<KisTransformMask*>(node.data()) &&
                         KisLayerUtils::checkIsChildOf(node, m_nodes))) {
 
                    m_blacklistedNodes.insert(node);
                }
            });
        }
 
        if (m_sharedNodes) {
            *m_sharedNodes = std::make_pair(m_nodes, m_blacklistedNodes);
        }
    } else {
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_sharedNodes);
        std::tie(m_nodes, m_blacklistedNodes) = *m_sharedNodes;
    }
 
    if (m_nodes.isEmpty()) {
        Q_EMIT sigStrokeStartedEmpty();
        return;
    }
 
    QVector<KisRunnableStrokeJobData*> jobs;
 
    KritaUtils::addJobBarrier(jobs, [this]() {
        Q_FOREACH(KisNodeSP node, m_nodes) {
            KisLayerUtils::forceAllHiddenOriginalsUpdate(node);
        }
    });
 
    KritaUtils::addJobBarrier(jobs, [this]() {
        Q_FOREACH(KisNodeSP node, m_nodes) {
            KisLayerUtils::forceAllDelayedNodesUpdate(node);
        }
    });
 
    KritaUtils::addJobBarrier(jobs, [this]() {
        QRect handlesRect;
 
        recursiveApplyNodes(m_nodes,
            [&handlesRect, this] (KisNodeSP node) {
                if (node->inherits("KisFilterMask") && m_nodes.contains(node)) {
                    if (node->paintDevice()) {
                        handlesRect |= node->paintDevice()->nonDefaultPixelArea();
                    }
                } else {
                    handlesRect |= node->projectionPlane()->tightUserVisibleBounds();
                }
            });
 
        KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
        Q_FOREACH(KisNodeSP node, m_nodes) {
            if (node->hasEditablePaintDevice()) {
                KUndo2Command *autoKeyframeCommand =
                        KisAutoKey::tryAutoCreateDuplicatedFrame(node->paintDevice(),
                                                                 KisAutoKey::SupportsLod);
                if (autoKeyframeCommand) {
                    runAndSaveCommand(toQShared(autoKeyframeCommand), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
                }
            } else if (KisTransformMask *mask = dynamic_cast<KisTransformMask*>(node.data())) {
                const bool maskAnimated = KisLazyCreateTransformMaskKeyframesCommand::maskHasAnimation(mask);
 
                if (maskAnimated) {
                    runAndSaveCommand(toQShared(new KisLazyCreateTransformMaskKeyframesCommand(mask)), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
                }
            }
        }
 
        recursiveApplyNodes(m_nodes,
            [this] (KisNodeSP node) {
                if (dynamic_cast<KisTransformMask*>(node.data())) {
                    m_d->strategy.emplace(node, new MoveTransformMaskStrategy(node));
                } else if (node->paintDevice()) {
                    m_d->strategy.emplace(node, new MovePaintableNodeStrategy(node));
                } else {
                    m_d->strategy.emplace(node, new MoveNormalNodeStrategy(node));
                }
            });
 
        if (m_updatesEnabled) {
            KisLodTransform t(m_nodes.first()->image()->currentLevelOfDetail());
            handlesRect = t.mapInverted(handlesRect);
 
            Q_EMIT this->sigHandlesRectCalculated(handlesRect);
        }
 
        m_updateTimer.start();
    });
 
    runnableJobsInterface()->addRunnableJobs(jobs);
}

References KritaUtils::addJobBarrier(), KisStrokeJobData::BARRIER, KisLayerUtils::checkIsChildOf(), KisLayerUtils::checkIsCloneOf(), KisSharedPtr< T >::data(), KisLayerUtils::forceAllDelayedNodesUpdate(), KisLayerUtils::forceAllHiddenOriginalsUpdate(), KisBaseNode::hasEditablePaintDevice(), KisStrokeStrategyUndoCommandBased::initStrokeCallback(), KisBaseNode::isEditable(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_blacklistedNodes, m_nodes, m_requestedNodeSelection, m_sharedNodes, m_updatesEnabled, m_updateTimer, KisLodTransformBase::mapInverted(), KisLazyCreateTransformMaskKeyframesCommand::maskHasAnimation(), KisPaintDevice::nonDefaultPixelArea(), KisStrokeJobData::NORMAL, KisBaseNode::paintDevice(), KisNode::projectionPlane(), recursiveApplyNodes(), KisLayerUtils::recursiveApplyNodes(), KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisNodeSelectionRecipe::selectNodesToProcess(), sigHandlesRectCalculated(), sigStrokeStartedEmpty(), KisLayerUtils::sortAndFilterMergeableInternalNodes(), KisAutoKey::SupportsLod, toQShared(), and KisAutoKey::tryAutoCreateDuplicatedFrame().

◆ recursiveApplyNodes()

template<typename Functor >

void MoveStrokeStrategy::recursiveApplyNodes	(	KisNodeList	nodes,
		Functor &&	func )

private

Definition at line 197 of file move_stroke_strategy.cpp.

                                                                              {
    Q_FOREACH(KisNodeSP subtree, nodes) {
        KisLayerUtils::recursiveApplyNodes(subtree,
            [&] (KisNodeSP node) {
                if (!m_blacklistedNodes.contains(node)) {
                    func(node);
                }
            });
    }
}

References m_blacklistedNodes, and KisLayerUtils::recursiveApplyNodes().

◆ setUndoEnabled()

void MoveStrokeStrategy::setUndoEnabled ( bool value )

private

◆ setUpdatesEnabled()

void MoveStrokeStrategy::setUpdatesEnabled ( bool value )

private

Definition at line 532 of file move_stroke_strategy.cpp.

{
    m_updatesEnabled = value;
}

References m_updatesEnabled, and value().

◆ sigHandlesRectCalculated

void MoveStrokeStrategy::sigHandlesRectCalculated ( const QRect & handlesRect )

signal

◆ sigLayersPicked

void MoveStrokeStrategy::sigLayersPicked ( const KisNodeList & nodes )

signal

◆ sigStrokeStartedEmpty

void MoveStrokeStrategy::sigStrokeStartedEmpty ( )

signal

◆ tryPostUpdateJob()

void MoveStrokeStrategy::tryPostUpdateJob ( bool forceUpdate )

private

Definition at line 451 of file move_stroke_strategy.cpp.

{
    if (!m_hasPostponedJob) return;
 
    if (forceUpdate ||
        (m_updateTimer.elapsed() > m_updateInterval &&
         !m_updatesFacade->hasUpdatesRunning())) {
 
        addMutatedJob(new BarrierUpdateData(forceUpdate));
    }
}

References KisStrokeStrategy::addMutatedJob(), KisUpdatesFacade::hasUpdatesRunning(), m_hasPostponedJob, m_updateInterval, m_updatesFacade, and m_updateTimer.

Member Data Documentation

◆ m_blacklistedNodes

QSet<KisNodeSP> MoveStrokeStrategy::m_blacklistedNodes

private

Definition at line 103 of file move_stroke_strategy.h.

◆ m_d

QScopedPointer<Private> MoveStrokeStrategy::m_d

private

Definition at line 98 of file move_stroke_strategy.h.

◆ m_dirtyRects

QHash<KisNodeSP, QRect> MoveStrokeStrategy::m_dirtyRects

private

Definition at line 106 of file move_stroke_strategy.h.

◆ m_finalOffset

QPoint MoveStrokeStrategy::m_finalOffset

private

Definition at line 105 of file move_stroke_strategy.h.

◆ m_hasPostponedJob

bool MoveStrokeStrategy::m_hasPostponedJob {false}

private

Definition at line 110 of file move_stroke_strategy.h.

110{false};

◆ m_nodes

KisNodeList MoveStrokeStrategy::m_nodes

private

Definition at line 101 of file move_stroke_strategy.h.

◆ m_requestedNodeSelection

KisNodeSelectionRecipe MoveStrokeStrategy::m_requestedNodeSelection

private

Definition at line 100 of file move_stroke_strategy.h.

◆ m_sharedNodes

QSharedPointer<std::pair<KisNodeList, QSet<KisNodeSP> > > MoveStrokeStrategy::m_sharedNodes

private

Definition at line 102 of file move_stroke_strategy.h.

◆ m_updateInterval

const int MoveStrokeStrategy::m_updateInterval {30}

private

Definition at line 111 of file move_stroke_strategy.h.

111{30};

◆ m_updatesEnabled

bool MoveStrokeStrategy::m_updatesEnabled {true}

private

Definition at line 107 of file move_stroke_strategy.h.

107{true};

◆ m_updatesFacade

KisUpdatesFacade* MoveStrokeStrategy::m_updatesFacade {nullptr}

private

Definition at line 104 of file move_stroke_strategy.h.

104{nullptr};

◆ m_updateTimer

QElapsedTimer MoveStrokeStrategy::m_updateTimer

private

Definition at line 109 of file move_stroke_strategy.h.

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

libs/ui/tool/strokes/move_stroke_strategy.h
libs/ui/tool/strokes/move_stroke_strategy.cpp

Classes

Signals

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MoveStrokeStrategy() [1/3]

◆ MoveStrokeStrategy() [2/3]

◆ ~MoveStrokeStrategy()

◆ MoveStrokeStrategy() [3/3]

Member Function Documentation

◆ cancelStrokeCallback()

◆ createLodClone()

◆ doCanvasUpdate()

◆ doStrokeCallback()

◆ finishStrokeCallback()

◆ initStrokeCallback()

◆ recursiveApplyNodes()

◆ setUndoEnabled()

◆ setUpdatesEnabled()

◆ sigHandlesRectCalculated

◆ sigLayersPicked

◆ sigStrokeStartedEmpty

◆ tryPostUpdateJob()

Member Data Documentation

◆ m_blacklistedNodes

◆ m_d

◆ m_dirtyRects

◆ m_finalOffset

◆ m_hasPostponedJob

◆ m_nodes

◆ m_requestedNodeSelection

◆ m_sharedNodes

◆ m_updateInterval

◆ m_updatesEnabled

◆ m_updatesFacade

◆ m_updateTimer