#include <inplace_transform_stroke_strategy.h>

Inheritance diagram for InplaceTransformStrokeStrategy:

Classes
struct	BarrierUpdateData

class	CalculateConvexHullData

struct	Private

class	UpdateTransformData

Public Types
enum	CommandGroup { Clear = 0 , ClearTemporary , Transform , TransformTemporary , TransformLod , TransformLodTemporary }

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

Signals
void	sigConvexHullCalculated (QPolygon convexHull, void *cookie)

void	sigTransactionGenerated (TransformTransactionProperties transaction, ToolTransformArgs args, void *cookie)

Public Member Functions
void	cancelStrokeCallback () override

void	doStrokeCallback (KisStrokeJobData *data) override

void	finishStrokeCallback () override

void	initStrokeCallback () override

	InplaceTransformStrokeStrategy (ToolTransformArgs::TransformMode mode, const QString &filterId, bool forceReset, KisNodeList rootNodes, KisSelectionSP selection, KisPaintDeviceSP externalSource, KisStrokeUndoFacade undoFacade, KisUpdatesFacade updatesFacade, KisNodeSP imageRoot, bool forceLodMode)

	Q_ENUM (CommandGroup)

	~InplaceTransformStrokeStrategy () 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

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 ()

Protected Member Functions
void	postProcessToplevelCommand (KUndo2Command *command) override
	Applies some modifications (e.g. assigning extra data) to the toplevel command.

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)

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)

Private Member Functions
void	addDirtyRect (KisNodeSP node, const QRect &rect, int levelOfDetail)

QPolygon	calculateConvexHull ()

int	calculatePreferredLevelOfDetail (const QRect &srcRect)

void	cancelAction (QVector< KisStrokeJobData * > &mutatedJobs)

void	createCacheAndClearNode (KisNodeSP node)

void	doCanvasUpdate (bool forceUpdate)

void	executeAndAddCommand (KUndo2Command *cmd, CommandGroup group, KisStrokeJobData::Sequentiality seq)

void	fetchAllUpdateRequests (int levelOfDetail, KisBatchNodeUpdateSP updateData)

void	finalizeStrokeImpl (QVector< KisStrokeJobData * > &mutatedJobs, bool saveCommands)

void	finishAction (QVector< KisStrokeJobData * > &mutatedJobs)

	InplaceTransformStrokeStrategy (const InplaceTransformStrokeStrategy &rhs, int levelOfDetail)

void	notifyAllCommandsDone ()

void	reapplyTransform (ToolTransformArgs args, QVector< KisStrokeJobData * > &mutatedJobs, int levelOfDetail, bool useHoldUI)

void	transformNode (KisNodeSP node, const ToolTransformArgs &config, int levelOfDetail)

void	tryPostUpdateJob (bool forceUpdate)

void	undoAllCommands ()

void	undoTransformCommands (int levelOfDetail)

Static Private Member Functions
static void	repopulateUI (QVector< KisStrokeJobData * > &mutatedJobs, KisUpdatesFacade *updatesFacade, const QRect &dirtyRect)

Private Attributes
const QScopedPointer< Private >	m_d

Friends
class	InitializeTransformModeStrokeStrategy

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

Detailed Description

Definition at line 28 of file inplace_transform_stroke_strategy.h.

Member Enumeration Documentation

◆ CommandGroup

enum InplaceTransformStrokeStrategy::CommandGroup

The transformation pipeline usually looks like that:

1) Apply Clear commands for all the layers. Some clear commands might be "temporary", that is, they do not go to the final history, e.g. when clearing a shape layer's projection.

2) Apply TransformLod commands to generate preview of the transformation. Some commands may be declared as "temporary", that is, they do not go to the final history, e.g. for the shape layer, for which we just write to the projection device explicitly.

3) When transformation is changed we undo all TransformLod and TransformTemporary commands to recover the old state. The temporary command recovers the state of shape layers' projection device.

4) Repeat steps 2) and 3) until the user is satisfied.

5) When "Apply" button is pressed, all transform commands are undone like in step 2).

6) All Transform commands are applied at Lod0-level. TransformTemporary is not used atm.

7) All non-temporary commands go to the undo history.

Enumerator
Clear
ClearTemporary
Transform
TransformTemporary
TransformLod
TransformLodTemporary

Definition at line 114 of file inplace_transform_stroke_strategy.h.

                      {
        Clear = 0,
        ClearTemporary,
        Transform,
        TransformTemporary,
        TransformLod,
        TransformLodTemporary
    };

Constructor & Destructor Documentation

◆ InplaceTransformStrokeStrategy() [1/2]

InplaceTransformStrokeStrategy::InplaceTransformStrokeStrategy	(	ToolTransformArgs::TransformMode	mode,
		const QString &	filterId,
		bool	forceReset,
		KisNodeList	rootNodes,
		KisSelectionSP	selection,
		KisPaintDeviceSP	externalSource,
		KisStrokeUndoFacade *	undoFacade,
		KisUpdatesFacade *	updatesFacade,
		KisNodeSP	imageRoot,
		bool	forceLodMode )

Definition at line 143 of file inplace_transform_stroke_strategy.cpp.

    : KisStrokeStrategyUndoCommandBased(kundo2_i18n("Transform"), false, undoFacade),
      m_d(new Private())
{
 
    m_d->mode = mode;
    m_d->filterId = filterId;
    m_d->forceReset = forceReset;
    m_d->rootNodes = rootNodes;
    m_d->selection = selection;
    m_d->externalSource = externalSource;
    m_d->updatesFacade = updatesFacade;
    m_d->undoFacade = undoFacade;
    m_d->imageRoot = imageRoot;
    m_d->forceLodMode = forceLodMode;
    m_d->commandUpdatesBlockerCookie.reset(new boost::none_t(boost::none));
 
    if (selection) {
        Q_FOREACH(KisNodeSP node, rootNodes) {
            KIS_SAFE_ASSERT_RECOVER_NOOP(!dynamic_cast<KisTransformMask*>(node.data()));
        }
    }
    setMacroId(KisCommandUtils::TransformToolId);
 
    // TODO: check if can be relaxed
    setNeedsExplicitCancel(true);
}

References KisSharedPtr< T >::data(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisStrokeStrategyUndoCommandBased::setMacroId(), KisStrokeStrategy::setNeedsExplicitCancel(), KisCommandUtils::TransformToolId, and KisStrokeStrategyUndoCommandBased::undoFacade().

◆ ~InplaceTransformStrokeStrategy()

InplaceTransformStrokeStrategy::~InplaceTransformStrokeStrategy ( )

override

Definition at line 180 of file inplace_transform_stroke_strategy.cpp.

181{

182}

◆ InplaceTransformStrokeStrategy() [2/2]

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

private

Member Function Documentation

◆ addDirtyRect()

void InplaceTransformStrokeStrategy::addDirtyRect	(	KisNodeSP	node,
		const QRect &	rect,
		int	levelOfDetail )

private

Definition at line 1228 of file inplace_transform_stroke_strategy.cpp.

                                                                                                      {
    QMutexLocker l(&m_d->dirtyRectsMutex);
    m_d->effectiveDirtyRects(levelOfDetail).addUpdate(node, rect);
}

References m_d.

◆ calculateConvexHull()

QPolygon InplaceTransformStrokeStrategy::calculateConvexHull ( )

private

Definition at line 300 of file inplace_transform_stroke_strategy.cpp.

{
    // Best effort attempt to calculate the convex hull, mimicking the
    // approach that computes srcRect in initStrokeCallback below
    KisPaintDeviceSP externalSource =
        m_d->externalSource ? m_d->externalSource :
        m_d->initialTransformArgs.externalSource() ?
            m_d->initialTransformArgs.externalSource() : 0;
 
    QVector<QPoint> points;
    if (externalSource) {
        points = KisConvexHull::findConvexHull(externalSource);
    } else if (m_d->selection) {
        points = KisConvexHull::findConvexHull(m_d->selection->pixelSelection());
    } else {
        int numContributions = 0;
        Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
            if (node->inherits("KisGroupLayer")) continue;
 
            if (dynamic_cast<const KisTransformMask*>(node.data())) {
                return QPolygon(); // Produce no convex hull if a KisTransformMask is present
            } else {
                KisPaintDeviceSP device;
                // Get the original device as per createCacheAndClearNode below
                if (KisExternalLayer *extLayer = dynamic_cast<KisExternalLayer*>(node.data())) {
                    device = extLayer->projection();
                } else {
                    device = node->paintDevice();
                }
                if (device) {
                    // Use the original device to get the cached device containing the original image data
                    KisPaintDeviceSP toUse;
                    {
                        QMutexLocker l(&m_d->devicesCacheMutex);
                        if (m_d->devicesCacheHash.contains(device.data())) {
                            toUse = m_d->devicesCacheHash[device.data()];
                        } else {
                            toUse = device;
                        }
                    }
                    /* This sometimes does not agree with the original exactBounds
                       because of colorspace changes between the original device
                       and cached. E.g. When the defaultPixel changes as follows it
                       triggers different behavior in calculateExactBounds:
                       KoColor ("ALPHA", "Alpha":0) => KoColor ("GRAYA", "Gray":0, "Alpha":255) 
                    */
                    const bool isConvertedSelection =
                        node->paintDevice() &&
                        node->paintDevice()->colorSpace()->colorModelId() == AlphaColorModelID &&
                        *toUse->colorSpace() == *node->paintDevice()->compositionSourceColorSpace();
 
 
                    QPolygon polygon = isConvertedSelection ?
                        KisConvexHull::findConvexHullSelectionLike(toUse) :
                        KisConvexHull::findConvexHull(toUse);
 
                    points += polygon;
 
                    numContributions += 1;
                } else {
                    // When can this happen?  Should it continue instead?
                    ENTER_FUNCTION() << "Bailing out, device was null" << ppVar(node);
                    return QPolygon();
                }
            }
        }
        if (numContributions > 1) {
            points = KisConvexHull::findConvexHull(points);
        }
    }
    return QPolygon(points);
}

References AlphaColorModelID, KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KisPaintDevice::compositionSourceColorSpace(), KisSharedPtr< T >::data(), ENTER_FUNCTION, KisConvexHull::findConvexHull(), KisConvexHull::findConvexHullSelectionLike(), m_d, KisBaseNode::paintDevice(), and ppVar.

◆ calculatePreferredLevelOfDetail()

int InplaceTransformStrokeStrategy::calculatePreferredLevelOfDetail ( const QRect & srcRect )

private

Definition at line 270 of file inplace_transform_stroke_strategy.cpp.

{
    KisLodPreferences lodPreferences = this->currentLodPreferences();
    if (!lodPreferences.lodSupported() ||
        !(lodPreferences.lodPreferred() || m_d->forceLodMode)) return -1;
 
    const int maxSize = 2000;
    const int maxDimension = KisAlgebra2D::maxDimension(srcRect);
 
    const qreal zoom = qMax(1.0, qreal(maxDimension) / maxSize);
 
    const int calculatedLod = qCeil(std::log2(zoom));
 
    return qMax(calculatedLod, lodPreferences.desiredLevelOfDetail());
 
}

References KisStrokeStrategy::currentLodPreferences(), KisLodPreferences::desiredLevelOfDetail(), KisLodPreferences::lodPreferred(), KisLodPreferences::lodSupported(), m_d, and KisAlgebra2D::maxDimension().

◆ cancelAction()

void InplaceTransformStrokeStrategy::cancelAction ( QVector< KisStrokeJobData * > & mutatedJobs )

private

It is too late to cancel anything, the transformation has been completed and its commands have been pushed into the undo adapter, so there is no way to stop that.

We could have issues updates on lodN planes, which did not end up in the final lod0 update, so we should reupload lod0 data to the UI part manually.

Definition at line 1133 of file inplace_transform_stroke_strategy.cpp.

{
    if (m_d->strokeCompletionHasBeenStarted) return;
 
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->transformMaskCacheHash.isEmpty() ||
                                 (m_d->transformMaskCacheHash.size() == 1 && m_d->processedNodes.size() == 1));
 
    const bool isChangingTransformMask = !m_d->transformMaskCacheHash.isEmpty();
 
    if (m_d->initialTransformArgs.isIdentity()) {
        KritaUtils::addJobSequential(mutatedJobs, [this]() {
            Q_FOREACH (KisTransformMask *mask, m_d->transformMaskCacheHash.keys()) {
                mask->overrideStaticCacheDevice(0);
            }
        });
 
 
        KritaUtils::addJobBarrier(mutatedJobs, [this]() {
            m_d->commandUpdatesBlockerCookie.reset();
            undoTransformCommands(0);
            undoAllCommands();
        });
 
        if (m_d->previewLevelOfDetail > 0) {
            KritaUtils::addJobBarrier(mutatedJobs, [this]() { Q_UNUSED(this) });
            repopulateUI(mutatedJobs, m_d->updatesFacade, m_d->updatesFacade->bounds());
        }
 
        finalizeStrokeImpl(mutatedJobs, false);
 
        KritaUtils::addJobSequential(mutatedJobs, [this]() {
            Q_FOREACH (KisTransformMask *mask, m_d->transformMaskCacheHash.keys()) {
                mask->threadSafeForceStaticImageUpdate();
            }
        });
 
        KritaUtils::addJobBarrier(mutatedJobs, [this]() {
            KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
        });
    } else {
        KIS_SAFE_ASSERT_RECOVER_NOOP(isChangingTransformMask || m_d->overriddenCommand);
 
        KritaUtils::addJobSequential(mutatedJobs, [this]() {
            Q_FOREACH (KisTransformMask *mask, m_d->transformMaskCacheHash.keys()) {
                mask->overrideStaticCacheDevice(0);
            }
        });
 
        reapplyTransform(m_d->initialTransformArgs, mutatedJobs, 0, true);
 
        if (m_d->previewLevelOfDetail > 0) {
            KritaUtils::addJobBarrier(mutatedJobs, [this]() { Q_UNUSED(this) });
            repopulateUI(mutatedJobs, m_d->updatesFacade, m_d->updatesFacade->bounds());
        }
 
        mutatedJobs << new UpdateTransformData(m_d->initialTransformArgs,
                                               UpdateTransformData::SELECTION);
 
        finalizeStrokeImpl(mutatedJobs, bool(m_d->overriddenCommand));
 
        KritaUtils::addJobSequential(mutatedJobs, [this]() {
            Q_FOREACH (KisTransformMask *mask, m_d->transformMaskCacheHash.keys()) {
                mask->threadSafeForceStaticImageUpdate();
            }
        });
 
        if (m_d->overriddenCommand) {
            KritaUtils::addJobBarrier(mutatedJobs, [this]() {
                m_d->currentTransformArgs = m_d->initialTransformArgs;
                KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
            });
        } else {
            KritaUtils::addJobBarrier(mutatedJobs, [this]() {
                KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
            });
        }
    }
}

References KritaUtils::addJobBarrier(), KritaUtils::addJobSequential(), KisStrokeStrategyUndoCommandBased::cancelStrokeCallback(), finalizeStrokeImpl(), KisStrokeStrategyUndoCommandBased::finishStrokeCallback(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisTransformMask::overrideStaticCacheDevice(), reapplyTransform(), repopulateUI(), InplaceTransformStrokeStrategy::UpdateTransformData::SELECTION, KisTransformMask::threadSafeForceStaticImageUpdate(), undoAllCommands(), and undoTransformCommands().

◆ cancelStrokeCallback()

void InplaceTransformStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 662 of file inplace_transform_stroke_strategy.cpp.

{
    QVector<KisStrokeJobData *> mutatedJobs;
 
    cancelAction(mutatedJobs);
 
    if (!mutatedJobs.isEmpty()) {
        addMutatedJobs(mutatedJobs);
    }
}

References KisStrokeStrategy::addMutatedJobs(), and cancelAction().

◆ createCacheAndClearNode()

void InplaceTransformStrokeStrategy::createCacheAndClearNode ( KisNodeSP node )

private

Definition at line 873 of file inplace_transform_stroke_strategy.cpp.

{
    KisPaintDeviceSP device;
    CommandGroup commandGroup = Clear;
 
    if (KisExternalLayer *extLayer =
                   dynamic_cast<KisExternalLayer*>(node.data())) {
 
        if (m_d->mode == ToolTransformArgs::FREE_TRANSFORM ||
            (m_d->mode == ToolTransformArgs::PERSPECTIVE_4POINT &&
             extLayer->supportsPerspectiveTransform())) {
 
            device = node->projection();
            commandGroup = ClearTemporary;
        }
    } else if (KisTransformMask *mask = dynamic_cast<KisTransformMask*>(node.data())) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->selection);
 
        // NOTE: this action should be either sequential or barrier
        QMutexLocker l(&m_d->devicesCacheMutex);
        if (!m_d->transformMaskCacheHash.contains(mask)) {
 
            KisPaintDeviceSP dev = mask->buildSourcePreviewDevice();
            m_d->transformMaskCacheHash.insert(mask, new KisPaintDevice(*dev));
 
            return;
        }
 
    } else {
        device = node->paintDevice();
    }
 
    if (device) {
 
        {
            QMutexLocker l(&m_d->devicesCacheMutex);
 
            if (!m_d->devicesCacheHash.contains(device.data())) {
                KisPaintDeviceSP cache;
 
                // The image that will be transformed is linked to the original
                // layer. We copy existing pixels or use an external source.
                if (m_d->initialTransformArgs.externalSource()) {
                    cache = device->createCompositionSourceDevice(m_d->initialTransformArgs.externalSource());
                } else if (m_d->selection) {
                    QRect srcRect = m_d->selection->selectedExactRect();
 
                    cache = device->createCompositionSourceDevice();
                    KisPainter gc(cache);
                    gc.setSelection(m_d->selection);
                    gc.bitBlt(srcRect.topLeft(), device, srcRect);
                } else {
                    cache = device->createCompositionSourceDevice(device);
                }
 
                m_d->devicesCacheHash.insert(device.data(), cache);
            }
        }
 
        // Don't clear the selection or layer when the source is external
        if (m_d->initialTransformArgs.externalSource()) return;
 
        KisTransaction transaction(device);
        if (m_d->selection) {
            device->clearSelection(m_d->selection);
        } else {
            QRect oldExtent = device->extent();
            device->clear();
            device->setDirty(oldExtent);
        }
 
        executeAndAddCommand(transaction.endAndTake(), commandGroup, KisStrokeJobData::CONCURRENT);
    }
}

References KisPainter::bitBlt(), KisPaintDevice::clear(), Clear, KisPaintDevice::clearSelection(), ClearTemporary, KisStrokeJobData::CONCURRENT, KisPaintDevice::createCompositionSourceDevice(), KisSharedPtr< T >::data(), KisTransaction::endAndTake(), executeAndAddCommand(), KisPaintDevice::extent(), ToolTransformArgs::FREE_TRANSFORM, KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisBaseNode::paintDevice(), ToolTransformArgs::PERSPECTIVE_4POINT, KisBaseNode::projection(), KisPaintDevice::setDirty(), and KisPainter::setSelection().

◆ doCanvasUpdate()

void InplaceTransformStrokeStrategy::doCanvasUpdate ( bool forceUpdate )

private

Definition at line 242 of file inplace_transform_stroke_strategy.cpp.

{
    if (!m_d->pendingUpdateArgs) return;
 
    if (!forceUpdate &&
            (m_d->updateTimer.elapsed() < m_d->updateInterval ||
             m_d->updatesFacade->hasUpdatesRunning())) {
 
        return;
    }
 
    QVector<KisStrokeJobData *> jobs;
 
    ToolTransformArgs args = *m_d->pendingUpdateArgs;
    m_d->pendingUpdateArgs = boost::none;
 
    reapplyTransform(args, jobs, m_d->previewLevelOfDetail, false);
 
    KritaUtils::addJobBarrier(jobs, [this, args]() {
        m_d->currentTransformArgs = args;
        m_d->updateTimer.restart();
        // sanity check that no job has been squeezed in between
        KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->pendingUpdateArgs);
    });
 
    addMutatedJobs(jobs);
}

References KritaUtils::addJobBarrier(), KisStrokeStrategy::addMutatedJobs(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and reapplyTransform().

◆ doStrokeCallback()

void InplaceTransformStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 184 of file inplace_transform_stroke_strategy.cpp.

{
    if (UpdateTransformData *upd = dynamic_cast<UpdateTransformData*>(data)) {
        if (upd->destination == UpdateTransformData::PAINT_DEVICE) {
            m_d->pendingUpdateArgs = upd->args;
            tryPostUpdateJob(false);
        } else if (m_d->selection) {
            // NOTE: selection is hidden during the transformation, so we
            //       don't have to do any preview for that. We transform
            //       that in one go in the end of the stroke.
 
            KisTransaction transaction(m_d->selection->pixelSelection());
 
            KisProcessingVisitor::ProgressHelper helper(m_d->imageRoot.data());
            KisTransformUtils::transformDevice(upd->args,
                                               m_d->selection->pixelSelection(), &helper);
 
            runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                              KisStrokeJobData::CONCURRENT, KisStrokeJobData::NORMAL);
        }
 
    } 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 if (dynamic_cast<CalculateConvexHullData*>(data)) {
 
        if (!m_d->convexHullHasBeenCalculated) {
            m_d->convexHullHasBeenCalculated = true;
            QPolygon hull = calculateConvexHull();
            if (!hull.isEmpty()) {
                Q_EMIT sigConvexHullCalculated(hull, this);
            }
        }
 
    } else {
        KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
    }
 
}

References calculateConvexHull(), KisStrokeJobData::CONCURRENT, doCanvasUpdate(), KisStrokeStrategyUndoCommandBased::doStrokeCallback(), KisTransaction::endAndTake(), m_d, KisStrokeJobData::NORMAL, InplaceTransformStrokeStrategy::UpdateTransformData::PAINT_DEVICE, KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), sigConvexHullCalculated(), KisTransformUtils::transformDevice(), and tryPostUpdateJob().

◆ executeAndAddCommand()

void InplaceTransformStrokeStrategy::executeAndAddCommand	(	KUndo2Command *	cmd,
		InplaceTransformStrokeStrategy::CommandGroup	group,
		KisStrokeJobData::Sequentiality	seq )

private

Definition at line 688 of file inplace_transform_stroke_strategy.cpp.

{
    QMutexLocker l(&m_d->commandsMutex);
    KUndo2CommandSP sharedCommand = toQShared(cmd);
    executeCommand(sharedCommand, false);
    m_d->commands.append({group, sharedCommand, seq});
}

References KisStrokeStrategyUndoCommandBased::executeCommand(), m_d, and toQShared().

◆ fetchAllUpdateRequests()

void InplaceTransformStrokeStrategy::fetchAllUpdateRequests	(	int	levelOfDetail,
		KisBatchNodeUpdateSP	updateData )

private

Definition at line 743 of file inplace_transform_stroke_strategy.cpp.

{
    KisBatchNodeUpdate &dirtyRects = m_d->effectiveDirtyRects(levelOfDetail);
    KisBatchNodeUpdate &prevDirtyRects = m_d->effectivePrevDirtyRects(levelOfDetail);
 
    *updateData = (prevDirtyRects | dirtyRects).compressed();
 
    KisBatchNodeUpdate savedUndoRects = dirtyRects;
 
    if (levelOfDetail > 0) {
 
        for (auto it = savedUndoRects.begin(); it != savedUndoRects.end(); ++it) {
            it->second = KisLodTransform::upscaledRect(it->second, levelOfDetail);
        }
    }
 
    *m_d->updateDataForUndo = (m_d->initialUpdatesBeforeClear | savedUndoRects).compressed();
    prevDirtyRects.clear();
    dirtyRects.swap(prevDirtyRects);
}

References m_d, and KisLodTransformBase::upscaledRect().

◆ finalizeStrokeImpl()

void InplaceTransformStrokeStrategy::finalizeStrokeImpl	(	QVector< KisStrokeJobData * > &	mutatedJobs,
		bool	saveCommands )

private

Definition at line 1015 of file inplace_transform_stroke_strategy.cpp.

{
    KritaUtils::addJobBarrier(mutatedJobs, [this]() {
        Q_FOREACH (KisSelectionSP selection, m_d->deactivatedSelections) {
            selection->setVisible(true);
        }
 
        Q_FOREACH(KisSelectionMaskSP deactivatedOverlaySelectionMask, m_d->deactivatedOverlaySelectionMasks) {
            deactivatedOverlaySelectionMask->selection()->setVisible(true);
            deactivatedOverlaySelectionMask->setDirty();
        }
 
        m_d->commandUpdatesBlockerCookie.reset();
    });
 
 
    if (saveCommands) {
        KritaUtils::addJobBarrier(mutatedJobs, [this]() {
            notifyAllCommandsDone();
            m_d->commands.clear();
        });
    }
}

References KritaUtils::addJobBarrier(), m_d, notifyAllCommandsDone(), KisMask::selection, KisSelectionMask::setDirty(), and KisSelection::setVisible().

◆ finishAction()

void InplaceTransformStrokeStrategy::finishAction ( QVector< KisStrokeJobData * > & mutatedJobs )

private

Forward to cancelling should happen before the guard for finalizingActionsStarted.
Transform masks may switch mode and become identity, that shouldn't be cancelled.

Update jobs from level of detail updates may cause dirtying of the transform mask's static cache device. Therefore we must ensure that final update of the mask happens strictly after them.

Transform masks don't have internal state switch for LoD mode, therefore all the preview transformations must be cancelled before applying the final command

We could have issues updates on lodN planes, which did not end up in the final lod0 update, so we should reupload lod0 data to the UI part manually.

Definition at line 1052 of file inplace_transform_stroke_strategy.cpp.

{
    if (m_d->currentTransformArgs.isUnchanging() &&
        m_d->transformMaskCacheHash.isEmpty() &&
        !m_d->overriddenCommand) {
 
        cancelAction(mutatedJobs);
        return;
    }
 
    if (m_d->previewLevelOfDetail > 0) {
        KritaUtils::addJobBarrier(mutatedJobs, [this]() { Q_UNUSED(this) });
 
        if (!m_d->transformMaskCacheHash.isEmpty()) {
            KritaUtils::addJobSequential(mutatedJobs, [this]() {
                Q_FOREACH (KisTransformMask *mask, m_d->transformMaskCacheHash.keys()) {
                    mask->overrideStaticCacheDevice(0);
                }
 
                undoTransformCommands(m_d->previewLevelOfDetail);
            });
        }
 
        reapplyTransform(m_d->currentTransformArgs, mutatedJobs, 0, true);
 
        KritaUtils::addJobBarrier(mutatedJobs, [this]() { Q_UNUSED(this) });
        repopulateUI(mutatedJobs, m_d->updatesFacade, m_d->updatesFacade->bounds());
 
    } else {
        if (m_d->pendingUpdateArgs) {
            mutatedJobs << new BarrierUpdateData(true);
        }
    }
 
    mutatedJobs << new UpdateTransformData(m_d->currentTransformArgs,
                                           UpdateTransformData::SELECTION);
 
    // the rest of the transform finishing work cannot be cancelled...
    KritaUtils::addJobBarrier(mutatedJobs, [this]() {
        m_d->strokeCompletionHasBeenStarted = true;
 
        QVector<KisStrokeJobData *> nonCancellableFinishJobs;
 
        finalizeStrokeImpl(nonCancellableFinishJobs, true);
 
        KritaUtils::addJobBarrier(nonCancellableFinishJobs, [this]() {
            KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
        });
 
        for (auto it = nonCancellableFinishJobs.begin(); it != nonCancellableFinishJobs.end(); ++it) {
            (*it)->setCancellable(false);
        }
 
        this->addMutatedJobs(nonCancellableFinishJobs);
 
    });
}

References KritaUtils::addJobBarrier(), KritaUtils::addJobSequential(), KisStrokeStrategy::addMutatedJobs(), cancelAction(), finalizeStrokeImpl(), KisStrokeStrategyUndoCommandBased::finishStrokeCallback(), m_d, KisTransformMask::overrideStaticCacheDevice(), reapplyTransform(), repopulateUI(), InplaceTransformStrokeStrategy::UpdateTransformData::SELECTION, and undoTransformCommands().

◆ finishStrokeCallback()

void InplaceTransformStrokeStrategy::finishStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 651 of file inplace_transform_stroke_strategy.cpp.

{
    QVector<KisStrokeJobData *> mutatedJobs;
 
    finishAction(mutatedJobs);
 
    if (!mutatedJobs.isEmpty()) {
        addMutatedJobs(mutatedJobs);
    }
}

References KisStrokeStrategy::addMutatedJobs(), and finishAction().

◆ initStrokeCallback()

void InplaceTransformStrokeStrategy::initStrokeCallback ( )

overridevirtual

In case we are doing a continued action, we need to set initial update to the "very initial" state that was present before the previous stroke. So here we just override the rect calculated before

We need to make sure that the nodes will be successfully be transformed back in case the stroke will be finished before sigTransactionGenerated() signal is delivered.

We must request shape layers to rerender areas outside image bounds

We must ensure that the currently selected subtree has finished all its updates.

Disable all decorated nodes to generate outline and preview correctly. We will enable them back as soon as preview generation is finished.

Filter masks have special handling of transparency. Their filter may declare if they affect transparent pixels or not. In case of transformations we don't care about that, we should just transform non-default area of the mask.

We shouldn't include masks or layer styles into the handles rect, in the end, we process the paint device only

recover back visibility of decorated nodes

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 374 of file inplace_transform_stroke_strategy.cpp.

{
    KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
    m_d->currentTime = KisTransformUtils::fetchCurrentImageTime(m_d->rootNodes);
 
    QVector<KisStrokeJobData *> extraInitJobs;
 
    if (m_d->selection) {
        m_d->selection->setVisible(false);
        m_d->deactivatedSelections.append(m_d->selection);
    }
 
    Q_FOREACH(KisNodeSP node, m_d->rootNodes) {
        KisSelectionMaskSP overlaySelectionMask =
                dynamic_cast<KisSelectionMask*>(node->graphListener()->graphOverlayNode());
        if (overlaySelectionMask && node != KisNodeSP(overlaySelectionMask)) {
            overlaySelectionMask->setDecorationsVisible(false);
            m_d->deactivatedOverlaySelectionMasks.append(overlaySelectionMask);
        }
    }
 
    if (m_d->rootNodes.size() == 1) {
        KisNodeSP rootNode = m_d->rootNodes[0];
        rootNode = KisTransformUtils::tryOverrideRootToTransformMask(rootNode);
 
        if (rootNode->inherits("KisTransformMask") && rootNode->projectionLeaf()->isDroppedNode()) {
            rootNode.clear();
            m_d->processedNodes.clear();
 
            TransformTransactionProperties transaction(QRect(), &m_d->initialTransformArgs, m_d->rootNodes, m_d->processedNodes);
            Q_EMIT sigTransactionGenerated(transaction, m_d->initialTransformArgs, this);
            return;
        }
    }
 
    // When placing an external source image, we never work recursively on any layer masks
    m_d->processedNodes = KisTransformUtils::fetchNodesList(m_d->mode, m_d->rootNodes, m_d->externalSource, m_d->selection);
 
    bool argsAreInitialized = false;
    QVector<KisStrokeJobData *> lastCommandUndoJobs;
 
    // When externalSource is set, it means that we are initializing a new
    // stroke following a newActivationWithExternalSource, thus we never try
    // to reuse an existing transformation from the undo queue. However, when
    // externalSource is not set, tryFetchArgsFromCommandAndUndo may still
    // recover a previous stroke that referenced an external source.
    if (!m_d->forceReset && !m_d->externalSource) {
        if (KisTransformUtils::tryFetchArgsFromCommandAndUndo(&m_d->initialTransformArgs,
                                                              m_d->mode,
                                                              m_d->rootNodes,
                                                              m_d->processedNodes,
                                                              m_d->undoFacade,
                                                              m_d->currentTime,
                                                              &lastCommandUndoJobs,
                                                              &m_d->overriddenCommand)) {
            argsAreInitialized = true;
        } else if (KisTransformUtils::tryInitArgsFromNode(m_d->rootNodes, &m_d->initialTransformArgs)) {
            argsAreInitialized = true;
        }
    }
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
            m_d->prevDirtyRects.addUpdate(node, node->projectionPlane()->tightUserVisibleBounds());
        }
 
        m_d->initialUpdatesBeforeClear = m_d->prevDirtyRects.compressed();
        m_d->updateDataForUndo.reset(new KisBatchNodeUpdate(m_d->initialUpdatesBeforeClear));
 
        executeAndAddCommand(new KisUpdateCommandEx(m_d->updateDataForUndo, m_d->updatesFacade, KisUpdateCommandEx::INITIALIZING, m_d->commandUpdatesBlockerCookie), Clear, KisStrokeJobData::BARRIER);
        executeAndAddCommand(new KisDisableDirtyRequestsCommand(m_d->updatesFacade, KisDisableDirtyRequestsCommand::INITIALIZING), Clear, KisStrokeJobData::BARRIER);
    });
 
    extraInitJobs << lastCommandUndoJobs;
 
    if (!lastCommandUndoJobs.isEmpty()) {
        KritaUtils::addJobBarrier(extraInitJobs, [this]() {
            KisBatchNodeUpdate updates;
 
            Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
                updates.addUpdate(node, node->projectionPlane()->tightUserVisibleBounds());
            }
 
            m_d->initialUpdatesBeforeClear = updates.compressed();
            *m_d->updateDataForUndo = m_d->initialUpdatesBeforeClear;
 
            m_d->pendingUpdateArgs = m_d->initialTransformArgs;
        });
    }
 
    KritaUtils::addJobSequential(extraInitJobs, [this]() {
        // When dealing with animated transform mask layers, create keyframe and save the command for undo.
        // NOTE: for transform masks we create a keyframe no matter what the user
        //       settings are
        Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
            if (KisTransformMask* transformMask = dynamic_cast<KisTransformMask*>(node.data())) {
                if (KisLazyCreateTransformMaskKeyframesCommand::maskHasAnimation(transformMask)) {
                    runAndSaveCommand(toQShared(new KisLazyCreateTransformMaskKeyframesCommand(transformMask)), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
                }
            } else if (KisAutoKey::activeMode() > KisAutoKey::NONE &&
                       node->hasEditablePaintDevice()){
 
                KUndo2Command *autoKeyframeCommand =
                        KisAutoKey::tryAutoCreateDuplicatedFrame(node->paintDevice(),
                                                                 KisAutoKey::SupportsLod);
                if (autoKeyframeCommand) {
                    runAndSaveCommand(toQShared(autoKeyframeCommand), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
                }
            }
        }
    });
 
    KritaUtils::addJobSequential(extraInitJobs, [this]() {
        Q_FOREACH(KisNodeSP node, m_d->rootNodes) {
            KisLayerUtils::forceAllHiddenOriginalsUpdate(node);
        }
    });
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        Q_FOREACH(KisNodeSP node, m_d->rootNodes) {
            KisLayerUtils::forceAllDelayedNodesUpdate(node);
        }
    });
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
            KisDecoratedNodeInterface *decoratedNode = dynamic_cast<KisDecoratedNodeInterface*>(node.data());
            if (decoratedNode && decoratedNode->decorationsVisible()) {
                decoratedNode->setDecorationsVisible(false);
                m_d->disabledDecoratedNodes << decoratedNode;
            }
        }
    });
 
    KritaUtils::addJobBarrier(extraInitJobs,
                              [this,
                              argsAreInitialized]() mutable {
        QRect srcRect;
 
        KisPaintDeviceSP externalSource =
            m_d->externalSource ? m_d->externalSource :
            (argsAreInitialized && m_d->initialTransformArgs.externalSource()) ?
                m_d->initialTransformArgs.externalSource() : 0;
 
        if (externalSource) {
            // Start the transformation around the visible pixels of the external image
            srcRect = externalSource->exactBounds();
        } else if (m_d->selection) {
            srcRect = m_d->selection->selectedExactRect();
        } else {
            srcRect = QRect();
            Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
                // group layers may have a projection of layers
                // that are locked and will not be transformed
                if (node->inherits("KisGroupLayer")) continue;
 
                if (const KisTransformMask *mask = dynamic_cast<const KisTransformMask*>(node.data())) {
                    srcRect |= mask->sourceDataBounds();
                } else if (const KisSelectionMask *mask = dynamic_cast<const KisSelectionMask*>(node.data())) {
                    srcRect |= mask->selection()->selectedExactRect();
                } else if (const KisTransparencyMask *mask = dynamic_cast<const KisTransparencyMask*>(node.data())) {
                    srcRect |= mask->selection()->selectedExactRect();
                } else if (const KisFilterMask *mask = dynamic_cast<const KisFilterMask*>(node.data())) {
                    if (mask->paintDevice()) {
                        srcRect |= mask->paintDevice()->nonDefaultPixelArea();
                    }
                } else {
                    srcRect |= node->paintDevice() ? node->paintDevice()->exactBounds() : node->exactBounds();
                }
            }
        }
 
        TransformTransactionProperties transaction(srcRect, &m_d->initialTransformArgs, m_d->rootNodes, m_d->processedNodes);
        if (!argsAreInitialized) {
            m_d->initialTransformArgs = KisTransformUtils::resetArgsForMode(m_d->mode, m_d->filterId, transaction, m_d->externalSource);
        }
        m_d->externalSource.clear();
 
        const QRect imageBoundsRect = m_d->imageRoot->projection()->defaultBounds()->bounds();
        m_d->previewLevelOfDetail = calculatePreferredLevelOfDetail(srcRect & imageBoundsRect);
 
        if (m_d->previewLevelOfDetail > 0) {
            for (auto it = m_d->prevDirtyRects.begin(); it != m_d->prevDirtyRects.end(); ++it) {
                KisLodTransform t(m_d->previewLevelOfDetail);
                m_d->prevDirtyPreviewRects.addUpdate(it->first, t.map(it->second));
            }
        }
 
        if (transaction.currentConfig()->boundsRotation() != 0.0) {
            m_d->convexHullHasBeenCalculated = true;
            transaction.setConvexHull(calculateConvexHull());
            transaction.setConvexHullHasBeenRequested(true);
        }
 
        Q_EMIT sigTransactionGenerated(transaction, m_d->initialTransformArgs, this);
    });
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        Q_FOREACH (KisDecoratedNodeInterface *decoratedNode, m_d->disabledDecoratedNodes) {
            decoratedNode->setDecorationsVisible(true);
        }
        m_d->disabledDecoratedNodes.clear();
    });
 
    Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
        KritaUtils::addJobSequential(extraInitJobs, [this, node]() mutable {
            createCacheAndClearNode(node);
        });
    }
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        QMutexLocker l(&m_d->dirtyRectsMutex);
 
        executeAndAddCommand(new KisDisableDirtyRequestsCommand(m_d->updatesFacade, KisDisableDirtyRequestsCommand::FINALIZING), Clear, KisStrokeJobData::BARRIER);
 
        m_d->updateTimer.start();
    });
 
    if (!lastCommandUndoJobs.isEmpty()) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->overriddenCommand);
 
        for (auto it = extraInitJobs.begin(); it != extraInitJobs.end(); ++it) {
            (*it)->setCancellable(false);
        }
    }
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        if (m_d->previewLevelOfDetail > 0) {
            QVector<KisStrokeJobData*> lodSyncJobs;
 
            KisSyncLodCacheStrokeStrategy::createJobsData(lodSyncJobs,
                                                          m_d->imageRoot,
                                                          m_d->updatesFacade,
                                                          m_d->previewLevelOfDetail,
                                                          m_d->devicesCacheHash.values() +
                                                          m_d->transformMaskCacheHash.values());
 
            for (auto it = lodSyncJobs.begin(); it != lodSyncJobs.end(); ++it) {
                (*it)->setLevelOfDetailOverride(m_d->previewLevelOfDetail);
            }
 
            addMutatedJobs(lodSyncJobs);
        }
    });
 
    addMutatedJobs(extraInitJobs);
}

References KisAutoKey::activeMode(), KritaUtils::addJobBarrier(), KritaUtils::addJobSequential(), KisStrokeStrategy::addMutatedJobs(), KisBatchNodeUpdate::addUpdate(), KisStrokeJobData::BARRIER, ToolTransformArgs::boundsRotation(), calculateConvexHull(), calculatePreferredLevelOfDetail(), KisSharedPtr< T >::clear(), Clear, KisBatchNodeUpdate::compressed(), createCacheAndClearNode(), TransformTransactionProperties::currentConfig(), KisSharedPtr< T >::data(), KisDecoratedNodeInterface::decorationsVisible(), KisBaseNode::exactBounds(), KisPaintDevice::exactBounds(), executeAndAddCommand(), KisTransformUtils::fetchCurrentImageTime(), KisTransformUtils::fetchNodesList(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisLayerUtils::forceAllDelayedNodesUpdate(), KisLayerUtils::forceAllHiddenOriginalsUpdate(), KisNode::graphListener, KisNodeGraphListener::graphOverlayNode(), KisBaseNode::hasEditablePaintDevice(), KisCommandUtils::FlipFlopCommand::INITIALIZING, KisStrokeStrategyUndoCommandBased::initStrokeCallback(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisLodTransform::map(), KisLazyCreateTransformMaskKeyframesCommand::maskHasAnimation(), KisAutoKey::NONE, KisStrokeJobData::NORMAL, KisBaseNode::paintDevice(), KisNode::projectionLeaf, KisNode::projectionPlane(), KisTransformUtils::resetArgsForMode(), KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), TransformTransactionProperties::setConvexHull(), TransformTransactionProperties::setConvexHullHasBeenRequested(), KisSelectionMask::setDecorationsVisible(), KisDecoratedNodeInterface::setDecorationsVisible(), sigTransactionGenerated(), KisAutoKey::SupportsLod, toQShared(), KisAutoKey::tryAutoCreateDuplicatedFrame(), KisTransformUtils::tryFetchArgsFromCommandAndUndo(), KisTransformUtils::tryInitArgsFromNode(), and KisTransformUtils::tryOverrideRootToTransformMask().

◆ notifyAllCommandsDone()

void InplaceTransformStrokeStrategy::notifyAllCommandsDone ( )

private

Definition at line 696 of file inplace_transform_stroke_strategy.cpp.

{
    for (auto it = m_d->commands.begin(); it != m_d->commands.end(); ++it) {
        if (it->commandGroup == Clear) {
            notifyCommandDone(it->command, it->sequentiality, KisStrokeJobData::NORMAL);
        }
    }
 
    notifyCommandDone(toQShared(new KUndo2Command()), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
 
    for (auto it = m_d->commands.begin(); it != m_d->commands.end(); ++it) {
        if (it->commandGroup == Transform) {
            notifyCommandDone(it->command, it->sequentiality, KisStrokeJobData::NORMAL);
        }
    }
}

References Clear, m_d, KisStrokeJobData::NORMAL, KisStrokeStrategyUndoCommandBased::notifyCommandDone(), KisStrokeJobData::SEQUENTIAL, toQShared(), and Transform.

◆ postProcessToplevelCommand()

void InplaceTransformStrokeStrategy::postProcessToplevelCommand ( KUndo2Command * command )

overrideprotectedvirtual

Applies some modifications (e.g. assigning extra data) to the toplevel command.

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 288 of file inplace_transform_stroke_strategy.cpp.

{
    KisTransformUtils::postProcessToplevelCommand(command,
                                                  m_d->currentTransformArgs,
                                                  m_d->rootNodes,
                                                  m_d->processedNodes,
                                                  m_d->currentTime,
                                                  m_d->overriddenCommand);
 
    KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(command);
}

References m_d, KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(), and KisTransformUtils::postProcessToplevelCommand().

◆ Q_ENUM()

InplaceTransformStrokeStrategy::Q_ENUM ( CommandGroup )

◆ reapplyTransform()

void InplaceTransformStrokeStrategy::reapplyTransform	(	ToolTransformArgs	args,
		QVector< KisStrokeJobData * > &	mutatedJobs,
		int	levelOfDetail,
		bool	useHoldUI )

private

We also Q_EMIT the updates manually, because KisUpdateCommandEx is still blocked by m_d->commandUpdatesBlockerCookie (for easy undo purposes)

Definition at line 948 of file inplace_transform_stroke_strategy.cpp.

{
    if (levelOfDetail > 0) {
        args.scale3dSrcAndDst(KisLodTransform::lodToScale(levelOfDetail));
    }
 
    KisBatchNodeUpdateSP updateData(new KisBatchNodeUpdate());
 
    CommandGroup commandGroup =
        levelOfDetail > 0 ? TransformLod : Transform;
 
    KritaUtils::addJobBarrier(mutatedJobs, levelOfDetail,
                              [this, args, levelOfDetail, updateData, useHoldUI, commandGroup]() {
 
        // it has its own dirty requests blocking inside
        undoTransformCommands(levelOfDetail);
 
        if (useHoldUI) {
            executeAndAddCommand(new KisHoldUIUpdatesCommand(m_d->updatesFacade, KisCommandUtils::FlipFlopCommand::INITIALIZING), commandGroup, KisStrokeJobData::BARRIER);
        }
 
        executeAndAddCommand(new KisDisableDirtyRequestsCommand(m_d->updatesFacade, KisUpdateCommandEx::INITIALIZING), commandGroup, KisStrokeJobData::BARRIER);
    });
 
    Q_FOREACH (KisNodeSP node, m_d->processedNodes) {
        KritaUtils::addJobConcurrent(mutatedJobs, levelOfDetail,
                                     [this, node, args, levelOfDetail]() {
            transformNode(node, args, levelOfDetail);
        });
    }
 
    KritaUtils::addJobBarrier(mutatedJobs, levelOfDetail,
                              [this, levelOfDetail, updateData, useHoldUI, commandGroup]() {
 
        fetchAllUpdateRequests(levelOfDetail, updateData);
 
        executeAndAddCommand(new KisDisableDirtyRequestsCommand(m_d->updatesFacade, KisUpdateCommandEx::FINALIZING), commandGroup, KisStrokeJobData::BARRIER);
        executeAndAddCommand(new KisUpdateCommandEx(m_d->updateDataForUndo, m_d->updatesFacade, KisUpdateCommandEx::FINALIZING, m_d->commandUpdatesBlockerCookie), commandGroup, KisStrokeJobData::BARRIER);
 
        if (useHoldUI) {
            executeAndAddCommand(new KisHoldUIUpdatesCommand(m_d->updatesFacade, KisCommandUtils::FlipFlopCommand::FINALIZING), commandGroup, KisStrokeJobData::BARRIER);
        }
 
        for (auto it = updateData->begin(); it != updateData->end(); ++it) {
            KisTransformMask *transformMask = dynamic_cast<KisTransformMask*>(it->first.data());
 
            if (transformMask &&
                    ((levelOfDetail <= 0 && !transformMask->transformParams()->isAffine()) ||
                     (levelOfDetail <= 0 && m_d->previewLevelOfDetail > 0))) {
 
                transformMask->threadSafeForceStaticImageUpdate(it->second);
            } else {
                m_d->updatesFacade->refreshGraphAsync(it->first, it->second);
            }
 
        }
    });
}

References KritaUtils::addJobBarrier(), KritaUtils::addJobConcurrent(), KisStrokeJobData::BARRIER, executeAndAddCommand(), fetchAllUpdateRequests(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisCommandUtils::FlipFlopCommand::INITIALIZING, KisLodTransformBase::lodToScale(), m_d, ToolTransformArgs::scale3dSrcAndDst(), KisTransformMask::threadSafeForceStaticImageUpdate(), Transform, TransformLod, transformNode(), and undoTransformCommands().

◆ repopulateUI()

void InplaceTransformStrokeStrategy::repopulateUI	(	QVector< KisStrokeJobData * > &	mutatedJobs,
		KisUpdatesFacade *	updatesFacade,
		const QRect &	dirtyRect )

staticprivate

Definition at line 1039 of file inplace_transform_stroke_strategy.cpp.

{
    const QVector<QRect> finalDirtyRects =
        KritaUtils::splitRectIntoPatchesTight(dirtyRect,
                                              KritaUtils::optimalPatchSize());
 
    Q_FOREACH (const QRect &rc, finalDirtyRects) {
        KritaUtils::addJobConcurrent(mutatedJobs, [rc, updatesFacade] () {
            updatesFacade->notifyUIUpdateCompleted(rc);
        });
    }
}

References KritaUtils::addJobConcurrent(), KisUpdatesFacade::notifyUIUpdateCompleted(), KritaUtils::optimalPatchSize(), and KritaUtils::splitRectIntoPatchesTight().

◆ sigConvexHullCalculated

void InplaceTransformStrokeStrategy::sigConvexHullCalculated	(	QPolygon	convexHull,
		void *	cookie )

signal

◆ sigTransactionGenerated

void InplaceTransformStrokeStrategy::sigTransactionGenerated	(	TransformTransactionProperties	transaction,
		ToolTransformArgs	args,
		void *	cookie )

signal

◆ transformNode()

void InplaceTransformStrokeStrategy::transformNode	(	KisNodeSP	node,
		const ToolTransformArgs &	config,
		int	levelOfDetail )

private

we should make sure that the asynchronous shape regeneration has completed before we issue the updates a bit later

Shape layer's projection may not be yet ready right after transformation, because it need to do that in the GUI thread, so we should approximate that.

Definition at line 764 of file inplace_transform_stroke_strategy.cpp.

{
    KisPaintDeviceSP device = node->paintDevice();
 
    CommandGroup commandGroup =
        levelOfDetail > 0 ? TransformLod : Transform;
 
    if (KisExternalLayer *extLayer =
        dynamic_cast<KisExternalLayer*>(node.data())) {
 
            if (config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
                    (config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT &&
                     extLayer->supportsPerspectiveTransform())) {
 
                if (levelOfDetail <= 0) {
                    const QRect oldDirtyRect = extLayer->projectionPlane()->tightUserVisibleBounds() | extLayer->theoreticalBoundingRect();
 
                    KisTransformWorker w = KisTransformUtils::createTransformWorker(config, 0, 0);
                    QTransform t = w.transform();
                    KUndo2Command *cmd = extLayer->transform(t);
 
                    executeAndAddCommand(cmd, Transform, KisStrokeJobData::CONCURRENT);
 
                    if (KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(extLayer)) {
                        shapeLayer->forceUpdateTimedNode();
                    }
 
                    const QRect theoreticalNewDirtyRect =
                        kisGrowRect(t.mapRect(oldDirtyRect), 1);
 
                    addDirtyRect(node,
                                 oldDirtyRect |
                                 theoreticalNewDirtyRect |
                                 extLayer->projectionPlane()->tightUserVisibleBounds() |
                                 extLayer->theoreticalBoundingRect(), 0);
                    return;
                } else {
                    device = node->projection();
                    commandGroup = TransformLodTemporary;
                }
            }
 
    } else {
        device = node->paintDevice();
    }
 
    if (device) {
        KisPaintDeviceSP cachedPortion;
 
        {
            QMutexLocker l(&m_d->devicesCacheMutex);
            cachedPortion = m_d->devicesCacheHash[device.data()];
        }
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(cachedPortion);
 
        KisTransaction transaction(device);
 
        KisProcessingVisitor::ProgressHelper helper(node);
        KisTransformUtils::transformAndMergeDevice(config, cachedPortion,
                                                   device, &helper);
 
        executeAndAddCommand(transaction.endAndTake(), commandGroup, KisStrokeJobData::CONCURRENT);
        addDirtyRect(node, cachedPortion->extent() | node->projectionPlane()->tightUserVisibleBounds(), levelOfDetail);
 
    } else if (KisTransformMask *transformMask =
               dynamic_cast<KisTransformMask*>(node.data())) {
 
        const QRect oldDirtyRect = transformMask->extent();
 
        if (levelOfDetail > 0) {
            KisPaintDeviceSP cachedPortion;
 
            {
                QMutexLocker l(&m_d->devicesCacheMutex);
                cachedPortion = m_d->transformMaskCacheHash[transformMask];
            }
 
            KIS_SAFE_ASSERT_RECOVER_RETURN(cachedPortion);
 
            KisPaintDeviceSP dst = new KisPaintDevice(cachedPortion->colorSpace());
            dst->prepareClone(cachedPortion);
 
            KisProcessingVisitor::ProgressHelper helper(node);
            KisTransformUtils::transformAndMergeDevice(config, cachedPortion,
                                                       dst, &helper);
 
            transformMask->overrideStaticCacheDevice(dst);
        }
 
        {
            KUndo2Command *cmd = new KisSimpleModifyTransformMaskCommand(transformMask,
                                                                         KisTransformMaskParamsInterfaceSP(
                                                                             new KisTransformMaskAdapter(config)),
                                                                         m_d->commandUpdatesBlockerCookie);
            executeAndAddCommand(cmd, commandGroup, KisStrokeJobData::CONCURRENT);
            addDirtyRect(node, oldDirtyRect | transformMask->extent(), levelOfDetail);
        }
 
    }
}

References addDirtyRect(), KisPaintDevice::colorSpace(), KisStrokeJobData::CONCURRENT, KisTransformUtils::createTransformWorker(), KisSharedPtr< T >::data(), KisTransaction::endAndTake(), executeAndAddCommand(), KisPaintDevice::extent(), ToolTransformArgs::FREE_TRANSFORM, KIS_SAFE_ASSERT_RECOVER_RETURN, kisGrowRect(), m_d, ToolTransformArgs::mode(), KisBaseNode::paintDevice(), ToolTransformArgs::PERSPECTIVE_4POINT, KisPaintDevice::prepareClone(), KisBaseNode::projection(), KisNode::projectionPlane(), Transform, KisTransformUtils::transformAndMergeDevice(), TransformLod, and TransformLodTemporary.

◆ tryPostUpdateJob()

void InplaceTransformStrokeStrategy::tryPostUpdateJob ( bool forceUpdate )

private

Definition at line 230 of file inplace_transform_stroke_strategy.cpp.

{
    if (!m_d->pendingUpdateArgs) return;
 
    if (forceUpdate ||
        (m_d->updateTimer.elapsed() > m_d->updateInterval &&
         !m_d->updatesFacade->hasUpdatesRunning())) {
 
        addMutatedJob(new BarrierUpdateData(forceUpdate));
    }
}

References KisStrokeStrategy::addMutatedJob(), and m_d.

◆ undoAllCommands()

void InplaceTransformStrokeStrategy::undoAllCommands ( )

private

Definition at line 713 of file inplace_transform_stroke_strategy.cpp.

{
    for (auto it = std::make_reverse_iterator(m_d->commands.end());
         it != std::make_reverse_iterator(m_d->commands.begin());
         ++it) {
 
        executeCommand(it->command, true);
    }
 
    m_d->commands.clear();
}

References KisStrokeStrategyUndoCommandBased::executeCommand(), and m_d.

◆ undoTransformCommands()

void InplaceTransformStrokeStrategy::undoTransformCommands ( int levelOfDetail )

private

Definition at line 725 of file inplace_transform_stroke_strategy.cpp.

{
    for (auto it = std::make_reverse_iterator(m_d->commands.end());
         it != std::make_reverse_iterator(m_d->commands.begin());) {
 
        if ((levelOfDetail > 0 &&
             (it->commandGroup == TransformLod || it->commandGroup == TransformLodTemporary)) ||
            (levelOfDetail <= 0 &&
             (it->commandGroup == Transform || it->commandGroup == TransformTemporary))) {
 
            executeCommand(it->command, true);
            it = std::make_reverse_iterator(m_d->commands.erase(std::next(it).base()));
        } else {
            ++it;
        }
    }
}

References KisStrokeStrategyUndoCommandBased::executeCommand(), m_d, Transform, TransformLod, TransformLodTemporary, and TransformTemporary.

Friends And Related Symbol Documentation

◆ InitializeTransformModeStrokeStrategy

friend class InitializeTransformModeStrokeStrategy

friend

Definition at line 149 of file inplace_transform_stroke_strategy.h.

Member Data Documentation

◆ m_d

const QScopedPointer<Private> InplaceTransformStrokeStrategy::m_d

private

Definition at line 180 of file inplace_transform_stroke_strategy.h.

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

plugins/tools/tool_transform2/strokes/inplace_transform_stroke_strategy.h
plugins/tools/tool_transform2/strokes/inplace_transform_stroke_strategy.cpp

Classes

Public Types

Signals

Public Member Functions

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ CommandGroup

Constructor & Destructor Documentation

◆ InplaceTransformStrokeStrategy() [1/2]

◆ ~InplaceTransformStrokeStrategy()

◆ InplaceTransformStrokeStrategy() [2/2]

Member Function Documentation

◆ addDirtyRect()

◆ calculateConvexHull()

◆ calculatePreferredLevelOfDetail()

◆ cancelAction()

◆ cancelStrokeCallback()

◆ createCacheAndClearNode()

◆ doCanvasUpdate()

◆ doStrokeCallback()

◆ executeAndAddCommand()

◆ fetchAllUpdateRequests()

◆ finalizeStrokeImpl()

◆ finishAction()

◆ finishStrokeCallback()

◆ initStrokeCallback()

◆ notifyAllCommandsDone()

◆ postProcessToplevelCommand()

◆ Q_ENUM()

◆ reapplyTransform()

◆ repopulateUI()

◆ sigConvexHullCalculated

◆ sigTransactionGenerated

◆ transformNode()

◆ tryPostUpdateJob()

◆ undoAllCommands()

◆ undoTransformCommands()

Friends And Related Symbol Documentation

◆ InitializeTransformModeStrokeStrategy

Member Data Documentation

◆ m_d