#include <kis_tool_move.h>

Inheritance diagram for KisToolMove:

Public Types
enum	MoveDirection { Up , Down , Left , Right }

enum	MoveToolMode { MoveSelectedLayer , MoveFirstLayer , MoveGroup }

Public Types inherited from KisTool
enum	{ FLAG_USES_CUSTOM_PRESET =0x01 , FLAG_USES_CUSTOM_COMPOSITEOP =0x02 , FLAG_USES_CUSTOM_SIZE =0x04 }

enum	AlternateAction { ChangeSize = AlternateChangeSize , ChangeSizeSnap = AlternateChangeSizeSnap , SampleFgNode = AlternateSampleFgNode , SampleBgNode = AlternateSampleBgNode , SampleFgImage = AlternateSampleFgImage , SampleBgImage = AlternateSampleBgImage , Secondary = AlternateSecondary , Third = AlternateThird , Fourth = AlternateFourth , Fifth = AlternateFifth , NONE = 10000 }

enum	NodePaintAbility { VECTOR , CLONE , PAINT , UNPAINTABLE , MYPAINTBRUSH_UNPAINTABLE }

enum	ToolAction { Primary , AlternateChangeSize , AlternateChangeSizeSnap , AlternateSampleFgNode , AlternateSampleBgNode , AlternateSampleFgImage , AlternateSampleBgImage , AlternateSecondary , AlternateThird , AlternateFourth , AlternateFifth , Alternate_NONE = 10000 }

Public Slots
void	activate (const QSet< KoShape * > &shapes) override

void	commitChanges ()

void	deactivate () override

void	moveBySpinX (int newX)

void	moveBySpinY (int newY)

void	moveDiscrete (MoveDirection direction, bool big)

void	requestRedoDuringStroke () override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

void	requestUndoDuringStroke () override

void	slotHandlesRectCalculated (const QRect &handlesRect)

void	slotNodeChanged (const KisNodeList &nodes)

void	slotSelectionChanged ()

void	slotStrokePickedLayers (const KisNodeList &nodes)

void	slotStrokeStartedEmpty ()

Public Slots inherited from KisTool
void	activate (const QSet< KoShape * > &shapes) override

void	canvasResourceChanged (int key, const QVariant &res) override

void	deactivate () override

virtual void	updateSettingsViews ()

Public Slots inherited from KoToolBase
virtual void	activate (const QSet< KoShape * > &shapes)

virtual void	canvasResourceChanged (int key, const QVariant &res)

virtual void	deactivate ()

virtual void	documentResourceChanged (int key, const QVariant &res)

virtual void	repaintDecorations ()

virtual void	requestRedoDuringStroke ()

virtual void	requestStrokeCancellation ()

virtual void	requestStrokeEnd ()

virtual void	requestUndoDuringStroke ()

void	setStatusText (const QString &statusText)

void	updateOptionsWidgetIcons ()

Signals
void	moveInNewPosition (QPoint)

void	moveToolModeChanged ()

Signals inherited from KisTool
void	isActiveChanged (bool isActivated)

Signals inherited from KoToolBase
void	activateTool (const QString &id)

void	cursorChanged (const QCursor &cursor)

void	selectionChanged (bool hasSelection)

void	statusTextChanged (const QString &statusText)

void	textModeChanged (bool inTextMode)

Public Member Functions
void	beginAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	beginPrimaryAction (KoPointerEvent *event) override

void	continueAction (KoPointerEvent *event)

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

void	endAction (KoPointerEvent *event)

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	endPrimaryAction (KoPointerEvent *event) override

	KisToolMove (KoCanvasBase *canvas)

void	mouseMoveEvent (KoPointerEvent *event) override

MoveToolMode	moveToolMode () const

void	paint (QPainter &gc, const KoViewConverter &converter) override

void	setShowCoordinates (bool value)

void	startAction (KoPointerEvent *event, MoveToolMode mode)

void	updateUIUnit (int newUnit)

bool	wantsAutoScroll () const override
	wantsAutoScroll reimplemented from KoToolBase there's an issue where autoscrolling with this tool never makes the stroke end, so we return false here so that users don't get stuck with the tool. See bug 362659

	~KisToolMove () override

Public Member Functions inherited from KisTool
virtual void	activateAlternateAction (AlternateAction action)

virtual void	activatePrimaryAction ()

virtual bool	alternateActionSupportsHiResEvents (AlternateAction action) const

virtual void	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action)

virtual void	beginPrimaryDoubleClickAction (KoPointerEvent *event)

virtual void	deactivateAlternateAction (AlternateAction action)

virtual void	deactivatePrimaryAction ()

void	deleteSelection () override

virtual int	flags () const

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

virtual void	newActivationWithExternalSource (KisPaintDeviceSP externalSource)
	newActivationWithExternalSource Makes sure that the tool is active and starts a new stroke, which will be able to access the pixels from the specified external source.

KisTool::NodePaintAbility	nodePaintAbility ()

virtual bool	primaryActionSupportsHiResEvents () const

virtual bool	supportsPaintingAssistants () const

	~KisTool () override

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KoToolBase
QAction *	action (const QString &name) const

KoCanvasBase *	canvas () const
	Returns the canvas the tool is working on.

virtual void	copy () const

QCursor	cursor () const
	return the last emitted cursor

virtual void	customMoveEvent (KoPointerEvent *event)

virtual void	customPressEvent (KoPointerEvent *event)

virtual void	customReleaseEvent (KoPointerEvent *event)

virtual void	cut ()

virtual QRectF	decorationsRect () const

int	decorationThickness () const
	decorationThickness The minimum thickness for tool decoration lines, this is derived from the screen magnification, thus the HiDPI settings. Note: to use this effectively, also set the pen to isCosmetic(true);

virtual void	deselect ()
	deselect the tool should clear the selection if it has one.

virtual void	dragLeaveEvent (QDragLeaveEvent *event)

virtual void	dragMoveEvent (QDragMoveEvent *event, const QPointF &point)

virtual void	dropEvent (QDropEvent *event, const QPointF &point)

virtual void	explicitUserStrokeEndRequest ()
	explicitUserStrokeEndRequest is called by the input manager when the user presses Enter key or any equivalent. This callback comes before requestStrokeEnd(), which comes from a different source.

KoToolFactoryBase *	factory () const

virtual void	focusInEvent (QFocusEvent *event)

virtual void	focusOutEvent (QFocusEvent *event)

virtual bool	hasSelection ()

virtual void	inputMethodEvent (QInputMethodEvent *event)

virtual QVariant	inputMethodQuery (Qt::InputMethodQuery query) const

bool	isInTextMode () const

bool	isOpacityPresetMode () const

virtual void	keyPressEvent (QKeyEvent *event)

virtual void	keyReleaseEvent (QKeyEvent *event)

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

virtual QMenu *	popupActionsMenu ()

virtual KisPopupWidgetInterface *	popupWidget ()

virtual bool	selectAll ()
	selectAll select all data the tool can select.

virtual KoToolSelection *	selection ()

Q_INVOKABLE QString	toolId () const

	~KoToolBase () override

Protected Slots
void	resetCursorStyle () override

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Private Slots
void	endStroke ()

void	slotMoveDiscreteDown ()

void	slotMoveDiscreteDownMore ()

void	slotMoveDiscreteLeft ()

void	slotMoveDiscreteLeftMore ()

void	slotMoveDiscreteRight ()

void	slotMoveDiscreteRightMore ()

void	slotMoveDiscreteUp ()

void	slotMoveDiscreteUpMore ()

void	slotTrackerChangedConfig (KisToolChangesTrackerDataSP state)

Private Member Functions
QPoint	applyModifiers (Qt::KeyboardModifiers modifiers, QPoint pos)

void	cancelStroke ()

QPoint	currentOffset () const

void	drag (const QPoint &newPos)

void	notifyGuiAfterMove (bool showFloatingMessage=true)

	Q_ENUMS (MoveToolMode)

void	requestHandlesRectUpdate ()

bool	startStrokeImpl (MoveToolMode mode, const QPoint *pos)

bool	tryEndPreviousStroke (const KisNodeList &nodes)

Private Attributes
QPoint	m_accumulatedOffset
	Total offset including multiple clicks, up/down/left/right keys, etc. added together.

KisSignalAutoConnectionsStore	m_actionConnections

KisAsynchronousStrokeUpdateHelper	m_asyncUpdateHelper

KisSignalAutoConnectionsStore	m_canvasConnections

KisToolChangesTracker	m_changesTracker

KisNodeList	m_currentlyProcessingNodes

bool	m_currentlyUsingSelection {false}

MoveToolMode	m_currentMode {MoveSelectedLayer}

QPoint	m_dragPos

QPoint	m_dragStart
	Point where current cursor dragging began.

QRect	m_handlesRect

QPoint	m_lastCursorPos

MoveToolOptionsWidget *	m_optionsWidget {0}

int	m_resolution {0}

QAction *	m_showCoordinatesAction {0}

KisStrokeId	m_strokeId

KisSignalCompressor	m_updateCursorCompressor

Additional Inherited Members
Static Public Member Functions inherited from KisTool
static AlternateAction	actionToAlternateAction (ToolAction action)

Public Attributes inherited from KisTool
KoColor	currentBgColor

float	currentExposure {1.0}

KoColor	currentFgColor

KisFilterConfigurationSP	currentGenerator

KoAbstractGradientSP	currentGradient

KoPatternSP	currentPattern

QCursor	cursor

bool	m_isActive {false}

ToolMode	m_mode {HOVER_MODE}

QWidget *	optionWidget {0}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Protected Types inherited from KisTool
enum	ToolMode : int { HOVER_MODE , PAINT_MODE , SECONDARY_PAINT_MODE , MIRROR_AXIS_SETUP_MODE , GESTURE_MODE , PAN_MODE , OTHER , OTHER_1 }

Protected Member Functions inherited from KisTool
bool	blockUntilOperationsFinished ()

void	blockUntilOperationsFinishedForced ()

QPointF	convertDocumentToWidget (const QPointF &pt)

QPoint	convertToImagePixelCoordFloored (KoPointerEvent *e)

QPointF	convertToPixelCoord (const QPointF &pt)

QPointF	convertToPixelCoord (KoPointerEvent *e)

QPointF	convertToPixelCoordAndAlignOnWidget (const QPointF &pt)

QPointF	convertToPixelCoordAndSnap (const QPointF &pt, const QPointF &offset=QPointF())

QPointF	convertToPixelCoordAndSnap (KoPointerEvent *e, const QPointF &offset=QPointF(), bool useModifiers=true)

QRectF	convertToPt (const QRectF &rect)

qreal	convertToPt (qreal value)

KoColor	currentBgColor ()

KoColor	currentFgColor ()

KisFilterConfigurationSP	currentGenerator ()

KoAbstractGradientSP	currentGradient ()

KisImageWSP	currentImage ()

KisNodeSP	currentNode () const

KisPaintOpPresetSP	currentPaintOpPreset ()

KoPatternSP	currentPattern ()

QCursor	cursor () const

KisImageWSP	image () const

virtual bool	listeningToModifiers ()

virtual void	listenToModifiers (bool listen)

virtual ToolMode	mode () const

bool	nodeEditable ()
	Checks checks if the current node is editable.

bool	overrideCursorIfNotEditable ()
	Override the cursor appropriately if current node is not editable.

void	paintToolOutline (QPainter *painter, const KisOptimizedBrushOutline &path)

KisOptimizedBrushOutline	pixelToView (const KisOptimizedBrushOutline &path) const

QPainterPath	pixelToView (const QPainterPath &pixelPath) const
	Convert a pixel path into a view path.

QPointF	pixelToView (const QPoint &pixelCoord) const

QPointF	pixelToView (const QPointF &pixelCoord) const
	Convert a floating point pixel coordinate into a view coordinate.

QPolygonF	pixelToView (const QPolygonF &pixelPolygon) const
	Convert a pixel polygon into a view path.

QRectF	pixelToView (const QRectF &pixelRect) const
	Convert a pixel rectangle into a view rectangle.

KisNodeList	selectedNodes () const

bool	selectionEditable ()
	Checks checks if the selection is editable, only applies to local selection as global selection is always editable.

void	setCursor (const QCursor &cursor)

virtual void	setMode (ToolMode mode)

void	updateCanvasPixelRect (const QRectF &pixelRect)
	Update the canvas for the given rectangle in image pixel coordinates.

void	updateCanvasViewRect (const QRectF &viewRect)
	Update the canvas for the given rectangle in view coordinates.

QPointF	viewToPixel (const QPointF &viewCoord) const

QPointF	widgetCenterInWidgetPixels ()

Protected Member Functions inherited from KoToolBase
virtual QList< QPointer< QWidget > >	createOptionWidgets ()

int	grabSensitivity () const
	Convenience function to get the current grab sensitivity.

qreal	handleDocRadius () const

QRectF	handleGrabRect (const QPointF &position) const

QRectF	handlePaintRect (const QPointF &position) const

int	handleRadius () const
	Convenience function to get the current handle radius.

bool	isActivated () const

	KoToolBase (KoToolBasePrivate &dd)

KoPointerEvent *	lastDeliveredPointerEvent () const

void	setAbstractResource (KoAbstractCanvasResourceInterfaceSP abstractResource)

void	setConverter (KoDerivedResourceConverterSP converter)

void	setIsOpacityPresetMode (bool value)

void	setMaskSyntheticEvents (bool value)

void	setTextMode (bool value)

QHash< int, KoAbstractCanvasResourceInterfaceSP >	toolAbstractResources ()

QHash< int, KoDerivedResourceConverterSP >	toolConverters ()

void	useCursor (const QCursor &cursor)

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Properties inherited from KisTool
bool	isActive

Detailed Description

Definition at line 33 of file kis_tool_move.h.

Member Enumeration Documentation

◆ MoveDirection

enum KisToolMove::MoveDirection

Enumerator
Up
Down
Left
Right

Definition at line 73 of file kis_tool_move.h.

                       {
        Up,
        Down,
        Left,
        Right
    };

◆ MoveToolMode

enum KisToolMove::MoveToolMode

Enumerator
MoveSelectedLayer
MoveFirstLayer
MoveGroup

Definition at line 67 of file kis_tool_move.h.

                      {
        MoveSelectedLayer,
        MoveFirstLayer,
        MoveGroup
    };

Constructor & Destructor Documentation

◆ KisToolMove()

KisToolMove::KisToolMove ( KoCanvasBase * canvas )

Definition at line 55 of file kis_tool_move.cc.

    : KisTool(canvas, KisCursor::moveCursor())
    , m_updateCursorCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
{
    setObjectName("tool_move");
 
    m_showCoordinatesAction = action("movetool-show-coordinates");
    m_showCoordinatesAction = action("movetool-show-coordinates");
    connect(&m_updateCursorCompressor, SIGNAL(timeout()), this, SLOT(resetCursorStyle()));
 
    m_optionsWidget = new MoveToolOptionsWidget(nullptr, currentImage()->xRes(), toolId());
 
    // See https://bugs.kde.org/show_bug.cgi?id=316896
    QWidget *specialSpacer = new QWidget(m_optionsWidget);
    specialSpacer->setObjectName("SpecialSpacer");
    specialSpacer->setFixedSize(0, 0);
    m_optionsWidget->layout()->addWidget(specialSpacer);
 
    m_optionsWidget->setFixedHeight(m_optionsWidget->sizeHint().height());
 
    m_showCoordinatesAction->setChecked(m_optionsWidget->showCoordinates());
 
    m_optionsWidget->slotSetTranslate(m_handlesRect.topLeft() + currentOffset());
 
    connect(this, SIGNAL(moveInNewPosition(QPoint)), m_optionsWidget, SLOT(slotSetTranslate(QPoint)), Qt::UniqueConnection);
}

References KoToolBase::action(), connect(), KisTool::currentImage(), currentOffset(), m_handlesRect, m_optionsWidget, m_showCoordinatesAction, m_updateCursorCompressor, moveInNewPosition(), resetCursorStyle(), MoveToolOptionsWidget::showCoordinates(), MoveToolOptionsWidget::slotSetTranslate(), and KoToolBase::toolId().

◆ ~KisToolMove()

KisToolMove::~KisToolMove ( )

override

Definition at line 82 of file kis_tool_move.cc.

{
    endStroke();
    delete m_optionsWidget;
}

References endStroke(), and m_optionsWidget.

Member Function Documentation

◆ activate

void KisToolMove::activate ( const QSet< KoShape * > & shapes )

overrideslot

Definition at line 391 of file kis_tool_move.cc.

{
    KisTool::activate(shapes);
 
    m_actionConnections.addConnection(action("movetool-move-up"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteUp()));
    m_actionConnections.addConnection(action("movetool-move-down"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteDown()));
    m_actionConnections.addConnection(action("movetool-move-left"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteLeft()));
    m_actionConnections.addConnection(action("movetool-move-right"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteRight()));
 
    m_actionConnections.addConnection(action("movetool-move-up-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteUpMore()));
    m_actionConnections.addConnection(action("movetool-move-down-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteDownMore()));
    m_actionConnections.addConnection(action("movetool-move-left-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteLeftMore()));
    m_actionConnections.addConnection(action("movetool-move-right-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteRightMore()));
 
    m_canvasConnections.addUniqueConnection(qobject_cast<KisCanvas2*>(canvas())->viewManager()->nodeManager(), SIGNAL(sigUiNeedChangeSelectedNodes(KisNodeList)), this, SLOT(slotNodeChanged(KisNodeList)));
    m_canvasConnections.addUniqueConnection(qobject_cast<KisCanvas2*>(canvas())->viewManager()->selectionManager(), SIGNAL(currentSelectionChanged()), this, SLOT(slotSelectionChanged()));
 
    connect(m_showCoordinatesAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(setShowCoordinates(bool)), Qt::UniqueConnection);
    connect(m_optionsWidget, SIGNAL(showCoordinatesChanged(bool)), m_showCoordinatesAction, SLOT(setChecked(bool)), Qt::UniqueConnection);
    connect(m_optionsWidget, SIGNAL(sigSetTranslateX(int)), SLOT(moveBySpinX(int)), Qt::UniqueConnection);
    connect(m_optionsWidget, SIGNAL(sigSetTranslateY(int)), SLOT(moveBySpinY(int)), Qt::UniqueConnection);
    connect(m_optionsWidget, SIGNAL(sigRequestCommitOffsetChanges()), this, SLOT(commitChanges()), Qt::UniqueConnection);
 
    connect(&m_changesTracker,
            SIGNAL(sigConfigChanged(KisToolChangesTrackerDataSP)),
            SLOT(slotTrackerChangedConfig(KisToolChangesTrackerDataSP)));
 
 
    slotNodeChanged(this->selectedNodes());
}

References KoToolBase::action(), KisTool::activate(), KisSignalAutoConnectionsStore::addConnection(), KisSignalAutoConnectionsStore::addUniqueConnection(), Private::canvas, commitChanges(), connect(), m_actionConnections, m_canvasConnections, m_changesTracker, m_optionsWidget, m_showCoordinatesAction, moveBySpinX(), moveBySpinY(), KisTool::selectedNodes(), setShowCoordinates(), slotMoveDiscreteDown(), slotMoveDiscreteDownMore(), slotMoveDiscreteLeft(), slotMoveDiscreteLeftMore(), slotMoveDiscreteRight(), slotMoveDiscreteRightMore(), slotMoveDiscreteUp(), slotMoveDiscreteUpMore(), slotNodeChanged(), slotSelectionChanged(), and slotTrackerChangedConfig().

◆ applyModifiers()

QPoint KisToolMove::applyModifiers	(	Qt::KeyboardModifiers	modifiers,
		QPoint	pos )

private

Definition at line 723 of file kis_tool_move.cc.

{
    QPoint move = pos - m_dragStart;
 
    // Snap to axis
    if (modifiers & Qt::ShiftModifier) {
        move = snapToClosestAxis(move);
    }
 
    // "Precision mode" - scale down movement by 1/5
    if (modifiers & Qt::AltModifier) {
        const qreal SCALE_FACTOR = .2;
        move = SCALE_FACTOR * move;
    }
 
    return m_dragStart + move;
}

References m_dragStart, and snapToClosestAxis().

◆ beginAlternateAction()

void KisToolMove::beginAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overridevirtual

Reimplemented from KisTool.

Definition at line 502 of file kis_tool_move.cc.

{
    // Ctrl+Right click toggles between moving current layer and moving layer w/ content
    if (action == SampleFgNode || action == SampleBgImage) {
        MoveToolMode mode = moveToolMode();
 
        if (mode == MoveSelectedLayer) {
            mode = MoveFirstLayer;
        } else if (mode == MoveFirstLayer) {
            mode = MoveSelectedLayer;
        }
 
        startAction(event, mode);
    } else {
        startAction(event, MoveGroup);
    }
}

References KoToolBase::action(), KisTool::mode(), MoveFirstLayer, MoveGroup, MoveSelectedLayer, moveToolMode(), KisTool::SampleBgImage, KisTool::SampleFgNode, and startAction().

◆ beginPrimaryAction()

void KisToolMove::beginPrimaryAction ( KoPointerEvent * event )

overridevirtual

Called by KisToolProxy when a primary action for the tool is started. The event stores the original event that started the stroke. The event is accepted by default. If the tool decides to ignore this particular action (e.g. when the node is not editable), it should call event->ignore(). Then no further continuePrimaryAction() or endPrimaryAction() will be called until the next user action.

Reimplemented from KisTool.

Definition at line 487 of file kis_tool_move.cc.

{
    startAction(event, moveToolMode());
}

References moveToolMode(), and startAction().

◆ cancelStroke()

void KisToolMove::cancelStroke ( )

private

Definition at line 691 of file kis_tool_move.cc.

{
    if (!m_strokeId) return;
 
    if (m_asyncUpdateHelper.isActive()) {
        m_asyncUpdateHelper.cancelUpdateStream();
    }
 
    KisImageSP image = currentImage();
    image->cancelStroke(m_strokeId);
    m_strokeId.clear();
    m_changesTracker.reset();
    m_currentlyProcessingNodes.clear();
    m_currentlyUsingSelection = false;
    m_currentMode = MoveSelectedLayer;
    m_accumulatedOffset = QPoint();
    notifyGuiAfterMove();
    qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
}

References KisImage::cancelStroke(), KisAsynchronousStrokeUpdateHelper::cancelUpdateStream(), Private::canvas, KisTool::currentImage(), KisTool::image(), KisAsynchronousStrokeUpdateHelper::isActive(), m_accumulatedOffset, m_asyncUpdateHelper, m_changesTracker, m_currentlyProcessingNodes, m_currentlyUsingSelection, m_currentMode, m_strokeId, MoveSelectedLayer, notifyGuiAfterMove(), and KisToolChangesTracker::reset().

◆ commitChanges

void KisToolMove::commitChanges ( )

slot

Definition at line 314 of file kis_tool_move.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_strokeId);
 
    QSharedPointer<KisToolMoveState> newState(new KisToolMoveState(m_accumulatedOffset));
    KisToolMoveState *lastState = dynamic_cast<KisToolMoveState*>(m_changesTracker.lastState().data());
    if (lastState && *lastState == *newState) return;
 
    m_changesTracker.commitConfig(newState);
}

References KisToolChangesTracker::commitConfig(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisToolChangesTracker::lastState(), m_accumulatedOffset, m_changesTracker, and m_strokeId.

◆ continueAction()

void KisToolMove::continueAction ( KoPointerEvent * event )

Definition at line 567 of file kis_tool_move.cc.

{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    if (!m_strokeId) return;
 
    QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
    pos = applyModifiers(event->modifiers(), pos);
    m_dragPos = pos;
 
    drag(pos);
    notifyGuiAfterMove();
 
    qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
}

References applyModifiers(), Private::canvas, CHECK_MODE_SANITY_OR_RETURN, KisTool::convertToPixelCoordAndSnap(), drag(), m_dragPos, m_strokeId, KoPointerEvent::modifiers(), notifyGuiAfterMove(), and KisTool::PAINT_MODE.

◆ continueAlternateAction()

void KisToolMove::continueAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overridevirtual

Reimplemented from KisTool.

Definition at line 520 of file kis_tool_move.cc.

{
    Q_UNUSED(action);
    continueAction(event);
}

References KoToolBase::action(), and continueAction().

◆ continuePrimaryAction()

void KisToolMove::continuePrimaryAction ( KoPointerEvent * event )

overridevirtual

Called by KisToolProxy when the primary action is in progress of pointer movement. If the tool has ignored the event in beginPrimaryAction(), this method will not be called.

Reimplemented from KisTool.

Definition at line 492 of file kis_tool_move.cc.

{
    continueAction(event);
}

References continueAction().

◆ createOptionWidget()

QWidget * KisToolMove::createOptionWidget ( )

overridevirtual

Reimplement this if your tool actually has an option widget. Sets the option widget to 0 by default.

Reimplemented from KisTool.

Definition at line 711 of file kis_tool_move.cc.

{
    return m_optionsWidget;
}

References m_optionsWidget.

◆ currentOffset()

QPoint KisToolMove::currentOffset ( ) const

private

Definition at line 270 of file kis_tool_move.cc.

{
    return m_accumulatedOffset + m_dragPos - m_dragStart;
}

References m_accumulatedOffset, m_dragPos, and m_dragStart.

◆ deactivate

void KisToolMove::deactivate ( )

overrideslot

Definition at line 445 of file kis_tool_move.cc.

{
    m_actionConnections.clear();
    m_canvasConnections.clear();
 
    disconnect(m_showCoordinatesAction, 0, this, 0);
    disconnect(m_optionsWidget, 0, this, 0);
 
    endStroke();
    KisTool::deactivate();
}

References KisSignalAutoConnectionsStore::clear(), KisTool::deactivate(), endStroke(), m_actionConnections, m_canvasConnections, m_optionsWidget, and m_showCoordinatesAction.

◆ drag()

void KisToolMove::drag ( const QPoint & newPos )

private

Definition at line 609 of file kis_tool_move.cc.

{
    KisImageSP image = currentImage();
 
    QPoint offset = m_accumulatedOffset + newPos - m_dragStart;
 
    image->addJob(m_strokeId,
                  new MoveStrokeStrategy::Data(offset));
}

References KisImage::addJob(), KisTool::currentImage(), KisTool::image(), m_accumulatedOffset, m_dragStart, and m_strokeId.

◆ endAction()

void KisToolMove::endAction ( KoPointerEvent * event )

Definition at line 583 of file kis_tool_move.cc.

{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
    setMode(KisTool::HOVER_MODE);
    if (!m_strokeId) return;
 
    QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
    pos = applyModifiers(event->modifiers(), pos);
    drag(pos);
 
    m_accumulatedOffset += pos - m_dragStart;
    m_dragStart = QPoint();
    m_dragPos = QPoint();
    commitChanges();
 
    if (m_currentlyUsingSelection) {
        KisImageSP image = currentImage();
        image->addJob(m_strokeId,
                      new MoveSelectionStrokeStrategy::ShowSelectionData(true));
    }
 
    notifyGuiAfterMove();
 
    qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
}

References KisImage::addJob(), applyModifiers(), Private::canvas, CHECK_MODE_SANITY_OR_RETURN, commitChanges(), KisTool::convertToPixelCoordAndSnap(), KisTool::currentImage(), drag(), KisTool::HOVER_MODE, KisTool::image(), m_accumulatedOffset, m_currentlyUsingSelection, m_dragPos, m_dragStart, m_strokeId, KoPointerEvent::modifiers(), notifyGuiAfterMove(), KisTool::PAINT_MODE, and KisTool::setMode().

◆ endAlternateAction()

void KisToolMove::endAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overridevirtual

Reimplemented from KisTool.

Definition at line 526 of file kis_tool_move.cc.

{
    Q_UNUSED(action);
    endAction(event);
}

References KoToolBase::action(), and endAction().

◆ endPrimaryAction()

void KisToolMove::endPrimaryAction ( KoPointerEvent * event )

overridevirtual

Called by KisToolProxy when the primary action is being finished, that is while mouseRelease or tabletRelease event. If the tool has ignored the event in beginPrimaryAction(), this method will not be called.

Reimplemented from KisTool.

Definition at line 497 of file kis_tool_move.cc.

{
    endAction(event);
}

References endAction().

◆ endStroke

void KisToolMove::endStroke ( )

privateslot

Definition at line 619 of file kis_tool_move.cc.

{
    if (!m_strokeId) return;
 
    if (m_asyncUpdateHelper.isActive()) {
        m_asyncUpdateHelper.endUpdateStream();
    }
 
    KisImageSP image = currentImage();
    image->endStroke(m_strokeId);
    m_strokeId.clear();
    m_changesTracker.reset();
    m_currentlyProcessingNodes.clear();
    m_currentlyUsingSelection = false;
    m_currentMode = MoveSelectedLayer;
    m_accumulatedOffset = QPoint();
    qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
}

References Private::canvas, KisTool::currentImage(), KisImage::endStroke(), KisAsynchronousStrokeUpdateHelper::endUpdateStream(), KisTool::image(), KisAsynchronousStrokeUpdateHelper::isActive(), m_accumulatedOffset, m_asyncUpdateHelper, m_changesTracker, m_currentlyProcessingNodes, m_currentlyUsingSelection, m_currentMode, m_strokeId, MoveSelectedLayer, and KisToolChangesTracker::reset().

◆ mouseMoveEvent()

void KisToolMove::mouseMoveEvent ( KoPointerEvent * event )

overridevirtual

Called when the mouse or stylus moved over the canvas. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus move

Reimplemented from KisTool.

Definition at line 532 of file kis_tool_move.cc.

{
    m_lastCursorPos = convertToPixelCoord(event).toPoint();
    KisTool::mouseMoveEvent(event);
 
    if (moveToolMode() != MoveSelectedLayer ||
            (m_strokeId && m_currentMode != MoveSelectedLayer)) {
 
        m_updateCursorCompressor.start();
    }
}

References KisTool::convertToPixelCoord(), m_currentMode, m_lastCursorPos, m_strokeId, m_updateCursorCompressor, KisTool::mouseMoveEvent(), MoveSelectedLayer, moveToolMode(), and KisSignalCompressor::start().

◆ moveBySpinX

void KisToolMove::moveBySpinX ( int newX )

slot

Definition at line 741 of file kis_tool_move.cc.

{
    if (mode() == KisTool::PAINT_MODE ||    // Don't interact with dragging
            !currentNode()->isEditable() || // Don't move invisible nodes
            m_handlesRect.isEmpty()) {
        return;
    }
 
    // starting a new stroke resets m_handlesRect and it gets updated asynchronously,
    // but in this case no change is expected
    int handlesRectX = m_handlesRect.x();
 
    if (startStrokeImpl(MoveSelectedLayer, nullptr)) {
        setMode(KisTool::PAINT_MODE);
    }
 
    m_accumulatedOffset.rx() =  newX - handlesRectX;
 
    image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
    notifyGuiAfterMove(false);
    setMode(KisTool::HOVER_MODE);
}

References KisImage::addJob(), KisTool::currentNode(), KisTool::HOVER_MODE, KisTool::image(), m_accumulatedOffset, m_handlesRect, m_strokeId, KisTool::mode(), MoveSelectedLayer, notifyGuiAfterMove(), KisTool::PAINT_MODE, KisTool::setMode(), and startStrokeImpl().

◆ moveBySpinY

void KisToolMove::moveBySpinY ( int newY )

slot

Definition at line 765 of file kis_tool_move.cc.

{
    if (mode() == KisTool::PAINT_MODE ||    // Don't interact with dragging
            !currentNode()->isEditable() || // Don't move invisible nodes
            m_handlesRect.isEmpty()) {
        return;
    }
 
    // starting a new stroke resets m_handlesRect and it gets updated asynchronously,
    // but in this case no change is expected
    int handlesRectY = m_handlesRect.y();
 
    if (startStrokeImpl(MoveSelectedLayer, nullptr)) {
        setMode(KisTool::PAINT_MODE);
    }
 
    m_accumulatedOffset.ry() =  newY - handlesRectY;
 
    image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
    notifyGuiAfterMove(false);
    setMode(KisTool::HOVER_MODE);
}

References KisImage::addJob(), KisTool::currentNode(), KisTool::HOVER_MODE, KisTool::image(), m_accumulatedOffset, m_handlesRect, m_strokeId, KisTool::mode(), MoveSelectedLayer, notifyGuiAfterMove(), KisTool::PAINT_MODE, KisTool::setMode(), and startStrokeImpl().

◆ moveDiscrete

void KisToolMove::moveDiscrete	(	MoveDirection	direction,
		bool	big )

slot

Definition at line 362 of file kis_tool_move.cc.

{
    if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
    if (!currentNode()) return;
    if (!image()) return;
    if (!currentNode()->isEditable()) return; // Don't move invisible nodes
 
    if (startStrokeImpl(MoveSelectedLayer, nullptr)) {
        setMode(KisTool::PAINT_MODE);
    }
 
    // Larger movement if "shift" key is pressed.
    qreal scale = big ? m_optionsWidget->moveScale() : 1.0;
    qreal moveStep = m_optionsWidget->moveStep() * scale;
 
    const QPoint offset =
        direction == Up   ? QPoint( 0, -moveStep) :
        direction == Down ? QPoint( 0,  moveStep) :
        direction == Left ? QPoint(-moveStep,  0) :
        QPoint( moveStep,  0) ;
 
    m_accumulatedOffset += offset;
    image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
 
    notifyGuiAfterMove();
    commitChanges();
    setMode(KisTool::HOVER_MODE);
}

References KisImage::addJob(), commitChanges(), KisTool::currentNode(), Down, KisTool::HOVER_MODE, KisTool::image(), Left, m_accumulatedOffset, m_optionsWidget, m_strokeId, KisTool::mode(), MoveToolOptionsWidget::moveScale(), MoveSelectedLayer, MoveToolOptionsWidget::moveStep(), notifyGuiAfterMove(), KisTool::PAINT_MODE, KisTool::setMode(), startStrokeImpl(), and Up.

◆ moveInNewPosition

void KisToolMove::moveInNewPosition ( QPoint )

signal

◆ moveToolMode()

KisToolMove::MoveToolMode KisToolMove::moveToolMode ( ) const

Definition at line 716 of file kis_tool_move.cc.

{
    if (m_optionsWidget)
        return m_optionsWidget->mode();
    return MoveSelectedLayer;
}

References m_optionsWidget, MoveToolOptionsWidget::mode(), and MoveSelectedLayer.

◆ moveToolModeChanged

void KisToolMove::moveToolModeChanged ( )

signal

◆ notifyGuiAfterMove()

void KisToolMove::notifyGuiAfterMove ( bool showFloatingMessage = true )

private

Definition at line 275 of file kis_tool_move.cc.

{
    if (!m_optionsWidget) return;
    if (m_handlesRect.isEmpty()) return;
 
    const QPoint currentTopLeft = m_handlesRect.topLeft() + currentOffset();
 
    KisSignalsBlocker b(m_optionsWidget);
    Q_EMIT moveInNewPosition(currentTopLeft);
 
    // TODO: fetch this info not from options widget, but from config
    const bool showCoordinates = m_optionsWidget->showCoordinates();
 
    if (showCoordinates && showFloatingMessage) {
        KisCanvas2 *kisCanvas = static_cast<KisCanvas2*>(canvas());
        kisCanvas->viewManager()->
            showFloatingMessage(
                i18nc("floating message in move tool",
                      "X: %1 px, Y: %2 px",
                      QLocale().toString(currentTopLeft.x()),
                      QLocale().toString(currentTopLeft.y())),
                QIcon(), 1000, KisFloatingMessage::High);
    }
}

References Private::canvas, currentOffset(), KisFloatingMessage::High, m_handlesRect, m_optionsWidget, moveInNewPosition(), MoveToolOptionsWidget::showCoordinates(), and KisCanvas2::viewManager().

◆ paint()

void KisToolMove::paint	(	QPainter &	painter,
		const KoViewConverter &	converter )

overridevirtual

Called by the canvas to paint any decorations that the tool deems needed. The painter has the top left of the canvas as its origin.

Parameters

painter	used for painting the shape
converter	to convert between internal and view coordinates.

Implements KoToolBase.

Definition at line 432 of file kis_tool_move.cc.

{
    Q_UNUSED(converter);
 
    if (m_strokeId && !m_handlesRect.isEmpty() && !m_currentlyUsingSelection) {
        QPainterPath handles;
        handles.addRect(m_handlesRect.translated(currentOffset()));
 
        QPainterPath path = pixelToView(handles);
        paintToolOutline(&gc, path);
    }
}

References currentOffset(), m_currentlyUsingSelection, m_handlesRect, m_strokeId, KisTool::paintToolOutline(), and KisTool::pixelToView().

◆ Q_ENUMS()

KisToolMove::Q_ENUMS ( MoveToolMode )

private

◆ requestHandlesRectUpdate()

void KisToolMove::requestHandlesRectUpdate ( )

private

Definition at line 789 of file kis_tool_move.cc.

{
    KisResourcesSnapshotSP resources =
        new KisResourcesSnapshot(image(), currentNode(), canvas()->resourceManager());
    KisSelectionSP selection = resources->activeSelection();
 
    KisMoveBoundsCalculationJob *job = new KisMoveBoundsCalculationJob(this->selectedNodes(),
                                                                       selection, this);
    connect(job,
            SIGNAL(sigCalculationFinished(const QRect&)),
            SLOT(slotHandlesRectCalculated(const QRect &)));
 
    KisImageSP image = this->image();
    image->addSpontaneousJob(job);
 
    notifyGuiAfterMove(false);
}

References KisResourcesSnapshot::activeSelection(), KisImage::addSpontaneousJob(), Private::canvas, connect(), KisTool::currentNode(), KisTool::image(), notifyGuiAfterMove(), KisTool::selectedNodes(), KoToolBase::selection(), and slotHandlesRectCalculated().

◆ requestRedoDuringStroke

void KisToolMove::requestRedoDuringStroke ( )

overrideslot

Definition at line 478 of file kis_tool_move.cc.

{
    if (!m_strokeId) return;
 
    if (m_changesTracker.canRedo()) {
        m_changesTracker.requestRedo();
    }
}

References KisToolChangesTracker::canRedo(), m_changesTracker, m_strokeId, and KisToolChangesTracker::requestRedo().

◆ requestStrokeCancellation

void KisToolMove::requestStrokeCancellation ( )

overrideslot

Definition at line 462 of file kis_tool_move.cc.

{
    cancelStroke();
}

References cancelStroke().

◆ requestStrokeEnd

void KisToolMove::requestStrokeEnd ( )

overrideslot

Definition at line 457 of file kis_tool_move.cc.

{
    endStroke();
}

References endStroke().

◆ requestUndoDuringStroke

void KisToolMove::requestUndoDuringStroke ( )

overrideslot

Definition at line 467 of file kis_tool_move.cc.

{
    if (!m_strokeId) return;
 
    if (!m_changesTracker.canUndo()) {
        cancelStroke();
    } else {
        m_changesTracker.requestUndo();
    }
}

References cancelStroke(), KisToolChangesTracker::canUndo(), m_changesTracker, m_strokeId, and KisToolChangesTracker::requestUndo().

◆ resetCursorStyle

void KisToolMove::resetCursorStyle ( )

overrideprotectedslot

noop; whatever the cursor position, we always show move cursor, because we don't use 'layer under cursor' mode for moving selections

we cannot pick layer's pixel data while the stroke is running, because it may run in lodN mode; therefore, we delegate this work to the stroke itself

Definition at line 88 of file kis_tool_move.cc.

{
    if (!isActive()) return;
 
    bool canMove = true;
 
    if (m_strokeId && m_currentlyUsingSelection) {
    } else if (m_strokeId && !m_currentlyUsingSelection) {
        if (m_currentMode != MoveSelectedLayer &&
            (m_handlesRect.isEmpty() ||
             !m_handlesRect.translated(currentOffset()).contains(m_lastCursorPos))) {
 
            image()->addJob(m_strokeId, new MoveStrokeStrategy::PickLayerData(m_lastCursorPos));
            return;
        }
    } else {
        KisResourcesSnapshotSP resources =
            new KisResourcesSnapshot(this->image(), currentNode(), canvas()->resourceManager());
        KisSelectionSP selection = resources->activeSelection();
 
        KisPaintLayerSP paintLayer =
            dynamic_cast<KisPaintLayer*>(this->currentNode().data());
 
        const bool canUseSelectionMode =
                paintLayer && selection &&
                !selection->selectedRect().isEmpty() &&
                !selection->selectedExactRect().isEmpty();
 
        if (canUseSelectionMode) {
            canMove = (m_currentMode == MoveSelectedLayer ? paintLayer->isEditable() : true);
        } else {
            KisNodeSelectionRecipe nodeSelection =
                    KisNodeSelectionRecipe(
                        this->selectedNodes(),
                        (KisNodeSelectionRecipe::SelectionMode)moveToolMode(),
                        m_lastCursorPos);
 
            if (nodeSelection.selectNodesToProcess().isEmpty()) {
                canMove = false;
            }
        }
    }
 
    if (canMove) {
        KisTool::resetCursorStyle();
    } else {
       useCursor(Qt::ForbiddenCursor);
    }
}

References KisResourcesSnapshot::activeSelection(), KisImage::addJob(), Private::canvas, KisTool::currentNode(), currentOffset(), KisSharedPtr< T >::data(), KisTool::image(), KisTool::isActive, KisBaseNode::isEditable(), m_currentlyUsingSelection, m_currentMode, m_handlesRect, m_lastCursorPos, m_strokeId, MoveSelectedLayer, moveToolMode(), KisTool::resetCursorStyle(), KisTool::selectedNodes(), KoToolBase::selection(), KisNodeSelectionRecipe::selectNodesToProcess(), and KoToolBase::useCursor().

◆ setShowCoordinates()

void KisToolMove::setShowCoordinates ( bool value )

◆ slotHandlesRectCalculated

void KisToolMove::slotHandlesRectCalculated ( const QRect & handlesRect )

slot

Definition at line 325 of file kis_tool_move.cc.

{
    m_handlesRect = handlesRect;
    notifyGuiAfterMove(false);
}

References m_handlesRect, and notifyGuiAfterMove().

◆ slotMoveDiscreteDown

void KisToolMove::slotMoveDiscreteDown ( )

privateslot

Definition at line 666 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Down, false);
}

References Down, and moveDiscrete().

◆ slotMoveDiscreteDownMore

void KisToolMove::slotMoveDiscreteDownMore ( )

privateslot

Definition at line 686 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Down, true);
}

References Down, and moveDiscrete().

◆ slotMoveDiscreteLeft

void KisToolMove::slotMoveDiscreteLeft ( )

privateslot

Definition at line 651 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Left, false);
}

References Left, and moveDiscrete().

◆ slotMoveDiscreteLeftMore

void KisToolMove::slotMoveDiscreteLeftMore ( )

privateslot

Definition at line 671 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Left, true);
}

References Left, and moveDiscrete().

◆ slotMoveDiscreteRight

void KisToolMove::slotMoveDiscreteRight ( )

privateslot

Definition at line 656 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Right, false);
}

References moveDiscrete(), and Right.

◆ slotMoveDiscreteRightMore

void KisToolMove::slotMoveDiscreteRightMore ( )

privateslot

Definition at line 676 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Right, true);
}

References moveDiscrete(), and Right.

◆ slotMoveDiscreteUp

void KisToolMove::slotMoveDiscreteUp ( )

privateslot

Definition at line 661 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Up, false);
}

References moveDiscrete(), and Up.

◆ slotMoveDiscreteUpMore

void KisToolMove::slotMoveDiscreteUpMore ( )

privateslot

Definition at line 681 of file kis_tool_move.cc.

{
    moveDiscrete(MoveDirection::Up, true);
}

References moveDiscrete(), and Up.

◆ slotNodeChanged

void KisToolMove::slotNodeChanged ( const KisNodeList & nodes )

slot

Definition at line 807 of file kis_tool_move.cc.

{
    if (m_strokeId && !tryEndPreviousStroke(nodes)) {
        return;
    }
    requestHandlesRectUpdate();
}

References m_strokeId, requestHandlesRectUpdate(), and tryEndPreviousStroke().

◆ slotSelectionChanged

void KisToolMove::slotSelectionChanged ( )

slot

Definition at line 815 of file kis_tool_move.cc.

{
    if (m_strokeId) return;
    requestHandlesRectUpdate();
}

References m_strokeId, and requestHandlesRectUpdate().

◆ slotStrokePickedLayers

void KisToolMove::slotStrokePickedLayers ( const KisNodeList & nodes )

slot

Definition at line 353 of file kis_tool_move.cc.

{
    if (nodes.isEmpty()) {
        useCursor(Qt::ForbiddenCursor);
    } else {
        KisTool::resetCursorStyle();
    }
}

References KisTool::resetCursorStyle(), and KoToolBase::useCursor().

◆ slotStrokeStartedEmpty

void KisToolMove::slotStrokeStartedEmpty ( )

slot

Notify that move-selection stroke ended unexpectedly

Since the choice of nodes for the operation happens in the stroke itself, it may happen that there are no nodes at all. In such a case, we should just cancel already started stroke.

Definition at line 331 of file kis_tool_move.cc.

{
    if (m_currentlyUsingSelection) {
        KisCanvas2 *kisCanvas = static_cast<KisCanvas2*>(canvas());
        kisCanvas->viewManager()->
            showFloatingMessage(
                i18nc("floating message in move tool",
                      "Selected area has no pixels"),
                QIcon(), 1000, KisFloatingMessage::High);
    }
 
    cancelStroke();
}

References cancelStroke(), Private::canvas, KisFloatingMessage::High, m_currentlyUsingSelection, and KisCanvas2::viewManager().

◆ slotTrackerChangedConfig

void KisToolMove::slotTrackerChangedConfig ( KisToolChangesTrackerDataSP state )

privateslot

Definition at line 638 of file kis_tool_move.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_strokeId);
 
    KisToolMoveState *newState = dynamic_cast<KisToolMoveState*>(state.data());
    KIS_SAFE_ASSERT_RECOVER_RETURN(newState);
 
    if (mode() == KisTool::PAINT_MODE) return;  // Don't interact with dragging
    m_accumulatedOffset = newState->accumulatedOffset;
    image()->addJob(m_strokeId, new MoveStrokeStrategy::Data(m_accumulatedOffset));
    notifyGuiAfterMove();
}

References KisToolMoveState::accumulatedOffset, KisImage::addJob(), KisTool::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_accumulatedOffset, m_strokeId, KisTool::mode(), notifyGuiAfterMove(), and KisTool::PAINT_MODE.

◆ startAction()

void KisToolMove::startAction	(	KoPointerEvent *	event,
		MoveToolMode	mode )

Definition at line 544 of file kis_tool_move.cc.

{
    QPoint pos = convertToPixelCoordAndSnap(event).toPoint();
    m_dragStart = pos;
    m_dragPos = pos;
 
    if (startStrokeImpl(mode, &pos)) {
        setMode(KisTool::PAINT_MODE);
 
        if (m_currentlyUsingSelection) {
            KisImageSP image = currentImage();
            image->addJob(m_strokeId,
                          new MoveSelectionStrokeStrategy::ShowSelectionData(false));
        }
 
    } else {
        event->ignore();
        m_dragPos = QPoint();
        m_dragStart = QPoint();
    }
    qobject_cast<KisCanvas2*>(canvas())->updateCanvas();
}

References KisImage::addJob(), Private::canvas, KisTool::convertToPixelCoordAndSnap(), KisTool::currentImage(), KisTool::image(), m_currentlyUsingSelection, m_dragPos, m_dragStart, m_strokeId, KisTool::mode(), KisTool::PAINT_MODE, KisTool::setMode(), and startStrokeImpl().

◆ startStrokeImpl()

bool KisToolMove::startStrokeImpl	(	MoveToolMode	mode,
		const QPoint *	pos )

private

Definition at line 144 of file kis_tool_move.cc.

{
    KisNodeSP node;
    KisImageSP image = this->image();
 
    KisResourcesSnapshotSP resources =
        new KisResourcesSnapshot(image, currentNode(), canvas()->resourceManager());
    KisSelectionSP selection = resources->activeSelection();
 
    KisPaintLayerSP paintLayer =
        dynamic_cast<KisPaintLayer*>(this->currentNode().data());
 
 
 
    const bool canUseSelectionMode =
            paintLayer && selection &&
            !selection->selectedRect().isEmpty() &&
            !selection->selectedExactRect().isEmpty();
 
    if (pos) {
        // finish stroke by clicking outside image bounds
        if (m_strokeId && !image->bounds().contains(*pos)) {
            endStroke();
            return false;
        }
 
        // restart stroke when the mode has changed or the user tried to
        // pick another layer in "layer under cursor" mode.
        if (m_strokeId &&
                (m_currentMode != mode ||
                 m_currentlyUsingSelection != canUseSelectionMode ||
                 (!m_currentlyUsingSelection &&
                  mode != MoveSelectedLayer &&
                  !m_handlesRect.translated(currentOffset()).contains(*pos)))) {
 
            endStroke();
        }
    }
 
    if (m_strokeId) return true;
 
 
    if (canUseSelectionMode && !nodeEditable()) {
        // if there is a selection, it would only use the current layer anyway
        // if the current layer is not editable, don't continue
        return false;
    }
 
    KisNodeList nodes;
 
    KisStrokeStrategy *strategy;
 
    bool isMoveSelection = false;
    if (canUseSelectionMode) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(selection, false);
 
        MoveSelectionStrokeStrategy *moveStrategy =
            new MoveSelectionStrokeStrategy(paintLayer,
                                            selection,
                                            image.data(),
                                            image.data());
 
        connect(moveStrategy,
                SIGNAL(sigHandlesRectCalculated(const QRect&)),
                SLOT(slotHandlesRectCalculated(const QRect&)));
        connect(moveStrategy,
                SIGNAL(sigStrokeStartedEmpty()),
                SLOT(slotStrokeStartedEmpty()));
 
        strategy = moveStrategy;
        isMoveSelection = true;
        nodes = {paintLayer};
 
    } else {
        KisNodeSelectionRecipe nodeSelection =
            pos ?
                KisNodeSelectionRecipe(
                        this->selectedNodes(),
                        (KisNodeSelectionRecipe::SelectionMode)mode,
                        *pos) :
                KisNodeSelectionRecipe(this->selectedNodes());
 
 
        MoveStrokeStrategy *moveStrategy =
            new MoveStrokeStrategy(nodeSelection, image.data(), image.data());
        connect(moveStrategy,
                SIGNAL(sigHandlesRectCalculated(const QRect&)),
                SLOT(slotHandlesRectCalculated(const QRect&)));
        connect(moveStrategy,
                SIGNAL(sigStrokeStartedEmpty()),
                SLOT(slotStrokeStartedEmpty()));
        connect(moveStrategy,
                SIGNAL(sigLayersPicked(const KisNodeList&)),
                SLOT(slotStrokePickedLayers(const KisNodeList&)));
 
        strategy = moveStrategy;
        nodes = nodeSelection.selectedNodes;
    }
 
    {
        KConfigGroup group = KSharedConfig::openConfig()->group(toolId());
        const bool forceLodMode = group.readEntry("forceLodMode", false);
        strategy->setForceLodModeIfPossible(forceLodMode);
    }
 
    // disable outline feedback until the stroke calculates
    // correct bounding rect
    m_handlesRect = QRect();
    m_strokeId = image->startStroke(strategy);
    m_currentlyProcessingNodes = nodes;
    m_currentlyUsingSelection = isMoveSelection;
    m_currentMode = mode;
    m_accumulatedOffset = QPoint();
 
    if (!isMoveSelection) {
        m_asyncUpdateHelper.startUpdateStream(image.data(), m_strokeId);
    }
 
    KIS_SAFE_ASSERT_RECOVER(m_changesTracker.isEmpty()) {
        m_changesTracker.reset();
    }
    commitChanges();
 
    return true;
}

References KisResourcesSnapshot::activeSelection(), KisImage::bounds(), Private::canvas, commitChanges(), connect(), KisTool::currentNode(), currentOffset(), KisSharedPtr< T >::data(), KisWeakSharedPtr< T >::data(), endStroke(), KisTool::image(), KisToolChangesTracker::isEmpty(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_accumulatedOffset, m_asyncUpdateHelper, m_changesTracker, m_currentlyProcessingNodes, m_currentlyUsingSelection, m_currentMode, m_handlesRect, m_strokeId, KisTool::mode(), MoveSelectedLayer, KisTool::nodeEditable(), KisToolChangesTracker::reset(), KisTool::selectedNodes(), KisNodeSelectionRecipe::selectedNodes, KoToolBase::selection(), KisStrokeStrategy::setForceLodModeIfPossible(), slotHandlesRectCalculated(), slotStrokePickedLayers(), slotStrokeStartedEmpty(), KisImage::startStroke(), KisAsynchronousStrokeUpdateHelper::startUpdateStream(), and KoToolBase::toolId().

◆ tryEndPreviousStroke()

bool KisToolMove::tryEndPreviousStroke ( const KisNodeList & nodes )

private

Definition at line 300 of file kis_tool_move.cc.

{
    if (!m_strokeId) return false;
 
    bool strokeEnded = false;
 
    if (!KritaUtils::compareListsUnordered(nodes, m_currentlyProcessingNodes)) {
        endStroke();
        strokeEnded = true;
    }
 
    return strokeEnded;
}

References KritaUtils::compareListsUnordered(), endStroke(), m_currentlyProcessingNodes, and m_strokeId.

◆ updateUIUnit()

void KisToolMove::updateUIUnit ( int newUnit )

◆ wantsAutoScroll()

bool KisToolMove::wantsAutoScroll ( ) const

inlineoverridevirtual

wantsAutoScroll reimplemented from KoToolBase there's an issue where autoscrolling with this tool never makes the stroke end, so we return false here so that users don't get stuck with the tool. See bug 362659

Returns: false

Reimplemented from KoToolBase.

Definition at line 49 of file kis_tool_move.h.

                                          {
        return false;
    }

Member Data Documentation

◆ m_accumulatedOffset

QPoint KisToolMove::m_accumulatedOffset

private

Total offset including multiple clicks, up/down/left/right keys, etc. added together.

Definition at line 151 of file kis_tool_move.h.

◆ m_actionConnections

KisSignalAutoConnectionsStore KisToolMove::m_actionConnections

private

Definition at line 170 of file kis_tool_move.h.

◆ m_asyncUpdateHelper

KisAsynchronousStrokeUpdateHelper KisToolMove::m_asyncUpdateHelper

private

Definition at line 173 of file kis_tool_move.h.

◆ m_canvasConnections

KisSignalAutoConnectionsStore KisToolMove::m_canvasConnections

private

Definition at line 171 of file kis_tool_move.h.

◆ m_changesTracker

KisToolChangesTracker KisToolMove::m_changesTracker

private

Definition at line 166 of file kis_tool_move.h.

◆ m_currentlyProcessingNodes

KisNodeList KisToolMove::m_currentlyProcessingNodes

private

Definition at line 155 of file kis_tool_move.h.

◆ m_currentlyUsingSelection

bool KisToolMove::m_currentlyUsingSelection {false}

private

Definition at line 156 of file kis_tool_move.h.

156{false};

◆ m_currentMode

MoveToolMode KisToolMove::m_currentMode {MoveSelectedLayer}

private

Definition at line 157 of file kis_tool_move.h.

157{MoveSelectedLayer};

◆ m_dragPos

QPoint KisToolMove::m_dragPos

private

Definition at line 163 of file kis_tool_move.h.

◆ m_dragStart

QPoint KisToolMove::m_dragStart

private

Point where current cursor dragging began.

Definition at line 150 of file kis_tool_move.h.

◆ m_handlesRect

QRect KisToolMove::m_handlesRect

private

Definition at line 164 of file kis_tool_move.h.

◆ m_lastCursorPos

QPoint KisToolMove::m_lastCursorPos

private

Definition at line 168 of file kis_tool_move.h.

◆ m_optionsWidget

MoveToolOptionsWidget* KisToolMove::m_optionsWidget {0}

private

Definition at line 149 of file kis_tool_move.h.

149{0};

◆ m_resolution

int KisToolMove::m_resolution {0}

private

Definition at line 159 of file kis_tool_move.h.

159{0};

◆ m_showCoordinatesAction

QAction* KisToolMove::m_showCoordinatesAction {0}

private

Definition at line 161 of file kis_tool_move.h.

161{0};

◆ m_strokeId

KisStrokeId KisToolMove::m_strokeId

private

Definition at line 153 of file kis_tool_move.h.

◆ m_updateCursorCompressor

KisSignalCompressor KisToolMove::m_updateCursorCompressor

private

Definition at line 169 of file kis_tool_move.h.

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

plugins/tools/basictools/kis_tool_move.h
plugins/tools/basictools/kis_tool_move.cc

Public Types

Public Slots

Signals

Public Member Functions

Protected Slots

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ MoveDirection

◆ MoveToolMode

Constructor & Destructor Documentation

◆ KisToolMove()

◆ ~KisToolMove()

Member Function Documentation

◆ activate

◆ applyModifiers()

◆ beginAlternateAction()

◆ beginPrimaryAction()

◆ cancelStroke()

◆ commitChanges

◆ continueAction()

◆ continueAlternateAction()

◆ continuePrimaryAction()

◆ createOptionWidget()

◆ currentOffset()

◆ deactivate

◆ drag()

◆ endAction()

◆ endAlternateAction()

◆ endPrimaryAction()

◆ endStroke

◆ mouseMoveEvent()

◆ moveBySpinX

◆ moveBySpinY

◆ moveDiscrete

◆ moveInNewPosition

◆ moveToolMode()

◆ moveToolModeChanged

◆ notifyGuiAfterMove()

◆ paint()

◆ Q_ENUMS()

◆ requestHandlesRectUpdate()

◆ requestRedoDuringStroke

◆ requestStrokeCancellation

◆ requestStrokeEnd

◆ requestUndoDuringStroke

◆ resetCursorStyle

◆ setShowCoordinates()

◆ slotHandlesRectCalculated

◆ slotMoveDiscreteDown

◆ slotMoveDiscreteDownMore

◆ slotMoveDiscreteLeft

◆ slotMoveDiscreteLeftMore

◆ slotMoveDiscreteRight

◆ slotMoveDiscreteRightMore

◆ slotMoveDiscreteUp

◆ slotMoveDiscreteUpMore

◆ slotNodeChanged

◆ slotSelectionChanged

◆ slotStrokePickedLayers

◆ slotStrokeStartedEmpty

◆ slotTrackerChangedConfig

◆ startAction()

◆ startStrokeImpl()

◆ tryEndPreviousStroke()

◆ updateUIUnit()

◆ wantsAutoScroll()

Member Data Documentation

◆ m_accumulatedOffset

◆ m_actionConnections

◆ m_asyncUpdateHelper

◆ m_canvasConnections

◆ m_changesTracker

◆ m_currentlyProcessingNodes

◆ m_currentlyUsingSelection

◆ m_currentMode

◆ m_dragPos