#include <transform_stroke_strategy.h>

Inheritance diagram for TransformStrokeStrategy:

Classes
class	CalculateConvexHullData

class	ClearSelectionData

class	PreparePreviewData

struct	TransformAllData

class	TransformData

Signals
void	sigConvexHullCalculated (QPolygon convexHull, void *cookie)

void	sigPreviewDeviceReady (KisPaintDeviceSP device)

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

	TransformStrokeStrategy (ToolTransformArgs::TransformMode mode, const QString &filterId, bool forceReset, KisNodeList rootNodes, KisSelectionSP selection, KisStrokeUndoFacade undoFacade, KisUpdatesFacade updatesFacade)

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

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

bool	checkBelongsToSelection (KisPaintDeviceSP device) const

void	clearSelection (KisPaintDeviceSP device)

KisPaintDeviceSP	createDeviceCache (KisPaintDeviceSP src)

KoUpdaterPtr	fetchUpdater (KisNodeSP node)

void	finishStrokeImpl (bool applyTransform, const ToolTransformArgs &args)

KisPaintDeviceSP	getDeviceCache (KisPaintDeviceSP src)

bool	haveDeviceInCache (KisPaintDeviceSP src)

void	putDeviceCache (KisPaintDeviceSP src, KisPaintDeviceSP cache)

Private Attributes
bool	m_convexHullHasBeenCalculated = false

int	m_currentTime = -1

QList< KisSelectionMaskSP >	m_deactivatedOverlaySelectionMasks

QList< KisSelectionSP >	m_deactivatedSelections

QHash< KisPaintDevice *, KisPaintDeviceSP >	m_devicesCacheHash

QMutex	m_devicesCacheMutex

QVector< KisDecoratedNodeInterface * >	m_disabledDecoratedNodes

QString	m_filterId

bool	m_finalizingActionsStarted = false

bool	m_forceReset

QList< KisNodeSP >	m_hiddenProjectionLeaves

ToolTransformArgs	m_initialTransformArgs

ToolTransformArgs::TransformMode	m_mode

const KisSavedMacroCommand *	m_overriddenCommand = 0

KisNodeList	m_processedNodes

KisNodeList	m_rootNodes

boost::optional< ToolTransformArgs >	m_savedTransformArgs

KisSelectionSP	m_selection

QVector< const KUndo2Command * >	m_skippedWhileMergeCommands

KisBatchNodeUpdateSP	m_updateData

bool	m_updatesDisabled = false

KisUpdatesFacade *	m_updatesFacade

KisTransformMaskSP	writeToTransformMask

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)

Detailed Description

Definition at line 27 of file transform_stroke_strategy.h.

Constructor & Destructor Documentation

◆ TransformStrokeStrategy()

TransformStrokeStrategy::TransformStrokeStrategy	(	ToolTransformArgs::TransformMode	mode,
		const QString &	filterId,
		bool	forceReset,
		KisNodeList	rootNodes,
		KisSelectionSP	selection,
		KisStrokeUndoFacade *	undoFacade,
		KisUpdatesFacade *	updatesFacade )

Definition at line 56 of file transform_stroke_strategy.cpp.

    : KisStrokeStrategyUndoCommandBased(kundo2_i18n("Transform"), false, undoFacade),
      m_updatesFacade(updatesFacade),
      m_mode(mode),
      m_filterId(filterId),
      m_forceReset(forceReset),
      m_selection(selection)
{
    if (selection) {
        Q_FOREACH(KisNodeSP node, rootNodes) {
            KIS_SAFE_ASSERT_RECOVER_NOOP(!dynamic_cast<KisTransformMask*>(node.data()));
        }
    }
 
    m_rootNodes = rootNodes;
    setMacroId(KisCommandUtils::TransformToolId);
}

References KisSharedPtr< T >::data(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_rootNodes, KisStrokeStrategyUndoCommandBased::setMacroId(), and KisCommandUtils::TransformToolId.

◆ ~TransformStrokeStrategy()

TransformStrokeStrategy::~TransformStrokeStrategy ( )

override

Definition at line 80 of file transform_stroke_strategy.cpp.

81{

82}

Member Function Documentation

◆ calculateConvexHull()

QPolygon TransformStrokeStrategy::calculateConvexHull ( )

private

Definition at line 448 of file transform_stroke_strategy.cpp.

{
    // Best effort attempt to calculate the convex hull, mimicking the
    // approach that computes srcRect in initStrokeCallback below
    QVector<QPoint> points;
    if (m_selection) {
        points = KisConvexHull::findConvexHull(m_selection->pixelSelection());
    } else {
        int numContributions = 0;
        Q_FOREACH (KisNodeSP node, m_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;
                if (KisExternalLayer *extLayer = dynamic_cast<KisExternalLayer*>(node.data())) {
                    device = extLayer->projection();
                } else {
                    device = node->paintDevice();
                }
                if (device) {
                    KisPaintDeviceSP toUse;
                    // Use the original device to get the cached device containing the original image data
                    if (haveDeviceInCache(device)) {
                        toUse = getDeviceCache(device);
                    } 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(), getDeviceCache(), haveDeviceInCache(), m_processedNodes, m_selection, KisBaseNode::paintDevice(), KisSelection::pixelSelection, and ppVar.

◆ cancelStrokeCallback()

void TransformStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 805 of file transform_stroke_strategy.cpp.

{
    if (m_updatesDisabled) {
        m_updatesFacade->enableDirtyRequests();
    }
 
    finishStrokeImpl(!m_initialTransformArgs.isUnchanging(), m_initialTransformArgs);
}

References KisUpdatesFacade::enableDirtyRequests(), finishStrokeImpl(), ToolTransformArgs::isUnchanging(), m_initialTransformArgs, m_updatesDisabled, and m_updatesFacade.

◆ checkBelongsToSelection()

bool TransformStrokeStrategy::checkBelongsToSelection ( KisPaintDeviceSP device ) const

private

Definition at line 125 of file transform_stroke_strategy.cpp.

{
    return m_selection &&
        (device == m_selection->pixelSelection().data() ||
         device == m_selection->projection().data());
}

References KisSharedPtr< T >::data(), m_selection, KisSelection::pixelSelection, and KisSelection::projection().

◆ clearSelection()

void TransformStrokeStrategy::clearSelection ( KisPaintDeviceSP device )

private

Definition at line 421 of file transform_stroke_strategy.cpp.

{
    KisTransaction transaction(device);
    if (m_selection) {
        device->clearSelection(m_selection);
    } else {
        device->clear();
    }
    runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::NORMAL);
}

References KisPaintDevice::clear(), KisPaintDevice::clearSelection(), KisTransaction::endAndTake(), m_selection, KisStrokeJobData::NORMAL, KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), and KisStrokeJobData::SEQUENTIAL.

◆ createDeviceCache()

KisPaintDeviceSP TransformStrokeStrategy::createDeviceCache ( KisPaintDeviceSP src )

private

Definition at line 84 of file transform_stroke_strategy.cpp.

{
    KisPaintDeviceSP cache;
 
    if (m_selection) {
        QRect srcRect = m_selection->selectedExactRect();
 
        cache = dev->createCompositionSourceDevice();
        KisPainter gc(cache);
        gc.setSelection(m_selection);
        gc.bitBlt(srcRect.topLeft(), dev, srcRect);
    } else {
        cache = dev->createCompositionSourceDevice(dev);
    }
 
    return cache;
}

References KisPainter::bitBlt(), KisPaintDevice::createCompositionSourceDevice(), m_selection, KisSelection::selectedExactRect(), and KisPainter::setSelection().

◆ doStrokeCallback()

void TransformStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overridevirtual

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.

We use usual transaction here, because we cannot calculate transformation for perspective and warp workers.

Selection masks might have an overlay enabled, we should disable that

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 132 of file transform_stroke_strategy.cpp.

{
    TransformData *td = dynamic_cast<TransformData*>(data);
    ClearSelectionData *csd = dynamic_cast<ClearSelectionData*>(data);
    PreparePreviewData *ppd = dynamic_cast<PreparePreviewData*>(data);
    TransformAllData *runAllData = dynamic_cast<TransformAllData*>(data);
    CalculateConvexHullData *cch = dynamic_cast<CalculateConvexHullData*>(data);
 
 
    if (runAllData) {
        // here we only save the passed args, actual
        // transformation will be performed during
        // finish job
        m_savedTransformArgs = runAllData->config;
    } else if (ppd) {
        KisNodeSP rootNode = m_rootNodes[0];
        KisNodeList processedNodes = m_processedNodes;
        KisPaintDeviceSP previewDevice;
 
 
        if (processedNodes.size() > 1) {
            const QRect bounds = rootNode->image()->bounds();
            const int desiredAnimTime = rootNode->image()->animationInterface()->currentTime();
 
            KisImageSP clonedImage = new KisImage(0,
                                                  bounds.width(),
                                                  bounds.height(),
                                                  rootNode->image()->colorSpace(),
                                                  "transformed_image");
 
            // BUG: 413968
            // Workaround: Group layers wouldn't properly render the right frame
            // since `clonedImage` would always have a time value of 0.
            clonedImage->animationInterface()->explicitlySetCurrentTime(desiredAnimTime);
 
            KisNodeSP cloneRoot = clonedImage->rootLayer();
 
            Q_FOREACH(KisNodeSP node, processedNodes) {
                // Masks with unselected parents can't be added.
                if (!node->inherits("KisMask")) {
                    clonedImage->addNode(node->clone().data(), cloneRoot);
                }
            }
 
            clonedImage->refreshGraphAsync();
            KisLayerUtils::refreshHiddenAreaAsync(clonedImage, cloneRoot, clonedImage->bounds());
 
            KisLayerUtils::forceAllDelayedNodesUpdate(cloneRoot);
            clonedImage->waitForDone();
 
            previewDevice = createDeviceCache(clonedImage->projection());
            previewDevice->setDefaultBounds(cloneRoot->projection()->defaultBounds());
 
            // we delete the cloned image in GUI thread to ensure
            // no signals are still pending
            makeKisDeleteLaterWrapper(clonedImage)->deleteLater();
        }
        else if (rootNode->childCount() || !rootNode->paintDevice()) {
            if (KisTransformMask* tmask =
                dynamic_cast<KisTransformMask*>(rootNode.data())) {
                previewDevice = createDeviceCache(tmask->buildPreviewDevice());
 
                KIS_SAFE_ASSERT_RECOVER(!m_selection) {
                    m_selection = 0;
                }
 
            } else if (KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(rootNode.data())) {
                const QRect bounds = group->image()->bounds();
                const int desiredAnimTime = group->image()->animationInterface()->currentTime();
 
                KisImageSP clonedImage = new KisImage(0,
                                                      bounds.width(),
                                                      bounds.height(),
                                                      group->colorSpace(),
                                                      "transformed_image");
 
                // BUG: 413968
                // Workaround: Group layers wouldn't properly render the right frame
                // since `clonedImage` would always have a time value of 0.
                clonedImage->animationInterface()->explicitlySetCurrentTime(desiredAnimTime);
 
                KisGroupLayerSP clonedGroup = dynamic_cast<KisGroupLayer*>(group->clone().data());
 
                // In case the group is pass-through, it needs to be disabled for the preview,
                //   otherwise it will crash (no parent for a preview leaf).
                // Also it needs to be done before setting the root layer for clonedImage.
                // Result: preview for pass-through group is the same as for standard group
                //   (i.e. filter layers in the group won't affect the layer stack for a moment).
                clonedGroup->setPassThroughMode(false);
                clonedImage->setRootLayer(clonedGroup);
 
                QQueue<KisNodeSP> linearizedSrcNodes;
                KisLayerUtils::recursiveApplyNodes(rootNode, [&linearizedSrcNodes] (KisNodeSP node) {
                    linearizedSrcNodes.enqueue(node);
                });
 
                KisLayerUtils::recursiveApplyNodes(KisNodeSP(clonedGroup), [&linearizedSrcNodes, processedNodes] (KisNodeSP node) {
                    KisNodeSP srcNode = linearizedSrcNodes.dequeue();
 
                    if (!processedNodes.contains(srcNode)) {
                        node->setVisible(false);
                    }
                });
 
                clonedImage->refreshGraphAsync();
                KisLayerUtils::refreshHiddenAreaAsync(clonedImage, clonedGroup, clonedImage->bounds());
 
                KisLayerUtils::forceAllDelayedNodesUpdate(clonedGroup);
                clonedImage->waitForDone();
 
                previewDevice = createDeviceCache(clonedImage->projection());
                previewDevice->setDefaultBounds(group->projection()->defaultBounds());
 
                // we delete the cloned image in GUI thread to ensure
                // no signals are still pending
                makeKisDeleteLaterWrapper(clonedImage)->deleteLater();
 
            } else {
                rootNode->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
                previewDevice = createDeviceCache(rootNode->projection());
            }
 
 
 
        } else {
            KisPaintDeviceSP cacheDevice = createDeviceCache(rootNode->paintDevice());
 
            if (dynamic_cast<KisSelectionMask*>(rootNode.data())) {
                KIS_SAFE_ASSERT_RECOVER (cacheDevice->colorSpace()->colorModelId() == GrayAColorModelID &&
                                         cacheDevice->colorSpace()->colorDepthId() == Integer8BitsColorDepthID) {
 
                    cacheDevice->convertTo(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id()));
                }
 
                previewDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
                const QRect srcRect = cacheDevice->exactBounds();
 
                KisSequentialConstIterator srcIt(cacheDevice, srcRect);
                KisSequentialIterator dstIt(previewDevice, srcRect);
 
                const int pixelSize = previewDevice->colorSpace()->pixelSize();
 
 
                KisImageConfig cfg(true);
                KoColor pixel(cfg.selectionOverlayMaskColor(), previewDevice->colorSpace());
 
                const qreal coeff = 1.0 / 255.0;
                const qreal baseOpacity = 0.5;
 
                while (srcIt.nextPixel() && dstIt.nextPixel()) {
                    qreal gray = srcIt.rawDataConst()[0];
                    qreal alpha = srcIt.rawDataConst()[1];
 
                    pixel.setOpacity(quint8(gray * alpha * baseOpacity * coeff));
                    memcpy(dstIt.rawData(), pixel.data(), pixelSize);
                }
 
            } else {
                previewDevice = cacheDevice;
            }
 
            putDeviceCache(rootNode->paintDevice(), cacheDevice);
        }
 
        Q_EMIT sigPreviewDeviceReady(previewDevice);
    }
    else if (td) {
        if (td->destination == TransformData::PAINT_DEVICE) {
            QRect oldExtent = td->node->projectionPlane()->tightUserVisibleBounds();
            KisPaintDeviceSP device = td->node->paintDevice();
 
            if (device && !checkBelongsToSelection(device)) {
                KisPaintDeviceSP cachedPortion = getDeviceCache(device);
                Q_ASSERT(cachedPortion);
 
                KisTransaction transaction(device);
 
                KisProcessingVisitor::ProgressHelper helper(td->node);
                KisTransformUtils::transformAndMergeDevice(td->config, cachedPortion,
                                                           device, &helper);
 
                runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                                  KisStrokeJobData::CONCURRENT,
                                  KisStrokeJobData::NORMAL);
 
                m_updateData->addUpdate(td->node, cachedPortion->extent() | oldExtent | td->node->projectionPlane()->tightUserVisibleBounds());
            } else if (KisExternalLayer *extLayer =
                  dynamic_cast<KisExternalLayer*>(td->node.data())) {
 
                if (td->config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
                    (td->config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT &&
                     extLayer->supportsPerspectiveTransform())) {
 
                    QRect oldDirtyRect = oldExtent | extLayer->theoreticalBoundingRect();
 
                    KisTransformWorker w = KisTransformUtils::createTransformWorker(td->config, 0, 0);
                    QTransform t = w.transform();
 
                    runAndSaveCommand(KUndo2CommandSP(extLayer->transform(t)),
                                      KisStrokeJobData::CONCURRENT,
                                      KisStrokeJobData::NORMAL);
 
                    const QRect theoreticalNewDirtyRect =
                        kisGrowRect(t.mapRect(oldDirtyRect), 1);
 
                    m_updateData->addUpdate(td->node, oldDirtyRect | td->node->projectionPlane()->tightUserVisibleBounds() | extLayer->theoreticalBoundingRect() | theoreticalNewDirtyRect);
                }
 
            } else if (KisTransformMask *transformMask =
                       dynamic_cast<KisTransformMask*>(td->node.data())) {
 
                runAndSaveCommand(KUndo2CommandSP(
                                      new KisSimpleModifyTransformMaskCommand(transformMask,
                                                                              KisTransformMaskParamsInterfaceSP(
                                                                                  new KisTransformMaskAdapter(td->config)))),
                                  KisStrokeJobData::CONCURRENT,
                                  KisStrokeJobData::NORMAL);
 
                m_updateData->addUpdate(td->node, oldExtent | td->node->extent());
            }
        } else if (m_selection) {
 
            KisTransaction transaction(m_selection->pixelSelection());
 
            KisProcessingVisitor::ProgressHelper helper(td->node);
            KisTransformUtils::transformDevice(td->config,
                                               m_selection->pixelSelection(),
                                               &helper);
 
            runAndSaveCommand(KUndo2CommandSP(transaction.endAndTake()),
                              KisStrokeJobData::CONCURRENT,
                              KisStrokeJobData::NORMAL);
        }
    } else if (csd) {
        KisPaintDeviceSP device = csd->node->paintDevice();
 
        if (device && !checkBelongsToSelection(device)) {
            if (!haveDeviceInCache(device)) {
                putDeviceCache(device, createDeviceCache(device));
            }
            clearSelection(device);
 
            if (KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(csd->node.data())) {
                KisSelectionSP selection = mask->selection();
                if (selection) {
                    selection->setVisible(false);
                    m_deactivatedSelections.append(selection);
                }
            }
        } else if (KisExternalLayer *externalLayer = dynamic_cast<KisExternalLayer*>(csd->node.data())) {
            externalLayer->projectionLeaf()->setTemporaryHiddenFromRendering(true);
            m_hiddenProjectionLeaves.append(csd->node);
        } else if (KisTransformMask *transformMask =
                   dynamic_cast<KisTransformMask*>(csd->node.data())) {
 
            KisTransformMaskParamsInterfaceSP params = transformMask->transformParams();
            params->setHidden(true);
 
            runAndSaveCommand(KUndo2CommandSP(
                                  new KisSimpleModifyTransformMaskCommand(transformMask,
                                                                          params)),
                                  KisStrokeJobData::SEQUENTIAL,
                                  KisStrokeJobData::NORMAL);
        }
    } else if (cch) {
        if (!m_convexHullHasBeenCalculated) {
            m_convexHullHasBeenCalculated = true;
            QPolygon hull = calculateConvexHull();
            if (!hull.isEmpty()) {
                Q_EMIT sigConvexHullCalculated(hull, this);
            }
        }
    } else {
        KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
    }
}

References KisNodeFacade::addNode(), KisImage::animationInterface(), KisImage::bounds(), bounds, calculateConvexHull(), checkBelongsToSelection(), KisNode::childCount(), clearSelection(), KisNode::clone(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisImage::colorSpace(), KisPaintDevice::colorSpace(), KisStrokeJobData::CONCURRENT, TransformStrokeStrategy::TransformAllData::config, TransformStrokeStrategy::TransformData::config, KisPaintDevice::convertTo(), createDeviceCache(), KisTransformUtils::createTransformWorker(), KisImageAnimationInterface::currentTime(), KisSharedPtr< T >::data(), KoColor::data(), KisPaintDevice::defaultBounds(), TransformStrokeStrategy::TransformData::destination, KisStrokeStrategyUndoCommandBased::doStrokeCallback(), KisTransaction::endAndTake(), KisPaintDevice::exactBounds(), KisImageAnimationInterface::explicitlySetCurrentTime(), KisBaseNode::extent(), KisPaintDevice::extent(), KisLayerUtils::forceAllDelayedNodesUpdate(), ToolTransformArgs::FREE_TRANSFORM, getDeviceCache(), GrayAColorModelID, haveDeviceInCache(), KoID::id(), KisBaseNode::image, KoColorSpaceRegistry::instance(), Integer8BitsColorDepthID, KIS_SAFE_ASSERT_RECOVER, kisGrowRect(), m_convexHullHasBeenCalculated, m_deactivatedSelections, m_hiddenProjectionLeaves, m_processedNodes, m_rootNodes, m_savedTransformArgs, m_selection, m_updateData, makeKisDeleteLaterWrapper(), ToolTransformArgs::mode(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), TransformStrokeStrategy::TransformData::node, TransformStrokeStrategy::ClearSelectionData::node, KisStrokeJobData::NORMAL, TransformStrokeStrategy::TransformData::PAINT_DEVICE, KisBaseNode::paintDevice(), ToolTransformArgs::PERSPECTIVE_4POINT, KisSelection::pixelSelection, KoColorSpace::pixelSize(), KisImage::projection(), KisBaseNode::projection(), KisNode::projectionLeaf, KisNode::projectionPlane(), putDeviceCache(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst(), KisLayerUtils::recursiveApplyNodes(), KisImage::refreshGraphAsync(), KisLayerUtils::refreshHiddenAreaAsync(), KisImage::rootLayer(), KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisImageConfig::selectionOverlayMaskColor(), KisStrokeJobData::SEQUENTIAL, KisPaintDevice::setDefaultBounds(), KoColor::setOpacity(), KisGroupLayer::setPassThroughMode(), KisImage::setRootLayer(), KisSelection::setVisible(), sigConvexHullCalculated(), sigPreviewDeviceReady(), KisTransformUtils::transformAndMergeDevice(), KisTransformUtils::transformDevice(), and KisImage::waitForDone().

◆ fetchUpdater()

KoUpdaterPtr TransformStrokeStrategy::fetchUpdater ( KisNodeSP node )

private

◆ finishStrokeCallback()

void TransformStrokeStrategy::finishStrokeCallback ( )

overridevirtual

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 795 of file transform_stroke_strategy.cpp.

{
    if (!m_savedTransformArgs || m_savedTransformArgs->isUnchanging()) {
        cancelStrokeCallback();
        return;
    }
 
    finishStrokeImpl(true, *m_savedTransformArgs);
}

References cancelStrokeCallback(), finishStrokeImpl(), and m_savedTransformArgs.

◆ finishStrokeImpl()

void TransformStrokeStrategy::finishStrokeImpl	(	bool	applyTransform,
		const ToolTransformArgs &	args )

private

Since our finishStrokeCallback() initiates new jobs, cancellation request may come even after finishStrokeCallback() (cancellations may be called until there are no jobs left in the stroke's queue).

Therefore we should check for double-entry here and make sure the finalizing jobs are no cancellable.

Definition at line 710 of file transform_stroke_strategy.cpp.

{
    if (m_finalizingActionsStarted) return;
    m_finalizingActionsStarted = true;
 
    QVector<KisStrokeJobData *> mutatedJobs;
 
    auto restoreTemporaryHiddenNodes = [this] () {
        Q_FOREACH (KisNodeSP node, m_hiddenProjectionLeaves) {
            node->projectionLeaf()->setTemporaryHiddenFromRendering(false);
            if (KisDelayedUpdateNodeInterface *delayedNode = dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data())) {
                delayedNode->forceUpdateTimedNode();
            } else {
                node->setDirty();
            }
        }
    };
 
    if (applyTransform) {
        m_savedTransformArgs = args;
 
        m_updateData.reset(new KisBatchNodeUpdate());
 
        KritaUtils::addJobBarrier(mutatedJobs, [this] () {
            runAndSaveCommand(toQShared(new KisUpdateCommandEx(m_updateData, m_updatesFacade, KisUpdateCommandEx::INITIALIZING)), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
            m_updatesDisabled = true;
            m_updatesFacade->disableDirtyRequests();
        });
 
        Q_FOREACH (KisNodeSP node, m_processedNodes) {
            mutatedJobs << new TransformData(TransformData::PAINT_DEVICE,
                                             args,
                                             node);
        }
        mutatedJobs << new TransformData(TransformData::SELECTION,
                                         args,
                                         m_rootNodes[0]);
 
        KritaUtils::addJobBarrier(mutatedJobs, restoreTemporaryHiddenNodes);
 
        KritaUtils::addJobBarrier(mutatedJobs, [this] () {
            m_updatesFacade->enableDirtyRequests();
            m_updatesDisabled = false;
 
            m_updateData->compress();
            runAndSaveCommand(toQShared(new KisUpdateCommandEx(m_updateData, m_updatesFacade, KisUpdateCommandEx::FINALIZING)), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
        });
    } else {
        KritaUtils::addJobBarrier(mutatedJobs, restoreTemporaryHiddenNodes);
    }
 
    KritaUtils::addJobBarrier(mutatedJobs, [this, applyTransform]() {
        Q_FOREACH (KisSelectionSP selection, m_deactivatedSelections) {
            selection->setVisible(true);
        }
 
        Q_FOREACH(KisSelectionMaskSP deactivatedOverlaySelectionMask, m_deactivatedOverlaySelectionMasks) {
            deactivatedOverlaySelectionMask->selection()->setVisible(true);
            deactivatedOverlaySelectionMask->setDirty();
        }
 
        if (applyTransform) {
            KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
        } else {
            KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
        }
    });
 
    for (auto it = mutatedJobs.begin(); it != mutatedJobs.end(); ++it) {
        (*it)->setCancellable(false);
    }
 
    addMutatedJobs(mutatedJobs);
}

References KritaUtils::addJobBarrier(), KisStrokeStrategy::addMutatedJobs(), KisStrokeJobData::BARRIER, KisStrokeStrategyUndoCommandBased::cancelStrokeCallback(), KisSharedPtr< T >::data(), KisUpdatesFacade::disableDirtyRequests(), KisUpdatesFacade::enableDirtyRequests(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisStrokeStrategyUndoCommandBased::finishStrokeCallback(), KisCommandUtils::FlipFlopCommand::INITIALIZING, m_deactivatedOverlaySelectionMasks, m_deactivatedSelections, m_finalizingActionsStarted, m_hiddenProjectionLeaves, m_processedNodes, m_rootNodes, m_savedTransformArgs, m_updateData, m_updatesDisabled, m_updatesFacade, KisStrokeJobData::NORMAL, TransformStrokeStrategy::TransformData::PAINT_DEVICE, KisNode::projectionLeaf, KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisMask::selection, TransformStrokeStrategy::TransformData::SELECTION, KisNode::setDirty(), KisSelectionMask::setDirty(), KisSelection::setVisible(), and toQShared().

◆ getDeviceCache()

KisPaintDeviceSP TransformStrokeStrategy::getDeviceCache ( KisPaintDeviceSP src )

private

Definition at line 114 of file transform_stroke_strategy.cpp.

{
    QMutexLocker l(&m_devicesCacheMutex);
    KisPaintDeviceSP cache = m_devicesCacheHash.value(src.data());
    if (!cache) {
        warnKrita << "WARNING: Transform Stroke: the device is absent in cache!";
    }
 
    return cache;
}

References m_devicesCacheHash, m_devicesCacheMutex, and warnKrita.

◆ haveDeviceInCache()

bool TransformStrokeStrategy::haveDeviceInCache ( KisPaintDeviceSP src )

private

Definition at line 102 of file transform_stroke_strategy.cpp.

{
    QMutexLocker l(&m_devicesCacheMutex);
    return m_devicesCacheHash.contains(src.data());
}

References m_devicesCacheHash, and m_devicesCacheMutex.

◆ initStrokeCallback()

void TransformStrokeStrategy::initStrokeCallback ( )

overridevirtual

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 KisStrokeStrategyUndoCommandBased.

Definition at line 508 of file transform_stroke_strategy.cpp.

{
    KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
    m_currentTime = KisTransformUtils::fetchCurrentImageTime(m_rootNodes);
 
    if (m_selection) {
        m_selection->setVisible(false);
        m_deactivatedSelections.append(m_selection);
    }
 
    Q_FOREACH(KisNodeSP node, m_rootNodes) {
        KisSelectionMaskSP overlaySelectionMask =
                dynamic_cast<KisSelectionMask*>(node->graphListener()->graphOverlayNode());
        if (overlaySelectionMask) {
            overlaySelectionMask->setDecorationsVisible(false);
            m_deactivatedOverlaySelectionMasks.append(overlaySelectionMask);
        }
    }
 
    if (m_rootNodes.size() == 1){
        KisNodeSP rootNode = m_rootNodes[0];
        rootNode = KisTransformUtils::tryOverrideRootToTransformMask(rootNode);
 
        if (rootNode->inherits("KisTransformMask") && rootNode->projectionLeaf()->isDroppedNode()) {
            rootNode.clear();
            m_processedNodes.clear();
 
            TransformTransactionProperties transaction(QRect(), &m_initialTransformArgs, m_rootNodes, m_processedNodes);
            Q_EMIT sigTransactionGenerated(transaction, m_initialTransformArgs, this);
            return;
        }
    }
 
    ToolTransformArgs initialTransformArgs;
    bool isExternalSourcePresent = false;
    m_processedNodes = KisTransformUtils::fetchNodesList(m_mode, m_rootNodes, isExternalSourcePresent, m_selection);
 
    bool argsAreInitialized = false;
    QVector<KisStrokeJobData *> lastCommandUndoJobs;
 
    if (!m_forceReset && KisTransformUtils::tryFetchArgsFromCommandAndUndo(&initialTransformArgs,
                                                                           m_mode,
                                                                           m_rootNodes,
                                                                           m_processedNodes,
                                                                           undoFacade(),
                                                                           m_currentTime,
                                                                           &lastCommandUndoJobs,
                                                                           &m_overriddenCommand)) {
        argsAreInitialized = true;
    } else if (!m_forceReset && KisTransformUtils::tryInitArgsFromNode(m_rootNodes, &initialTransformArgs)) {
        argsAreInitialized = true;
    }
 
    QVector<KisStrokeJobData *> extraInitJobs;
 
    extraInitJobs << new Data(new KisHoldUIUpdatesCommand(m_updatesFacade, KisCommandUtils::FlipFlopCommand::INITIALIZING), false, KisStrokeJobData::BARRIER);
 
    extraInitJobs << lastCommandUndoJobs;
 
    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_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_rootNodes) {
            KisLayerUtils::forceAllHiddenOriginalsUpdate(node);
        }
    });
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        Q_FOREACH(KisNodeSP node, m_rootNodes) {
            KisLayerUtils::forceAllDelayedNodesUpdate(node);
        }
    });
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        Q_FOREACH (KisNodeSP node, m_processedNodes) {
            KisDecoratedNodeInterface *decoratedNode = dynamic_cast<KisDecoratedNodeInterface*>(node.data());
            if (decoratedNode && decoratedNode->decorationsVisible()) {
                decoratedNode->setDecorationsVisible(false);
                m_disabledDecoratedNodes << decoratedNode;
            }
        }
    });
 
    KritaUtils::addJobBarrier(extraInitJobs, [this, initialTransformArgs, argsAreInitialized]() mutable {
        QRect srcRect;
 
        if (m_selection) {
            srcRect = m_selection->selectedExactRect();
        } else {
            srcRect = QRect();
            Q_FOREACH (KisNodeSP node, m_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, &initialTransformArgs, m_rootNodes, m_processedNodes);
        if (!argsAreInitialized) {
            initialTransformArgs = KisTransformUtils::resetArgsForMode(m_mode, m_filterId, transaction, 0);
        }
 
        this->m_initialTransformArgs = initialTransformArgs;
        if (transaction.currentConfig()->boundsRotation() != 0.0) {
            this->m_convexHullHasBeenCalculated = true;
            transaction.setConvexHull(calculateConvexHull());
            transaction.setConvexHullHasBeenRequested(true);
        }
        Q_EMIT this->sigTransactionGenerated(transaction, initialTransformArgs, this);
    });
 
    extraInitJobs << new PreparePreviewData();
 
    KisBatchNodeUpdateSP sharedData(new KisBatchNodeUpdate());
 
    KritaUtils::addJobBarrier(extraInitJobs, [this, sharedData]() {
        KisNodeList filteredRoots = KisLayerUtils::sortAndFilterMergeableInternalNodes(m_processedNodes, true);
        Q_FOREACH (KisNodeSP root, filteredRoots) {
            sharedData->addUpdate(root, root->projectionPlane()->tightUserVisibleBounds());
        }
    });
 
    extraInitJobs << new Data(new KisUpdateCommandEx(sharedData, m_updatesFacade, KisUpdateCommandEx::INITIALIZING), false, Data::BARRIER);
 
    Q_FOREACH (KisNodeSP node, m_processedNodes) {
        extraInitJobs << new ClearSelectionData(node);
    }
 
    extraInitJobs << new Data(new KisUpdateCommandEx(sharedData, m_updatesFacade, KisUpdateCommandEx::FINALIZING), false, Data::BARRIER);
 
    KritaUtils::addJobBarrier(extraInitJobs, [this]() {
        Q_FOREACH (KisDecoratedNodeInterface *decoratedNode, m_disabledDecoratedNodes) {
            decoratedNode->setDecorationsVisible(true);
        }
        m_disabledDecoratedNodes.clear();
    });
 
    extraInitJobs << new Data(toQShared(new KisHoldUIUpdatesCommand(m_updatesFacade, KisCommandUtils::FlipFlopCommand::FINALIZING)), false, KisStrokeJobData::BARRIER);
 
    if (!lastCommandUndoJobs.isEmpty()) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_overriddenCommand);
 
        for (auto it = extraInitJobs.begin(); it != extraInitJobs.end(); ++it) {
            (*it)->setCancellable(false);
        }
    }
 
    addMutatedJobs(extraInitJobs);
}

References KisAutoKey::activeMode(), KritaUtils::addJobBarrier(), KritaUtils::addJobSequential(), KisStrokeStrategy::addMutatedJobs(), KisStrokeJobData::BARRIER, ToolTransformArgs::boundsRotation(), calculateConvexHull(), KisSharedPtr< T >::clear(), TransformTransactionProperties::currentConfig(), KisSharedPtr< T >::data(), KisDecoratedNodeInterface::decorationsVisible(), KisBaseNode::exactBounds(), KisPaintDevice::exactBounds(), 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_convexHullHasBeenCalculated, m_currentTime, m_deactivatedOverlaySelectionMasks, m_deactivatedSelections, m_disabledDecoratedNodes, m_filterId, m_forceReset, m_initialTransformArgs, m_mode, m_overriddenCommand, m_processedNodes, m_rootNodes, m_selection, m_updatesFacade, KisLazyCreateTransformMaskKeyframesCommand::maskHasAnimation(), KisAutoKey::NONE, KisStrokeJobData::NORMAL, KisBaseNode::paintDevice(), KisNode::projectionLeaf, KisNode::projectionPlane(), KisTransformUtils::resetArgsForMode(), KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisSelection::selectedExactRect(), TransformTransactionProperties::setConvexHull(), TransformTransactionProperties::setConvexHullHasBeenRequested(), KisSelectionMask::setDecorationsVisible(), KisDecoratedNodeInterface::setDecorationsVisible(), KisSelection::setVisible(), sigTransactionGenerated(), KisLayerUtils::sortAndFilterMergeableInternalNodes(), KisAutoKey::SupportsLod, toQShared(), KisAutoKey::tryAutoCreateDuplicatedFrame(), KisTransformUtils::tryFetchArgsFromCommandAndUndo(), KisTransformUtils::tryInitArgsFromNode(), KisTransformUtils::tryOverrideRootToTransformMask(), and KisStrokeStrategyUndoCommandBased::undoFacade().

◆ postProcessToplevelCommand()

void TransformStrokeStrategy::postProcessToplevelCommand ( KUndo2Command * command )

overrideprotectedvirtual

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

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 434 of file transform_stroke_strategy.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_savedTransformArgs);
 
    KisTransformUtils::postProcessToplevelCommand(command,
                                                  *m_savedTransformArgs,
                                                  m_rootNodes,
                                                  m_processedNodes,
                                                  m_currentTime,
                                                  m_overriddenCommand);
 
    KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(command);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_currentTime, m_overriddenCommand, m_processedNodes, m_rootNodes, m_savedTransformArgs, KisStrokeStrategyUndoCommandBased::postProcessToplevelCommand(), and KisTransformUtils::postProcessToplevelCommand().

◆ putDeviceCache()

void TransformStrokeStrategy::putDeviceCache	(	KisPaintDeviceSP	src,
		KisPaintDeviceSP	cache )

private

Definition at line 108 of file transform_stroke_strategy.cpp.

{
    QMutexLocker l(&m_devicesCacheMutex);
    m_devicesCacheHash.insert(src.data(), cache);
}

References m_devicesCacheHash, and m_devicesCacheMutex.

◆ sigConvexHullCalculated

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

signal

◆ sigPreviewDeviceReady

void TransformStrokeStrategy::sigPreviewDeviceReady ( KisPaintDeviceSP device )

signal

◆ sigTransactionGenerated

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

signal

Member Data Documentation

◆ m_convexHullHasBeenCalculated

bool TransformStrokeStrategy::m_convexHullHasBeenCalculated = false

private

Definition at line 156 of file transform_stroke_strategy.h.

◆ m_currentTime

int TransformStrokeStrategy::m_currentTime = -1

private

Definition at line 146 of file transform_stroke_strategy.h.

◆ m_deactivatedOverlaySelectionMasks

QList<KisSelectionMaskSP> TransformStrokeStrategy::m_deactivatedOverlaySelectionMasks

private

Definition at line 149 of file transform_stroke_strategy.h.

◆ m_deactivatedSelections

QList<KisSelectionSP> TransformStrokeStrategy::m_deactivatedSelections

private

Definition at line 147 of file transform_stroke_strategy.h.

◆ m_devicesCacheHash

QHash<KisPaintDevice*, KisPaintDeviceSP> TransformStrokeStrategy::m_devicesCacheHash

private

Definition at line 138 of file transform_stroke_strategy.h.

◆ m_devicesCacheMutex

QMutex TransformStrokeStrategy::m_devicesCacheMutex

private

Definition at line 137 of file transform_stroke_strategy.h.

◆ m_disabledDecoratedNodes

QVector<KisDecoratedNodeInterface*> TransformStrokeStrategy::m_disabledDecoratedNodes

private

Definition at line 150 of file transform_stroke_strategy.h.

◆ m_filterId

QString TransformStrokeStrategy::m_filterId

private

Definition at line 132 of file transform_stroke_strategy.h.

◆ m_finalizingActionsStarted

bool TransformStrokeStrategy::m_finalizingActionsStarted = false

private

Definition at line 155 of file transform_stroke_strategy.h.

◆ m_forceReset

bool TransformStrokeStrategy::m_forceReset

private

Definition at line 133 of file transform_stroke_strategy.h.

◆ m_hiddenProjectionLeaves

QList<KisNodeSP> TransformStrokeStrategy::m_hiddenProjectionLeaves

private

Definition at line 148 of file transform_stroke_strategy.h.

◆ m_initialTransformArgs

ToolTransformArgs TransformStrokeStrategy::m_initialTransformArgs

private

Definition at line 142 of file transform_stroke_strategy.h.

◆ m_mode

ToolTransformArgs::TransformMode TransformStrokeStrategy::m_mode

private

Definition at line 131 of file transform_stroke_strategy.h.

◆ m_overriddenCommand

const KisSavedMacroCommand* TransformStrokeStrategy::m_overriddenCommand = 0

private

Definition at line 152 of file transform_stroke_strategy.h.

◆ m_processedNodes

KisNodeList TransformStrokeStrategy::m_processedNodes

private

Definition at line 145 of file transform_stroke_strategy.h.

◆ m_rootNodes

KisNodeList TransformStrokeStrategy::m_rootNodes

private

Definition at line 144 of file transform_stroke_strategy.h.

◆ m_savedTransformArgs

boost::optional<ToolTransformArgs> TransformStrokeStrategy::m_savedTransformArgs

private

Definition at line 143 of file transform_stroke_strategy.h.

◆ m_selection

KisSelectionSP TransformStrokeStrategy::m_selection

private

Definition at line 135 of file transform_stroke_strategy.h.

◆ m_skippedWhileMergeCommands

QVector<const KUndo2Command*> TransformStrokeStrategy::m_skippedWhileMergeCommands

private

Definition at line 153 of file transform_stroke_strategy.h.

◆ m_updateData

KisBatchNodeUpdateSP TransformStrokeStrategy::m_updateData

private

Definition at line 129 of file transform_stroke_strategy.h.

◆ m_updatesDisabled

bool TransformStrokeStrategy::m_updatesDisabled = false

private

Definition at line 130 of file transform_stroke_strategy.h.

◆ m_updatesFacade

KisUpdatesFacade* TransformStrokeStrategy::m_updatesFacade

private

Definition at line 128 of file transform_stroke_strategy.h.

◆ writeToTransformMask

KisTransformMaskSP TransformStrokeStrategy::writeToTransformMask

private

Definition at line 140 of file transform_stroke_strategy.h.

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

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

Classes

Signals

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TransformStrokeStrategy()

◆ ~TransformStrokeStrategy()

Member Function Documentation

◆ calculateConvexHull()

◆ cancelStrokeCallback()

◆ checkBelongsToSelection()

◆ clearSelection()

◆ createDeviceCache()

◆ doStrokeCallback()

◆ fetchUpdater()

◆ finishStrokeCallback()

◆ finishStrokeImpl()

◆ getDeviceCache()

◆ haveDeviceInCache()

◆ initStrokeCallback()

◆ postProcessToplevelCommand()

◆ putDeviceCache()

◆ sigConvexHullCalculated

◆ sigPreviewDeviceReady

◆ sigTransactionGenerated

Member Data Documentation

◆ m_convexHullHasBeenCalculated

◆ m_currentTime

◆ m_deactivatedOverlaySelectionMasks

◆ m_deactivatedSelections

◆ m_devicesCacheHash

◆ m_devicesCacheMutex

◆ m_disabledDecoratedNodes

◆ m_filterId

◆ m_finalizingActionsStarted

◆ m_forceReset

◆ m_hiddenProjectionLeaves

◆ m_initialTransformArgs

◆ m_mode

◆ m_overriddenCommand

◆ m_processedNodes

◆ m_rootNodes

◆ m_savedTransformArgs

◆ m_selection

◆ m_skippedWhileMergeCommands

◆ m_updateData

◆ m_updatesDisabled

◆ m_updatesFacade

◆ writeToTransformMask