#include <move_selection_stroke_strategy.h>

Inheritance diagram for MoveSelectionStrokeStrategy:

Classes
struct	ShowSelectionData

Signals
void	sigHandlesRectCalculated (const QRect &handlesRect)

void	sigStrokeStartedEmpty ()

Public Member Functions
void	cancelStrokeCallback () override

void	doStrokeCallback (KisStrokeJobData *data) override

void	finishStrokeCallback () override

void	initStrokeCallback () override

	MoveSelectionStrokeStrategy (KisPaintLayerSP paintLayer, KisSelectionSP selection, KisUpdatesFacade updatesFacade, KisStrokeUndoFacade undoFacade)

Public Member Functions inherited from KisStrokeStrategyUndoCommandBased
	KisStrokeStrategyUndoCommandBased (const KUndo2MagicString &name, bool undo, KisStrokeUndoFacade *undoFacade, KUndo2CommandSP initCommand=KUndo2CommandSP(0), KUndo2CommandSP finishCommand=KUndo2CommandSP(0))

void	setCommandExtraData (KUndo2CommandExtraData *data)

void	setMacroId (int value)

void	setSupportsWrapAroundMode (bool value)

void	setUsedWhileUndoRedo (bool value)

Public Member Functions inherited from KisRunnableBasedStrokeStrategy
	KisRunnableBasedStrokeStrategy (const KisRunnableBasedStrokeStrategy &rhs)

	KisRunnableBasedStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

KisRunnableStrokeJobsInterface *	runnableJobsInterface () const

	~KisRunnableBasedStrokeStrategy ()

Public Member Functions inherited from KisSimpleStrokeStrategy
KisStrokeJobData *	createCancelData () override

KisStrokeJobStrategy *	createCancelStrategy () override

KisStrokeJobStrategy *	createDabStrategy () override

KisStrokeJobData *	createFinishData () override

KisStrokeJobStrategy *	createFinishStrategy () override

KisStrokeJobData *	createInitData () override

KisStrokeJobStrategy *	createInitStrategy () override

KisStrokeJobData *	createResumeData () override

KisStrokeJobStrategy *	createResumeStrategy () override

KisStrokeJobData *	createSuspendData () override

KisStrokeJobStrategy *	createSuspendStrategy () override

	KisSimpleStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

virtual void	resumeStrokeCallback ()

virtual void	suspendStrokeCallback ()

Public Member Functions inherited from KisStrokeStrategy
qreal	balancingRatioOverride () const

bool	canForgetAboutMe () const

bool	clearsRedoOnStart () const

KisLodPreferences	currentLodPreferences () const

bool	forceLodModeIfPossible () const

QString	id () const

bool	isAsynchronouslyCancellable () const

bool	isExclusive () const

	KisStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

KUndo2MagicString	name () const

bool	needsExplicitCancel () const

virtual void	notifyUserEndedStroke ()

virtual void	notifyUserStartedStroke ()

bool	requestsOtherStrokesToEnd () const

void	setForceLodModeIfPossible (bool forceLodModeIfPossible)

void	setMutatedJobsInterface (KisStrokesQueueMutatedJobInterface *mutatedJobsInterface, KisStrokeId strokeId)

bool	supportsWrapAroundMode () const

virtual void	tryCancelCurrentStrokeJobAsync ()
	tryCancelCurrentStrokeJobAsync is called by the strokes queue when the stroke is being cancelled. The stroke strategy may or may not handle this request and cancel the currently running long action.

virtual	~KisStrokeStrategy ()

Private Member Functions
KisStrokeStrategy *	createLodClone (int levelOfDetail) override

	MoveSelectionStrokeStrategy (const MoveSelectionStrokeStrategy &rhs)

Private Attributes
QPoint	m_finalOffset

QPoint	m_initialDeviceOffset

QPoint	m_initialSelectionOffset

KisPaintLayerSP	m_paintLayer

KisSelectionSP	m_selection

KisUpdatesFacade *	m_updatesFacade

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

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

Protected Member Functions inherited from KisStrokeStrategyUndoCommandBased
void	cancelStrokeCallbackImpl (QVector< KisStrokeJobData * > &mutatedJobs)

void	executeCommand (KUndo2CommandSP command, bool undo)

	KisStrokeStrategyUndoCommandBased (const KisStrokeStrategyUndoCommandBased &rhs)

void	notifyCommandDone (KUndo2CommandSP command, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)

virtual void	postProcessToplevelCommand (KUndo2Command *command)
	Applies some modifications (e.g. assigning extra data) to the toplevel command.

void	runAndSaveCommand (KUndo2CommandSP command, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)

KisStrokeUndoFacade *	undoFacade () const

Protected Member Functions inherited from KisSimpleStrokeStrategy
void	enableJob (JobType type, bool enable=true, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)

	KisSimpleStrokeStrategy (const KisSimpleStrokeStrategy &rhs)

Protected Member Functions inherited from KisStrokeStrategy
void	addMutatedJob (KisStrokeJobData *data)

void	addMutatedJobs (const QVector< KisStrokeJobData * > list)

	KisStrokeStrategy (const KisStrokeStrategy &rhs)

void	setAsynchronouslyCancellable (bool value)

void	setBalancingRatioOverride (qreal value)

void	setCanForgetAboutMe (bool value)

void	setClearsRedoOnStart (bool value)

void	setExclusive (bool value)

void	setNeedsExplicitCancel (bool value)

void	setRequestsOtherStrokesToEnd (bool value)

void	setSupportsWrapAroundMode (bool value)

Detailed Description

Definition at line 19 of file move_selection_stroke_strategy.h.

Constructor & Destructor Documentation

◆ MoveSelectionStrokeStrategy() [1/2]

MoveSelectionStrokeStrategy::MoveSelectionStrokeStrategy	(	KisPaintLayerSP	paintLayer,
		KisSelectionSP	selection,
		KisUpdatesFacade *	updatesFacade,
		KisStrokeUndoFacade *	undoFacade )

Selection might have some update projection jobs pending, so we should ensure all of them are completed before we start our stroke.

Definition at line 25 of file move_selection_stroke_strategy.cpp.

    : KisStrokeStrategyUndoCommandBased(kundo2_i18n("Move Selection"), false, undoFacade),
      m_paintLayer(paintLayer),
      m_selection(selection),
      m_updatesFacade(updatesFacade)
{
    enableJob(KisSimpleStrokeStrategy::JOB_INIT, true, KisStrokeJobData::BARRIER);
    enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
    enableJob(KisSimpleStrokeStrategy::JOB_CANCEL);
}

References KisStrokeJobData::BARRIER, KisSimpleStrokeStrategy::enableJob(), KisSimpleStrokeStrategy::JOB_CANCEL, KisSimpleStrokeStrategy::JOB_FINISH, and KisSimpleStrokeStrategy::JOB_INIT.

◆ MoveSelectionStrokeStrategy() [2/2]

MoveSelectionStrokeStrategy::MoveSelectionStrokeStrategy ( const MoveSelectionStrokeStrategy & rhs )

private

Definition at line 43 of file move_selection_stroke_strategy.cpp.

    : QObject(),
      KisStrokeStrategyUndoCommandBased(rhs),
      m_paintLayer(rhs.m_paintLayer),
      m_selection(rhs.m_selection),
      m_updatesFacade(rhs.m_updatesFacade)
{
}

Member Function Documentation

◆ cancelStrokeCallback()

void MoveSelectionStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 138 of file move_selection_stroke_strategy.cpp.

{
    KisIndirectPaintingSupport *indirect =
        static_cast<KisIndirectPaintingSupport*>(m_paintLayer.data());
 
    if (indirect) {
        KisPaintDeviceSP t = indirect->temporaryTarget();
        if (t) {
            KisRegion dirtyRegion = t->region();
 
            indirect->setTemporaryTarget(0);
 
            m_paintLayer->setDirty(dirtyRegion);
 
            m_selection->setX(m_initialSelectionOffset.x());
            m_selection->setY(m_initialSelectionOffset.y());
            m_selection->setVisible(true);
            m_selection->notifySelectionChanged();
        }
    }
    KisStrokeStrategyUndoCommandBased::cancelStrokeCallback();
}

References KisStrokeStrategyUndoCommandBased::cancelStrokeCallback(), KisSharedPtr< T >::data(), m_initialSelectionOffset, m_paintLayer, m_selection, KisSelection::notifySelectionChanged(), KisPaintDevice::region(), KisNode::setDirty(), KisIndirectPaintingSupport::setTemporaryTarget(), KisSelection::setVisible(), KisSelection::setX(), KisSelection::setY(), and KisIndirectPaintingSupport::temporaryTarget.

◆ createLodClone()

KisStrokeStrategy * MoveSelectionStrokeStrategy::createLodClone ( int levelOfDetail )

overrideprivatevirtual

Reimplemented from KisStrokeStrategy.

Definition at line 201 of file move_selection_stroke_strategy.cpp.

{
    Q_UNUSED(levelOfDetail);
 
    // Vector selections don't support lod-moves
    if (m_selection->hasShapeSelection()) return 0;
 
    MoveSelectionStrokeStrategy *clone = new MoveSelectionStrokeStrategy(*this);
    connect(clone, SIGNAL(sigHandlesRectCalculated(QRect)), this, SIGNAL(sigHandlesRectCalculated(QRect)));
    return clone;
}

References connect(), KisSelection::hasShapeSelection(), m_selection, MoveSelectionStrokeStrategy(), and sigHandlesRectCalculated().

◆ doStrokeCallback()

void MoveSelectionStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overridevirtual

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 163 of file move_selection_stroke_strategy.cpp.

{
    MoveStrokeStrategy::Data *d = dynamic_cast<MoveStrokeStrategy::Data*>(data);
    ShowSelectionData *ssd = dynamic_cast<ShowSelectionData*>(data);
 
    if (d) {
        KisIndirectPaintingSupport *indirect =
            static_cast<KisIndirectPaintingSupport*>(m_paintLayer.data());
 
        KisPaintDeviceSP movedDevice = indirect->temporaryTarget();
 
        QRegion dirtyRegion = movedDevice->region().toQRegion();
 
        QPoint currentDeviceOffset(movedDevice->x(), movedDevice->y());
        QPoint newDeviceOffset(m_initialDeviceOffset + d->offset);
 
        dirtyRegion |= dirtyRegion.translated(newDeviceOffset - currentDeviceOffset);
 
        movedDevice->setX(newDeviceOffset.x());
        movedDevice->setY(newDeviceOffset.y());
        m_finalOffset = d->offset;
 
        m_paintLayer->setDirty(KisRegion::fromQRegion(dirtyRegion));
 
        m_selection->setX((m_initialSelectionOffset + d->offset).x());
        m_selection->setY((m_initialSelectionOffset + d->offset).y());
 
        if (m_selection->isVisible()) {
            m_selection->notifySelectionChanged();
        }
 
    } else if (ssd) {
        m_selection->setVisible(ssd->showSelection);
    } else {
        KisStrokeStrategyUndoCommandBased::doStrokeCallback(data);
    }
}

References KisSharedPtr< T >::data(), KisStrokeStrategyUndoCommandBased::doStrokeCallback(), KisRegion::fromQRegion(), KisSelection::isVisible, m_finalOffset, m_initialDeviceOffset, m_initialSelectionOffset, m_paintLayer, m_selection, KisSelection::notifySelectionChanged(), KisPaintDevice::region(), KisNode::setDirty(), KisSelection::setVisible(), KisPaintDevice::setX(), KisSelection::setX(), KisPaintDevice::setY(), KisSelection::setY(), MoveSelectionStrokeStrategy::ShowSelectionData::showSelection, KisIndirectPaintingSupport::temporaryTarget, KisRegion::toQRegion(), KisPaintDevice::x(), and KisPaintDevice::y().

◆ finishStrokeCallback()

void MoveSelectionStrokeStrategy::finishStrokeCallback ( )

overridevirtual

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 104 of file move_selection_stroke_strategy.cpp.

{
    KisIndirectPaintingSupport *indirect =
        static_cast<KisIndirectPaintingSupport*>(m_paintLayer.data());
 
    KUndo2CommandSP parentCommand(new KUndo2Command());
 
    indirect->mergeToLayer(m_paintLayer, parentCommand.data(), name(), -1);
 
    runAndSaveCommand(parentCommand,
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::NORMAL);
 
    indirect->setTemporaryTarget(0);
 
    m_updatesFacade->blockUpdates();
 
    KUndo2CommandSP moveSelectionCommand(
        new KisSelectionMoveCommand2(m_selection,
                                     m_initialSelectionOffset,
                                     m_initialSelectionOffset + m_finalOffset));
 
    runAndSaveCommand(
        moveSelectionCommand,
            KisStrokeJobData::SEQUENTIAL,
            KisStrokeJobData::EXCLUSIVE);
 
    m_updatesFacade->unblockUpdates();
 
    m_selection->setVisible(true);
 
    KisStrokeStrategyUndoCommandBased::finishStrokeCallback();
}

References KisUpdatesFacade::blockUpdates(), KisSharedPtr< T >::data(), KisStrokeJobData::EXCLUSIVE, KisStrokeStrategyUndoCommandBased::finishStrokeCallback(), m_finalOffset, m_initialSelectionOffset, m_paintLayer, m_selection, m_updatesFacade, KisIndirectPaintingSupport::mergeToLayer(), KisStrokeStrategy::name(), KisStrokeJobData::NORMAL, KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisStrokeJobData::SEQUENTIAL, KisIndirectPaintingSupport::setTemporaryTarget(), KisSelection::setVisible(), and KisUpdatesFacade::unblockUpdates().

◆ initStrokeCallback()

void MoveSelectionStrokeStrategy::initStrokeCallback ( )

overridevirtual

Reimplemented from KisStrokeStrategyUndoCommandBased.

Definition at line 52 of file move_selection_stroke_strategy.cpp.

{
    KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    KisPaintDeviceSP movedDevice = new KisPaintDevice(m_paintLayer.data(), paintDevice->colorSpace());
 
    KUndo2Command *autoKeyframeCommand =
        KisAutoKey::tryAutoCreateDuplicatedFrame(m_paintLayer->paintDevice(),
                                                 KisAutoKey::SupportsLod);
    if (autoKeyframeCommand) {
        runAndSaveCommand(toQShared(autoKeyframeCommand), KisStrokeJobData::BARRIER, KisStrokeJobData::NORMAL);
    }
 
    QRect copyRect = m_selection->selectedRect();
    KisPainter gc(movedDevice);
    gc.setSelection(m_selection);
    gc.bitBlt(copyRect.topLeft(), paintDevice, copyRect);
    gc.end();
 
    KisTransaction cutTransaction(name(), paintDevice);
    paintDevice->clearSelection(m_selection);
    runAndSaveCommand(KUndo2CommandSP(cutTransaction.endAndTake()),
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::NORMAL);
 
    KisIndirectPaintingSupport *indirect =
        static_cast<KisIndirectPaintingSupport*>(m_paintLayer.data());
    indirect->setTemporaryTarget(movedDevice);
    indirect->setTemporaryCompositeOp(COMPOSITE_OVER);
    indirect->setTemporaryOpacity(OPACITY_OPAQUE_F);
    indirect->setTemporarySelection(0);
    indirect->setTemporaryChannelFlags(QBitArray());
 
    m_initialDeviceOffset = QPoint(movedDevice->x(), movedDevice->y());
    m_initialSelectionOffset = QPoint(m_selection->x(), m_selection->y());
 
    {
        QRect handlesRect = movedDevice->exactBounds();
        KisLodTransform t(paintDevice);
        handlesRect = t.mapInverted(handlesRect);
 
        if (!handlesRect.isEmpty()) {
            Q_EMIT this->sigHandlesRectCalculated(handlesRect);
        } else {
            Q_EMIT this->sigStrokeStartedEmpty();
        }
 
    }
}

References KisStrokeJobData::BARRIER, KisPainter::bitBlt(), KisPaintDevice::clearSelection(), KisPaintDevice::colorSpace(), COMPOSITE_OVER, KisSharedPtr< T >::data(), KisPainter::end(), KisTransaction::endAndTake(), KisPaintDevice::exactBounds(), KisStrokeStrategyUndoCommandBased::initStrokeCallback(), m_initialDeviceOffset, m_initialSelectionOffset, m_paintLayer, m_selection, KisLodTransformBase::mapInverted(), KisStrokeStrategy::name(), KisStrokeJobData::NORMAL, OPACITY_OPAQUE_F, KisPaintLayer::paintDevice, KisStrokeStrategyUndoCommandBased::runAndSaveCommand(), KisSelection::selectedRect(), KisStrokeJobData::SEQUENTIAL, KisPainter::setSelection(), KisIndirectPaintingSupport::setTemporaryChannelFlags(), KisIndirectPaintingSupport::setTemporaryCompositeOp(), KisIndirectPaintingSupport::setTemporaryOpacity(), KisIndirectPaintingSupport::setTemporarySelection(), KisIndirectPaintingSupport::setTemporaryTarget(), sigHandlesRectCalculated(), sigStrokeStartedEmpty(), KisAutoKey::SupportsLod, toQShared(), KisAutoKey::tryAutoCreateDuplicatedFrame(), KisPaintDevice::x(), KisSelection::x(), KisPaintDevice::y(), and KisSelection::y().

◆ sigHandlesRectCalculated

void MoveSelectionStrokeStrategy::sigHandlesRectCalculated ( const QRect & handlesRect )

signal

◆ sigStrokeStartedEmpty

void MoveSelectionStrokeStrategy::sigStrokeStartedEmpty ( )

signal

Member Data Documentation

◆ m_finalOffset

QPoint MoveSelectionStrokeStrategy::m_finalOffset

private

Definition at line 63 of file move_selection_stroke_strategy.h.

◆ m_initialDeviceOffset

QPoint MoveSelectionStrokeStrategy::m_initialDeviceOffset

private

Definition at line 64 of file move_selection_stroke_strategy.h.

◆ m_initialSelectionOffset

QPoint MoveSelectionStrokeStrategy::m_initialSelectionOffset

private

Definition at line 65 of file move_selection_stroke_strategy.h.

◆ m_paintLayer

KisPaintLayerSP MoveSelectionStrokeStrategy::m_paintLayer

private

Definition at line 60 of file move_selection_stroke_strategy.h.

◆ m_selection

KisSelectionSP MoveSelectionStrokeStrategy::m_selection

private

Definition at line 61 of file move_selection_stroke_strategy.h.

◆ m_updatesFacade

KisUpdatesFacade* MoveSelectionStrokeStrategy::m_updatesFacade

private

Definition at line 62 of file move_selection_stroke_strategy.h.

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

plugins/tools/basictools/strokes/move_selection_stroke_strategy.h
plugins/tools/basictools/strokes/move_selection_stroke_strategy.cpp

Classes

Signals

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MoveSelectionStrokeStrategy() [1/2]

◆ MoveSelectionStrokeStrategy() [2/2]

Member Function Documentation

◆ cancelStrokeCallback()

◆ createLodClone()

◆ doStrokeCallback()

◆ finishStrokeCallback()

◆ initStrokeCallback()

◆ sigHandlesRectCalculated

◆ sigStrokeStartedEmpty

Member Data Documentation

◆ m_finalOffset

◆ m_initialDeviceOffset

◆ m_initialSelectionOffset

◆ m_paintLayer

◆ m_selection

◆ m_updatesFacade